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!

  • git pull currently tracked branch
  • Git commit with no commit message
  • Git clear remote repository
  • Can we finally move to DVCS in Corporate Software? Is SVN still a 'must have' for development?
  • How can I use git-archive to include submodules from a bare repository
  • Is there a way with Git to make future merges ignore version number difference in a pom file between branches?
  • Do collaborators have commit access on GitHub?
  • How can I keep a subfolder of a git repo in sync with a subfolder of another git repo
  • To put the prefix ?<revision-number> to codes by Git/Svn
  • file grained vs line grained version control systems
  • Extending a version control system with custom delta algorithm
  • push failed ( merge returned `already up to date ` )
  • 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.