public static void main(String[] args) throws IOException { try (Repository repository = CookbookHelper.openJGitCookbookRepository()) { Ref head = repository.findRef("HEAD"); // a RevWalk allows to walk over commits based on some filtering that is defined try (RevWalk walk = new RevWalk(repository)) { RevCommit commit = walk.parseCommit(head.getObjectId()); RevTree tree = commit.getTree(); System.out.println("Having tree: " + tree); // now use a TreeWalk to iterate over all files in the Tree // you can set Filters to narrow down the results if needed try (TreeWalk treeWalk = new TreeWalk(repository)) { treeWalk.addTree(tree); // not walk the tree recursively so we only get the elements in the top-level directory treeWalk.setRecursive(false); while (treeWalk.next()) { System.out.println("found: " + treeWalk.getPathString()); } } } } } }
List<ReceiveCommand> delta = new ArrayList<>(); Map<String, Ref> remote = new HashMap<>(current); try (RevWalk rw = new RevWalk(git); TreeWalk tw = new TreeWalk(rw.getObjectReader())) { tw.setRecursive(true); tw.addTree(rw.parseCommit(committed).getTree()); while (tw.next()) { if (tw.getRawMode(0) != TYPE_GITLINK || tw.isPathSuffix(PEEL, 2)) { String name = RefTree.refName(tw.getPathString()); Ref oldRef = remote.remove(name); ObjectId oldId = getId(oldRef); ObjectId newId = tw.getObjectId(0); if (!AnyObjectId.equals(oldId, newId)) { delta.add(new ReceiveCommand(oldId, newId, name));
private static void printDirectory(Repository repository, RevTree tree) throws IOException { // look at directory, this has FileMode.TREE try (TreeWalk treeWalk = new TreeWalk(repository)) { treeWalk.addTree(tree); treeWalk.setRecursive(false); treeWalk.setFilter(PathFilter.create("src")); if (!treeWalk.next()) { throw new IllegalStateException("Did not find expected folder 'src'"); } // FileMode now indicates that this is a directory, i.e. FileMode.TREE.equals(fileMode) holds true FileMode fileMode = treeWalk.getFileMode(0); System.out.println("src: " + getFileMode(fileMode) + ", type: " + fileMode.getObjectType() + ", mode: " + fileMode); } }
WorkingTreeSource(WorkingTreeIterator iterator) { this.tw = new TreeWalk((ObjectReader) null); this.tw.setRecursive(true); this.iterator = iterator; }
/** * Advance to next submodule in the index tree. * * The object id and path of the next entry can be obtained by calling * {@link #getObjectId()} and {@link #getPath()}. * * @return true if entry found, false otherwise * @throws java.io.IOException */ public boolean next() throws IOException { while (walk.next()) { if (FileMode.GITLINK != walk.getFileMode(0)) continue; path = walk.getPathString(); return true; } path = null; return false; }
private boolean find(RevCommit commit, PathFilter path) throws IOException { treeWalk.setFilter(path); treeWalk.reset(commit.getTree()); if (treeWalk.next() && isFile(treeWalk.getRawMode(0))) { treeWalk.getObjectId(idBuf, 0); return true; } return false; }
@NotNull public static String loadRepositoryId(@NotNull ObjectReader objectReader, ObjectId commit) throws IOException { RevWalk revWalk = new RevWalk(objectReader); TreeWalk treeWalk = TreeWalk.forPath(objectReader, ENTRY_UUID, revWalk.parseCommit(commit).getTree()); if (treeWalk != null) { return GitRepository.loadContent(objectReader, treeWalk.getObjectId(0)); } throw new FileNotFoundException(ENTRY_UUID); }
public List<BlobIdent> getChildren(BlobIdent blobIdent, BlobIdentFilter blobIdentFilter, ObjectId commitId) { Repository repository = getRepository(); try (RevWalk revWalk = new RevWalk(repository)) { RevTree revTree = revWalk.parseCommit(commitId).getTree(); TreeWalk treeWalk; if (blobIdent.path != null) { treeWalk = TreeWalk.forPath(repository, blobIdent.path, revTree); treeWalk.enterSubtree(); } else { treeWalk = new TreeWalk(repository); treeWalk.addTree(revTree); } List<BlobIdent> children = new ArrayList<>(); while (treeWalk.next()) { BlobIdent child = new BlobIdent(blobIdent.revision, treeWalk.getPathString(), treeWalk.getRawMode(0)); if (blobIdentFilter.filter(child)) children.add(child); } Collections.sort(children); return children; } catch (IOException e) { throw new RuntimeException(e); } }
/** * Lookup an entry stored in a tree, failing if not present. * * @param tree * the tree to search. * @param path * the path to find the entry of. * @return the parsed object entry at this path, never null. * @throws Exception */ public RevObject get(final RevTree tree, final String path) throws Exception { final TreeWalk tw = new TreeWalk(pool.getObjectReader()); tw.setFilter(PathFilterGroup.createFromStrings(Collections .singleton(path))); tw.reset(tree); while (tw.next()) { if (tw.isSubtree() && !path.equals(tw.getPathString())) { tw.enterSubtree(); continue; } final ObjectId entid = tw.getObjectId(0); final FileMode entmode = tw.getFileMode(0); return pool.lookupAny(entid, entmode.getObjectType()); } fail("Can't find " + path + " in tree " + tree.name()); return null; // never reached. }
File repoDir = new File("test-git"); // open the repository Repository repository = new Repository(repoDir); // find the HEAD ObjectId lastCommitId = repository.resolve(Constants.HEAD); // now we have to get the commit 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(path)); if (!treeWalk.next()) { return null; } ObjectId objectId = treeWalk.getObjectId(0); ObjectLoader loader = repository.open(objectId); // and then one can use either InputStream in = loader.openStream() // or loader.copyTo(out)
RevTree tree = revCommit.getTree(); try (TreeWalk treeWalk = new TreeWalk(repository)) { treeWalk.addTree(tree); treeWalk.setRecursive(false); treeWalk.setPostOrderTraversal(false); while(treeWalk.next()) { items.add(treeWalk.getPathString()); if((treeWalk.getFileMode(0).getBits() & FileMode.TYPE_TREE) == 0) { throw new IllegalStateException("Tried to read the elements of a non-tree for commit '" + commit + "' and path '" + path + "', had filemode " + treeWalk.getFileMode(0).getBits()); try (TreeWalk dirWalk = new TreeWalk(repository)) { dirWalk.addTree(treeWalk.getObjectId(0)); dirWalk.setRecursive(false); while(dirWalk.next()) { items.add(dirWalk.getPathString());
public static void main(String[] args) throws IOException { try (Repository repository = CookbookHelper.openJGitCookbookRepository()) { ObjectId revId = repository.resolve(Constants.HEAD); try (TreeWalk treeWalk = new TreeWalk(repository)) { try (RevWalk revWalk = new RevWalk(repository)) { treeWalk.addTree(revWalk.parseTree(revId)); while (treeWalk.next()) { System.out.println("---------------------------"); System.out.append("name: ").println(treeWalk.getNameString()); System.out.append("path: ").println(treeWalk.getPathString()); ObjectLoader loader = repository.open(treeWalk.getObjectId(0)); System.out.append("directory: ").println(loader.getType() == Constants.OBJ_TREE); System.out.append("size: ").println(loader.getSize()); } } } } } }
private <T extends Closeable> OutputStream writeArchive(Format<T> fmt) { try { try (TreeWalk walk = new TreeWalk(repo); RevWalk rw = new RevWalk(walk.getObjectReader()); T outa = fmt.createArchiveOutputStream(out, formatOptions)) { String pfx = prefix == null ? "" : prefix; //$NON-NLS-1$ MutableObjectId idBuf = new MutableObjectId(); ObjectReader reader = walk.getObjectReader(); walk.reset(rw.parseTree(tree)); if (!paths.isEmpty()) walk.setFilter(PathFilterGroup.createFromStrings(paths)); while (walk.next()) { String name = pfx + walk.getPathString(); FileMode mode = walk.getFileMode(0); if (walk.isSubtree()) walk.enterSubtree(); continue; walk.getObjectId(idBuf, 0); fmt.putEntry(outa, tree, name, mode, reader.open(idBuf));
return Collections.emptySet(); try (TreeWalk treeWalk = new TreeWalk(repo)) { treeWalk.addTree(new DirCacheIterator(repo.readDirCache())); ObjectId headID = repo.resolve(Constants.HEAD); if (headID != null) { try (RevWalk revWalk = new RevWalk(repo)) { treeWalk.addTree(revWalk.parseTree(headID)); treeWalk.setFilter(TreeFilter.ANY_DIFF); treeWalk.setRecursive(true); Set<ObjectId> ret = new HashSet<>(); while (treeWalk.next()) { checkCancelled(); ObjectId objectId = treeWalk.getObjectId(0); switch (treeWalk.getRawMode(0) & FileMode.TYPE_MASK) { case FileMode.TYPE_MISSING: case FileMode.TYPE_GITLINK: JGitText.get().corruptObjectInvalidMode3, String.format("%o", //$NON-NLS-1$ Integer.valueOf(treeWalk.getRawMode(0))), (objectId == null) ? "null" : objectId.name(), //$NON-NLS-1$ treeWalk.getPathString(), // repo.getIndexFile()));
try (RevWalk rw = new RevWalk(git); TreeWalk tw = new TreeWalk(rw.getObjectReader()); ObjectInserter ins = git.newObjectInserter()) { if (AnyObjectId.equals(oldTree, ObjectId.zeroId())) { tw.addTree(new EmptyTreeIterator()); } else { tw.addTree(rw.parseTree(oldTree)); tw.addTree(rw.parseTree(newTree)); tw.setFilter(TreeFilter.ANY_DIFF); tw.setRecursive(true); while (tw.next()) { if (tw.getRawMode(1) == TYPE_GITLINK && !tw.isPathSuffix(PEEL, 2)) { newObjs.add(tw.getObjectId(1));
ObjectId commitId; try (ObjectInserter inserter = repo.newObjectInserter(); TreeWalk treeWalk = new TreeWalk(repo, reader)) { treeWalk.setRecursive(true); treeWalk.addTree(headCommit.getTree()); treeWalk.addTree(new DirCacheIterator(cache)); treeWalk.addTree(new FileTreeIterator(repo)); treeWalk.getTree(2, FileTreeIterator.class) .setDirCacheIterator(treeWalk, 1); treeWalk.setFilter(AndTreeFilter.create(new SkipWorkTreeFilter( 1), new IndexDiffFilter(1, 2))); if (!treeWalk.next()) return null; boolean hasChanges = false; do { AbstractTreeIterator headIter = treeWalk.getTree(0, AbstractTreeIterator.class); DirCacheIterator indexIter = treeWalk.getTree(1, DirCacheIterator.class); WorkingTreeIterator wtIter = treeWalk.getTree(2, WorkingTreeIterator.class); if (indexIter != null if (headIter != null && wtIter.idEqual(headIter)) continue; treeWalk.getObjectId(id, 0);
private TreeWalk initTreeWalk( Repository repository, ObjectId objectId ) throws IOException { if (objectId == null) { return null; } RevWalk walk = new RevWalk(repository); TreeWalk treeWalk = new TreeWalk(repository); treeWalk.addTree(walk.parseCommit(objectId).getTree()); treeWalk.setRecursive(true); return treeWalk; }
private void checkoutPathsFromCommit(TreeWalk treeWalk, DirCache dc, RevCommit commit) throws IOException { treeWalk.addTree(commit.getTree()); final ObjectReader r = treeWalk.getObjectReader(); DirCacheEditor editor = dc.editor(); while (treeWalk.next()) { final ObjectId blobId = treeWalk.getObjectId(0); final FileMode mode = treeWalk.getFileMode(0); final EolStreamType eolStreamType = treeWalk .getEolStreamType(CHECKOUT_OP); final String filterCommand = treeWalk .getFilterCommand(Constants.ATTR_FILTER_TYPE_SMUDGE); final String path = treeWalk.getPathString(); editor.add(new PathEdit(path) { @Override public void apply(DirCacheEntry ent) { ent.setObjectId(blobId); ent.setFileMode(mode); checkoutPath(ent, r, new CheckoutMetadata(eolStreamType, filterCommand)); actuallyModifiedPaths.add(path); } }); } editor.commit(); }
actuallyModifiedPaths = new HashSet<>(); DirCache dc = repo.lockDirCache(); try (RevWalk revWalk = new RevWalk(repo); TreeWalk treeWalk = new TreeWalk(repo, revWalk.getObjectReader())) { treeWalk.setRecursive(true); if (!checkoutAllPaths) treeWalk.setFilter(PathFilterGroup.createFromStrings(paths)); if (isCheckoutIndex()) checkoutPathsFromIndex(treeWalk, dc); else { RevCommit commit = revWalk.parseCommit(getStartPointObjectId()); checkoutPathsFromCommit(treeWalk, dc, commit);
public static ObjectId findFileObject(Repository repository, RevCommit commit, String fileName) throws IOException { TreeWalk walk = new TreeWalk(repository); walk.setRecursive(true); walk.setFilter(PathFilterGroup.createFromStrings(fileName)); walk.addTree(commit.getTree()); if (walk.next()) { return walk.getObjectId(0); } return null; }