Java DiffEntry.getChangeType方法代码示例

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
private boolean hasMatchingChanges(Revision from, Revision to, PathPatternFilter filter) {
    try (RevWalk revWalk = new RevWalk(jGitRepository)) {
        final List<DiffEntry> diff =
                compareTrees(toTreeId(revWalk, from), toTreeId(revWalk, to), TreeFilter.ALL);
        for (DiffEntry e : diff) {
            final String path;
            switch (e.getChangeType()) {
            case ADD:
                path = e.getNewPath();
                break;
            case MODIFY:
            case DELETE:
                path = e.getOldPath();
                break;
            default:
                throw new Error();
            }

            if (filter.matches(path)) {
                return true;
            }
        }
    }

    return false;
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
private void notifyWatchers(Revision newRevision, ObjectId prevTreeId, ObjectId nextTreeId) {
    final List<DiffEntry> diff = compareTrees(prevTreeId, nextTreeId, TreeFilter.ALL);
    for (DiffEntry e: diff) {
        switch (e.getChangeType()) {
        case ADD:
            commitWatchers.notify(newRevision, e.getNewPath());
            break;
        case MODIFY:
        case DELETE:
            commitWatchers.notify(newRevision, e.getOldPath());
            break;
        default:
            throw new Error();
        }
    }
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
public static DiffInfo ofDiff(DiffEntry diffEntry, FileContent oldContent, FileContent newContent, List<DiffBlock> diffBlocks) {
  DiffInfo diffInfo = new DiffInfo();
  diffInfo.diffEntry = diffEntry;
  diffInfo.changeType = diffEntry.getChangeType();
  diffInfo.diffBlocks = diffBlocks;
  diffInfo.binary = (oldContent != null && oldContent.isBinary()) || (newContent != null && newContent.isBinary());
  if (oldContent != null) {
    diffInfo.oldPath = oldContent.getPath();
    // diffInfo.oldText = oldContent.getText();
  }
  if (newContent != null) {
    diffInfo.newPath = newContent.getPath();
    // diffInfo.newText = newContent.getText();
  }
  return diffInfo;
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
public static BlobIdent getOldBlobIdent(DiffEntry diffEntry, String oldRev) {
  	BlobIdent blobIdent;
if (diffEntry.getChangeType() != ChangeType.ADD) {
	blobIdent = new BlobIdent(oldRev, diffEntry.getOldPath(), diffEntry.getOldMode().getBits());
} else {
	blobIdent = new BlobIdent(oldRev, null, null);
}
return blobIdent;
  }
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
public static BlobIdent getNewBlobIdent(DiffEntry diffEntry, String newRev) {
  	BlobIdent blobIdent;
if (diffEntry.getChangeType() != ChangeType.DELETE) {
	blobIdent = new BlobIdent(newRev, diffEntry.getNewPath(), diffEntry.getNewMode().getBits());
} else {
	blobIdent = new BlobIdent(newRev, null, null);
}
return blobIdent;
  }
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
public BlobChange(String oldRev, String newRev, DiffEntry diffEntry, 
		WhitespaceOption whitespaceOption) {
	if (diffEntry.getChangeType() == ChangeType.RENAME 
			&& diffEntry.getOldPath().equals(diffEntry.getNewPath())) {
		// for some unknown reason, jgit detects rename even if path 
		// is the same
		type = ChangeType.MODIFY;
	} else {
		type = diffEntry.getChangeType();
	}
	this.whitespaceOption = whitespaceOption;
	oldBlobIdent = GitUtils.getOldBlobIdent(diffEntry, oldRev);
	newBlobIdent = GitUtils.getNewBlobIdent(diffEntry, newRev);
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
private ScmItem adaptDiffEntry(DiffEntry diff) {
    ScmItemAttribute attr = new ScmItemAttribute();
    if (diff.getChangeType() == DiffEntry.ChangeType.DELETE) {
        attr.setName(diff.getOldPath());
    } else if (diff.getChangeType() == DiffEntry.ChangeType.COPY || diff.getChangeType() == DiffEntry.ChangeType.RENAME) {
        attr.setName(diff.getNewPath());
        attr.setOldName(diff.getOldPath());
    } else {
        attr.setName(diff.getNewPath());
    }
    return new ScmItem(diff.getChangeType().name(), attr);
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
private static Set<ContextAwareEdit> getEditsDueToRebase(
    Multimap<String, ContextAwareEdit> editsDueToRebasePerFilePath, DiffEntry diffEntry) {
  if (editsDueToRebasePerFilePath.isEmpty()) {
    return ImmutableSet.of();
  }

  String filePath = diffEntry.getNewPath();
  if (diffEntry.getChangeType() == ChangeType.DELETE) {
    filePath = diffEntry.getOldPath();
  }
  return ImmutableSet.copyOf(editsDueToRebasePerFilePath.get(filePath));
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
public void updateViewFor(FileDiff fileDiff) {
    DiffEntry diffEntry = fileDiff.getDiffEntry();
    int changeTypeIcon = diff_changetype_modify;
    String filename = diffEntry.getNewPath();
    switch (diffEntry.getChangeType()) {
        case ADD:
            changeTypeIcon = diff_changetype_add;
            break;
        case DELETE:
            changeTypeIcon = diff_changetype_delete;
            filename = diffEntry.getOldPath();
            break;
        case MODIFY:
            changeTypeIcon = diff_changetype_modify;
            break;
        case RENAME:
            changeTypeIcon = diff_changetype_rename;
            filename = filePathDiffer.diff(diffEntry.getOldPath(), diffEntry.getNewPath());
            break;
        case COPY:
            changeTypeIcon = diff_changetype_add;
            break;
    }

    filePathTextView.setText(filename);
    changeTypeImageView.setImageResource(changeTypeIcon);
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
/**
 * Fetch the list of changes since the last refresh of the repository and apply the changes to the {@link FlowCatalog}
 * @throws GitAPIException
 * @throws IOException
 */
@VisibleForTesting
void processGitConfigChanges() throws GitAPIException, IOException {
  // if not active or if the flow catalog is not up yet then can't process config changes
  if (!isActive || !this.flowCatalog.isRunning()) {
    log.info("GitConfigMonitor: skip poll since the JobCatalog is not yet running.");
    return;
  }

  List<DiffEntry> changes = this.gitRepo.getChanges();

  for (DiffEntry change : changes) {
    switch (change.getChangeType()) {
      case ADD:
      case MODIFY:
        addSpec(change);
        break;
      case DELETE:
        removeSpec(change);
        break;
      case RENAME:
        removeSpec(change);
        addSpec(change);
        break;
      default:
        throw new RuntimeException("Unsupported change type " + change.getChangeType());
    }
  }

  // Done processing changes, so checkpoint
  this.gitRepo.moveCheckpointAndHashesForward();
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
/**
 * Construct a generic file object from the attributes of a git DiffEntry.
 *
 * @param  diff    DiffEntry data object
 * @return CMnFile data object
 */
private CMnFile convert(DiffEntry diff) {
    String filename = diff.getNewPath();
    CMnFile.Operation op = null;
    DiffEntry.ChangeType changeType = diff.getChangeType();
    if (changeType == DiffEntry.ChangeType.ADD){
        op = CMnFile.Operation.ADD;
    } else if (changeType == DiffEntry.ChangeType.DELETE){
        op = CMnFile.Operation.DELETE;
    } else if (changeType == DiffEntry.ChangeType.RENAME){
        op = CMnFile.Operation.RENAME;
    } else {
        op = CMnFile.Operation.EDIT;
    }
    CMnFile file = new CMnFile(filename, op);

    // Convert the file diff to a string
    try {
        OutputStream out = new ByteArrayOutputStream();
        DiffFormatter df = new DiffFormatter(out);
        df.setRepository(repository.getRepository());
        df.setDiffComparator(diffComparator);
        df.setDetectRenames(true);
        df.format(diff);
        df.flush();
        file.setDiff(out.toString());
    } catch (IOException ioex) {
    }

    return file;
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
/**
 *
 * Based on http://stackoverflow.com/a/11504177/2246865 by OneWorld
 *
 * @param follow
 * @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;
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
private String statusOf(DiffEntry d) {
    switch (d.getChangeType()) {
    case ADD:       return "A";
    case MODIFY:    return "M";
    case DELETE:    return "D";
    case RENAME:    return "R"+d.getScore();
    case COPY:      return "C"+d.getScore();
    default:
        throw new AssertionError("Unexpected change type: "+d.getChangeType());
    }
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
private static boolean isRename(DiffEntry ent) {
	return ent.getChangeType() == ChangeType.RENAME
			|| ent.getChangeType() == ChangeType.COPY;
}
 

import org.eclipse.jgit.diff.DiffEntry; //导入方法依赖的package包/类
protected DiffInfo createDiffInfo(DiffEntry diffEntry, String diff) {
    return new DiffInfo(diffEntry.getChangeType(), diffEntry.getNewPath(), toInt(diffEntry.getNewMode()), diffEntry.getOldPath(), toInt(diffEntry.getOldMode()), diff);
}