Example usage for org.eclipse.jgit.diff RenameDetector RenameDetector

List of usage examples for org.eclipse.jgit.diff RenameDetector RenameDetector

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.diff.*
  5. RenameDetector
  6. RenameDetector

Introduction

In this page you can find the example usage for org.eclipse.jgit.diff RenameDetector RenameDetector.

Prototype

public RenameDetector(Repository repo)

Source Link

Document

Create a new rename detector for the given repository

Usage

From source file:MyDiffFormatter.java

License:Eclipse Distribution License

/**
 * Enable or disable rename detection./*  w  w  w. j av a  2  s.  c o  m*/
 * <p/>
 * Before enabling rename detection the repository must be set with
 * {@link #setRepository(Repository)}. Once enabled the detector can be
 * configured away from its defaults by obtaining the instance directly from
 * {@link #getRenameDetector()} and invoking configuration.
 *
 * @param on if rename detection should be enabled.
 */
public void setDetectRenames(boolean on) {
    if (on && renameDetector == null) {
        assertHaveRepository();
        renameDetector = new RenameDetector(db);
    } else if (!on)
        renameDetector = null;
}

From source file:com.microsoft.gittf.core.tasks.pendDiff.PendDifferenceTask.java

License:Open Source License

/**
 * Creates the CheckinAnalysisChangeCollection analysis object that includes
 * the list of pending changes needed that map to the differences between
 * the fromCommit and toCommit//ww  w  .  java2 s. com
 * 
 * @param repository
 *        the git repository
 * @param fromRootTree
 *        the from commit tree
 * @param toRootTree
 *        the to commit tree
 * @param renameMode
 *        the rename mode to use when generating the analysis
 * @param progressMonitor
 *        the progress monitor to use to report progress
 * @return
 * @throws Exception
 */
public static CheckinAnalysisChangeCollection analyzeDifferences(Repository repository, RevObject fromRootTree,
        RevObject toRootTree, RenameMode renameMode, final TaskProgressMonitor progressMonitor)
        throws Exception {
    Check.notNull(fromRootTree, "fromRootTree"); //$NON-NLS-1$
    Check.notNull(toRootTree, "toRootTree"); //$NON-NLS-1$
    Check.notNull(progressMonitor, "progressMonitor"); //$NON-NLS-1$

    progressMonitor.beginTask(Messages.getString("PendDifferencesTask.AnalyzingCommits"), //$NON-NLS-1$
            TaskProgressMonitor.INDETERMINATE, TaskProgressDisplay.DISPLAY_SUBTASK_DETAIL);

    /* Init the analysis object */
    final CheckinAnalysisChangeCollection analysis = new CheckinAnalysisChangeCollection(repository,
            fromRootTree, toRootTree);

    log.debug("Walking thru the git-repository tree.");

    /* Init the tree walker object */
    final TreeWalk treeWalker = new NameConflictTreeWalk(repository);
    final RenameDetector repositoryRenameDetector = new RenameDetector(repository);

    try {
        treeWalker.setRecursive(true);

        treeWalker.addTree(fromRootTree);
        treeWalker.addTree(toRootTree);

        treeWalker.setFilter(TreeFilter.ANY_DIFF);

        List<DiffEntry> treeDifferences = DiffEntry.scan(treeWalker);

        log.debug("The number of differences found: " + treeDifferences.size());

        /*
         * If we need to detect file renames then use the rename detector to
         * analayze the differences first
         */
        if (renameMode != RenameMode.NONE) {
            repositoryRenameDetector.addAll(treeDifferences);
            treeDifferences = repositoryRenameDetector.compute();
        }

        /*
         * If the rename mode is either none or file only then we do not
         * need to detect folder deletes as well, since deleting empty
         * folders that have items that have been renamed out is not
         * supported in TFS
         */
        if (renameMode != RenameMode.ALL) {
            analysis.setProcessDeletedFolders(false);
        }

        Map<String, DiffEntry> deleteChanges = new HashMap<String, DiffEntry>();
        Map<String, DiffEntry> addChanges = new HashMap<String, DiffEntry>();

        for (DiffEntry change : treeDifferences) {
            switch (change.getChangeType()) {
            case ADD:
                addChanges.put(change.getNewPath().toUpperCase(), change);
                break;

            case DELETE:
                deleteChanges.put(change.getOldPath().toUpperCase(), change);
                break;
            }
        }

        /* Append each change in to the analysis object */
        for (DiffEntry change : treeDifferences) {
            switch (change.getChangeType()) {
            case ADD:
            case COPY:
                if (!isCaseSensitiveRename(change, deleteChanges, addChanges)) {
                    analysis.pendAdd(new AddChange(change.getNewPath(),
                            CommitUtil.resolveAbbreviatedId(repository, change.getNewId())));
                    analysis.pendPropertyIfChanged(new PropertyChange(change.getNewPath(),
                            CommitUtil.resolveAbbreviatedId(repository, change.getNewId()),
                            change.getNewMode()));
                }
                break;

            case DELETE:
                if (isCaseSensitiveRename(change, deleteChanges, addChanges)) {
                    DiffEntry addChange = addChanges.get(change.getOldPath().toUpperCase());

                    analysis.pendRename(new RenameChange(change.getOldPath(), addChange.getNewPath(),
                            CommitUtil.resolveAbbreviatedId(repository, addChange.getNewId()),
                            !change.getOldId().equals(addChange.getNewId())));
                    analysis.pendPropertyIfChanged(new PropertyChange(addChange.getNewPath(),
                            CommitUtil.resolveAbbreviatedId(repository, addChange.getNewId()),
                            change.getOldMode(), addChange.getNewMode()));
                } else {
                    analysis.pendDelete(new DeleteChange(change.getOldPath(), change.getOldMode()));
                }
                break;

            case MODIFY:
                analysis.pendEdit(new EditChange(change.getNewPath(),
                        CommitUtil.resolveAbbreviatedId(repository, change.getNewId())));
                analysis.pendPropertyIfChanged(new PropertyChange(change.getNewPath(),
                        CommitUtil.resolveAbbreviatedId(repository, change.getNewId()), change.getOldMode(),
                        change.getNewMode()));
                break;

            case RENAME:
                analysis.pendRename(new RenameChange(change.getOldPath(), change.getNewPath(),
                        CommitUtil.resolveAbbreviatedId(repository, change.getNewId()),
                        !change.getOldId().equals(change.getNewId())));
                analysis.pendPropertyIfChanged(new PropertyChange(change.getNewPath(),
                        CommitUtil.resolveAbbreviatedId(repository, change.getNewId()), change.getOldMode(),
                        change.getNewMode()));
            }
        }
    } finally {
        if (treeWalker != null) {
            treeWalker.release();
        }

        progressMonitor.endTask();
    }

    log.debug("Walk thru the git-repository tree finished.");

    return analysis;
}

From source file:de.andreasgiemza.jgeagle.repo.rcs.JGit.java

License:Open Source License

/**
 *
 * Based on http://stackoverflow.com/a/11504177/2246865 by OneWorld
 *
 * @param follow/*from  w  w w .  j  a v  a2 s.  com*/
 * @param start
 * @param path
 * @return
 * @throws IOException
 * @throws GitAPIException
 */
private String getRenamedPath(boolean follow, RevCommit start, String path)
        throws IOException, GitAPIException {
    if (!follow) {
        return null;
    }

    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 deffE : files) {
            if ((deffE.getChangeType() == DiffEntry.ChangeType.RENAME
                    || deffE.getChangeType() == DiffEntry.ChangeType.COPY)
                    && deffE.getNewPath().contains(path)) {
                return deffE.getOldPath();
            }
        }
    }

    return null;
}

From source file:org.eclipse.che.git.impl.jgit.JGitDiffPage.java

License:Open Source License

private RenameDetector createRenameDetector() {
    RenameDetector renameDetector = new RenameDetector(repository);
    int renameLimit = request.getRenameLimit();
    if (renameLimit > 0) {
        renameDetector.setRenameLimit(renameLimit);
    }/* ww  w .  j  a  va2 s.  c  om*/
    return renameDetector;
}

From source file:org.eclipse.egit.bc.BeyondCompareRepositoryActionHandler.java

License:Open Source License

protected String getPreviousPath(Repository repository, ObjectReader reader, RevCommit headCommit,
        RevCommit previousCommit, String path) throws IOException {
    TreeWalk walk = new TreeWalk(reader);
    walk.setRecursive(true);/*  w w  w  .j a v a2  s.co m*/
    walk.addTree(previousCommit.getTree());
    walk.addTree(headCommit.getTree());

    List<DiffEntry> entries = DiffEntry.scan(walk);
    if (entries.size() < 2)
        return path;

    for (DiffEntry diff : entries)
        if (diff.getChangeType() == ChangeType.MODIFY && path.equals(diff.getNewPath()))
            return path;

    RenameDetector detector = new RenameDetector(repository);
    detector.addAll(entries);
    List<DiffEntry> renames = detector.compute(walk.getObjectReader(), NullProgressMonitor.INSTANCE);
    for (DiffEntry diff : renames)
        if (diff.getChangeType() == ChangeType.RENAME && path.equals(diff.getNewPath()))
            return diff.getOldPath();

    return path;
}

From source file:org.gitective.core.filter.commit.CommitDiffFilter.java

License:Open Source License

@Override
public CommitFilter setRepository(Repository repository) {
    if (detectRenames)
        renameDetector = new RenameDetector(repository);
    return super.setRepository(repository);
}

From source file:svnserver.repository.git.GitRepository.java

License:GNU General Public License

@NotNull
private Map<String, String> collectRename(@NotNull GitFile oldTree, @NotNull GitFile newTree)
        throws IOException {
    if (!renameDetection) {
        return Collections.emptyMap();
    }//from w ww.java  2s  .c o  m
    final GitObject<ObjectId> oldTreeId = oldTree.getObjectId();
    final GitObject<ObjectId> newTreeId = newTree.getObjectId();
    if (oldTreeId == null || newTreeId == null || !Objects.equals(oldTreeId.getRepo(), newTreeId.getRepo())) {
        return Collections.emptyMap();
    }
    final TreeWalk tw = new TreeWalk(repository);
    tw.setRecursive(true);
    tw.addTree(oldTree.getObjectId().getObject());
    tw.addTree(newTree.getObjectId().getObject());

    final RenameDetector rd = new RenameDetector(repository);
    rd.addAll(DiffEntry.scan(tw));

    final Map<String, String> result = new HashMap<>();
    for (DiffEntry diff : rd.compute(tw.getObjectReader(), null)) {
        if (diff.getScore() >= rd.getRenameScore()) {
            result.put(StringHelper.normalize(diff.getNewPath()), StringHelper.normalize(diff.getOldPath()));
        }
    }
    return result;
}