Example usage for org.eclipse.jgit.treewalk.filter TreeFilter ALL

Introduction

In this page you can find the example usage for org.eclipse.jgit.treewalk.filter TreeFilter ALL.

Prototype

TreeFilter ALL

To view the source code for org.eclipse.jgit.treewalk.filter TreeFilter ALL.

Click Source Link

Document

Selects all tree entries.

Usage

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

License:Open Source License

/**
 * Validates that the commit tree does not have the any item twice with the
 * same name only different in case. TFS does not support having the same
 * item with different case so we should not allow that.
 * /*from ww w .  j av a  2  s.  c o m*/
 * @param commit
 * @throws Exception
 */
private void validateCaseSensitivityRequirements(RevCommit commit) throws Exception {
    /* Create a tree walker */
    RevTree tree = commit.getTree();
    final TreeWalk treeWalker = new NameConflictTreeWalk(repository);

    try {
        treeWalker.addTree(tree);
        treeWalker.setFilter(TreeFilter.ALL);

        /*
         * Build a list of items in the tree in a hash set for quicker
         * lookup
         */
        Set<String> existingTreeItems = new HashSet<String>();

        /* Walk the tree looking for duplicates in the tree */
        while (treeWalker.next()) {
            String pathString = treeWalker.getPathString().toLowerCase();

            if (existingTreeItems.contains(pathString)) {
                throw new Exception(
                        Messages.formatString("PendDifferenceTask.SimilarItemWithDifferentCaseInCommitFormat", //$NON-NLS-1$
                                pathString, ObjectIdUtil.abbreviate(repository, commit.getId())));
            }

            existingTreeItems.add(pathString);

            int objectType = treeWalker.getFileMode(0).getObjectType();
            if (objectType == OBJ_TREE) {
                treeWalker.enterSubtree();
            }
        }
    } finally {
        if (treeWalker != null) {
            treeWalker.release();
        }
    }
}

---

From source file:facade.GitFacade.java

public static Map<String, COGClass> getCOGClassesFromCommit(Repository repository, ObjectId commitID)
        throws Exception {
    Map<String, COGClass> allClasses = new TreeMap<>();
    RevWalk revWalk = new RevWalk(repository);
    RevCommit commit = revWalk.parseCommit(commitID);
    RevTree tree = commit.getTree();//from   ww w .ja va 2s  . com

    TreeWalk treeWalk = new TreeWalk(repository);
    treeWalk.addTree(tree);
    treeWalk.setRecursive(true);
    treeWalk.setFilter(TreeFilter.ALL);

    classesInFileMap.clear();

    while (treeWalk.next()) {
        String extension = treeWalk.getPathString().substring(treeWalk.getPathLength() - 4);
        if (!extension.equals("java"))
            continue;

        //System.out.println(treeWalk.getPathString());
        ObjectId id = treeWalk.getObjectId(0);
        ObjectLoader loader = repository.open(id);
        Map<String, COGClass> classes = Source2ClassConverter.convertFromStream(loader.openStream());
        allClasses.putAll(classes);
        classesInFileMap.put(treeWalk.getPathString(), new LinkedList<>(classes.values()));
    }
    return allClasses;
}

---

From source file:jbenchmarker.trace.git.GitWalker.java

License:Open Source License

/**
 * List the files to compute in phases two
 *
 * @throws MissingObjectException//from  w ww.j av a 2  s . co m
 * @throws IncorrectObjectTypeException
 * @throws IOException
 */
public void extractFiles() throws MissingObjectException, IncorrectObjectTypeException, IOException {
    RevWalk revWalk = new RevWalk(repository);
    RevCommit revCom = revWalk.parseCommit(fromCommit);
    TreeWalk tw = new TreeWalk(repository);

    files = new HashMap<String, BlockLine>();
    tw.addTree(revCom.getTree());

    if (this.fileFilter != null) {
        tw.setFilter(PathFilter.create(this.fileFilter));
    } else {
        tw.setFilter(TreeFilter.ALL);
    }

    tw.setRecursive(true);
    while (tw.next()) {
        String filename = tw.getPathString();
        files.put(filename, new BlockLine(filename));
        logger.log(Level.INFO, "Get file {0}.", filename);
    }
    tw.release();
    revWalk.release();
    this.fileNumber = files.size();
    this.filePercent = fileNumber / 100.0;

}

---

From source file:org.codice.git.GitHandler.java

License:Open Source License

@Override
public String getDiff() throws Exception {
    final ObjectId head = repo.resolve(Constants.HEAD + "^{tree}");

    if (head == null) {
        LOGGER.warning("Unable to resolve the HEAD of this git tree");
        throw new NoHeadException(JGitText.get().cannotReadTree);
    }//from w  w  w  .ja  v  a  2  s  .c  o m
    final CanonicalTreeParser p = new CanonicalTreeParser();
    final ObjectReader reader = repo.newObjectReader();

    try {
        p.reset(reader, head);
    } finally {
        reader.release();
    }
    final AbstractTreeIterator oldTree = p;
    final AbstractTreeIterator newTree = new DirCacheIterator(repo.readDirCache());
    final OutputStream out = new ByteArrayOutputStream();
    final ChangeOnlyDiffFormatter diffFmt = new ChangeOnlyDiffFormatter(new BufferedOutputStream(out));

    diffFmt.setRepository(repo);
    diffFmt.setPathFilter(TreeFilter.ALL);
    diffFmt.setProgressMonitor(NullProgressMonitor.INSTANCE);

    LOGGER.finer("Scanning the git tree for diffs");
    final List<DiffEntry> result = diffFmt.scan(oldTree, newTree);

    diffFmt.format(result);
    diffFmt.flush();
    diffFmt.release();

    return out.toString();
}

---

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

License:Open Source License

@Override
public final void writeTo(OutputStream out) throws IOException {
    DiffFormatter formatter = new DiffFormatter(new BufferedOutputStream(out));
    formatter.setRepository(repository);
    List<String> rawFileFilter = request.getFileFilter();
    TreeFilter pathFilter = (rawFileFilter != null && rawFileFilter.size() > 0)
            ? PathFilterGroup.createFromStrings(rawFileFilter)
            : TreeFilter.ALL;
    formatter.setPathFilter(AndTreeFilter.create(TreeFilter.ANY_DIFF, pathFilter));

    try {/*from ww  w  .jav a2  s  .  c  o  m*/
        String commitA = request.getCommitA();
        String commitB = request.getCommitB();
        boolean cached = request.isCached();

        List<DiffEntry> diff;
        if (commitA == null && commitB == null && !cached) {
            diff = indexToWorkingTree(formatter);
        } else if (commitA != null && commitB == null && !cached) {
            diff = commitToWorkingTree(commitA, formatter);
        } else if (commitB == null) {
            diff = commitToIndex(commitA, formatter);
        } else {
            diff = commitToCommit(commitA, commitB, formatter);
        }

        DiffType type = request.getType();
        if (type == DiffType.NAME_ONLY) {
            writeNames(diff, out);
        } else if (type == DiffType.NAME_STATUS) {
            writeNamesAndStatus(diff, out);
        } else {
            writeRawDiff(diff, formatter);
        }
    } finally {
        formatter.close();
        repository.close();
    }
}

---

From source file:org.eclipse.egit.ui.internal.commit.RepositoryCommit.java

License:Open Source License

/**
 * Get file diffs// w  ww  .  j  ava2 s .c om
 *
 * @return non-null but possibly empty array of {@link FileDiff} instances.
 */
public FileDiff[] getDiffs() {
    if (diffs == null) {
        RevWalk revWalk = new RevWalk(repository);
        TreeWalk treewalk = new TreeWalk(revWalk.getObjectReader());
        treewalk.setRecursive(true);
        treewalk.setFilter(TreeFilter.ANY_DIFF);
        try {
            for (RevCommit parent : commit.getParents())
                revWalk.parseBody(parent);
            diffs = FileDiff.compute(treewalk, commit, TreeFilter.ALL);
        } catch (IOException e) {
            diffs = new FileDiff[0];
        } finally {
            revWalk.release();
            treewalk.release();
        }
    }
    return diffs;
}

---

From source file:org.eclipse.egit.ui.internal.history.CommitSelectionDialog.java

License:Open Source License

private TreeFilter createTreeFilter() {
    if (filterResources == null)
        return TreeFilter.ALL;

    List<TreeFilter> filters = new ArrayList<TreeFilter>();
    for (IResource resource : filterResources) {
        RepositoryMapping mapping = RepositoryMapping.getMapping(resource);
        if (mapping != null) {
            String path = mapping.getRepoRelativePath(resource);
            if (path != null && !"".equals(path)) { //$NON-NLS-1$
                if (resource.getType() == IResource.FILE)
                    filters.add(FollowFilter.create(path));
                else
                    filters.add(AndTreeFilter.create(PathFilter.create(path), TreeFilter.ANY_DIFF));
            }//  w w w  .  j a  v a2 s.  co  m
        }
    }

    if (filters.isEmpty())
        return TreeFilter.ALL;
    else if (filters.size() == 1)
        return filters.get(0);
    else
        return OrTreeFilter.create(filters);
}

---

From source file:org.eclipse.egit.ui.internal.history.GitHistoryPage.java

License:Open Source License

void initAndStartRevWalk(boolean forceNewWalk) throws IllegalStateException {
    try {/*from  www.j  a v  a 2s .c o m*/
        if (trace)
            GitTraceLocation.getTrace().traceEntry(GitTraceLocation.HISTORYVIEW.getLocation());

        cancelRefreshJob();
        Repository db = input.getRepository();
        AnyObjectId headId;
        try {
            headId = db.resolve(Constants.HEAD);
        } catch (IOException e) {
            throw new IllegalStateException(NLS.bind(UIText.GitHistoryPage_errorParsingHead,
                    Activator.getDefault().getRepositoryUtil().getRepositoryName(db)));
        }
        if (headId == null)
            throw new IllegalStateException(NLS.bind(UIText.GitHistoryPage_errorParsingHead,
                    Activator.getDefault().getRepositoryUtil().getRepositoryName(db)));

        List<String> paths = buildFilterPaths(input.getItems(), input.getFileList(), db);

        if (forceNewWalk || pathChange(pathFilters, paths) || currentWalk == null
                || !headId.equals(currentHeadId)) {
            // TODO Do not dispose SWTWalk just because HEAD changed
            // In theory we should be able to update the graph and
            // not dispose of the SWTWalk, even if HEAD was reset to
            // HEAD^1 and the old HEAD commit should not be visible.
            //
            currentHeadId = headId;
            if (currentWalk != null)
                currentWalk.release();
            currentWalk = new SWTWalk(db);
            currentWalk.sort(RevSort.COMMIT_TIME_DESC, true);
            currentWalk.sort(RevSort.BOUNDARY, true);
            highlightFlag = currentWalk.newFlag("highlight"); //$NON-NLS-1$
        } else {
            currentWalk.reset();
        }

        try {
            if (store.getBoolean(UIPreferences.RESOURCEHISTORY_SHOW_ALL_BRANCHES)) {
                markStartAllRefs(Constants.R_HEADS);
                markStartAllRefs(Constants.R_REMOTES);
            } else
                currentWalk.markStart(currentWalk.parseCommit(headId));
        } catch (IOException e) {
            throw new IllegalStateException(NLS.bind(UIText.GitHistoryPage_errorReadingHeadCommit, headId,
                    db.getDirectory().getAbsolutePath()), e);
        }

        final TreeWalk fileWalker = new TreeWalk(db);
        fileWalker.setRecursive(true);
        if (paths.size() > 0) {
            pathFilters = paths;
            currentWalk.setTreeFilter(
                    AndTreeFilter.create(PathFilterGroup.createFromStrings(paths), TreeFilter.ANY_DIFF));
            fileWalker.setFilter(currentWalk.getTreeFilter().clone());

        } else {
            pathFilters = null;
            currentWalk.setTreeFilter(TreeFilter.ALL);
            fileWalker.setFilter(TreeFilter.ANY_DIFF);
        }
        fileViewer.setTreeWalk(db, fileWalker);
        fileViewer.refresh();
        fileViewer.addSelectionChangedListener(commentViewer);
        commentViewer.setTreeWalk(fileWalker);
        commentViewer.setDb(db);
        commentViewer.refresh();

        final SWTCommitList list;
        list = new SWTCommitList(graph.getControl().getDisplay());
        list.source(currentWalk);
        final GenerateHistoryJob rj = new GenerateHistoryJob(this, list);
        rj.addJobChangeListener(new JobChangeAdapter() {
            @Override
            public void done(final IJobChangeEvent event) {
                final Control graphctl = graph.getControl();
                if (job != rj || graphctl.isDisposed())
                    return;
                graphctl.getDisplay().asyncExec(new Runnable() {
                    public void run() {
                        if (job == rj)
                            job = null;
                    }
                });
            }
        });
        job = rj;
        if (trace)
            GitTraceLocation.getTrace().trace(GitTraceLocation.HISTORYVIEW.getLocation(),
                    "Scheduling GenerateHistoryJob"); //$NON-NLS-1$
        schedule(rj);
    } finally {
        if (trace)
            GitTraceLocation.getTrace().traceExit(GitTraceLocation.HISTORYVIEW.getLocation());

    }
}

---

From source file:org.eclipse.egit.ui.internal.repository.tree.command.ImportChangedProjectsCommand.java

License:Open Source License

private List<File> getChangedFiles(RevCommit commit, Repository repo) {
    try {//  w  w w  . j  av  a 2  s .  c  om
        List<File> files = new ArrayList<File>();
        try (TreeWalk tw = new TreeWalk(repo); final RevWalk walk = new RevWalk(repo)) {
            tw.setRecursive(true);
            FileDiff[] diffs = FileDiff.compute(repo, tw, commit, TreeFilter.ALL);
            if (diffs != null && diffs.length > 0) {
                String workDir = repo.getWorkTree().getAbsolutePath();
                for (FileDiff d : diffs) {
                    String path = d.getPath();
                    File f = new File(workDir + File.separator + path);
                    files.add(f);
                }
            }
        }
        return files;
    } catch (IOException e) {
        Activator.error(e.getMessage(), e);
    }
    return null;
}

---

From source file:org.flowerplatform.web.git.history.remote.GitHistoryStatefulService.java

License:Open Source License

private TreeWalk createFileWalker(RevWalk walk, Repository db, String path) {
    TreeWalk fileWalker = new TreeWalk(db);
    fileWalker.setRecursive(true);/*  w ww .  j a  va 2  s .c om*/
    fileWalker.setFilter(TreeFilter.ANY_DIFF);

    if (path == null || path.isEmpty()) {
        walk.setTreeFilter(TreeFilter.ALL);
    } else {
        List<String> stringPaths = new ArrayList<String>(1);
        stringPaths.add(path);

        walk.setTreeFilter(
                AndTreeFilter.create(PathFilterGroup.createFromStrings(stringPaths), TreeFilter.ANY_DIFF));
    }
    return fileWalker;
}

---

• «
• 1
• 2
• »