/** * Locate a reference to any object without loading it. * <p> * The object may or may not exist in the repository. It is impossible to * tell from this method's return value. * * @param id * name of the object. * @param type * type of the object. Must be a valid Git object type. * @return reference to the object. Never null. */ public RevObject lookupAny(final AnyObjectId id, final int type) { RevObject r = objects.get(id); if (r == null) { switch (type) { case Constants.OBJ_COMMIT: r = createCommit(id); break; case Constants.OBJ_TREE: r = new RevTree(id); break; case Constants.OBJ_BLOB: r = new RevBlob(id); break; case Constants.OBJ_TAG: r = new RevTag(id); break; default: throw new IllegalArgumentException(MessageFormat.format( JGitText.get().invalidGitType, Integer.valueOf(type))); } objects.add(r); } return r; }
/** * * @param columns * @param objectInserter * @param tblTree * @param walkTbl * @return * @throws SQLException * @throws IOException */ public static ObjectId putColumnMetaAsObject(ResultSet columns, ObjectInserter objectInserter, TreeFormatter tblTree, RevWalk walkTbl) throws SQLException, IOException { // Build object for column attributs ObjectId objectId = buildMetaObject(columns, Consts.COLUMN_META_ATTRIBUTES, objectInserter); tblTree.append(Consts.COLUMN_META, FileMode.REGULAR_FILE, (AnyObjectId) objectId); // Add empty tree for the column content TreeFormatter clmnDataTree = new TreeFormatter(); ObjectId clmnDataTreeId = objectInserter.insert(clmnDataTree); objectInserter.flush(); tblTree.append(Consts.COLUMN_DATA, walkTbl.parseTree(clmnDataTreeId)); return objectId; }
@Nonnull private Result updateFileSystemStatus(GfsStatusProvider.Update update, Merger merger) throws IOException { AnyObjectId treeId = merger.getResultTreeId(); checkout(gfs, treeId); RevCommit newCommit = null; if(commit && !squash) { prepareCommitter(); newCommit = createCommit(message, treeId, committer, committer, Arrays.asList(headCommit, sourceHeadCommit), repo); BranchUtils.merge(branch, newCommit, sourceRef, "Merge made by " + strategy.getName() + ".", repo); update.commit(newCommit); } if(!commit) { update.mergeNote(MergeNote.mergeNoCommit(sourceHeadCommit, message)); return Result.mergedNotCommitted(); } if(squash) { update.mergeNote(MergeNote.mergeSquash(message)); return Result.mergedSquashed(); } return Result.merged(newCommit); }
@Nonnull @Override protected GfsCreateStash.Result doExecute(GfsStatusProvider.Update update) throws IOException { prepareBranch(); prepareCommitter(); prepareParent(); prepareIndexMessage(); prepareDirectoryMessage(); AnyObjectId resultTree = gfs.flush(); GfsCreateStash.Result result; if(parent != null && parent.getTree().equals(resultTree)) { result = noChange(); } else { RevCommit indexCommit = makeIndexCommit(resultTree); RevCommit stashCommit = makeWorkingDirectoryCommit(indexCommit); addToStash(stashCommit, repo); result = success(stashCommit); } return result; }
public static GitRepoMetaData getGitRepositoryMetaData(String repoPath) { try { if(!repoPath.endsWith(".git")) repoPath = repoPath+File.separator+".git"; System.out.println("repopath: "+repoPath); GitRepoMetaData gitMetaData = new GitRepoMetaData(); FileRepositoryBuilder builder = new FileRepositoryBuilder(); Repository repository = builder.setGitDir(new File(repoPath)) .readEnvironment() .setMustExist(true) .findGitDir() .build(); RevWalk walk = new RevWalk(repository); AnyObjectId id = repository.resolve("HEAD"); if(id == null) return null;//Empty repository RevCommit rCommit =walk.parseCommit(id); walk.markStart(rCommit); gitMetaData.setRepository(repository); gitMetaData.setRevWalk(walk); return gitMetaData; } catch (IOException exception) { //[LOG] logger.debug("IOException getGitRepositoryMetaData", exception); }; return null; }
public RevCommit getSrcCommit() { try { RevWalk revWalk = new RevWalk(git.getRepository()); AnyObjectId headId = git.getRepository().resolve(Constants.HEAD); RevCommit root = revWalk.parseCommit(headId); revWalk.sort(RevSort.REVERSE); revWalk.markStart(root); return revWalk.next(); } catch (Exception e) { throw new RuntimeException(e); } }
public List<Path> getChangedFiles() throws IOException { List<Path> changedFiles = new ArrayList<>(); RevWalk revWalk = new RevWalk(git.getRepository()); AnyObjectId headId = git.getRepository().resolve(Constants.HEAD); RevCommit head = revWalk.parseCommit(headId); DiffFormatter formatter = new DiffFormatter(null); formatter.setRepository(git.getRepository()); formatter.setDiffComparator(RawTextComparator.DEFAULT); formatter.setDetectRenames(true); List<DiffEntry> entries = formatter.scan(getSrcCommit().getTree(), head); entries.forEach((diffEntry -> changedFiles.add(Paths.get(diffEntry.getPath(DiffEntry.Side.NEW))))); return changedFiles; }
private String getCommitIndexVersion(final IndexSearcher searcher, AnyObjectId commitId) throws IOException { final AtomicReference<String> indexVersion = new AtomicReference<>(null); searcher.search(COMMIT_HASH.query(commitId.getName()), new Collector() { private int docBase; @Override public void setScorer(Scorer scorer) throws IOException { } @Override public void collect(int doc) throws IOException { indexVersion.set(searcher.doc(docBase+doc).get(COMMIT_INDEX_VERSION.name())); } @Override public void setNextReader(AtomicReaderContext context) throws IOException { docBase = context.docBase; } @Override public boolean acceptsDocsOutOfOrder() { return true; } }); return indexVersion.get(); }
private RevObject parseNew(AnyObjectId id, ObjectLoader ldr) throws LargeObjectException, CorruptObjectException, MissingObjectException, IOException { RevObject r; int type = ldr.getType(); switch (type) { case Constants.OBJ_COMMIT: { final RevCommit c = createCommit(id); c.parseCanonical(this, getCachedBytes(c, ldr)); r = c; break; } case Constants.OBJ_TREE: { r = new RevTree(id); r.flags |= PARSED; break; } case Constants.OBJ_BLOB: { r = new RevBlob(id); r.flags |= PARSED; break; } case Constants.OBJ_TAG: { final RevTag t = new RevTag(id); t.parseCanonical(this, getCachedBytes(t, ldr)); r = t; break; } default: throw new IllegalArgumentException(MessageFormat.format( JGitText.get().badObjectType, Integer.valueOf(type))); } objects.add(r); return r; }
public static List<DiffEntry> diff(Repository repository, AnyObjectId oldRevId, AnyObjectId newRevId) { List<DiffEntry> diffs = new ArrayList<>(); try ( DiffFormatter diffFormatter = new DiffFormatter(NullOutputStream.INSTANCE); RevWalk revWalk = new RevWalk(repository); ObjectReader reader = repository.newObjectReader();) { diffFormatter.setRepository(repository); diffFormatter.setDetectRenames(true); diffFormatter.setDiffComparator(RawTextComparator.DEFAULT); CanonicalTreeParser oldTreeParser = new CanonicalTreeParser(); if (!oldRevId.equals(ObjectId.zeroId())) oldTreeParser.reset(reader, revWalk.parseCommit(oldRevId).getTree()); CanonicalTreeParser newTreeParser = new CanonicalTreeParser(); if (!newRevId.equals(ObjectId.zeroId())) newTreeParser.reset(reader, revWalk.parseCommit(newRevId).getTree()); for (DiffEntry entry: diffFormatter.scan(oldTreeParser, newTreeParser)) { if (!Objects.equal(entry.getOldPath(), entry.getNewPath()) || !Objects.equal(entry.getOldMode(), entry.getNewMode()) || entry.getOldId()==null || !entry.getOldId().isComplete() || entry.getNewId()== null || !entry.getNewId().isComplete() || !entry.getOldId().equals(entry.getNewId())) { diffs.add(entry); } } } catch (IOException e) { throw new RuntimeException(e); } return diffs; }
/** * Restore to the initial state of the repository. Only applicable if the * repository has conflicts */ public void restartMerge() { try { AnyObjectId commitToMerge = git.getRepository().resolve("MERGE_HEAD"); git.clean().call(); git.reset().setMode(ResetType.HARD).call(); git.merge().include(commitToMerge).setStrategy(MergeStrategy.RECURSIVE).call(); fireFileStateChanged(new ChangeEvent(GitCommand.MERGE_RESTART, Collections.<String> emptyList())); } catch (GitAPIException | IOException e) { if (logger.isDebugEnabled()) { logger.debug(END_FETCH_DEBUG_MESSAGE); } } }
private static void setupMergeCommand(MergeCommand merge, List<Ref> commitsByRef, List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId, ProgressMonitor monitor, MergeStrategy strategy, MergeCommand.FastForwardMode fastForwardMode) { commitsByRef.forEach(merge::include); commitsById.forEach(merge::include); commitsByNameAndId.forEach(nc -> merge.include(nc.getName(), nc.getObjectId())); if (monitor != null) { merge.setProgressMonitor(monitor); } merge .setFastForward(fastForwardMode) .setStrategy(strategy); }
public static MergeResult mergeWithSquash(Git git, MergeStrategy strategy, List<Ref> commitsByRef, List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId, MergeCommand.FastForwardMode fastForwardMode, ProgressMonitor monitor) throws GitAPIException { MergeCommand merge = git.merge(); setupMergeCommand(merge, commitsByRef, commitsById, commitsByNameAndId, monitor, strategy, fastForwardMode); return merge .setStrategy(strategy) .setFastForward(fastForwardMode) .setSquash(true) .call(); }
public static MergeResult mergeWithoutCommit(Git git, MergeStrategy strategy, List<Ref> commitsByRef, List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId, MergeCommand.FastForwardMode fastForwardMode, ProgressMonitor monitor) throws GitAPIException { MergeCommand merge = git.merge(); setupMergeCommand(merge, commitsByRef, commitsById, commitsByNameAndId, monitor, strategy, fastForwardMode); return merge .setStrategy(strategy) .setFastForward(fastForwardMode) .setCommit(false) .call(); }
public static MergeResult mergeWithCommit(Git git, MergeStrategy strategy, List<Ref> commitsByRef, List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId, String commitMessage, MergeCommand.FastForwardMode fastForwardMode, ProgressMonitor monitor) throws GitAPIException { MergeCommand merge = git.merge(); setupMergeCommand(merge, commitsByRef, commitsById, commitsByNameAndId, monitor, strategy, fastForwardMode); return git.merge() .setMessage(commitMessage) // message to be used for merge commit .call(); }
/** * Creates a new commit that reverts the changes done in the previous (erroneous) commit(s) * @param git the git repository * @param commitsByRef one or more commits (can be null if at least one other "commitsBy*" is not null) * @param commitsById one or more commits (can be null if at least one other "commitsBy*" is not null) * @param commitsByNameAndId one or more commits (can be null if at least one other "commitsBy*" is not null) * @param strategy the merge strategy to use * @param ourCommitName named used for the "OURS" place when there are conflicts * (distinguishes our commits from others' commits) * @return the commit made that reverts previous commits' work * @throws GitAPIException */ public static RevCommit revertCommits(Git git, List<Ref> commitsByRef, List<AnyObjectId> commitsById, List<NamedCommit> commitsByNameAndId, MergeStrategy strategy, String ourCommitName) throws GitAPIException { RevertCommand revert = git.revert(); commitsByRef.forEach(revert::include); commitsById.forEach(revert::include); commitsByNameAndId.forEach(nc -> revert.include(nc.getName(), nc.getObjectId())); return revert .setStrategy(strategy) .setOurCommitName(ourCommitName) .call(); }
private void applyCommitRanges(RevWalk revWalk) { try { for (CommitRange commitRange : commitRanges) { AnyObjectId fromInclusive = commitRange.getToInclusive(); RevCommit revCommit; revCommit = revWalk.parseCommit(fromInclusive); revWalk.markStart(revCommit); } } catch (IOException e) { throw new RuntimeException("Can't create RevWalk instance", e); } }
@Override public ObjectLoader open(AnyObjectId objectId, int typeHint) throws MissingObjectException, IncorrectObjectTypeException, IOException { ObjectLoader objectLoader = objectLoaderCache.get(objectId); if (objectLoader == null) { objectLoader = delegate.open(objectId, Constants.OBJ_TREE); objectLoaderCache.put(objectId.copy(), objectLoader); } return objectLoader; }
private RevCommit getInitialCommit(AnyObjectId headId) throws IOException { Repository repository = getRepository(); RevWalk rw = new RevWalk(repository); RevCommit c = null; RevCommit root = rw.parseCommit(headId); rw.markStart(root); rw.sort(RevSort.REVERSE); c = rw.next(); return c; }
private boolean tryCheckout(AnyObjectId tree) throws IOException { try { checkout(gfs, tree); } catch(GfsCheckoutConflictException e) { return false; } return true; }
@Override public ObjectLoader open(AnyObjectId objectId, int typeHint) throws IOException { InsertedObject obj = inserted.get(objectId); if (obj == null) { return reader.open(objectId, typeHint); } if (typeHint != OBJ_ANY && obj.type() != typeHint) { throw new IncorrectObjectTypeException(objectId.copy(), typeHint); } return obj.newLoader(); }
@Before public void setUp() throws IOException { initRepository(); writeToCache("/test_file.txt", "base stuff"); AnyObjectId base = commit(); writeToCache("/test_file.txt", "base stuff + some stuff"); commitToBranch(OURS, base); writeToCache("/test_file.txt", "base stuff + other stuff"); commitToBranch(THEIRS, base); gfs = newFileSystem(OURS, repo); }
@Before public void setUp() throws IOException { initRepository(); writeSomethingToCache(); AnyObjectId base = commit(); writeToCache("/test_file.txt", "OUR VERSION"); commitToBranch(OURS, base); clearCache(); writeSomethingToCache(); commitToBranch(THEIRS, base); writeSomethingToCache(); commitToBranch(THEIRS); gfs = newFileSystem(OURS, repo); }
@Before public void setUp() throws Exception { initRepository(); AnyObjectId base = commit(); AnyObjectId theirs = commitToBranch(THEIRS, base); commitToBranch(OURS, theirs); gfs = Gfs.newFileSystem(OURS, repo); }
@Before public void setUp() throws IOException { initRepository(); writeToCache("/test_file.txt", "a\nb\nc\nd\ne"); AnyObjectId base = commit(); writeToCache("/test_file.txt", "a\nB\nc\nd\ne"); commitToBranch(OURS, base); writeToCache("/test_file.txt", "a\nb\nc\nD\nd\ne"); commitToBranch(THEIRS, base); gfs = newFileSystem(OURS, repo); }
@Test public void buildWithRevision() throws IOException { writeSomethingToCache(); AnyObjectId commit = commitToMaster(); GitFileSystem gfs = Gfs.newFileSystem(commit, repo); assertEquals(commit, gfs.getStatusProvider().commit()); }
@Test public void buildWithRevisionString() throws IOException { writeSomethingToCache(); AnyObjectId commit = commitToMaster(); GitFileSystem gfs = Gfs.newFileSystem(commit.getName(), repo); assertEquals(commit, gfs.getStatusProvider().commit()); }
@Test(expected = GfsCheckoutConflictException.class) public void case11_allTreesHaveDifferentFiles_shouldThrowGfsCheckoutConflictException() throws IOException { initGitFileSystem("/test_file.txt"); clearWorktreeAndWrite("/test_file.txt", someBytes()); AnyObjectId target = createTreeWithFile("/test_file.txt", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); }
@Test(expected = GfsCheckoutConflictException.class) public void case12_headHasFile_targetHasDirectory_worktreeHasFile_shouldThrowGfsCheckoutConflictException() throws IOException { initGitFileSystem("/test_target"); clearWorktreeAndWrite("/test_target/some_file.txt", someBytes()); AnyObjectId target = createTreeWithFile("/test_target", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); }
@Test(expected = GfsCheckoutConflictException.class) public void case13_headHasFile_targetHasFile_worktreeHasDirectory_shouldThrowGfsCheckoutConflictException() throws IOException { initGitFileSystem("/test_target"); clearWorktreeAndWrite("/test_target", someBytes()); AnyObjectId target = createTreeWithFile("/test_target/some_file.txt", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); }
@Test public void case14_targetAndWorktreeHaveNonConflictingDirectories_theFilesFromBothDirectoriesShouldBePresentAfterTheOperation() throws IOException { initGitFileSystem("/test_target"); clearWorktreeAndWrite("/test_target/some_file1.txt", someBytes()); AnyObjectId target = createTreeWithFile("/test_target/some_file2.txt", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); assertTrue(Files.exists(gfs.getPath("/test_target/some_file1.txt"))); assertTrue(Files.exists(gfs.getPath("/test_target/some_file2.txt"))); }
public List<String> execute() { existsBranch(git, sourceBranch); existsBranch(git, targetBranch); final Repository repo = git.getRepository(); final RevCommit lastSourceCommit = git.getLastCommit(sourceBranch); final RevCommit lastTargetCommit = git.getLastCommit(targetBranch); final RevCommit commonAncestor = getCommonAncestor(lastSourceCommit, lastTargetCommit); final List<RevCommit> commits = git.listCommits(commonAncestor, lastSourceCommit); Collections.reverse(commits); final String[] commitsIDs = commits.stream().map(AnyObjectId::getName).toArray(String[]::new); canMerge(repo, commonAncestor, lastSourceCommit, lastTargetCommit, sourceBranch, targetBranch); git.cherryPick(targetBranch, commitsIDs); if (logger.isDebugEnabled()) { logger.debug("Merging commits from <{}> to <{}>", sourceBranch, targetBranch); } return Arrays.asList(commitsIDs); }
@Test(expected = GfsCheckoutConflictException.class) public void case16_headHasDirectory_targetHasFile_worktreeHasDirectory_shouldThrowGfsCheckoutConflictException() throws IOException { initGitFileSystem("/test_target/some_file.txt"); clearWorktreeAndWrite("/test_target", someBytes()); AnyObjectId target = createTreeWithFile("/test_target/some_file.txt", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); }
@Test(expected = GfsCheckoutConflictException.class) public void case17_headHasDirectory_targetHasDirectory_worktreeHasFile_shouldThrowGfsCheckoutConflictException() throws IOException { initGitFileSystem("/test_target/some_file.txt"); clearWorktreeAndWrite("/test_target/some_file.txt", someBytes()); AnyObjectId target = createTreeWithFile("/test_target", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); }
@Test public void case18_allTreesHaveDifferentButNonConflictingDirectories_theFilesFromTargetAndDirectoryShouldBePresentAfterTheOperation() throws IOException { initGitFileSystem("/test_target/some_file1.txt"); clearWorktreeAndWrite("/test_target/some_file2.txt", someBytes()); AnyObjectId target = createTreeWithFile("/test_target/some_file3.txt", someBytes()); new GfsDefaultCheckout(gfs).checkout(target); assertFalse(Files.exists(gfs.getPath("/test_target/some_file1.txt"))); assertTrue(Files.exists(gfs.getPath("/test_target/some_file2.txt"))); assertTrue(Files.exists(gfs.getPath("/test_target/some_file3.txt"))); }
@Test public void case2_headNotEqualTarget_headEqualWorktree_targetFileShouldBeUsed() throws IOException { initGitFileSystem("/test_file.txt"); byte[] expected = someBytes(); AnyObjectId target = createTreeWithFile("/test_file.txt", expected); new GfsDefaultCheckout(gfs).checkout(target); assertArrayEquals(expected, Files.readAllBytes(gfs.getPath("/test_file.txt"))); }
@Test public void case3_headNotEqualTarget_targetEqualWorktree_worktreeFileShouldRemainTheSame() throws IOException { initGitFileSystem("/test_file.txt"); byte[] expected = someBytes(); clearWorktreeAndWrite("/test_file.txt", expected); AnyObjectId target = createTreeWithFile("/test_file.txt", expected); new GfsDefaultCheckout(gfs).checkout(target); assertArrayEquals(expected, Files.readAllBytes(gfs.getPath("/test_file.txt"))); }
@Test public void case5_headEqualTarget_targetNotEqualWorktree_worktreeFileShouldRemainTheSame() throws IOException { initRepository(); byte[] someBytes = someBytes(); writeToCache("/test_file.txt", someBytes); commitToMaster(); initGitFileSystem(); byte[] expected = someBytes(); clearWorktreeAndWrite("/test_file.txt", expected); AnyObjectId target = createTreeWithFile("/test_file.txt", someBytes); new GfsDefaultCheckout(gfs).checkout(target); assertArrayEquals(expected, Files.readAllBytes(gfs.getPath("/test_file.txt"))); }
@Test public void case8_allTreesEqual_worktreeFileShouldRemainTheSame() throws IOException { initRepository(); byte[] expected = someBytes(); writeToCache("/test_file.txt", expected); commitToMaster(); initGitFileSystem(); AnyObjectId target = createTreeWithFile("/test_file.txt", expected); new GfsDefaultCheckout(gfs).checkout(target); assertArrayEquals(expected, Files.readAllBytes(gfs.getPath("/test_file.txt"))); }
@Test public void whenEmptyChildrenDirectoriesIAreCreated_getObjectIdShouldReturnSameValue() throws IOException { initGitFileSystem("/dir/some_file.txt"); AnyObjectId original = objectId("/dir"); Files.createDirectories(gfs.getPath("/dir/empty_dir1/empty_dir2")); assertEquals(original, objectId("/dir")); }