static PushCertificate read(TreeWalk tw) throws IOException { if (tw == null || (tw.getRawMode(0) & TYPE_FILE) != TYPE_FILE) { return null; } ObjectLoader loader = tw.getObjectReader().open(tw.getObjectId(0), OBJ_BLOB); try (InputStream in = loader.openStream(); Reader r = new BufferedReader( new InputStreamReader(in, UTF_8))) { return PushCertificateParser.fromReader(r); } }
/** * Set the tree used by this walk for finding {@code .gitmodules}. * <p> * The root tree is not read until the first submodule is encountered by the * walk. * <p> * This method need only be called if constructing a walk manually instead of * with one of the static factory methods above. * * @param id * ID of a tree containing .gitmodules * @return this generator * @throws java.io.IOException */ public SubmoduleWalk setRootTree(AnyObjectId id) throws IOException { final CanonicalTreeParser p = new CanonicalTreeParser(); p.reset(walk.getObjectReader(), id); rootTree = p; modulesConfig = null; pathToName = null; return this; }
.getEntryAttributesNode(treeWalk.getObjectReader()); .getEntryAttributesNode(treeWalk.getObjectReader()); if (otherTree != null) { attributesNode = otherTree .getEntryAttributesNode(treeWalk.getObjectReader()); .getEntryAttributesNode(treeWalk.getObjectReader());
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();
final ObjectReader r = treeWalk.getObjectReader(); DirCacheEditor editor = dc.editor(); while (treeWalk.next()) {
if (workingTreeIterator.isModified( dirCacheIterator.getDirCacheEntry(), true, treeWalk.getObjectReader())) {
private void updateFollowFilter(ObjectId[] trees, DiffConfig cfg) throws MissingObjectException, IncorrectObjectTypeException, CorruptObjectException, IOException { TreeWalk tw = pathFilter; FollowFilter oldFilter = (FollowFilter) tw.getFilter(); tw.setFilter(TreeFilter.ANY_DIFF); tw.reset(trees); List<DiffEntry> files = DiffEntry.scan(tw); RenameDetector rd = new RenameDetector(tw.getObjectReader(), cfg); rd.addAll(files); files = rd.compute(); TreeFilter newFilter = oldFilter; for (DiffEntry ent : files) { if (isRename(ent) && ent.getNewPath().equals(oldFilter.getPath())) { newFilter = FollowFilter.create(ent.getOldPath(), cfg); RenameCallback callback = oldFilter.getRenameCallback(); if (callback != null) { callback.renamed(ent); // forward the callback to the new follow filter ((FollowFilter) newFilter).setRenameCallback(callback); } break; } } tw.setFilter(newFilter); }
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(); }
walk.setRecursive(true); final ObjectReader reader = walk.getObjectReader();
@Override public RemoteFile readFileWithMode(String uri, String ref, String path) throws GitAPIException, IOException { File dir = FileUtils.createTempDir("jgit_", ".git", null); //$NON-NLS-1$ //$NON-NLS-2$ try (Git git = Git.cloneRepository().setBare(true).setDirectory(dir) .setURI(uri).call()) { Repository repo = git.getRepository(); ObjectId refCommitId = sha1(uri, ref); if (refCommitId == null) { throw new InvalidRefNameException(MessageFormat .format(JGitText.get().refNotResolved, ref)); } RevCommit commit = repo.parseCommit(refCommitId); TreeWalk tw = TreeWalk.forPath(repo, path, commit.getTree()); // TODO(ifrade): Cope better with big files (e.g. using // InputStream instead of byte[]) return new RemoteFile( tw.getObjectReader().open(tw.getObjectId(0)) .getCachedBytes(Integer.MAX_VALUE), tw.getFileMode(0)); } finally { FileUtils.delete(dir, FileUtils.RECURSIVE); } } }
static PushCertificate read(TreeWalk tw) throws IOException { if (tw == null || (tw.getRawMode(0) & TYPE_FILE) != TYPE_FILE) { return null; } ObjectLoader loader = tw.getObjectReader().open(tw.getObjectId(0), OBJ_BLOB); try (InputStream in = loader.openStream(); Reader r = new BufferedReader(new InputStreamReader(in, UTF_8))) { return PushCertificateParser.fromReader(r); } }
static PushCertificate read(TreeWalk tw) throws IOException { if (tw == null || (tw.getRawMode(0) & TYPE_FILE) != TYPE_FILE) { return null; } ObjectLoader loader = tw.getObjectReader().open(tw.getObjectId(0), OBJ_BLOB); try (InputStream in = loader.openStream(); Reader r = new BufferedReader( new InputStreamReader(in, UTF_8))) { return PushCertificateParser.fromReader(r); } }
private void addTrees(Map<SubtreeConfig, RevCommit> parentCommits, TreeWalk treeWalk) throws IOException { for (Map.Entry<SubtreeConfig, RevCommit> entry : parentCommits.entrySet()) { String directory = entry.getKey().getSubtreeDirectory(); RevCommit parentCommit = entry.getValue(); if (".".equals(directory)) { treeWalk.addTree(parentCommit.getTree()); } else { byte[] prefix = directory.getBytes(RawParseUtils.UTF8_CHARSET); CanonicalTreeParser treeParser = new CanonicalTreeParser(prefix, treeWalk.getObjectReader(), parentCommit.getTree()); treeWalk.addTree(treeParser); } } }
TreeWalk tw = new TreeWalk(repository); tw.setRecursive(true); tw.addTree(CommitUtils.getHead(repository).getTree()); tw.addTree(new FileTreeIterator(repository)); RenameDetector rd = new RenameDetector(repository); rd.addAll(DiffEntry.scan(tw)); List<DiffEntry> lde = rd.compute(tw.getObjectReader(), null); for (DiffEntry de : lde) { if (de.getScore() >= rd.getRenameScore()) { System.out.println("file: " + de.getOldPath() + " copied/moved to: " + de.getNewPath()); } }
public static List<String> readLines(Repository repository, RevCommit commit, String path, WhitespaceOption whitespaceOption) { try { TreeWalk treeWalk = Preconditions.checkNotNull(TreeWalk.forPath(repository, path, commit.getTree())); ObjectId blobId = treeWalk.getObjectId(0); ObjectReader objectReader = treeWalk.getObjectReader(); BlobIdent blobIdent = new BlobIdent(commit.name(), path, FileMode.REGULAR_FILE.getBits()); Blob blob = new Blob(blobIdent, blobId, objectReader); List<String> normalizedLines = new ArrayList<>(); for (String line: Preconditions.checkNotNull(blob.getText()).getLines()) { normalizedLines.add(whitespaceOption.process(line)); } return normalizedLines; } catch (IOException e) { throw new RuntimeException(e); } }
private static boolean commitContainsChangesToParent(Git git, Repository repo, AnyObjectId commitTreeId, AnyObjectId parentTreeId) throws MissingObjectException, IncorrectObjectTypeException, CorruptObjectException, IOException, GitAPIException { DiffCommand diffCommand = git.diff(); TreeWalk parentWalk = new TreeWalk(repo); parentWalk.addTree(parentTreeId); parentWalk.setRecursive(true); TreeWalk commitWalk = new TreeWalk(repo); commitWalk.addTree(commitTreeId); commitWalk.setRecursive(true); CanonicalTreeParser commitTreeParser = new CanonicalTreeParser(null, commitWalk.getObjectReader(), commitTreeId); CanonicalTreeParser parentTreeParser = new CanonicalTreeParser(null, parentWalk.getObjectReader(), parentTreeId); diffCommand.setOldTree(parentTreeParser); diffCommand.setNewTree(commitTreeParser); List<DiffEntry> entries = diffCommand.call(); if (entries.size() > 0) return true; else return false; }
private static boolean commitContainsChangesToParent(Git git, Repository repo, AnyObjectId commitTreeId, AnyObjectId parentTreeId) throws MissingObjectException, IncorrectObjectTypeException, CorruptObjectException, IOException, GitAPIException { DiffCommand diffCommand = git.diff(); TreeWalk parentWalk = new TreeWalk(repo); parentWalk.addTree(parentTreeId); parentWalk.setRecursive(true); TreeWalk commitWalk = new TreeWalk(repo); commitWalk.addTree(commitTreeId); commitWalk.setRecursive(true); CanonicalTreeParser commitTreeParser = new CanonicalTreeParser(null, commitWalk.getObjectReader(), commitTreeId); CanonicalTreeParser parentTreeParser = new CanonicalTreeParser(null, parentWalk.getObjectReader(), parentTreeId); diffCommand.setOldTree(parentTreeParser); diffCommand.setNewTree(commitTreeParser); List<DiffEntry> entries = diffCommand.call(); if (entries.size() > 0) return true; else return false; }
/** {@inheritDoc} */ @Override public boolean include(TreeWalk walk) throws MissingObjectException, IncorrectObjectTypeException, IOException { pointer = null; if (walk.isSubtree()) { return walk.isRecursive(); } ObjectId objectId = walk.getObjectId(0); ObjectLoader object = walk.getObjectReader().open(objectId); if (object.getSize() > 1024) { return false; } try (ObjectStream stream = object.openStream()) { pointer = LfsPointer.parseLfsPointer(stream); return pointer != null; } }
public InputStream getInputStream(BlobIdent ident) { try (RevWalk revWalk = new RevWalk(getRepository())) { ObjectId commitId = getObjectId(ident.revision); RevTree revTree = revWalk.parseCommit(commitId).getTree(); TreeWalk treeWalk = TreeWalk.forPath(getRepository(), ident.path, revTree); if (treeWalk != null) { ObjectLoader objectLoader = treeWalk.getObjectReader().open(treeWalk.getObjectId(0)); return objectLoader.openStream(); } else { throw new ObjectNotFoundException("Unable to find blob path '" + ident.path + "' in revision '" + ident.revision + "'"); } } catch (IOException e) { throw new RuntimeException(e); } }