Java 类org.eclipse.jgit.lib.AnyObjectId 实例源码

/**
 * 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"));
}