Example usage for org.eclipse.jgit.revwalk RevWalk iterator

List of usage examples for org.eclipse.jgit.revwalk RevWalk iterator

Introduction

In this page you can find the example usage for org.eclipse.jgit.revwalk RevWalk iterator.

Prototype

@Override
public Iterator<RevCommit> iterator() 

Source Link

Document

Returns an Iterator over the commits of this walker.

Usage

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

License:Open Source License

private void _run() throws IOException, MinerException, SQLException {
    FileRepositoryBuilder builder = new FileRepositoryBuilder();
    Repository repository = builder.setGitDir(new File(settings.srcLocalPath, ".git")).readEnvironment()
            .findGitDir().build();// ww w  . jav a 2  s .co  m

    /*
    Map<String,Ref> refs = repository.getAllRefs();
    for (Map.Entry<String, Ref> ref : refs.entrySet ()) {
       System.out.println (ref.getKey ());
    }
    */

    Ref head = repository.getRef(startRef);
    if (head == null) {
        throw new MinerException("Unknown reference: '" + startRef + "'");
    }

    RevWalk walk = new RevWalk(repository);
    RevCommit commit = walk.parseCommit(head.getObjectId());
    walk.markStart(commit);
    walk.sort(RevSort.REVERSE);

    // count commit: (fast)
    int commitCount = 0;
    Iterator<RevCommit> iter = walk.iterator();
    while (iter.hasNext()) {
        iter.next();
        commitCount++;
    }

    emitTasksTotal(commitCount);

    // process commits: (slow)
    walk.reset();
    walk.markStart(commit);
    walk.sort(RevSort.REVERSE);

    Map<String, ManagedFile> fileCache = new HashMap<String, ManagedFile>();

    for (RevCommit rev : walk) {
        if (stopped == true) {
            break;
        }

        processCommit(repository, walk, rev, fileCache);
    }

    walk.dispose();
    repository.close();
}

From source file:ch.sourcepond.maven.release.scm.git.GitRepository.java

License:Apache License

@Override
public boolean hasChangedSince(final String modulePath, final List<String> childModules,
        final Collection<ProposedTag> tags) throws SCMException {
    final RevWalk walk = new RevWalk(getGit().getRepository());
    try {//  w ww. java2  s. c  o m
        walk.setRetainBody(false);
        walk.markStart(walk.parseCommit(getGit().getRepository().findRef("HEAD").getObjectId()));
        filterOutOtherModulesChanges(modulePath, childModules, walk);
        stopWalkingWhenTheTagsAreHit(tags, walk);

        final Iterator<RevCommit> it = walk.iterator();
        boolean changed = it.hasNext();

        if (config.isIncrementSnapshotVersionAfterRelease() && changed) {
            final RevCommit commit = it.next();
            walk.parseBody(commit);
            changed = !SNAPSHOT_COMMIT_MESSAGE.equals(commit.getShortMessage()) || it.hasNext();
        }

        return changed;
    } catch (final IOException e) {
        throw new SCMException(e, "Diff detector could not determine whether module %s has been changed!",
                modulePath);
    } finally {
        walk.dispose();
    }
}

From source file:com.gitblit.utils.IssueUtils.java

License:Apache License

/**
 * Returns all the issues in the repository. Querying issues from the
 * repository requires deserializing all changes for all issues. This is an
 * expensive process and not recommended. Issues should be indexed by Lucene
 * and queries should be executed against that index.
 * // w  ww . j  a  v  a 2 s. c o  m
 * @param repository
 * @param filter
 *            optional issue filter to only return matching results
 * @return a list of issues
 */
public static List<IssueModel> getIssues(Repository repository, IssueFilter filter) {
    List<IssueModel> list = new ArrayList<IssueModel>();
    RefModel issuesBranch = getIssuesBranch(repository);
    if (issuesBranch == null) {
        return list;
    }

    // Collect the set of all issue paths
    Set<String> issuePaths = new HashSet<String>();
    final TreeWalk tw = new TreeWalk(repository);
    try {
        RevCommit head = JGitUtils.getCommit(repository, GB_ISSUES);
        tw.addTree(head.getTree());
        tw.setRecursive(false);
        while (tw.next()) {
            if (tw.getDepth() < 2 && tw.isSubtree()) {
                tw.enterSubtree();
                if (tw.getDepth() == 2) {
                    issuePaths.add(tw.getPathString());
                }
            }
        }
    } catch (IOException e) {
        error(e, repository, "{0} failed to query issues");
    } finally {
        tw.release();
    }

    // Build each issue and optionally filter out unwanted issues

    for (String issuePath : issuePaths) {
        RevWalk rw = new RevWalk(repository);
        try {
            RevCommit start = rw.parseCommit(repository.resolve(GB_ISSUES));
            rw.markStart(start);
        } catch (Exception e) {
            error(e, repository, "Failed to find {1} in {0}", GB_ISSUES);
        }
        TreeFilter treeFilter = AndTreeFilter.create(PathFilterGroup.createFromStrings(issuePath),
                TreeFilter.ANY_DIFF);
        rw.setTreeFilter(treeFilter);
        Iterator<RevCommit> revlog = rw.iterator();

        List<RevCommit> commits = new ArrayList<RevCommit>();
        while (revlog.hasNext()) {
            commits.add(revlog.next());
        }

        // release the revwalk
        rw.release();

        if (commits.size() == 0) {
            LOGGER.warn("Failed to find changes for issue " + issuePath);
            continue;
        }

        // sort by commit order, first commit first
        Collections.reverse(commits);

        StringBuilder sb = new StringBuilder("[");
        boolean first = true;
        for (RevCommit commit : commits) {
            if (!first) {
                sb.append(',');
            }
            String message = commit.getFullMessage();
            // commit message is formatted: C ISSUEID\n\nJSON
            // C is an single char commit code
            // ISSUEID is an SHA-1 hash
            String json = message.substring(43);
            sb.append(json);
            first = false;
        }
        sb.append(']');

        // Deserialize the JSON array as a Collection<Change>, this seems
        // slightly faster than deserializing each change by itself.
        Collection<Change> changes = JsonUtils.fromJsonString(sb.toString(),
                new TypeToken<Collection<Change>>() {
                }.getType());

        // create an issue object form the changes
        IssueModel issue = buildIssue(changes, true);

        // add the issue, conditionally, to the list
        if (filter == null) {
            list.add(issue);
        } else {
            if (filter.accept(issue)) {
                list.add(issue);
            }
        }
    }

    // sort the issues by creation
    Collections.sort(list);
    return list;
}

From source file:com.tasktop.c2c.server.scm.service.GitServiceBean.java

License:Open Source License

@Secured({ Role.Observer, Role.User })
@Override//from www  .  j  a v  a 2s .  com
public List<Commit> getLogForBranch(String repoName, String branchName, Region region)
        throws EntityNotFoundException {
    if (region == null) {
        region = new Region(0, 100);
    }
    try {
        Repository repo;
        repo = findRepositoryByName(repoName);

        RevWalk revWal = new RevWalk(repo);

        Ref branchRef = repo.getRef(branchName);
        if (branchRef == null) {
            throw new EntityNotFoundException();
        }
        revWal.markStart(revWal.parseCommit(branchRef.getObjectId()));

        Iterator<RevCommit> iterator = revWal.iterator();

        int current = 0;
        // Skip the first
        while (current < region.getOffset() && iterator.hasNext()) {
            current++;
            iterator.next();
        }
        int page = 0;

        List<Commit> result = new ArrayList<Commit>();
        while (iterator.hasNext() && page < region.getSize()) {
            RevCommit commit = iterator.next();
            result.add(GitDomain.createCommit(commit));
            page++;
        }

        return result;

    } catch (IOException e) {
        throw new RuntimeException(e);
    } catch (URISyntaxException e) {
        throw new RuntimeException(e);
    }
}

From source file:eu.hohenegger.gitmine.jgit.impl.MiningService.java

License:Open Source License

@Override
public Map<PersonIdent, List<RevCommit>> scanAuthors(Repository repository) throws IOException {
    HashMap<PersonIdent, List<RevCommit>> result = new HashMap<>();

    RevWalk revwalk = new RevWalk(repository);
    ObjectId HEAD = repository.resolve(HEAD_REF);
    revwalk.markStart(revwalk.parseCommit(HEAD));
    Iterator<RevCommit> it = revwalk.iterator();
    while (it.hasNext()) {
        RevCommit commit = it.next();/* w  w  w .  j  a  v a  2  s. c o  m*/
        if (!result.containsKey(commit.getAuthorIdent())) {
            List<RevCommit> list = new ArrayList<>();
            list.add(commit);
            result.put(commit.getAuthorIdent(), list);
        } else {
            result.get(commit.getAuthorIdent()).add(commit);
        }
    }

    return result;
}

From source file:eu.hohenegger.gitmine.jgit.impl.MiningService.java

License:Open Source License

@Override
public List<Integer> scanCommitsPerDay(Repository repository) throws IOException {
    Map<Long, List<RevCommit>> result = new TreeMap<>();

    RevWalk revwalk = new RevWalk(repository);
    ObjectId HEAD;/*from  w  ww .  j  a  v a2 s.c o m*/
    HEAD = repository.resolve(HEAD_REF);
    revwalk.markStart(revwalk.parseCommit(HEAD));
    Iterator<RevCommit> it = revwalk.iterator();
    Long dayDate = 0l;
    while (it.hasNext()) {
        RevCommit commit = it.next();

        Long currentCommitDay = getCommitDay(commit);
        //         List<Date> daysInBetween = getDaysInBetween(dayDate, currentCommitDay);
        //         for (Date dayInBetween : daysInBetween) {
        //            result.put(dayInBetween.getTime(), new ArrayList<RevCommit>());
        //         }
        dayDate = currentCommitDay;
        if (!result.containsKey(dayDate)) {
            List<RevCommit> list = new ArrayList<>();
            list.add(commit);
            result.put(dayDate, list);
        } else {
            result.get(dayDate).add(commit);
        }

    }

    Long firstDay = result.keySet().iterator().next();
    List<Integer> result2 = new ArrayList<>();
    for (long i = firstDay + MILLISECONDS_IN_A_DAY; i < new Date().getTime(); i += MILLISECONDS_IN_A_DAY) {
        if (result.containsKey(i)) {
            result2.add(result.get(i).size());
        } else {
            result2.add(0);
        }
    }

    //      Set<Long> keySet = result.keySet();
    //      dayDate = 0l;
    //      List<Long> result2 = new ArrayList<>();
    //      for (Long currentCommitDay : keySet) {
    //         List<Date> daysInBetween = getDaysInBetween(dayDate, currentCommitDay);
    //         for (Date dayInBetween : daysInBetween) {
    //            result2.add(dayInBetween.getTime());
    //         }
    //         dayDate = currentCommitDay;
    //      }
    //      for (Long long1 : result2) {
    //         result.put(long1, new ArrayList<RevCommit>());   
    //      }

    return result2;
}

From source file:jbenchmarker.GitMain.java

License:Open Source License

private boolean gotMerge(String gitdir, String path) throws IOException {
    FileRepositoryBuilder builder = new FileRepositoryBuilder();
    Repository repo = builder.setGitDir(new File(gitdir + "/.git")).readEnvironment().findGitDir().build();
    RevWalk revwalk = new RevWalk(repo);
    revwalk.setTreeFilter(AndTreeFilter.create(PathFilter.create(path), TreeFilter.ANY_DIFF));
    revwalk.markStart(revwalk.parseCommit(repo.resolve("HEAD")));
    Iterator<RevCommit> it = revwalk.iterator();
    while (it.hasNext()) {
        if (it.next().getParentCount() > 1) {
            return true;
        }//from   ww w. j  a v a2s  . c om
    }
    return false;
}

From source file:jbenchmarker.trace.git.GitExtraction.java

License:Open Source License

Commit parseRepository(String path) throws IOException {
    HashMap<String, String> paths = new HashMap<String, String>();
    HashMapSet<String, Integer> identifiers = new HashMapSet<String, Integer>();
    HashMapSet<String, String> children = new HashMapSet<String, String>();
    int freeId = 2;
    Commit head = null;/*from  w w  w . j a  va  2  s  . c  om*/

    RevWalk revwalk = new RevWalk(repository);
    revwalk.sort(RevSort.TOPO);
    if (path != null) {
        revwalk.setTreeFilter(AndTreeFilter.create(PathFilter.create(path), TreeFilter.ANY_DIFF));
    }
    revwalk.markStart(revwalk.parseCommit(repository.resolve("HEAD")));
    Iterator<RevCommit> it = revwalk.iterator();

    while (it.hasNext()) {
        RevCommit commit = it.next();
        Commit co = new Commit(commit, children.getAll(ObjectId.toString(commit)));
        if (head == null) {
            // Head commit
            co.setId("HEAD");
            head = co;
            if (path != null) {
                paths.put("HEAD", path);
            }
            identifiers.put("HEAD", 1);
        }
        co.setReplica(Collections.min(identifiers.getAll(co.getId())));

        if (GitTrace.DEBUG || commit.getParentCount() > 1) {
            // Merge case -> store state
            List<String> mpaths = new LinkedList<String>();
            List<byte[]> mraws = new LinkedList<byte[]>();
            TreeWalk twalk = walker(commit, path); // paths.get(co.getId()));
            while (twalk.next()) {
                ObjectId id = twalk.getObjectId(0);
                mpaths.add(twalk.getPathString());
                mraws.add(open(twalk.getPathString(), id));
            }
            patchCrud.add(new Patch(co, mpaths, mraws));
        }

        if (commit.getParentCount() > 1) {
            ++nbrMergeBefore;
        }

        if (commit.getParentCount() == 0) {
            // Final case : patch without parent
            List<FileEdition> edits = new LinkedList<FileEdition>();
            TreeWalk walk = walker(commit, path); // paths.get(co.getId()));
            while (walk.next()) {
                ObjectId id = walk.getObjectId(0);
                edits.add(new FileEdition(walk.getPathString(),
                        diff(new byte[0], open(walk.getPathString(), id))));
            }
            patchCrud.add(new Patch(co, edits));
        } else {
            detectRevert(commit);
            // Computes replica identifiers
            Iterator<Integer> itid = identifiers.getAll(co.getId()).iterator();

            for (int p = 0; p < commit.getParentCount(); ++p) {
                RevCommit parent = commit.getParent(p);
                String parentId = ObjectId.toString(parent);
                children.put(parentId, co.getId());

                // compute diff
                if (commit.getParentCount() == 1) {
                    List<FileEdition> edits = new LinkedList<FileEdition>();
                    TreeWalk walk = walker(commit, parent, path); // paths.get(co.getId()));
                    for (DiffEntry entry : DiffEntry.scan(walk)) {
                        edits.add(createDiffResult(entry));
                        if (path != null) {
                            paths.put(parentId, entry.getOldPath());
                        }
                    }
                    patchCrud.add(new Patch(co, parent, edits));
                }

                if (itid.hasNext()) {
                    identifiers.put(parentId, itid.next());
                } else if (!identifiers.containsKey(ObjectId.toString(parent))) {
                    identifiers.put(parentId, freeId);
                    ++freeId;
                }
            }

            int i = 0;
            while (itid.hasNext()) {
                identifiers.put(ObjectId.toString(commit.getParent(i)), itid.next());
                i = (i + 1) % commit.getParentCount();
            }
        }
        commitCrud.add(co);
    }
    return head;
}

From source file:org.kuali.student.cleaner.TestFusionDataAwareRevSort.java

License:Educational Community License

@Test
public void testComparatorTopoEquivilenceWithThreeAggregateCommitsAndTwoPerModule() throws IOException {

    GitTreeProcessor treeProcessor = new GitTreeProcessor(repo);

    ObjectId initialAggregateHeadId = aggregateHeadRevCommit.getId();

    GitTreeData tree = treeProcessor.extractExistingTreeDataFromCommit(initialAggregateHeadId);

    ObjectInserter inserter = repo.newObjectInserter();

    super.storeFile(inserter, tree, "Readme.txt", "test file content");

    ObjectId newCommit = commit(repo.newObjectInserter(), tree, "second commit on aggregate branch",
            initialAggregateHeadId);//from  ww w  .j  a  v a2 s.  co m

    createBranch(newCommit, "aggregate");

    aggregateHeadRevCommit = rw.parseCommit(newCommit);

    // add a third commit

    ObjectId middleAggregateHeadId = newCommit;

    tree = treeProcessor.extractExistingTreeDataFromCommit(middleAggregateHeadId);

    super.storeFile(inserter, tree, "Readme.txt", "third file content");

    newCommit = commit(repo.newObjectInserter(), tree, "third commit on aggregate branch",
            middleAggregateHeadId);

    createBranch(newCommit, "aggregate");

    aggregateHeadRevCommit = rw.parseCommit(newCommit);

    // second commit to module1
    ObjectId existingModule1CommitId = branch1HeadRevCommit.getId();

    // second commit to module2
    ObjectId existingModule2CommitId = branch2HeadRevCommit.getId();

    /*
     * Sort the commits using a comparator and make sure the results are the same as with the TopoGenerator
     */

    List<RevCommit> commits = new LinkedList<RevCommit>();

    RevWalk rw = new RevWalk(repo);

    rw.markStart(branch1HeadRevCommit);
    rw.markStart(branch2HeadRevCommit);
    rw.markStart(aggregateHeadRevCommit);

    Iterator<RevCommit> iterator = rw.iterator();

    ObjectIdTranslationMapImpl translator = new ObjectIdTranslationMapImpl();

    RevCommitBitMapIndex index = new RevCommitBitMapIndex(repo, translator, iterator);

    commits = new LinkedList<RevCommit>(index.getRevCommitList());

    Collections.sort(commits, new FusionAwareTopoSortComparator(index));

    commits = new LinkedList<RevCommit>(index.getRevCommitList());

    Collections.sort(commits, new FusionAwareTopoSortComparator(index));

    iterator = commits.iterator();

    RevCommit candidate = null;
    RevCommit secondLastCandidate = null;
    RevCommit thirdLastCandidate = null;

    while (iterator.hasNext()) {

        if (secondLastCandidate != null)
            thirdLastCandidate = secondLastCandidate;

        if (candidate != null)
            secondLastCandidate = candidate;

        candidate = iterator.next();

        log.info("candidate = " + candidate.getId().name());

    }

    Assert.assertEquals(initialAggregateHeadId, thirdLastCandidate.getId());
    Assert.assertEquals(middleAggregateHeadId, secondLastCandidate.getId());
    Assert.assertEquals(aggregateHeadRevCommit.getId(), candidate.getId());

}

From source file:org.kuali.student.cleaner.TestFusionDataAwareRevSort.java

License:Educational Community License

@Test
public void testComparatorTopoEquivilenceWithThreeAggregateCommits() throws IOException {

    GitTreeProcessor treeProcessor = new GitTreeProcessor(repo);

    ObjectId initialAggregateHeadId = aggregateHeadRevCommit.getId();

    GitTreeData tree = treeProcessor.extractExistingTreeDataFromCommit(initialAggregateHeadId);

    ObjectInserter inserter = repo.newObjectInserter();

    super.storeFile(inserter, tree, "Readme.txt", "test file content");

    ObjectId newCommit = commit(repo.newObjectInserter(), tree, "second commit on aggregate branch",
            initialAggregateHeadId);//from  ww  w.  ja  v  a2 s  .co  m

    createBranch(newCommit, "aggregate");

    aggregateHeadRevCommit = rw.parseCommit(newCommit);

    // add a third commit

    ObjectId middleAggregateHeadId = newCommit;

    tree = treeProcessor.extractExistingTreeDataFromCommit(middleAggregateHeadId);

    super.storeFile(inserter, tree, "Readme.txt", "third file content");

    newCommit = commit(repo.newObjectInserter(), tree, "third commit on aggregate branch",
            middleAggregateHeadId);

    createBranch(newCommit, "aggregate");

    aggregateHeadRevCommit = rw.parseCommit(newCommit);

    /*
     * Sort the commits using a comparator and make sure the results are the same as with the TopoGenerator
     */

    List<RevCommit> commits = new LinkedList<RevCommit>();

    RevWalk rw = new RevWalk(repo);

    rw.markStart(branch1HeadRevCommit);
    rw.markStart(branch2HeadRevCommit);
    rw.markStart(aggregateHeadRevCommit);

    Iterator<RevCommit> iterator = rw.iterator();

    ObjectIdTranslationMapImpl translator = new ObjectIdTranslationMapImpl();

    RevCommitBitMapIndex index = new RevCommitBitMapIndex(repo, translator, iterator);

    commits = new LinkedList<RevCommit>(index.getRevCommitList());

    Collections.sort(commits, new FusionAwareTopoSortComparator(index));

    commits = new LinkedList<RevCommit>(index.getRevCommitList());

    Collections.sort(commits, new FusionAwareTopoSortComparator(index));

    iterator = commits.iterator();

    RevCommit candidate = null;
    RevCommit secondLastCandidate = null;
    RevCommit thirdLastCandidate = null;

    while (iterator.hasNext()) {

        if (secondLastCandidate != null)
            thirdLastCandidate = secondLastCandidate;

        if (candidate != null)
            secondLastCandidate = candidate;

        candidate = iterator.next();

        log.info("candidate = " + candidate.getId().name());

    }

    Assert.assertEquals(initialAggregateHeadId, thirdLastCandidate.getId());
    Assert.assertEquals(middleAggregateHeadId, secondLastCandidate.getId());
    Assert.assertEquals(aggregateHeadRevCommit.getId(), candidate.getId());

}