How to “git log –follow <path>” in JGit? (To retrieve the full history including renames)

How do I have to extend the following logCommand, to get the --follow option of the git log command working?

Git git = new Git(myRepository);
Iterable<RevCommit> log = git.log().addPath("com/mycompany/myclass.java").call();

This option is implemented in jGit, but I don’t know how to use it. The logCommand’s methods don’t appear to be useful. Thank you!

  • why my file permission being changed after pull from git repository
  • Setting up read-only http access to git repo
  • Where does gitosis store the working copies?
  • git push origin head?
  • Get git tag of checked out revision?
  • Git is slow on pushing submodules change to origin
  • Which file permissions are impacted by Git's core.sharedrepository setting?
  • Including js from raw.github.com
  • Java Client to Connect to Stash Repository
  • How to check real git diff before merging from remote branch?
  • Git fetch failing using jgit: Remote does not have <branchname> available for fetch
  • When a commit to revision control requires a developer to change their own config
  • One Solution collect form web for “How to “git log –follow <path>” in JGit? (To retrieve the full history including renames)”

    During some midnight work I got the following:

    The last commit of a LogCommand will get checked for renames against all older commits until a rename operation is found. This cycle will continue until no rename was found.

    However, that search can take some time, especially if it iterates over all commits until the end and doesn’t find any rename operation anymore. So, I am open for any improvement. I guess git normally uses indexes to perform the follow option in shorter time.

    import org.eclipse.jgit.api.Git;
    import org.eclipse.jgit.api.errors.GitAPIException;
    import org.eclipse.jgit.diff.DiffEntry;
    import org.eclipse.jgit.diff.RenameDetector;
    import org.eclipse.jgit.errors.MissingObjectException;
    import org.eclipse.jgit.lib.Repository;
    import org.eclipse.jgit.revwalk.RevCommit;
    import org.eclipse.jgit.treewalk.TreeWalk;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Create a Log command that enables the follow option: git log --follow -- < path >
     * User: OneWorld
     * Example for usage: ArrayList<RevCommit> commits =  new  LogFollowCommand(repo,"src/com/mycompany/myfile.java").call();
     */
    public class LogFollowCommand {
    
        private final Repository repository;
        private String path;
        private Git git;
    
        /**
         * Create a Log command that enables the follow option: git log --follow -- < path >
         * @param repository
         * @param path
         */
        public LogFollowCommand(Repository repository, String path){
            this.repository = repository;
            this.path = path;
        }
    
        /**
         * Returns the result of a git log --follow -- < path >
         * @return
         * @throws IOException
         * @throws MissingObjectException
         * @throws GitAPIException
         */
        public ArrayList<RevCommit> call() throws IOException, MissingObjectException, GitAPIException {
            ArrayList<RevCommit> commits = new ArrayList<RevCommit>();
            git = new Git(repository);
            RevCommit start = null;
            do {
                Iterable<RevCommit> log = git.log().addPath(path).call();
                for (RevCommit commit : log) {
                    if (commits.contains(commit)) {
                        start = null;
                    } else {
                        start = commit;
                        commits.add(commit);
                    }
                }
                if (start == null) return commits;
            }
            while ((path = getRenamedPath( start)) != null);
    
            return commits;
        }
    
        /**
         * Checks for renames in history of a certain file. Returns null, if no rename was found.
         * Can take some seconds, especially if nothing is found... Here might be some tweaking necessary or the LogFollowCommand must be run in a thread.
         * @param start
         * @return String or null
         * @throws IOException
         * @throws MissingObjectException
         * @throws GitAPIException
         */
        private String getRenamedPath( RevCommit start) throws IOException, MissingObjectException, GitAPIException {
            Iterable<RevCommit> allCommitsLater = git.log().add(start).call();
            for (RevCommit commit : allCommitsLater) {
    
                TreeWalk tw = new TreeWalk(repository);
                tw.addTree(commit.getTree());
                tw.addTree(start.getTree());
                tw.setRecursive(true);
                RenameDetector rd = new RenameDetector(repository);
                rd.addAll(DiffEntry.scan(tw));
                List<DiffEntry> files = rd.compute();
                for (DiffEntry diffEntry : files) {
                    if ((diffEntry.getChangeType() == DiffEntry.ChangeType.RENAME || diffEntry.getChangeType() == DiffEntry.ChangeType.COPY) && diffEntry.getNewPath().contains(path)) {
                        System.out.println("Found: " + diffEntry.toString() + " return " + diffEntry.getOldPath());
                        return diffEntry.getOldPath();
                    }
                }
            }
            return null;
        }
    }
    
    Git Baby is a git and github fan, let's start git clone.