Example usage for org.eclipse.jgit.diff DiffFormatter setRepository

Introduction

In this page you can find the example usage for org.eclipse.jgit.diff DiffFormatter setRepository.

Prototype

public void setRepository(Repository repository) 

Source Link

Document

Set the repository the formatter can load object contents from.

Usage

From source file:ShowFileDiff.java

License:Apache License

public static void main(String[] args) throws IOException, GitAPIException {
    Repository repository = null; //CookbookHelper.openJGitCookbookRepository();

    // the diff works on TreeIterators, we prepare two for the two branches
    AbstractTreeIterator oldTreeParser = prepareTreeParser(repository,
            "09c65401f3730eb3e619c33bf31e2376fb393727");
    AbstractTreeIterator newTreeParser = prepareTreeParser(repository,
            "aa31703b65774e4a06010824601e56375a70078c");

    // then the procelain diff-command returns a list of diff entries
    List<DiffEntry> diff = new Git(repository).diff().setOldTree(oldTreeParser).setNewTree(newTreeParser)
            .setPathFilter(PathFilter.create("README.md")).call();
    for (DiffEntry entry : diff) {
        System.out.println("Entry: " + entry + ", from: " + entry.getOldId() + ", to: " + entry.getNewId());
        DiffFormatter formatter = new DiffFormatter(System.out);
        formatter.setRepository(repository);
        formatter.format(entry);//from   w w  w . j  av a 2  s  .  c om
    }

    repository.close();
}

---

From source file:am.ik.categolj3.api.git.GitStore.java

License:Apache License

void syncHead() {
    log.info("Syncing HEAD...");

    ObjectId oldHead = this.currentHead.get();
    ObjectId newHead = this.head();

    try (Repository repository = this.git.getRepository()) {
        DiffFormatter diffFormatter = new DiffFormatter(System.out);
        diffFormatter.setRepository(repository);
        RevWalk walk = new RevWalk(repository);
        try {//  w  w w.j  a va 2  s .c  om
            RevCommit fromCommit = walk.parseCommit(oldHead);
            RevCommit toCommit = walk.parseCommit(newHead);
            List<DiffEntry> list = diffFormatter.scan(fromCommit.getTree(), toCommit.getTree());

            list.forEach(diff -> {
                log.info("[{}]\tnew={}\told={}", diff.getChangeType(), diff.getNewPath(), diff.getOldPath());
                if (diff.getOldPath() != null) {
                    Path path = Paths
                            .get(gitProperties.getBaseDir().getAbsolutePath() + "/" + diff.getOldPath());
                    if (Entry.isPublic(path)) {
                        Long entryId = Entry.parseEntryId(path);
                        log.info("evict Entry({})", entryId);
                        this.entryCache.evict(entryId);
                    }
                }
                if (diff.getNewPath() != null) {
                    Path path = Paths
                            .get(gitProperties.getBaseDir().getAbsolutePath() + "/" + diff.getNewPath());
                    this.loadEntry(path).ifPresent(entry -> {
                        log.info("put Entry({})", entry.getEntryId());
                        this.entryCache.put(entry.getEntryId(), entry);
                    });
                }
            });
        } finally {
            walk.dispose();
        }
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    } catch (Exception e) {
        throw new IllegalStateException(e);
    }

    this.currentHead.set(newHead);
}

---

From source file:at.ac.tuwien.inso.subcat.miner.GitMiner.java

License:Open Source License

private void processDiff(Repository repository, RevWalk walk, RevCommit current, DiffOutputStream outputStream,
        Map<String, FileStats> fileStatsMap) throws IOException {
    assert (repository != null);
    assert (walk != null);
    assert (current != null);
    assert (outputStream != null);
    assert (fileStatsMap != null);

    if (processDiffs == false) {
        return;/*from   w w  w  .j  a  v a2s  .  c  o  m*/
    }

    try {
        DiffFormatter df = new DiffFormatter(outputStream);
        df.setRepository(repository);
        df.setDetectRenames(true);

        List<DiffEntry> entries;
        if (current.getParentCount() > 0) {
            RevCommit parent = current.getParent(0);
            ObjectId oldTree = walk.parseCommit(parent).getTree();
            ObjectId newTree = current.getTree();
            entries = df.scan(oldTree, newTree);
        } else {
            entries = df.scan(new EmptyTreeIterator(),
                    new CanonicalTreeParser(null, walk.getObjectReader(), current.getTree()));
        }

        for (DiffEntry de : entries) {
            if (stopped == true) {
                break;
            }

            int emptyLinesAddedStart = outputStream.getTotalEmptyLinesAdded();
            int emptyLinesRemovedStart = outputStream.getTotalEmptyLinesRemoved();
            int linesAddedStart = outputStream.getTotalLinesAdded();
            int linesRemovedStart = outputStream.getTotalLinesRemoved();
            int chunksStart = outputStream.getTotalChunks();
            String oldPath = null;
            String path = null;

            switch (de.getChangeType()) {
            case ADD:
                path = de.getNewPath();
                break;
            case DELETE:
                path = de.getOldPath();
                break;
            case MODIFY:
                path = de.getOldPath();
                break;
            case COPY:
                oldPath = de.getOldPath();
                path = de.getNewPath();
                break;
            case RENAME:
                oldPath = de.getOldPath();
                path = de.getNewPath();
                break;
            default:
                continue;
            }

            assert (fileStatsMap.containsKey(path) == false);
            assert (path != null);

            FileStats fileStats = new FileStats();
            fileStatsMap.put(path, fileStats);

            outputStream.resetFile();
            df.format(de);
            df.flush();

            fileStats.emptyLinesAdded = outputStream.getTotalEmptyLinesAdded() - emptyLinesAddedStart;
            fileStats.emptyLinesRemoved = outputStream.getTotalEmptyLinesRemoved() - emptyLinesRemovedStart;
            fileStats.linesAdded += outputStream.getTotalLinesAdded() - linesAddedStart;
            fileStats.linesRemoved += outputStream.getTotalLinesRemoved() - linesRemovedStart;
            fileStats.chunks += outputStream.getTotalChunks() - chunksStart;

            fileStats.type = de.getChangeType();
            fileStats.oldPath = oldPath;
        }
    } catch (IOException e) {
        throw e;
    }
}

---

From source file:boa.datagen.scm.GitCommit.java

License:Apache License

private void getChangeFiles(final RevCommit parent, final RevCommit rc,
        final HashMap<String, String> rChangedPaths, final HashMap<String, String> rRemovedPaths,
        final HashMap<String, String> rAddedPaths) {
    final DiffFormatter df = new DiffFormatter(NullOutputStream.INSTANCE);
    df.setRepository(repository);
    df.setDiffComparator(RawTextComparator.DEFAULT);
    df.setDetectRenames(true);//from  w  ww .  j  a va 2  s . c om

    try {
        final AbstractTreeIterator parentIter;
        if (parent == null)
            parentIter = new EmptyTreeIterator();
        else
            parentIter = new CanonicalTreeParser(null, repository.newObjectReader(), parent.getTree());

        for (final DiffEntry diff : df.scan(parentIter,
                new CanonicalTreeParser(null, repository.newObjectReader(), rc.getTree()))) {
            if (diff.getChangeType() == ChangeType.MODIFY || diff.getChangeType() == ChangeType.COPY
                    || diff.getChangeType() == ChangeType.RENAME) {
                if (diff.getOldMode().getObjectType() == Constants.OBJ_BLOB
                        && diff.getNewMode().getObjectType() == Constants.OBJ_BLOB) {
                    String path = diff.getNewPath();
                    rChangedPaths.put(path, diff.getOldPath());
                    filePathGitObjectIds.put(path, diff.getNewId().toObjectId());
                }
            } else if (diff.getChangeType() == ChangeType.ADD) {
                if (diff.getNewMode().getObjectType() == Constants.OBJ_BLOB) {
                    String path = diff.getNewPath();
                    rAddedPaths.put(path, null);
                    filePathGitObjectIds.put(path, diff.getNewId().toObjectId());
                }
            } else if (diff.getChangeType() == ChangeType.DELETE) {
                if (diff.getOldMode().getObjectType() == Constants.OBJ_BLOB) {
                    rRemovedPaths.put(diff.getOldPath(), diff.getOldPath());
                }
            }
        }
    } catch (final IOException e) {
        if (debug)
            System.err.println("Git Error getting commit diffs: " + e.getMessage());
    }
    df.close();
}

---

From source file:br.com.metricminer2.scm.GitRepository.java

License:Apache License

private List<DiffEntry> diffsForTheCommit(Repository repo, RevCommit commit)
        throws IOException, AmbiguousObjectException, IncorrectObjectTypeException {

    AnyObjectId currentCommit = repo.resolve(commit.getName());
    AnyObjectId parentCommit = commit.getParentCount() > 0 ? repo.resolve(commit.getParent(0).getName()) : null;

    DiffFormatter df = new DiffFormatter(DisabledOutputStream.INSTANCE);
    df.setBinaryFileThreshold(2 * 1024); // 2 mb max a file
    df.setRepository(repo);
    df.setDiffComparator(RawTextComparator.DEFAULT);
    df.setDetectRenames(true);//from w ww  .ja v  a  2 s .co m
    List<DiffEntry> diffs = null;

    if (parentCommit == null) {
        RevWalk rw = new RevWalk(repo);
        diffs = df.scan(new EmptyTreeIterator(),
                new CanonicalTreeParser(null, rw.getObjectReader(), commit.getTree()));
        rw.release();
    } else {
        diffs = df.scan(parentCommit, currentCommit);
    }

    df.release();

    return diffs;
}

---

From source file:br.com.metricminer2.scm.GitRepository.java

License:Apache License

private String getDiffText(Repository repo, DiffEntry diff) throws IOException, UnsupportedEncodingException {
    DiffFormatter df2 = null;
    try {/*w  w w  .j av  a  2s  .c om*/
        String diffText;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        df2 = new DiffFormatter(out);
        df2.setRepository(repo);
        df2.format(diff);
        diffText = out.toString("UTF-8");
        return diffText;
    } catch (Throwable e) {
        return "";
    } finally {
        if (df2 != null)
            df2.release();
    }
}

---

From source file:br.edu.ifpb.scm.api.git.Git.java

private List<DiffEntry> getDiff(String commit, boolean flag) throws IOException {
    ObjectReader reader = git.getRepository().newObjectReader();
    CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
    ObjectId oldTree = git.getRepository().resolve(commit + "^{tree}"); // equals newCommit.getTree()
    oldTreeIter.reset(reader, oldTree);//from  w ww  . j  av  a  2 s  .  c o  m
    ObjectId newTree = null;
    if (flag) {
        newTree = git.getRepository().resolve(commit + HEAD); // equals oldCommit.getTree()
    } else {
        newTree = git.getRepository().resolve(commit + HEAD_NEIGHBOR); // equals oldCommit.getTree()
    }

    DiffFormatter formatter = new DiffFormatter(System.out);
    formatter.setRepository(git.getRepository());
    List<DiffEntry> scan = formatter.scan(oldTree, newTree);

    return scan;
}

---

From source file:br.edu.ifpb.scm.api.loads.Loader.java

public static void showFileDiffs(Git gitRepository) {
    Repository repo = gitRepository.getRepository();

    try {//w  ww .j  a  va2 s.  c  o  m
        ObjectId head = ObjectId.fromString("c24af304077e4a6d1925db7cd35d0cd1ed488d6a");
        ObjectId previousHead = ObjectId.fromString("c16be41e77bb53a4b639cb864c9a6e4d0f8df7c2");
        ObjectReader reader = repo.newObjectReader();

        CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
        oldTreeIter.reset(reader, previousHead);
        CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
        newTreeIter.reset(reader, head);

        List<DiffEntry> listDiffs = gitRepository.diff().setOldTree(oldTreeIter).setNewTree(newTreeIter).call();

        listDiffs.stream().forEach((DiffEntry diff) -> {

            DiffFormatter formatter = new DiffFormatter(System.out);
            formatter.setRepository(repo);
            System.out.println(diff);
            try {
                formatter.format(diff);
            } catch (IOException ex) {
                Logger.getLogger(Loader.class.getName()).log(Level.SEVERE, null, ex);
            }
        });
    } catch (IOException | GitAPIException ex) {
        Logger.getLogger(Loader.class.getName()).log(Level.SEVERE, null, ex);
    }
}

---

From source file:co.bledo.gitmin.servlet.Review.java

License:Apache License

public Response commit(Request req) throws IOException, GitAPIException {
    String repoName = req.getParam("repo", "");
    String hash = req.getParam("hash", "");

    Git git = Git.open(new File(GitminConfig.getGitRepositoriesPath() + "/" + repoName));

    /*/*from w w  w  . j av a  2s  .  c om*/
    ByteArrayOutputStream baos1 = new ByteArrayOutputStream();
    List<DiffEntry> diffTest = git.diff().setOutputStream(baos1)
    .setOldTree(getTreeIterator(git.getRepository(), hash))
    .setNewTree(getTreeIterator(git.getRepository(), hash + "^"))
    .call();
    System.out.println(baos1.toString());
    */

    RepositoryBuilder builder = new RepositoryBuilder();
    Repository repo = builder.setGitDir(new File(GitminConfig.getGitRepositoriesPath() + "/" + repoName))
            .readEnvironment().findGitDir().build();

    RevWalk rw = new RevWalk(repo);

    ObjectId hashOid = repo.resolve(hash);

    RevCommit commit = rw.parseCommit(hashOid);
    RevCommit parent = rw.parseCommit(commit.getParent(0).getId());

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    DiffFormatter df = new DiffFormatter(baos);
    df.setRepository(repo);
    df.setDiffComparator(RawTextComparator.DEFAULT);
    df.setDetectRenames(true);
    List<DiffEntry> diffs = df.scan(parent, commit);
    List<CommitInfo> commitInfos = new ArrayList<CommitInfo>();
    for (DiffEntry diff : diffs) {

        CommitInfo nfo = new CommitInfo();

        df.format(diff);

        nfo.diff = baos.toString();
        nfo.oldContents = getFileContent(repo, parent, diff.getOldPath());
        nfo.newContents = getFileContent(repo, parent, diff.getNewPath());
        nfo.newFile = diff.getNewPath();
        nfo.oldFile = diff.getOldPath();

        commitInfos.add(nfo);
    }

    VelocityResponse resp = VelocityResponse.newInstance(req, this);
    resp.assign("nfolist", commitInfos);
    return log.exit(resp);
}

---

From source file:com.chungkwong.jgitgui.LogTreeItem.java

License:Open Source License

@Override
public Node getContentPage() {
    GridPane page = new GridPane();
    TextField oldSrc = new TextField();
    TextField newSrc = new TextField();
    CheckBox detailed = new CheckBox(
            java.util.ResourceBundle.getBundle("com/chungkwong/jgitgui/text").getString("DETAILED"));
    Button ok = new Button(java.util.ResourceBundle.getBundle("com/chungkwong/jgitgui/text").getString("DIFF"));
    TextArea diff = new TextArea();
    diff.setEditable(false);/*from  w w w . j  a va 2  s . c om*/
    Git git = ((Git) getParent().getValue());
    GridPane.setVgrow(diff, Priority.ALWAYS);
    GridPane.setHgrow(diff, Priority.ALWAYS);
    GridPane.setHgrow(oldSrc, Priority.ALWAYS);
    GridPane.setHgrow(newSrc, Priority.ALWAYS);
    ok.setOnAction((ActionEvent e) -> {
        try (ObjectReader reader = git.getRepository().newObjectReader()) {
            List<DiffEntry> entries;
            if (oldSrc.getText().isEmpty() && newSrc.getText().isEmpty()) {
                entries = ((Git) getParent().getValue()).diff().setCached(true).call();
            } else {
                CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
                oldTreeIter.reset(reader, git.getRepository().resolve(oldSrc.getText() + "^{tree}"));
                CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
                newTreeIter.reset(reader, git.getRepository().resolve(newSrc.getText() + "^{tree}"));
                entries = ((Git) getParent().getValue()).diff().setNewTree(newTreeIter).setOldTree(oldTreeIter)
                        .call();
            }
            if (detailed.isSelected()) {
                PipedInputStream in = new PipedInputStream();
                PipedOutputStream out = new PipedOutputStream(in);
                DiffFormatter formatter = new DiffFormatter(out);
                formatter.setRepository(git.getRepository());
                formatter.format(entries);
                out.close();
                diff.setText(new BufferedReader(new InputStreamReader(in)).lines()
                        .collect(Collectors.joining("\n")));
            } else {
                diff.setText(entries.stream().map((o) -> toString(o)).collect(Collectors.joining("\n")));
            }
        } catch (Exception ex) {
            Logger.getLogger(LogTreeItem.class.getName()).log(Level.SEVERE, null, ex);
            Util.informUser(ex);
        }
    });
    page.addColumn(0, oldSrc, newSrc, detailed, ok, diff);

    page.setMaxSize(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    return page;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• »