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!

  • Pull requests merged manually after a rebase don't show as merged on Github
  • Stash what I am currently working on, and revert back to the last commit
  • How to use git as source control provider for SQL Server Management Studio
  • How to get rid of constant “merge branch” from github by git
  • Integrate existing Git Repository with Perforce (P4)
  • How to git pull from public repo via ssh without a key?
  • Git rm --cached and checkout
  • How to rewrite git history to match a popular git workflow
  • Git format-patch vs git log -p
  • git cherry-pick configuration
  • How to set the working directory to an older commit?
  • Github Desktop - Not showing changes
  • 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.