Java PathFilter类代码示例

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
/**
 * Gets the loader for a file from a specified commit and its path
 * 
 * @param commit
 *          - the commit from which to get the loader
 * @param path
 *          - the path to the file
 * @return the loader
 * @throws MissingObjectException
 * @throws IncorrectObjectTypeException
 * @throws CorruptObjectException
 * @throws IOException
 */
public ObjectLoader getLoaderFrom(ObjectId commit, String path)
		throws IOException {
	Repository repository = git.getRepository();
	RevWalk revWalk = new RevWalk(repository);
	RevCommit revCommit = revWalk.parseCommit(commit);
	// and using commit's tree find the path
	RevTree tree = revCommit.getTree();
	TreeWalk treeWalk = new TreeWalk(repository);
	treeWalk.addTree(tree);
	treeWalk.setRecursive(true);
	treeWalk.setFilter(PathFilter.create(path));

	ObjectLoader loader = null;
	if (treeWalk.next()) {
		ObjectId objectId = treeWalk.getObjectId(0);
		loader = repository.open(objectId);
	}

	treeWalk.close();
	revWalk.close();
	return loader;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
private static void printFile(Repository repository, RevTree tree) throws IOException {
    // now try to find a specific file
    try (TreeWalk treeWalk = new TreeWalk(repository)) {
        treeWalk.addTree(tree);
        treeWalk.setRecursive(false);
        treeWalk.setFilter(PathFilter.create("README.md"));
        if (!treeWalk.next()) {
            throw new IllegalStateException("Did not find expected file 'README.md'");
        }

        // FileMode specifies the type of file, FileMode.REGULAR_FILE for normal file, FileMode.EXECUTABLE_FILE for executable bit
// set
        FileMode fileMode = treeWalk.getFileMode(0);
        ObjectLoader loader = repository.open(treeWalk.getObjectId(0));
        System.out.println("README.md: " + getFileMode(fileMode) + ", type: " + fileMode.getObjectType() + ", mode: " + fileMode +
                " size: " + loader.getSize());
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public static boolean hasDiff(Git git, String base, String name, String ext) 
                                                throws WsSrvException {    
   checkFile(base, name, ext).getAbsolutePath();

   // Prepare path for git save
   String fp = getLocalPath(name);

   List<DiffEntry> diff;
   try {
       diff = git.diff().setPathFilter(PathFilter.create(fp)).call();
   } catch (GitAPIException e) {
     throw new WsSrvException(260, "Unable retrieve git diff", e);
   }

   return diff.size() > 0;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public RepositoryProcessor(boolean deduplicateChildCommits, String toRef, String nextRelease, String gitHubUrl,
                           Predicate<RevCommit> commitFilter, List<CommitHandler> commitHandlers, String pathFilter,
                           String tagPrefix, Log log) {
    this.deduplicateChildCommits = deduplicateChildCommits;
    this.toRef = toRef;
    this.nextRelease = nextRelease;
    this.gitHubUrl = gitHubUrl;
    this.commitFilter = commitFilter;
    if (!isBlank(pathFilter) && !"/".equals(pathFilter)) {
        this.pathFilter = PathFilter.create(pathFilter);
    } else {
        this.pathFilter = PathFilter.ALL;
    }
    this.commitHandlers.addAll(commitHandlers);
    tagPattern = Pattern.compile(tagPrefix + "-([^-]+?)$");
    this.log = log;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
/**
 * TODO: see if performance can be improved
 */
private ObjectId getObjectId(File file) throws IOException {
    try (TreeWalk treeWalk = new TreeWalk(localRepo)) {
        treeWalk.addTree(new FileTreeIterator(localRepo));

        String path = getRepoPath(file);
        treeWalk.setFilter(PathFilter.create(path));

        while (treeWalk.next()) {
            WorkingTreeIterator workingTreeIterator = treeWalk.getTree(0, WorkingTreeIterator.class);
            if (treeWalk.getPathString().equals(path))
                return workingTreeIterator.getEntryObjectId();
            if (workingTreeIterator.getEntryFileMode().equals(FileMode.TREE))
                treeWalk.enterSubtree();
        }

        return ObjectId.zeroId(); // not found
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public byte[] readFromCommit(String commitId, String path) throws Exception {
    try (RevWalk revWalk = new RevWalk(localRepo)) {
        RevCommit commit = revWalk.parseCommit(ObjectId.fromString(commitId));
        // use commit's tree find the path
        RevTree tree = commit.getTree();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (TreeWalk treeWalk = new TreeWalk(localRepo)) {
            treeWalk.addTree(tree);
            treeWalk.setRecursive(true);
            treeWalk.setFilter(PathFilter.create(path));
            if (!treeWalk.next()) {
                return null;
            }

            ObjectId objectId = treeWalk.getObjectId(0);
            ObjectLoader loader = localRepo.open(objectId);

            loader.copyTo(baos);
        }
        revWalk.dispose();
        return baos.toByteArray();
    }
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
private void filterOutOtherModulesChanges(final String modulePath, final List<String> childModules,
		final RevWalk walk) {
	final boolean isRootModule = ".".equals(modulePath);
	final boolean isMultiModuleProject = !isRootModule || !childModules.isEmpty();
	final List<TreeFilter> treeFilters = new LinkedList<>();
	treeFilters.add(TreeFilter.ANY_DIFF);
	if (isMultiModuleProject) {
		if (!isRootModule) {
			// for sub-modules, look for changes only in the sub-module
			// path...
			treeFilters.add(PathFilter.create(modulePath));
		}

		// ... but ignore any sub-modules of the current sub-module, because
		// they can change independently of the current module
		for (final String childModule : childModules) {
			final String path = isRootModule ? childModule : modulePath + "/" + childModule;
			treeFilters.add(PathFilter.create(path).negate());
		}

	}
	final TreeFilter treeFilter = treeFilters.size() == 1 ? treeFilters.get(0) : AndTreeFilter.create(treeFilters);
	walk.setTreeFilter(treeFilter);
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public static boolean getFileFromCommit(final OutputStream os, final String file, final Repository repo, final RevTree tree) throws IOException, GitAPIException {
    final TreeWalk treeWalk = new TreeWalk(repo);
    treeWalk.addTree(tree);
    treeWalk.setRecursive(true);
    treeWalk.setFilter(PathFilter.create(file));
    if (!treeWalk.next()) {
        logger.info("Did not find expected file '" + file + "'");
        return false;
    }

    final ObjectId objectId = treeWalk.getObjectId(0);
    final ObjectLoader loader = repo.open(objectId);

    // and then one can the loader to read the file
    loader.copyTo(os);
    return true;
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
private void filterOutOtherModulesChanges(String modulePath, List<String> childModules, RevWalk walk) {
    boolean isRootModule = ".".equals(modulePath);
    boolean isMultiModuleProject = !isRootModule || !childModules.isEmpty();
    List<TreeFilter> treeFilters = new ArrayList<TreeFilter>();
    treeFilters.add(TreeFilter.ANY_DIFF);
    if (isMultiModuleProject) {
        if (!isRootModule) {
            // for sub-modules, look for changes only in the sub-module path...
            treeFilters.add(PathFilter.create(modulePath));
        }

        // ... but ignore any sub-modules of the current sub-module, because they can change independently of the current module
        for (String childModule : childModules) {
            String path = isRootModule ? childModule : modulePath + "/" + childModule;
            treeFilters.add(PathFilter.create(path).negate());
        }

    }
    TreeFilter treeFilter = treeFilters.size() == 1 ? treeFilters.get(0) : AndTreeFilter.create(treeFilters);
    walk.setTreeFilter(treeFilter);
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
private Optional<String[]> getBlob(Git git, String fileName, CodeRevision revision)
		throws IOException {
	TreeWalk treeWalk = new TreeWalk(git.getRepository());
	treeWalk.addTree(getTreeIterator(git, revision));
	treeWalk.setFilter(PathFilter.create(fileName));
	treeWalk.setRecursive(true);
	if (!treeWalk.next()) {
		return Optional.empty();
	}
	ObjectId blobId = treeWalk.getObjectId(0);
	String content = new String(git.getRepository().getObjectDatabase().open(blobId).getBytes(),
			Charset.forName("UTF-8"));

	String[] lines = content.split("\n");
	return Optional.of(lines);
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
private String getDiffString() throws GitAPIException, IOException {
    ObjectId head = this.repo.resolve("HEAD");
    if(head == null) return "";

    // The following code is largely written by Tk421 on StackOverflow
    //      (http://stackoverflow.com/q/23486483)
    // Thanks! NOTE: comments are mine.
    ByteArrayOutputStream diffOutputStream = new ByteArrayOutputStream();
    DiffFormatter formatter = new DiffFormatter(diffOutputStream);
    formatter.setRepository(this.repo);
    formatter.setPathFilter(PathFilter.create(this.pathFilter.replaceAll("\\\\","/")));

    AbstractTreeIterator commitTreeIterator = prepareTreeParser(this.repo, head.getName());
    FileTreeIterator workTreeIterator = new FileTreeIterator(this.repo);

    // Scan gets difference between the two iterators.
    formatter.format(commitTreeIterator, workTreeIterator);

    return diffOutputStream.toString();
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public Optional<InputStream> execute() {
    try (final TreeWalk tw = new TreeWalk(git.getRepository())) {
        final ObjectId tree = git.getTreeFromRef(treeRef);
        tw.setFilter(PathFilter.create(path));
        tw.reset(tree);
        while (tw.next()) {
            if (tw.isSubtree() && !path.equals(tw.getPathString())) {
                tw.enterSubtree();
                continue;
            }
            return Optional.of(new ByteArrayInputStream(git.getRepository().open(tw.getObjectId(0),
                                                                                 Constants.OBJ_BLOB).getBytes()));
        }
    } catch (final Throwable t) {
        LOG.debug("Unexpected exception, this will trigger a NoSuchFileException.",
                  t);
        throw new NoSuchFileException("Can't find '" + path + "' in tree '" + treeRef + "'");
    }
    throw new NoSuchFileException("Can't find '" + path + "' in tree '" + treeRef + "'");
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public Optional<Revisao> getRevisaoMaisRecenteDoBranch(String branchRef, Path caminhoRelativo) {

        RevCommit commit = comRepositorioAberto(uncheckedFunction(git -> {
            Repository repo = git.getRepository();
            RevWalk revWalk = new RevWalk(repo);

            revWalk.setTreeFilter(AndTreeFilter.create(PathFilter.create(caminhoRelativo.toString()), TreeFilter.ANY_DIFF));
            revWalk.markStart(revWalk.lookupCommit(repo.resolve(branchRef)));

            Iterator<RevCommit> revs = revWalk.iterator();
            if (revs.hasNext()) {
                return revs.next();
            }

            return null;
        }));

        if (commit == null) {
            return empty();
        }

        return of(new Revisao(commit));
    }
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
public static boolean gitRepoContainsFile(Repository repository, String file) throws IllegalStateException, IOException {
	ObjectId lastCommitId = repository.resolve(Constants.HEAD);

       // a RevWalk allows to walk over commits based on some filtering
       RevWalk revWalk = new RevWalk(repository);
       RevCommit commit = revWalk.parseCommit(lastCommitId);

       // and using commit's tree find the path
       RevTree tree = commit.getTree();
       
       TreeWalk treeWalk = new TreeWalk(repository);
       treeWalk.addTree(tree);
       treeWalk.setRecursive(true);
       treeWalk.setFilter(PathFilter.create(file));
       return treeWalk.next(); 
}
 

import org.eclipse.jgit.treewalk.filter.PathFilter; //导入依赖的package包/类
private void formatHtmlDiff(OutputStream out,
    Repository repo, RevWalk walk,
    AbstractTreeIterator oldTree, AbstractTreeIterator newTree,
    String path)
    throws IOException {
  DiffFormatter diff = new HtmlDiffFormatter(renderer, out);
  try {
    if (!path.equals("")) {
      diff.setPathFilter(PathFilter.create(path));
    }
    diff.setRepository(repo);
    diff.setDetectRenames(true);
    diff.format(oldTree, newTree);
  } finally {
    diff.release();
  }
}