org.eclipse.jgit.lib.Repository.newObjectReader() - java examples

Here are the examples of the java api org.eclipse.jgit.lib.Repository.newObjectReader() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

55 Examples 7

19 View Complete Implementation : IntBlob.java
Copyright Apache License 2.0
Author : GerritCodeReview
public static Optional<IntBlob> parse(Repository repo, String refName) throws IOException {
    try (ObjectReader or = repo.newObjectReader()) {
        return parse(repo, refName, or);
    }
}

18 View Complete Implementation : GitFlowMetaData.java
Copyright Apache License 2.0
Author : apache
byte[] getContent(String objectId) throws IOException {
    final ObjectId flowSnapshotObjectId = gitRepo.resolve(objectId);
    return gitRepo.newObjectReader().open(flowSnapshotObjectId).getBytes();
}

18 View Complete Implementation : GitObject.java
Copyright GNU General Public License v2.0
Author : bozaro
@NotNull
public ObjectLoader openObject() throws IOException {
    return repo.newObjectReader().open(object);
}

18 View Complete Implementation : PatchScriptBuilder.java
Copyright Apache License 2.0
Author : GerritCodeReview
private PatchSide resolveSideA(Repository git, SidesResolver sidesResolver, String path, ObjectId baseId) throws IOException {
    try (ObjectReader reader = git.newObjectReader()) {
        return sidesResolver.resolve(registry, reader, path, null, baseId, true);
    }
}

17 View Complete Implementation : ResolveRevCommit.java
Copyright Apache License 2.0
Author : kiegroup
public RevCommit execute() throws IOException {
    try (final ObjectReader reader = repo.newObjectReader()) {
        return RevCommit.parse(reader.open(objectId).getBytes());
    }
}

17 View Complete Implementation : ExternalIdCacheLoader.java
Copyright Apache License 2.0
Author : GerritCodeReview
/**
 * Build a new {@link AllExternalIds} from an old state by applying additions and removals that
 * were performed since then.
 *
 * <p>Removals are applied before additions.
 *
 * @param repo open repository
 * @param oldExternalIds prior state that is used as base
 * @param additions map of name to blob ID for each external ID that should be added
 * @param removals set of name {@link ObjectId}s that should be removed
 */
private static AllExternalIds buildAllExternalIds(Repository repo, AllExternalIds oldExternalIds, Map<ObjectId, ObjectId> additions, Set<ObjectId> removals) throws IOException {
    ImmutableSetMultimap.Builder<Account.Id, ExternalId> byAccount = ImmutableSetMultimap.builder();
    ImmutableSetMultimap.Builder<String, ExternalId> byEmail = ImmutableSetMultimap.builder();
    // Copy over old ExternalIds but exclude deleted ones
    for (ExternalId externalId : oldExternalIds.byAccount().values()) {
        if (removals.contains(externalId.blobId())) {
            continue;
        }
        byAccount.put(externalId.accountId(), externalId);
        if (externalId.email() != null) {
            byEmail.put(externalId.email(), externalId);
        }
    }
    // Add newly discovered ExternalIds
    try (ObjectReader reader = repo.newObjectReader()) {
        for (Map.Entry<ObjectId, ObjectId> nameToBlob : additions.entrySet()) {
            ExternalId parsedExternalId;
            try {
                parsedExternalId = ExternalId.parse(nameToBlob.getKey().name(), reader.open(nameToBlob.getValue()).getCachedBytes(), nameToBlob.getValue());
            } catch (ConfigInvalidException | RuntimeException e) {
                logger.atSevere().withCause(e).log("Ignoring invalid external ID note %s", nameToBlob.getKey().name());
                continue;
            }
            byAccount.put(parsedExternalId.accountId(), parsedExternalId);
            if (parsedExternalId.email() != null) {
                byEmail.put(parsedExternalId.email(), parsedExternalId);
            }
        }
    }
    return new AutoValue_AllExternalIds(byAccount.build(), byEmail.build());
}

17 View Complete Implementation : PatchScriptBuilder.java
Copyright Apache License 2.0
Author : GerritCodeReview
private ResolvedSides resolveSides(Repository git, SidesResolver sidesResolver, String oldName, String newName, ObjectId aId, ObjectId bId) throws IOException {
    try (ObjectReader reader = git.newObjectReader()) {
        PatchSide a = sidesResolver.resolve(registry, reader, oldName, null, aId, true);
        PatchSide b = sidesResolver.resolve(registry, reader, newName, a, bId, Objects.equals(aId, bId));
        return new ResolvedSides(a, b);
    }
}

17 View Complete Implementation : AppraiseGitReviewClient.java
Copyright Eclipse Public License 1.0
Author : google
private AbstractTreeIterator prepareTreeParserHelper(RevWalk walk, RevCommit commit) throws IOException, MissingObjectException, IncorrectObjectTypeException {
    RevTree tree = walk.parseTree(commit.getTree().getId());
    CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
    try (ObjectReader oldReader = repo.newObjectReader()) {
        oldTreeParser.reset(oldReader, tree.getId());
    }
    return oldTreeParser;
}

16 View Complete Implementation : GitFlowMetaData.java
Copyright Apache License 2.0
Author : apache
@SuppressWarnings("unchecked")
private void loadBuckets(Repository gitRepo, RevCommit commit, boolean isLatestCommit, Map<String, ObjectId> bucketObjectIds, Map<String, ObjectId> flowSnapshotObjectIds) throws IOException {
    final Yaml yaml = new Yaml();
    for (String bucketFilePath : bucketObjectIds.keySet()) {
        final ObjectId bucketObjectId = bucketObjectIds.get(bucketFilePath);
        final Map<String, Object> bucketMeta;
        try (InputStream bucketIn = gitRepo.newObjectReader().open(bucketObjectId).openStream()) {
            bucketMeta = yaml.load(bucketIn);
        }
        if (!validateRequiredValue(bucketMeta, bucketFilePath, LAYOUT_VERSION, BUCKET_ID, FLOWS)) {
            continue;
        }
        int layoutVersion = (int) bucketMeta.get(LAYOUT_VERSION);
        if (layoutVersion > CURRENT_LAYOUT_VERSION) {
            logger.warn("{} has unsupported {} {}. This Registry can only support {} or lower. Skipping it.", bucketFilePath, LAYOUT_VERSION, layoutVersion, CURRENT_LAYOUT_VERSION);
            continue;
        }
        final String bucketId = (String) bucketMeta.get(BUCKET_ID);
        final Bucket bucket;
        if (isLatestCommit) {
            // If this is the latest commit, then create one.
            bucket = getBucketOrCreate(bucketId);
        } else {
            // Otherwise non-existing bucket means it's already deleted.
            final Optional<Bucket> bucketOpt = getBucket(bucketId);
            if (bucketOpt.isPresent()) {
                bucket = bucketOpt.get();
            } else {
                logger.debug("Bucket {} does not exist any longer. It may have been deleted.", bucketId);
                continue;
            }
        }
        // Since the bucketName is restored from pathname, it can be different from the original bucket name when it sanitized.
        final String bucketDirName = bucketFilePath.substring(0, bucketFilePath.lastIndexOf("/"));
        // Since commits are read in LIFO order, avoid old commits overriding the latest bucket name.
        if (isEmpty(bucket.getBucketDirName())) {
            bucket.setBucketDirName(bucketDirName);
        }
        final Map<String, Object> flows = (Map<String, Object>) bucketMeta.get(FLOWS);
        loadFlows(commit, isLatestCommit, bucket, bucketFilePath, flows, flowSnapshotObjectIds);
    }
}

16 View Complete Implementation : StarredChangesUtil.java
Copyright Apache License 2.0
Author : gerrit-review
public static StarRef readLabels(Repository repo, String refName) throws IOException {
    Ref ref = repo.exactRef(refName);
    if (ref == null) {
        return StarRef.MISSING;
    }
    try (ObjectReader reader = repo.newObjectReader()) {
        ObjectLoader obj = reader.open(ref.getObjectId(), Constants.OBJ_BLOB);
        return StarRef.create(ref, Splitter.on(CharMatcher.whitespace()).omitEmptyStrings().split(new String(obj.getCachedBytes(Integer.MAX_VALUE), UTF_8)));
    }
}

15 View Complete Implementation : SMAGit.java
Copyright MIT License
Author : aesanch2
/**
 * Returns the Canonical Tree Parser representation of a commit.
 *
 * @param commit Commit in the repository.
 * @return CanonicalTreeParser representing the tree for the commit.
 * @throws IOException
 */
private CanonicalTreeParser getTree(String commit) throws IOException {
    CanonicalTreeParser tree = new CanonicalTreeParser();
    ObjectReader reader = repository.newObjectReader();
    ObjectId head = repository.resolve(commit + "^{tree}");
    tree.reset(reader, head);
    return tree;
}

15 View Complete Implementation : CherryPickCommand.java
Copyright Apache License 2.0
Author : apache
private List<RebaseTodoLine> prepareCommand(ObjectId head) throws GitException, IOException {
    Repository repository = getRepository();
    ObjectReader or = repository.newObjectReader();
    RevWalk walk = new RevWalk(or);
    List<RevCommit> commits = new ArrayList<>(revisions.length);
    for (String rev : revisions) {
        RevCommit commit = Utils.findCommit(repository, rev, walk);
        commits.add(commit);
    }
    List<RebaseTodoLine> steps = new ArrayList<>(commits.size());
    if (commits.size() == 1) {
        RevCommit commit = commits.get(0);
        steps.add(new RebaseTodoLine(RebaseTodoLine.Action.PICK, or.abbreviate(commit), commit.getShortMessage()));
    } else if (!commits.isEmpty()) {
        File sequencer = getSequencerFolder();
        sequencer.mkdirs();
        try {
            for (RevCommit commit : commits) {
                steps.add(new RebaseTodoLine(RebaseTodoLine.Action.PICK, or.abbreviate(commit), commit.getShortMessage()));
            }
            writeTodoFile(repository, steps);
            writeFile(new File(sequencer, SEQUENCER_HEAD), head);
        } catch (IOException ex) {
            Utils.deleteRecursively(sequencer);
            throw new GitException(ex);
        }
    }
    return steps;
}

15 View Complete Implementation : OnlineNoteDbMigrationIT.java
Copyright Apache License 2.0
Author : gerrit-review
private void testEnableSequences(int builderOption, int expectedFirstId, String expectedRefValue) throws Exception {
    PushOneCommit.Result r = createChange();
    Change.Id id = r.getChange().getId();
    replacedertThat(id.get()).isEqualTo(1);
    migrate(b -> b.setSequenceGap(builderOption).setStopAtStateForTesting(READ_WRITE_WITH_SEQUENCE_REVIEW_DB_PRIMARY));
    replacedertThat(sequences.nextChangeId()).isEqualTo(expectedFirstId);
    replacedertThat(sequences.nextChangeId()).isEqualTo(expectedFirstId + 1);
    try (Repository repo = repoManager.openRepository(allProjects);
        ObjectReader reader = repo.newObjectReader()) {
        Ref ref = repo.exactRef("refs/sequences/changes");
        replacedertThat(ref).isNotNull();
        ObjectLoader loader = reader.open(ref.getObjectId());
        replacedertThat(loader.getType()).isEqualTo(Constants.OBJ_BLOB);
        // Acquired a block of 10 to serve the first nextChangeId call after migration.
        replacedertThat(new String(loader.getCachedBytes(), UTF_8)).isEqualTo(expectedRefValue);
    }
    try (ReviewDb db = schemaFactory.open()) {
        // Underlying, unused ReviewDb is still on its own sequence.
        @SuppressWarnings("deprecation")
        int nextFromReviewDb = db.nextChangeId();
        replacedertThat(nextFromReviewDb).isEqualTo(3);
    }
}

15 View Complete Implementation : StarredChangesUtil.java
Copyright Apache License 2.0
Author : GerritCodeReview
public static StarRef readLabels(Repository repo, String refName) throws IOException {
    try (TraceTimer traceTimer = TraceContext.newTimer("Read star labels", Metadata.builder().noteDbRefName(refName).build())) {
        Ref ref = repo.exactRef(refName);
        if (ref == null) {
            return StarRef.MISSING;
        }
        try (ObjectReader reader = repo.newObjectReader()) {
            ObjectLoader obj = reader.open(ref.getObjectId(), Constants.OBJ_BLOB);
            return StarRef.create(ref, Splitter.on(CharMatcher.whitespace()).omitEmptyStrings().split(new String(obj.getCachedBytes(Integer.MAX_VALUE), UTF_8)));
        }
    }
}

15 View Complete Implementation : CommitDiffTask.java
Copyright GNU General Public License v3.0
Author : maks
private AbstractTreeIterator getTreeIterator(Repository repo, String commit) throws IOException {
    if (commit.equals("dircache")) {
        return new DirCacheIterator(repo.readDirCache());
    }
    if (commit.equals("filetree")) {
        return new FileTreeIterator(repo);
    }
    ObjectId treeId = repo.resolve(commit + "^{tree}");
    if (treeId == null) {
        throw new NullPointerException();
    }
    CanonicalTreeParser treeIter = new CanonicalTreeParser();
    ObjectReader reader = repo.newObjectReader();
    treeIter.reset(reader, treeId);
    return treeIter;
}

14 View Complete Implementation : CheckoutTest.java
Copyright Apache License 2.0
Author : apache
public void testLargeFile() throws Exception {
    unpack("large.dat.zip");
    File large = new File(workDir, "large.dat");
    replacedertTrue(large.exists());
    replacedertEquals(2158310, large.length());
    add();
    DirCache cache = repository.readDirCache();
    DirCacheEntry e = cache.getEntry("large.dat");
    WindowCacheConfig cfg = new WindowCacheConfig();
    cfg.setStreamFileThreshold((int) large.length() - 1);
    cfg.install();
    DirCacheCheckout.checkoutEntry(repository, e, repository.newObjectReader());
}

14 View Complete Implementation : GitDiffHandlerV1.java
Copyright Eclipse Public License 1.0
Author : eclipse
private AbstractTreeIterator getTreeIterator(Repository db, String name) throws IOException {
    final ObjectId id = db.resolve(name);
    if (id == null)
        throw new IllegalArgumentException(name);
    final CanonicalTreeParser p = new CanonicalTreeParser();
    final ObjectReader or = db.newObjectReader();
    try {
        p.reset(or, new RevWalk(db).parseTree(id));
        return p;
    } finally {
        or.close();
    }
}

14 View Complete Implementation : PGA.java
Copyright MIT License
Author : SpoonLabs
private AbstractTreeIterator prepareTreeParser(Repository repository, String objectId) throws IOException {
    // from the commit we can build the tree which allows us to construct the TreeParser
    // noinspection Duplicates
    RevWalk walk = new RevWalk(repository);
    RevCommit commit = walk.parseCommit(repository.resolve(objectId));
    RevTree tree = walk.parseTree(commit.getTree().getId());
    CanonicalTreeParser treeParser = new CanonicalTreeParser();
    ObjectReader reader = repository.newObjectReader();
    treeParser.reset(reader, tree.getId());
    walk.dispose();
    return treeParser;
}

13 View Complete Implementation : GitUtils.java
Copyright MIT License
Author : theonedev
public static List<DiffEntry> diff(Repository repository, AnyObjectId oldRevId, AnyObjectId newRevId) {
    List<DiffEntry> diffs = new ArrayList<>();
    try (DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE);
        RevWalk revWalk = new RevWalk(repository);
        ObjectReader reader = repository.newObjectReader()) {
        diffFormatter.setRepository(repository);
        diffFormatter.setDetectRenames(true);
        diffFormatter.setDiffComparator(RawTextComparator.DEFAULT);
        CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
        if (!oldRevId.equals(ObjectId.zeroId()))
            oldTreeParser.reset(reader, revWalk.parseCommit(oldRevId).getTree());
        CanonicalTreeParser newTreeParser = new CanonicalTreeParser();
        if (!newRevId.equals(ObjectId.zeroId()))
            newTreeParser.reset(reader, revWalk.parseCommit(newRevId).getTree());
        for (DiffEntry entry : diffFormatter.scan(oldTreeParser, newTreeParser)) {
            if (!Objects.equal(entry.getOldPath(), entry.getNewPath()) || !Objects.equal(entry.getOldMode(), entry.getNewMode()) || entry.getOldId() == null || !entry.getOldId().isComplete() || entry.getNewId() == null || !entry.getNewId().isComplete() || !entry.getOldId().equals(entry.getNewId())) {
                diffs.add(entry);
            }
        }
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    return diffs;
}

12 View Complete Implementation : CherryPickCommand.java
Copyright Apache License 2.0
Author : apache
private void applySteps(List<RebaseTodoLine> steps, boolean skipFirstStep) throws GitAPIException, IOException {
    Repository repository = getRepository();
    ObjectReader or = repository.newObjectReader();
    CherryPickResult res = null;
    boolean skipped = false;
    List<Ref> cherryPickedRefs = new ArrayList<>();
    for (Iterator<RebaseTodoLine> it = steps.iterator(); it.hasNext(); ) {
        RebaseTodoLine step = it.next();
        if (step.getAction() == RebaseTodoLine.Action.PICK) {
            if (skipFirstStep && !skipped) {
                it.remove();
                writeTodoFile(repository, steps);
                skipped = true;
                continue;
            }
            Collection<ObjectId> ids = or.resolve(step.getCommit());
            if (ids.size() != 1) {
                throw new JGitInternalException("Could not resolve uniquely the abbreviated object ID");
            }
            org.eclipse.jgit.api.CherryPickCommand command = new Git(repository).cherryPick();
            command.include(ids.iterator().next());
            if (workAroundStrategyIssue) {
                command.setStrategy(new FailuresDetectRecurciveStrategy());
            }
            res = command.call();
            if (res.getStatus() == CherryPickResult.CherryPickStatus.OK) {
                it.remove();
                writeTodoFile(repository, steps);
                cherryPickedRefs.addAll(res.getCherryPickedRefs());
            } else {
                break;
            }
        } else {
            it.remove();
        }
    }
    if (res == null) {
        result = createCustomResult(GitCherryPickResult.CherryPickStatus.OK, cherryPickedRefs);
    } else {
        result = createResult(res, cherryPickedRefs);
    }
    if (steps.isEmpty()) {
        // sequencer no longer needed
        Utils.deleteRecursively(getSequencerFolder());
    }
}

12 View Complete Implementation : TreeCreator.java
Copyright Apache License 2.0
Author : gerrit-review
private DirCache readBaseTree(Repository repository) throws IOException {
    try (ObjectReader objectReader = repository.newObjectReader()) {
        DirCache dirCache = DirCache.newInCore();
        DirCacheBuilder dirCacheBuilder = dirCache.builder();
        dirCacheBuilder.addTree(new byte[0], DirCacheEntry.STAGE_0, objectReader, baseCommit.getTree());
        dirCacheBuilder.finish();
        return dirCache;
    }
}

12 View Complete Implementation : SubdirectoryClone.java
Copyright Apache License 2.0
Author : kiegroup
public Git execute() {
    final Git git = new Clone(repoDir, origin, false, branches, credentialsProvider, leaders, hookDir, sslVerify).execute().get();
    final Repository repository = git.getRepository();
    try (final ObjectReader reader = repository.newObjectReader();
        final ObjectInserter inserter = repository.newObjectInserter()) {
        // Map all transformed commits that are non-empty so that we can properly map parents
        final Map<ObjectId, ObjectId> commitMap = new HashMap<>();
        final RevWalk revWalk = createRevWalk(repository, reader);
        transformBranches(repository, reader, inserter, revWalk, commitMap);
        overrideBranchNames(repository, revWalk, commitMap);
        removeOriginRemote(repository);
        return git;
    } catch (Exception e) {
        String message = String.format("Error cloning origin <%s> with subdirectory <%s>.", origin, subdirectory);
        logger.error(message);
        cleanupDir(git.getRepository().getDirectory());
        throw new Clone.CloneException(message, e);
    }
}

11 View Complete Implementation : GitChangeResolver.java
Copyright Apache License 2.0
Author : arquillian
private Set<Change> retrieveCommitsChanges(String previous, String head, File repoRoot) {
    final Repository repository = git.getRepository();
    try (ObjectReader reader = repository.newObjectReader()) {
        final ObjectId oldHead = repository.resolve(previous + ENSURE_TREE);
        final ObjectId newHead = repository.resolve(head + ENSURE_TREE);
        validateCommitExists(oldHead, previous, repository);
        validateCommitExists(newHead, head, repository);
        final CanonicalTreeParser oldTree = new CanonicalTreeParser();
        oldTree.reset(reader, oldHead);
        final CanonicalTreeParser newTree = new CanonicalTreeParser();
        newTree.reset(reader, newHead);
        final List<DiffEntry> commitDiffs = git.diff().setNewTree(newTree).setOldTree(oldTree).call();
        return transformToChangeSet(reduceToRenames(commitDiffs), repoRoot);
    } catch (MissingObjectException e) {
        throw new IllegalArgumentException(format(WRONG_COMMIT_ID_EXCEPTION, e.getObjectId().getName(), repository.getDirectory().getAbsolutePath()));
    } catch (IOException | GitAPIException e) {
        throw new IllegalStateException(e);
    }
}

11 View Complete Implementation : JGitTemplate.java
Copyright Apache License 2.0
Author : creactiviti
private IdentifiableResource readBlob(Repository aRepo, String aPath, String aBlobId) throws Exception {
    try (ObjectReader reader = aRepo.newObjectReader()) {
        if (aBlobId.equals(LATEST)) {
            List<IdentifiableResource> headFiles = getHeadFiles(aRepo, aPath);
            replacedert.notEmpty(headFiles, "could not find: " + aPath + ":" + aBlobId);
            return headFiles.get(0);
        }
        ObjectId objectId = aRepo.resolve(aBlobId);
        replacedert.notNull(objectId, "could not find: " + aPath + ":" + aBlobId);
        byte[] data = reader.open(objectId).getBytes();
        AbbreviatedObjectId abbreviated = reader.abbreviate(objectId);
        return new IdentifiableResource(aPath + ":" + abbreviated.name(), new ByteArrayResource(data));
    }
}

11 View Complete Implementation : JGitDiscoveryTest.java
Copyright MIT License
Author : danielflower
@Test
public void name() throws IOException, GitAPIException {
    ObjectId head = repo.resolve("HEAD^{tree}");
    ObjectId oldHead = repo.resolve("HEAD^^{tree}");
    ObjectReader reader = repo.newObjectReader();
    CanonicalTreeParser prevParser = new CanonicalTreeParser();
    prevParser.reset(reader, oldHead);
    CanonicalTreeParser headParser = new CanonicalTreeParser();
    headParser.reset(reader, head);
    List<DiffEntry> diffs = new Git(repo).diff().setNewTree(headParser).setOldTree(prevParser).call();
    for (DiffEntry entry : diffs) System.out.println(entry);
}

11 View Complete Implementation : CommentsIT.java
Copyright Apache License 2.0
Author : gerrit-review
/**
 * All the commits, which contain the target comment before, should still contain the comment with
 * the updated message. All the other metas of the commits should be exactly the same.
 */
private void replacedertMetaBranchCommitsAfterRewriting(List<RevCommit> beforeDelete, Change.Id changeId, String targetCommentUuid, String expectedMessage) throws Exception {
    List<RevCommit> afterDelete = getCommits(changeId);
    replacedertThat(afterDelete).hreplacedize(beforeDelete.size());
    try (Repository repo = repoManager.openRepository(project);
        ObjectReader reader = repo.newObjectReader()) {
        for (int i = 0; i < beforeDelete.size(); i++) {
            RevCommit commitBefore = beforeDelete.get(i);
            RevCommit commitAfter = afterDelete.get(i);
            Map<String, com.google.gerrit.reviewdb.client.Comment> commentMapBefore = DeleteCommentRewriter.getPublishedComments(noteUtil, changeId, reader, NoteMap.read(reader, commitBefore));
            Map<String, com.google.gerrit.reviewdb.client.Comment> commentMapAfter = DeleteCommentRewriter.getPublishedComments(noteUtil, changeId, reader, NoteMap.read(reader, commitAfter));
            if (commentMapBefore.containsKey(targetCommentUuid)) {
                replacedertThat(commentMapAfter).containsKey(targetCommentUuid);
                com.google.gerrit.reviewdb.client.Comment comment = commentMapAfter.get(targetCommentUuid);
                replacedertThat(comment.message).isEqualTo(expectedMessage);
                comment.message = commentMapBefore.get(targetCommentUuid).message;
                commentMapAfter.put(targetCommentUuid, comment);
                replacedertThat(commentMapAfter).isEqualTo(commentMapBefore);
            } else {
                replacedertThat(commentMapAfter).doesNotContainKey(targetCommentUuid);
            }
            // Other metas should be exactly the same.
            replacedertThat(commitAfter.getFullMessage()).isEqualTo(commitBefore.getFullMessage());
            replacedertThat(commitAfter.getCommitterIdent()).isEqualTo(commitBefore.getCommitterIdent());
            replacedertThat(commitAfter.getAuthorIdent()).isEqualTo(commitBefore.getAuthorIdent());
            replacedertThat(commitAfter.getEncoding()).isEqualTo(commitBefore.getEncoding());
            replacedertThat(commitAfter.getEncodingName()).isEqualTo(commitBefore.getEncodingName());
        }
    }
}

10 View Complete Implementation : GitServiceImpl.java
Copyright MIT License
Author : aserg-ufmg
@Override
public Map<ChangeType, List<GitFile>> fileTreeDiff(Repository repository, RevCommit commitNew) throws Exception {
    Map<ChangeType, List<GitFile>> mapDiff = new HashMap<ChangeType, List<GitFile>>();
    mapDiff.put(ChangeType.ADD, new ArrayList<>());
    mapDiff.put(ChangeType.COPY, new ArrayList<>());
    mapDiff.put(ChangeType.DELETE, new ArrayList<>());
    mapDiff.put(ChangeType.MODIFY, new ArrayList<>());
    mapDiff.put(ChangeType.RENAME, new ArrayList<>());
    if (commitNew.getParentCount() == 0) {
        this.logger.warn("Commit don't have parent [commitId=" + commitNew.getId().getName() + "]");
        return mapDiff;
    }
    // Commit pai no grafo.
    ObjectId headOld = commitNew.getParent(0).getTree();
    // Commit corrente.
    ObjectId headNew = commitNew.getTree();
    // prepare the two iterators to compute the diff between
    ObjectReader reader = repository.newObjectReader();
    CanonicalTreeParser treeRepositoryOld = new CanonicalTreeParser();
    treeRepositoryOld.reset(reader, headOld);
    CanonicalTreeParser treeRepositoryNew = new CanonicalTreeParser();
    treeRepositoryNew.reset(reader, headNew);
    // finally get the list of changed files
    List<DiffEntry> diffs = new Git(repository).diff().setNewTree(treeRepositoryNew).setOldTree(treeRepositoryOld).setShowNameAndStatusOnly(true).call();
    for (DiffEntry entry : diffs) {
        if (UtilTools.isJavaFile(entry.getOldPath()) || UtilTools.isJavaFile(entry.getNewPath())) {
            String pathNew = "/dev/null".equals(entry.getNewPath()) ? null : entry.getNewPath();
            String pathOld = "/dev/null".equals(entry.getOldPath()) ? null : entry.getOldPath();
            GitFile file = new GitFile(pathOld, pathNew, entry.getChangeType());
            mapDiff.get(entry.getChangeType()).add(file);
        }
    }
    return mapDiff;
}

10 View Complete Implementation : JGitBugTest.java
Copyright Apache License 2.0
Author : centic9
@Test
public void testRevWalkDisposeClosesReader() throws IOException {
    try (Repository repo = CookbookHelper.openJGitCookbookRepository()) {
        try (ObjectReader reader = repo.newObjectReader()) {
            try (RevWalk walk = new RevWalk(reader)) {
                walk.dispose();
                Ref head = repo.exactRef("refs/heads/master");
                System.out.println("Found head: " + head);
                ObjectLoader loader = reader.open(head.getObjectId());
                replacedertNotNull(loader);
            }
        }
    }
}

9 View Complete Implementation : ShowChangedFilesBetweenCommits.java
Copyright Apache License 2.0
Author : centic9
public static void main(String[] args) throws IOException, GitAPIException {
    try (Repository repository = CookbookHelper.openJGitCookbookRepository()) {
        // The {tree} will return the underlying tree-id instead of the commit-id itself!
        // For a description of what the carets do see e.g. http://www.paulboxley.com/blog/2011/06/git-caret-and-tilde
        // This means we are selecting the parent of the parent of the parent of the parent of current HEAD and
        // take the tree-ish of it
        ObjectId oldHead = repository.resolve("HEAD^^^^{tree}");
        ObjectId head = repository.resolve("HEAD^{tree}");
        System.out.println("Printing diff between tree: " + oldHead + " and " + head);
        // prepare the two iterators to compute the diff between
        try (ObjectReader reader = repository.newObjectReader()) {
            CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
            oldTreeIter.reset(reader, oldHead);
            CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
            newTreeIter.reset(reader, head);
            // finally get the list of changed files
            try (Git git = new Git(repository)) {
                List<DiffEntry> diffs = git.diff().setNewTree(newTreeIter).setOldTree(oldTreeIter).call();
                for (DiffEntry entry : diffs) {
                    System.out.println("Entry: " + entry);
                }
            }
        }
    }
    System.out.println("Done");
}

9 View Complete Implementation : JGitDiffPage.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * Show changes between index and working tree.
 *
 * @param formatter
 *            diff formatter
 * @return list of diff entries
 * @throws IOException
 *             if any i/o errors occurs
 */
private List<DiffEntry> indexToWorkingTree(DiffFormatter formatter) throws IOException {
    DirCache dirCache = null;
    ObjectReader reader = repository.newObjectReader();
    List<DiffEntry> diff;
    try {
        dirCache = repository.lockDirCache();
        DirCacheIterator iterA = new DirCacheIterator(dirCache);
        FileTreeIterator iterB = new FileTreeIterator(repository);
        // Seems bug in DiffFormatter when work with working. Disable detect
        // renames by formatter and do it later.
        formatter.setDetectRenames(false);
        diff = formatter.scan(iterA, iterB);
        if (!request.isNoRenames()) {
            // Detect renames.
            RenameDetector renameDetector = createRenameDetector();
            ContentSource.Pair sourcePairReader = new ContentSource.Pair(ContentSource.create(reader), ContentSource.create(iterB));
            renameDetector.addAll(diff);
            diff = renameDetector.compute(sourcePairReader, NullProgressMonitor.INSTANCE);
        }
    } finally {
        reader.close();
        if (dirCache != null) {
            dirCache.unlock();
        }
    }
    return diff;
}

9 View Complete Implementation : UpdaterGenerator.java
Copyright GNU General Public License v3.0
Author : Neembuu-Uploader
/**
 * Populate all the files to update, if the system should update.
 */
private void populateDiff() {
    try {
        git.fetch().call();
        Repository repo = git.getRepository();
        ObjectId fetchHead = repo.resolve("FETCH_HEAD^{tree}");
        ObjectId head = repo.resolve("HEAD^{tree}");
        ObjectReader reader = repo.newObjectReader();
        CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
        oldTreeIter.reset(reader, head);
        CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
        newTreeIter.reset(reader, fetchHead);
        List<DiffEntry> diffs = git.diff().setShowNameAndStatusOnly(true).setNewTree(newTreeIter).setOldTree(oldTreeIter).call();
        pluginsToUpdate = new ArrayList<PluginToUpdate>();
        checkDiffEmpty(diffs);
    } catch (GitAPIException | IOException ex) {
        Logger.getLogger(UpdaterGenerator.clreplaced.getName()).log(Level.SEVERE, null, ex);
    }
}

8 View Complete Implementation : SMAGit.java
Copyright MIT License
Author : aesanch2
/**
 * Returns the blob information for the file at the specified path and commit
 *
 * @param repoItem
 * @param commit
 * @return
 * @throws Exception
 */
public byte[] getBlob(String repoItem, String commit) throws Exception {
    byte[] data;
    String parentPath = repository.getDirectory().getParent();
    ObjectId commitId = repository.resolve(commit);
    ObjectReader reader = repository.newObjectReader();
    RevWalk revWalk = new RevWalk(reader);
    RevCommit revCommit = revWalk.parseCommit(commitId);
    RevTree tree = revCommit.getTree();
    TreeWalk treeWalk = TreeWalk.forPath(reader, repoItem, tree);
    if (treeWalk != null) {
        data = reader.open(treeWalk.getObjectId(0)).getBytes();
    } else {
        throw new IllegalStateException("Did not find expected file '" + repoItem + "'");
    }
    reader.release();
    return data;
}

8 View Complete Implementation : DiffFilesInCommit.java
Copyright Apache License 2.0
Author : centic9
private static AbstractTreeIterator prepareTreeParser(Repository repository, String objectId) throws IOException {
    // from the commit we can build the tree which allows us to construct the TreeParser
    // noinspection Duplicates
    try (RevWalk walk = new RevWalk(repository)) {
        RevCommit commit = walk.parseCommit(repository.resolve(objectId));
        RevTree tree = walk.parseTree(commit.getTree().getId());
        CanonicalTreeParser treeParser = new CanonicalTreeParser();
        try (ObjectReader reader = repository.newObjectReader()) {
            treeParser.reset(reader, tree.getId());
        }
        walk.dispose();
        return treeParser;
    }
}

8 View Complete Implementation : ShowFileDiff.java
Copyright Apache License 2.0
Author : centic9
private static AbstractTreeIterator prepareTreeParser(Repository repository, String objectId) throws IOException {
    // from the commit we can build the tree which allows us to construct the TreeParser
    // noinspection Duplicates
    try (RevWalk walk = new RevWalk(repository)) {
        RevCommit commit = walk.parseCommit(ObjectId.fromString(objectId));
        RevTree tree = walk.parseTree(commit.getTree().getId());
        CanonicalTreeParser treeParser = new CanonicalTreeParser();
        try (ObjectReader reader = repository.newObjectReader()) {
            treeParser.reset(reader, tree.getId());
        }
        walk.dispose();
        return treeParser;
    }
}

8 View Complete Implementation : DiffHelper.java
Copyright MIT License
Author : dmusican
private static AbstractTreeIterator prepareTreeParser(Repository repository, String objectId) throws IOException {
    // from the commit we can build the tree which allows us to construct the TreeParser
    try (RevWalk walk = new RevWalk(repository)) {
        RevCommit commit = walk.parseCommit(ObjectId.fromString(objectId));
        RevTree tree = walk.parseTree(commit.getTree().getId());
        CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
        try (ObjectReader oldReader = repository.newObjectReader()) {
            oldTreeParser.reset(oldReader, tree.getId());
        }
        walk.dispose();
        return oldTreeParser;
    }
}

8 View Complete Implementation : RevisionServlet.java
Copyright Apache License 2.0
Author : google
@Override
protected void doGetText(HttpServletRequest req, HttpServletResponse res) throws IOException {
    GitilesView view = ViewFilter.getView(req);
    Repository repo = ServletUtils.getRepository(req);
    try (ObjectReader reader = repo.newObjectReader()) {
        ObjectLoader loader = reader.open(view.getRevision().getId());
        if (loader.getType() != OBJ_COMMIT) {
            throw new GitilesRequestFailureException(FailureReason.UNSUPPORTED_OBJECT_TYPE);
        }
        PathServlet.setTypeHeader(res, loader.getType());
        try (Writer writer = startRenderText(req, res);
            OutputStream out = BaseEncoding.base64().encodingStream(writer)) {
            loader.copyTo(out);
        }
    }
}

8 View Complete Implementation : GitRepoMetaData.java
Copyright Apache License 2.0
Author : jughyd
private static AbstractTreeIterator prepareTreeParser(Repository repository, String objectId) throws IOException, MissingObjectException, IncorrectObjectTypeException {
    RevWalk walk = new RevWalk(repository);
    RevCommit commit = walk.parseCommit(ObjectId.fromString(objectId));
    RevTree tree = walk.parseTree(commit.getTree().getId());
    CanonicalTreeParser oldTreeParser = new CanonicalTreeParser();
    ObjectReader oldReader = repository.newObjectReader();
    oldTreeParser.reset(oldReader, tree.getId());
    walk.dispose();
    return oldTreeParser;
}

7 View Complete Implementation : RewordActionHandler.java
Copyright BSD 3-Clause "New" or "Revised" License
Author : Coding
@Override
public RebaseResponse extractMessage(Repository repository) throws IOException {
    List<RebaseTodoLine> rebaseTodoLines = repository.readRebaseTodo(getRebasePath(repository, DONE), false);
    // the last rebase_todo_line
    RebaseTodoLine line = rebaseTodoLines.get(rebaseTodoLines.size() - 1);
    try (RevWalk walk = new RevWalk(repository)) {
        ObjectReader or = repository.newObjectReader();
        RevCommit commitToPick = walk.parseCommit(or.resolve(line.getCommit()).iterator().next());
        String oldMessage = commitToPick.getFullMessage();
        RebaseResponse response = new RebaseResponse(false, RebaseResponse.Status.INTERACTIVE_EDIT);
        response.setMessage(oldMessage);
        return response;
    }
}

7 View Complete Implementation : GitRepoMetaData.java
Copyright Apache License 2.0
Author : jughyd
// Given a commit index this API returns the diff between a commit and its parent.
// replaceduming only 1 parent.
public String getDiffBetweenCommits(int commitIndex) throws IOException, GitAPIException {
    if (commitIndex + 1 == commitCount)
        return "Nothing to Diff. This is first commit";
    AbstractTreeIterator current = prepareTreeParser(repository, commitSHA.get(commitIndex));
    AbstractTreeIterator parent = prepareTreeParser(repository, commitSHA.get(++commitIndex));
    ObjectReader reader = repository.newObjectReader();
    ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
    // finally get the list of changed files
    Git git = new Git(repository);
    List<DiffEntry> diff = git.diff().setOldTree(parent).setNewTree(current).call();
    for (DiffEntry entry : diff) {
        System.out.println("Entry: " + entry + ", from: " + entry.getOldId() + ", to: " + entry.getNewId());
        DiffFormatter formatter = new DiffFormatter(byteStream);
        formatter.setRepository(repository);
        formatter.format(entry);
    }
    // System.out.println(byteStream.toString());
    String diffContent = byteStream.toString();
    return byteStream.toString();
}

7 View Complete Implementation : UpdaterGenerator.java
Copyright GNU General Public License v3.0
Author : Neembuu-Uploader
/**
 * Populate all the files to update, if the system should update.
 */
private boolean populateDiff() {
    try {
        git.fetch().call();
        Repository repo = git.getRepository();
        ObjectId fetchHead = repo.resolve("FETCH_HEAD^{tree}");
        ObjectId head = repo.resolve("HEAD^{tree}");
        ObjectReader reader = repo.newObjectReader();
        CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
        oldTreeIter.reset(reader, head);
        CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
        newTreeIter.reset(reader, fetchHead);
        List<DiffEntry> diffs = git.diff().setShowNameAndStatusOnly(true).setNewTree(newTreeIter).setOldTree(oldTreeIter).call();
        if (diffs.isEmpty()) {
            System.out.println("No diff");
            return false;
        } else {
            return true;
        }
    } catch (GitAPIException | IOException ex) {
        Logger.getLogger(UpdaterGenerator.clreplaced.getName()).log(Level.SEVERE, null, ex);
    }
    // replacedume true
    return true;
}

6 View Complete Implementation : ShowBranchDiff.java
Copyright Apache License 2.0
Author : centic9
private static AbstractTreeIterator prepareTreeParser(Repository repository, String ref) throws IOException {
    // from the commit we can build the tree which allows us to construct the TreeParser
    Ref head = repository.exactRef(ref);
    try (RevWalk walk = new RevWalk(repository)) {
        RevCommit commit = walk.parseCommit(head.getObjectId());
        RevTree tree = walk.parseTree(commit.getTree().getId());
        CanonicalTreeParser treeParser = new CanonicalTreeParser();
        try (ObjectReader reader = repository.newObjectReader()) {
            treeParser.reset(reader, tree.getId());
        }
        walk.dispose();
        return treeParser;
    }
}

6 View Complete Implementation : JGitDiffPage.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * Show changes between specified revision and index. If
 * <code>commitId == null</code> then view changes between HEAD and index.
 *
 * @param commitId
 *            id of commit, preplaced <code>null</code> is the same as preplaced HEAD
 * @param formatter
 *            diff formatter
 * @return list of diff entries
 * @throws IOException
 *             if any i/o errors occurs
 */
private List<DiffEntry> commitToIndex(String commitId, DiffFormatter formatter) throws IOException {
    if (commitId == null) {
        commitId = Constants.HEAD;
    }
    ObjectId commitA = repository.resolve(commitId);
    if (commitA == null) {
        throw new IllegalArgumentException("Invalid commit id " + commitId);
    }
    RevTree treeA;
    try (RevWalk revWalkA = new RevWalk(repository)) {
        treeA = revWalkA.parseTree(commitA);
    }
    DirCache dirCache = null;
    List<DiffEntry> diff;
    try (ObjectReader reader = repository.newObjectReader()) {
        dirCache = repository.lockDirCache();
        CanonicalTreeParser iterA = new CanonicalTreeParser();
        iterA.reset(reader, treeA);
        DirCacheIterator iterB = new DirCacheIterator(dirCache);
        if (!request.isNoRenames()) {
            // Use embedded RenameDetector it works well with index and
            // revision history.
            formatter.setDetectRenames(true);
            int renameLimit = request.getRenameLimit();
            if (renameLimit > 0) {
                formatter.getRenameDetector().setRenameLimit(renameLimit);
            }
        }
        diff = formatter.scan(iterA, iterB);
    } finally {
        if (dirCache != null) {
            dirCache.unlock();
        }
    }
    return diff;
}

6 View Complete Implementation : GitUtils.java
Copyright MIT License
Author : jenkinsci
// TODO - remove once https://github.com/spotbugs/spotbugs/issues/756 is resolved
@SuppressFBWarnings(value = { "RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE" }, justification = "JDK11 produces different bytecode - https://github.com/spotbugs/spotbugs/issues/756")
static byte[] readFile(Repository repository, String ref, String filePath) {
    try (ObjectReader reader = repository.newObjectReader()) {
        // repository.exactRef(ref);
        ObjectId branchRef = repository.resolve(ref);
        if (branchRef != null) {
            // for empty repositories, branchRef may be null
            RevWalk revWalk = new RevWalk(repository);
            RevCommit commit = revWalk.parseCommit(branchRef);
            // and using commit's tree find the path
            RevTree tree = commit.getTree();
            TreeWalk treewalk = TreeWalk.forPath(reader, filePath, tree);
            if (treewalk != null) {
                // use the blob id to read the file's data
                return reader.open(treewalk.getObjectId(0)).getBytes();
            }
        }
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    return null;
}

5 View Complete Implementation : JGitDiffPage.java
Copyright Eclipse Public License 1.0
Author : codenvy-legacy
/**
 * Show changes between specified revision and working tree.
 *
 * @param commitId
 *            id of commit
 * @param formatter
 *            diff formatter
 * @return list of diff entries
 * @throws IOException
 *             if any i/o errors occurs
 */
private List<DiffEntry> commitToWorkingTree(String commitId, DiffFormatter formatter) throws IOException {
    ObjectId commitA = repository.resolve(commitId);
    if (commitA == null) {
        File heads = new File(repository.getWorkTree().getPath() + "/.git/refs/heads");
        if (heads.exists() && heads.list().length == 0) {
            return Collections.emptyList();
        }
        throw new IllegalArgumentException("Invalid commit id " + commitId);
    }
    RevTree treeA;
    try (RevWalk revWalkA = new RevWalk(repository)) {
        treeA = revWalkA.parseTree(commitA);
    }
    List<DiffEntry> diff;
    try (ObjectReader reader = repository.newObjectReader()) {
        CanonicalTreeParser iterA = new CanonicalTreeParser();
        iterA.reset(reader, treeA);
        FileTreeIterator iterB = new FileTreeIterator(repository);
        // Seems bug in DiffFormatter when work with working. Disable detect
        // renames by formatter and do it later.
        formatter.setDetectRenames(false);
        diff = formatter.scan(iterA, iterB);
        if (!request.isNoRenames()) {
            // Detect renames.
            RenameDetector renameDetector = createRenameDetector();
            ContentSource.Pair sourcePairReader = new ContentSource.Pair(ContentSource.create(reader), ContentSource.create(iterB));
            renameDetector.addAll(diff);
            diff = renameDetector.compute(sourcePairReader, NullProgressMonitor.INSTANCE);
        }
    }
    return diff;
}

5 View Complete Implementation : VersionedMetaDataOnInit.java
Copyright Apache License 2.0
Author : gerrit-review
protected void save(PersonIdent ident, String msg) throws IOException, ConfigInvalidException {
    File path = getPath();
    if (path == null) {
        throw new IOException(project + " does not exist.");
    }
    try (Repository repo = new FileRepository(path);
        ObjectInserter i = repo.newObjectInserter();
        ObjectReader r = repo.newObjectReader();
        RevWalk rw = new RevWalk(r)) {
        inserter = i;
        reader = r;
        RevTree srcTree = revision != null ? rw.parseTree(revision) : null;
        newTree = readTree(srcTree);
        CommitBuilder commit = new CommitBuilder();
        commit.setAuthor(ident);
        commit.setCommitter(ident);
        commit.setMessage(msg);
        onSave(commit);
        ObjectId res = newTree.writeTree(inserter);
        if (res.equals(srcTree)) {
            return;
        }
        commit.setTreeId(res);
        if (revision != null) {
            commit.addParentId(revision);
        }
        ObjectId newRevision = inserter.insert(commit);
        updateRef(repo, ident, newRevision, "commit: " + msg);
        revision = rw.parseCommit(newRevision);
    } finally {
        inserter = null;
        reader = null;
    }
}

5 View Complete Implementation : RefTreeUpdateCommand.java
Copyright Apache License 2.0
Author : kiegroup
private void commit(final Repository repo, final RevCommit original, final BiFunction fun) throws IOException {
    try (final ObjectReader reader = repo.newObjectReader();
        final ObjectInserter inserter = repo.newObjectInserter();
        final RevWalk rw = new RevWalk(reader)) {
        final RefTreeDatabase refdb = (RefTreeDatabase) repo.getRefDatabase();
        final RefDatabase bootstrap = refdb.getBootstrap();
        final RefUpdate refUpdate = bootstrap.newUpdate(refdb.getTxnCommitted(), false);
        final CommitBuilder cb = new CommitBuilder();
        final Ref ref = bootstrap.exactRef(refdb.getTxnCommitted());
        final RefTree tree;
        if (ref != null && ref.getObjectId() != null) {
            tree = RefTree.read(reader, rw.parseTree(ref.getObjectId()));
            cb.setParentId(ref.getObjectId());
            refUpdate.setExpectedOldObjectId(ref.getObjectId());
        } else {
            tree = RefTree.newEmptyTree();
            refUpdate.setExpectedOldObjectId(ObjectId.zeroId());
        }
        if (fun.apply(reader, tree)) {
            final Ref ref2 = bootstrap.exactRef(refdb.getTxnCommitted());
            if (ref2 == null || ref2.getObjectId().equals(ref != null ? ref.getObjectId() : null)) {
                cb.setTreeId(tree.writeTree(inserter));
                if (original != null) {
                    cb.setAuthor(original.getAuthorIdent());
                    cb.setCommitter(original.getAuthorIdent());
                } else {
                    final PersonIdent personIdent = new PersonIdent("user", "[email protected]");
                    cb.setAuthor(personIdent);
                    cb.setCommitter(personIdent);
                }
                refUpdate.setNewObjectId(inserter.insert(cb));
                inserter.flush();
                final RefUpdate.Result result = refUpdate.update(rw);
                switch(result) {
                    case NEW:
                    case FAST_FORWARD:
                        break;
                    default:
                        throw new RuntimeException(repo.getDirectory() + " -> " + result.toString() + " : " + refUpdate.getName());
                }
                final File commited = new File(repo.getDirectory(), refdb.getTxnCommitted());
                final File accepted = new File(repo.getDirectory(), refdb.getTxnNamespace() + "accepted");
                Files.copy(commited.toPath(), accepted.toPath(), StandardCopyOption.REPLACE_EXISTING);
            }
        }
    }
}

4 View Complete Implementation : CheckoutIndex.java
Copyright Apache License 2.0
Author : apache
public void checkout() throws IOException, GitException {
    try (ObjectReader od = repository.newObjectReader();
        TreeWalk treeWalk = new TreeWalk(repository)) {
        Collection<String> relativePaths = Utils.getRelativePaths(repository.getWorkTree(), roots);
        if (!relativePaths.isEmpty()) {
            treeWalk.setFilter(PathFilterGroup.createFromStrings(relativePaths));
        }
        treeWalk.setRecursive(true);
        treeWalk.reset();
        treeWalk.addTree(new DirCacheIterator(cache));
        treeWalk.addTree(new FileTreeIterator(repository));
        String lastAddedPath = null;
        while (treeWalk.next() && !monitor.isCanceled()) {
            File path = new File(repository.getWorkTree(), treeWalk.getPathString());
            if (treeWalk.getPathString().equals(lastAddedPath)) {
                // skip conflicts
                continue;
            } else {
                lastAddedPath = treeWalk.getPathString();
            }
            DirCacheIterator dit = treeWalk.getTree(0, DirCacheIterator.clreplaced);
            FileTreeIterator fit = treeWalk.getTree(1, FileTreeIterator.clreplaced);
            if (dit != null && (recursively || directChild(roots, repository.getWorkTree(), path)) && (fit == null || fit.isModified(dit.getDirCacheEntry(), checkContent, od))) {
                // update entry
                listener.notifyFile(path, treeWalk.getPathString());
                checkoutEntry(repository, path, dit.getDirCacheEntry(), od);
            }
        }
    }
}

3 View Complete Implementation : GitService.java
Copyright Apache License 2.0
Author : cai3178940
/**
 * 获取暂存区和HEAD的差异
 *
 * @param repository
 * @return
 */
public String getStashDiff(Repository repository, String stash) {
    try (Git git = new Git(repository)) {
        ObjectId newTreeId = repository.resolve(stash + "^{tree}");
        ObjectId oldTreeId = repository.resolve("HEAD^{tree}");
        ObjectReader reader = repository.newObjectReader();
        CanonicalTreeParser oldTreeIter = new CanonicalTreeParser();
        oldTreeIter.reset(reader, oldTreeId);
        CanonicalTreeParser newTreeIter = new CanonicalTreeParser();
        newTreeIter.reset(reader, newTreeId);
        List<DiffEntry> diffs = git.diff().setNewTree(newTreeIter).setOldTree(oldTreeIter).call();
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        DiffFormatter df = new DiffFormatter(out);
        df.setRepository(repository);
        df.setDiffComparator(RawTextComparator.WS_IGNORE_ALL);
        df.setDetectRenames(true);
        df.format(diffs);
        return out.toString("UTF-8");
    } catch (GitAPIException e) {
        LOGGER.error("显示代码差异异常", e);
        throw new BusinessException(ErrorCode.INTERNAL_SERVER_ERROR, "显示代码差异异常");
    } catch (IOException e) {
        LOGGER.error("显示代码差异异常", e);
        throw new BusinessException(ErrorCode.INTERNAL_SERVER_ERROR, "显示代码差异异常");
    }
}

2 View Complete Implementation : SMAGit.java
Copyright MIT License
Author : aesanch2
/**
 * Replicates ls-tree for the current commit.
 *
 * @return Map containing the full path and the data for all items in the repository.
 * @throws IOException
 */
public Map<String, byte[]> getAllMetadata() throws Exception {
    Map<String, byte[]> contents = new HashMap<String, byte[]>();
    ObjectReader reader = repository.newObjectReader();
    ObjectId commitId = repository.resolve(curCommit);
    RevWalk revWalk = new RevWalk(reader);
    RevCommit commit = revWalk.parseCommit(commitId);
    RevTree tree = commit.getTree();
    TreeWalk treeWalk = new TreeWalk(reader);
    treeWalk.addTree(tree);
    treeWalk.setRecursive(false);
    while (treeWalk.next()) {
        if (treeWalk.isSubtree()) {
            treeWalk.enterSubtree();
        } else {
            String member = treeWalk.getPathString();
            if (member.contains(SOURCEDIR)) {
                byte[] data = getBlob(member, curCommit);
                contents.put(member, data);
            }
        }
    }
    reader.release();
    return contents;
}

1 View Complete Implementation : CherryPickTest.java
Copyright Apache License 2.0
Author : apache
public void testCherryPickCommitsConflictQuit() throws Exception {
    File f = new File(workDir, "f");
    write(f, "init");
    add(f);
    commit(f);
    File[] roots = new File[] { f };
    GitClient client = getClient(workDir);
    client.createBranch(BRANCH, Constants.MASTER, NULL_PROGRESS_MONITOR);
    client.checkoutRevision(BRANCH, true, NULL_PROGRESS_MONITOR);
    write(f, "change 1 on branch");
    add(f);
    GitRevisionInfo c1 = client.commit(roots, "on branch 1\nblablabla", null, null, NULL_PROGRESS_MONITOR);
    write(f, "change 2 on branch");
    add(f);
    GitRevisionInfo c2 = client.commit(roots, "on branch 2", null, null, NULL_PROGRESS_MONITOR);
    write(f, "change 3 on branch");
    add(f);
    GitRevisionInfo c3 = client.commit(roots, "on branch 3\nBLABLABLA", null, null, NULL_PROGRESS_MONITOR);
    client.checkoutRevision(Constants.MASTER, true, NULL_PROGRESS_MONITOR);
    GitRevisionInfo initCommit = client.log("HEAD", NULL_PROGRESS_MONITOR);
    GitCherryPickResult res = client.cherryPick(GitClient.CherryPickOperation.BEGIN, new String[] { c1.getRevision(), c3.getRevision() }, NULL_PROGRESS_MONITOR);
    replacedertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());
    replacedertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);
    ObjectReader or = repository.newObjectReader();
    RevCommit commit = Utils.findCommit(repository, c3.getRevision());
    replacedertEquals("pick " + or.abbreviate(commit).name() + " " + commit.getShortMessage(), read(new File(repository.getDirectory(), "sequencer/todo")));
    res = client.cherryPick(GitClient.CherryPickOperation.QUIT, null, NULL_PROGRESS_MONITOR);
    replacedertEquals(GitCherryPickResult.CherryPickStatus.CONFLICTING, res.getCherryPickStatus());
    replacedertEquals(1, res.getConflicts().size());
    replacedertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);
    replacedertStatus(client.getStatus(roots, NULL_PROGRESS_MONITOR), workDir, f, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, true);
    replacedertEquals(RepositoryState.CHERRY_PICKING, repository.getRepositoryState());
    res = client.cherryPick(GitClient.CherryPickOperation.ABORT, null, NULL_PROGRESS_MONITOR);
    replacedertEquals(GitCherryPickResult.CherryPickStatus.ABORTED, res.getCherryPickStatus());
    replacedertEquals(initCommit.getRevision(), res.getCurrentHead().getParents()[0]);
    replacedertStatus(client.getStatus(roots, NULL_PROGRESS_MONITOR), workDir, f, true, Status.STATUS_NORMAL, Status.STATUS_NORMAL, Status.STATUS_NORMAL, false);
}