Examples of org.eclipse.jgit.treewalk.TreeWalk

org.eclipse.jgit.treewalk.TreeWalk
Walks one or more {@link AbstractTreeIterator}s in parallel.
This class can perform n-way differences across as many trees as necessary.
Each tree added must have the same root as existing trees in the walk.
A TreeWalk instance can only be used once to generate results. Running a second time requires creating a new TreeWalk instance, or invoking {@link #reset()} and adding new trees before starting again. Resetting anexisting instance may be faster for some applications as some internal buffers may be recycled.
TreeWalk instances are not thread-safe. Applications must either restrict usage of a TreeWalk instance to a single thread, or implement their own synchronization at a higher level.
Multiple simultaneous TreeWalk instances per {@link Repository} arepermitted, even from concurrent threads.

  public boolean diff(final ProgressMonitor monitor, int estWorkTreeSize,
      int estIndexSize, final String title)
      throws IOException {
    dirCache = repository.readDirCache();


    TreeWalk treeWalk = new TreeWalk(repository);
    treeWalk.setRecursive(true);
    // add the trees (tree, dirchache, workdir)
    if (tree != null)
      treeWalk.addTree(tree);
    else
      treeWalk.addTree(new EmptyTreeIterator());
    treeWalk.addTree(new DirCacheIterator(dirCache));
    treeWalk.addTree(initialWorkingTreeIterator);
    Collection<TreeFilter> filters = new ArrayList<TreeFilter>(4);


    if (monitor != null) {
      // Get the maximum size of the work tree and index
      // and add some (quite arbitrary)
      if (estIndexSize == 0)
        estIndexSize = dirCache.getEntryCount();
      int total = Math.max(estIndexSize * 10 / 9,
          estWorkTreeSize * 10 / 9);
      monitor.beginTask(title, total);
      filters.add(new ProgressReportingFilter(monitor, total));
    }


    if (filter != null)
      filters.add(filter);
    filters.add(new SkipWorkTreeFilter(INDEX));
    filters.add(new IndexDiffFilter(INDEX, WORKDIR));
    treeWalk.setFilter(AndTreeFilter.create(filters));
    while (treeWalk.next()) {
      AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
          AbstractTreeIterator.class);
      DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
          DirCacheIterator.class);
      WorkingTreeIterator workingTreeIterator = treeWalk.getTree(WORKDIR,
          WorkingTreeIterator.class);


      if (treeIterator != null) {
        if (dirCacheIterator != null) {
          if (!treeIterator.idEqual(dirCacheIterator)
              || treeIterator.getEntryRawMode()
              != dirCacheIterator.getEntryRawMode()) {
            // in repo, in index, content diff => changed
            changed.add(treeWalk.getPathString());
          }
        } else {
          // in repo, not in index => removed
          removed.add(treeWalk.getPathString());
          if (workingTreeIterator != null)
            untracked.add(treeWalk.getPathString());
        }
      } else {
        if (dirCacheIterator != null) {
          // not in repo, in index => added
          added.add(treeWalk.getPathString());
        } else {
          // not in repo, not in index => untracked
          if (workingTreeIterator != null
              && !workingTreeIterator.isEntryIgnored()) {
            untracked.add(treeWalk.getPathString());
          }
        }
      }


      if (dirCacheIterator != null) {
        if (workingTreeIterator == null) {
          // in index, not in workdir => missing
          missing.add(treeWalk.getPathString());
        } else {
          if (workingTreeIterator.isModified(
              dirCacheIterator.getDirCacheEntry(), true)) {
            // in index, in workdir, content differs => modified
            modified.add(treeWalk.getPathString());
          }
        }
      }
    }

View Full Code Here

    boolean hasUnmergedPaths = dc.hasUnmergedPaths();
    if (hasUnmergedPaths)
      throw new UnmergedPathsException();


    // determine whether we need to commit
    TreeWalk treeWalk = new TreeWalk(repo);
    treeWalk.reset();
    treeWalk.setRecursive(true);
    treeWalk.addTree(new DirCacheIterator(dc));
    ObjectId id = repo.resolve(Constants.HEAD + "^{tree}");
    if (id == null)
      throw new NoHeadException(
          JGitText.get().cannotRebaseWithoutCurrentHead);


    treeWalk.addTree(id);


    treeWalk.setFilter(TreeFilter.ANY_DIFF);


    boolean needsCommit = treeWalk.next();
    treeWalk.release();


    if (needsCommit) {
      CommitCommand commit = new Git(repo).commit();
      commit.setMessage(readFile(rebaseDir, MESSAGE));
      commit.setAuthor(parseAuthor());

View Full Code Here

  protected boolean streamFromRepo(HttpServletRequest request, HttpServletResponse response, Repository repository,
      RevCommit commit, String requestedPath) throws IOException {


    boolean served = false;
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    try {
      tw.reset();
      tw.addTree(commit.getTree());
      PathFilter f = PathFilter.create(requestedPath);
      tw.setFilter(f);
      tw.setRecursive(true);
      MutableObjectId id = new MutableObjectId();
      ObjectReader reader = tw.getObjectReader();
      while (tw.next()) {
        FileMode mode = tw.getFileMode(0);
        if (mode == FileMode.GITLINK || mode == FileMode.TREE) {
          continue;
        }
        tw.getObjectId(id, 0);


        String filename = StringUtils.getLastPathElement(requestedPath);
        try {
            String userAgent = request.getHeader("User-Agent");
          if (userAgent != null && userAgent.indexOf("MSIE 5.5") > -1) {
                response.setHeader("Content-Disposition", "filename=\""
                    +  URLEncoder.encode(filename, Constants.ENCODING) + "\"");
          } else if (userAgent != null && userAgent.indexOf("MSIE") > -1) {
                response.setHeader("Content-Disposition", "attachment; filename=\""
                    +  URLEncoder.encode(filename, Constants.ENCODING) + "\"");
          } else {
              response.setHeader("Content-Disposition", "attachment; filename=\""
                    + new String(filename.getBytes(Constants.ENCODING), "latin1") + "\"");
          }
        }
        catch (UnsupportedEncodingException e) {
          response.setHeader("Content-Disposition", "attachment; filename=\"" + filename + "\"");
        }


        long len = reader.getObjectSize(id, org.eclipse.jgit.lib.Constants.OBJ_BLOB);
        setContentType(response, "application/octet-stream");
        response.setIntHeader("Content-Length", (int) len);
        ObjectLoader ldr = repository.open(id);
        ldr.copyTo(response.getOutputStream());
        served = true;
      }
    } finally {
      tw.release();
      rw.dispose();
    }


    response.flushBuffer();
    return served;

View Full Code Here

   * @param path
   * @return content as a byte []
   */
  public static byte[] getByteContent(Repository repository, RevTree tree, final String path, boolean throwError) {
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
    byte[] content = null;
    try {
      if (tree == null) {
        ObjectId object = getDefaultBranch(repository);
        if (object == null)
          return null;
        RevCommit commit = rw.parseCommit(object);
        tree = commit.getTree();
      }
      tw.reset(tree);
      while (tw.next()) {
        if (tw.isSubtree() && !path.equals(tw.getPathString())) {
          tw.enterSubtree();
          continue;
        }
        ObjectId entid = tw.getObjectId(0);
        FileMode entmode = tw.getFileMode(0);
        if (entmode != FileMode.GITLINK) {
          ObjectLoader ldr = repository.open(entid, Constants.OBJ_BLOB);
          content = ldr.getCachedBytes();
        }
      }
    } catch (Throwable t) {
      if (throwError) {
        error(t, repository, "{0} can't find {1} in tree {2}", path, tree.name());
      }
    } finally {
      rw.dispose();
      tw.release();
    }
    return content;
  }

View Full Code Here

      return list;
    }
    if (commit == null) {
      commit = getCommit(repository, null);
    }
    final TreeWalk tw = new TreeWalk(repository);
    try {
      tw.addTree(commit.getTree());
      if (!StringUtils.isEmpty(path)) {
        PathFilter f = PathFilter.create(path);
        tw.setFilter(f);
        tw.setRecursive(false);
        boolean foundFolder = false;
        while (tw.next()) {
          if (!foundFolder && tw.isSubtree()) {
            tw.enterSubtree();
          }
          if (tw.getPathString().equals(path)) {
            foundFolder = true;
            continue;
          }
          if (foundFolder) {
            list.add(getPathModel(tw, path, commit));
          }
        }
      } else {
        tw.setRecursive(false);
        while (tw.next()) {
          list.add(getPathModel(tw, null, commit));
        }
      }
    } catch (IOException e) {
      error(e, repository, "{0} failed to get files for commit {1}", commit.getName());
    } finally {
      tw.release();
    }
    Collections.sort(list);
    return list;
  }

View Full Code Here

        ObjectId object = getDefaultBranch(repository);
        commit = rw.parseCommit(object);
      }


      if (commit.getParentCount() == 0) {
        TreeWalk tw = new TreeWalk(repository);
        tw.reset();
        tw.setRecursive(true);
        tw.addTree(commit.getTree());
        while (tw.next()) {
          list.add(new PathChangeModel(tw.getPathString(), tw.getPathString(), 0, tw
              .getRawMode(0), tw.getObjectId(0).getName(), commit.getId().getName(),
              ChangeType.ADD));
        }
        tw.release();
      } else {
        RevCommit parent = rw.parseCommit(commit.getParent(0).getId());
        DiffStatFormatter df = new DiffStatFormatter(commit.getName());
        df.setRepository(repository);
        df.setDiffComparator(RawTextComparator.DEFAULT);

View Full Code Here

    List<PathModel> list = new ArrayList<PathModel>();
    if (!hasCommits(repository)) {
      return list;
    }
    RevCommit commit = getCommit(repository, objectId);
    final TreeWalk tw = new TreeWalk(repository);
    try {
      tw.addTree(commit.getTree());
      if (extensions != null && extensions.size() > 0) {
        List<TreeFilter> suffixFilters = new ArrayList<TreeFilter>();
        for (String extension : extensions) {
          if (extension.charAt(0) == '.') {
            suffixFilters.add(PathSuffixFilter.create(extension));
          } else {
            // escape the . since this is a regexp filter
            suffixFilters.add(PathSuffixFilter.create("." + extension));
          }
        }
        TreeFilter filter;
        if (suffixFilters.size() == 1) {
          filter = suffixFilters.get(0);
        } else {
          filter = OrTreeFilter.create(suffixFilters);
        }
        tw.setFilter(filter);
        tw.setRecursive(true);
      }
      while (tw.next()) {
        list.add(getPathModel(tw, null, commit));
      }
    } catch (IOException e) {
      error(e, repository, "{0} failed to get documents for commit {1}", commit.getName());
    } finally {
      tw.release();
    }
    Collections.sort(list);
    return list;
  }

View Full Code Here

  }


  public static String getSubmoduleCommitId(Repository repository, String path, RevCommit commit) {
    String commitId = null;
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    tw.setFilter(PathFilterGroup.createFromStrings(Collections.singleton(path)));
    try {
      tw.reset(commit.getTree());
      while (tw.next()) {
        if (tw.isSubtree() && !path.equals(tw.getPathString())) {
          tw.enterSubtree();
          continue;
        }
        if (FileMode.GITLINK == tw.getFileMode(0)) {
          commitId = tw.getObjectId(0).getName();
          break;
        }
      }
    } catch (Throwable t) {
      error(t, repository, "{0} can't find {1} in commit {2}", path, commit.name());
    } finally {
      rw.dispose();
      tw.release();
    }
    return commitId;
  }

View Full Code Here

        // add to temporary in-core index
        dcBuilder.add(dcEntry);
      }


      // Traverse HEAD to add all other paths
      TreeWalk treeWalk = new TreeWalk(repo);
      int hIdx = -1;
      if (headId != null)
        hIdx = treeWalk.addTree(new RevWalk(repo).parseTree(headId));
      treeWalk.setRecursive(true);


      while (treeWalk.next()) {
        String path = treeWalk.getPathString();
        CanonicalTreeParser hTree = null;
        if (hIdx != -1)
          hTree = treeWalk.getTree(hIdx, CanonicalTreeParser.class);
        if (!ignorePaths.contains(path)) {
          // add entries from HEAD for all other paths
          if (hTree != null) {
            // create a new DirCacheEntry with data retrieved from
            // HEAD
            final DirCacheEntry dcEntry = new DirCacheEntry(path);
            dcEntry.setObjectId(hTree.getEntryObjectId());
            dcEntry.setFileMode(hTree.getEntryFileMode());


            // add to temporary in-core index
            dcBuilder.add(dcEntry);
          }
        }
      }


      // release the treewalk
      treeWalk.release();


      // finish temporary in-core index used for this commit
      dcBuilder.finish();
    } finally {
      inserter.release();

View Full Code Here

    if (commit == null) {
      return false;
    }
    boolean success = false;
    RevWalk rw = new RevWalk(repository);
    TreeWalk tw = new TreeWalk(repository);
    try {
      tw.reset();
      tw.addTree(commit.getTree());
      ZipArchiveOutputStream zos = new ZipArchiveOutputStream(os);
      zos.setComment("Generated by Gitblit");
      if (!StringUtils.isEmpty(basePath)) {
        PathFilter f = PathFilter.create(basePath);
        tw.setFilter(f);
      }
      tw.setRecursive(true);
      MutableObjectId id = new MutableObjectId();
      ObjectReader reader = tw.getObjectReader();
      long modified = commit.getAuthorIdent().getWhen().getTime();
      while (tw.next()) {
        FileMode mode = tw.getFileMode(0);
        if (mode == FileMode.GITLINK || mode == FileMode.TREE) {
          continue;
        }
        tw.getObjectId(id, 0);


        ZipArchiveEntry entry = new ZipArchiveEntry(tw.getPathString());
        entry.setSize(reader.getObjectSize(id, Constants.OBJ_BLOB));
        entry.setComment(commit.getName());
        entry.setUnixMode(mode.getBits());
        entry.setTime(modified);
        zos.putArchiveEntry(entry);


        ObjectLoader ldr = repository.open(id);
        ldr.copyTo(zos);
        zos.closeArchiveEntry();
      }
      zos.finish();
      success = true;
    } catch (IOException e) {
      error(e, repository, "{0} failed to zip files from commit {1}", commit.getName());
    } finally {
      tw.release();
      rw.dispose();
    }
    return success;
  }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.jgit.treewalk.TreeWalk

com.gitblit.tickets.BranchTicketService

com.gitblit.utils.CompressionUtils

com.gitblit.utils.JGitUtils

com.gitblit.wicket.panels.HistoryPanel

com.google.gerrit.server.git.VersionedMetaData

com.indeed.proctor.store.GitProctorCore

fitnesse.wiki.fs.GitFileVersionsController

org.apache.maven.scm.provider.git.jgit.command.checkout.JGitCheckOutCommand

org.dstadler.jgit.api.GetFileAttributes

org.eclipse.egit.core.synchronize.ThreeWayDiffEntryTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.