org.eclipse.jgit.lib.ObjectId.fromString() - java examples

Here are the examples of the java api org.eclipse.jgit.lib.ObjectId.fromString() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

155 Examples 7

19 View Complete Implementation : PatchListCacheIT.java
Copyright Apache License 2.0
Author : GerritCodeReview
private ObjectId getCurrentRevisionId(String changeId) throws Exception {
    return ObjectId.fromString(gApi.changes().id(changeId).get().currentRevision);
}

19 View Complete Implementation : Build.java
Copyright MIT License
Author : theonedev
/**
 * Get fixed issue numbers
 */
public Collection<Long> getFixedIssueNumbers() {
    if (fixedIssueNumbers == null) {
        fixedIssueNumbers = new HashSet<>();
        Build prevBuild = getStreamPrevious(null);
        if (prevBuild != null) {
            Repository repository = project.getRepository();
            try (RevWalk revWalk = new RevWalk(repository)) {
                revWalk.markStart(revWalk.parseCommit(ObjectId.fromString(getCommitHash())));
                revWalk.markUninteresting(revWalk.parseCommit(prevBuild.getCommitId()));
                RevCommit commit;
                while ((commit = revWalk.next()) != null) fixedIssueNumbers.addAll(IssueUtils.parseFixedIssueNumbers(commit.getFullMessage()));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    return fixedIssueNumbers;
}

19 View Complete Implementation : ProjectAdminServiceImpl.java
Copyright Apache License 2.0
Author : gerrit-review
private static ObjectId getBase(String baseRevision) {
    if (baseRevision != null && !baseRevision.isEmpty()) {
        return ObjectId.fromString(baseRevision);
    }
    return null;
}

19 View Complete Implementation : SubmoduleSubscriptionsIT.java
Copyright Apache License 2.0
Author : GerritCodeReview
@Test
public void skipUpdatingBrokenGitlinkPointer() throws Exception {
    allowMatchingSubmoduleSubscription(subKey, "refs/heads/master", superKey, "refs/heads/master");
    createSubmoduleSubscription(superRepo, "master", subKey, "master");
    // Push once to initialize submodule.
    ObjectId subTip = pushChangeTo(subRepo, "master");
    expectToHaveSubmoduleState(superRepo, "master", subKey, subTip);
    // Write an invalid SHA-1 directly to the gitlink.
    ObjectId badId = ObjectId.fromString("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef");
    directUpdateSubmodule(superKey, "refs/heads/master", subKey, badId);
    expectToHaveSubmoduleState(superRepo, "master", subKey, badId);
    // Push succeeds, but gitlink update is skipped.
    pushChangeTo(subRepo, "master");
    expectToHaveSubmoduleState(superRepo, "master", subKey, badId);
}

19 View Complete Implementation : Mergeable.java
Copyright Apache License 2.0
Author : gerrit-review
private static ObjectId toId(PatchSet ps) {
    try {
        return ObjectId.fromString(ps.getRevision().get());
    } catch (IllegalArgumentException e) {
        log.error("Invalid revision on patch set " + ps);
        return null;
    }
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void createNewPatchSetForExpectedMergeCommitWithNoChangeId() throws Exception {
    ChangeNotes notes = insertChange();
    String dest = notes.getChange().getDest().get();
    String rev = psUtil.current(db, notes).getRevision().get();
    RevCommit commit = testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev));
    RevCommit mergedAs = testRepo.commit().parent(commit.getParent(0)).message(commit.getShortMessage()).create();
    testRepo.getRevWalk().parseBody(mergedAs);
    replacedertThat(mergedAs.getFooterLines(FooterConstants.CHANGE_ID)).isEmpty();
    testRepo.update(dest, mergedAs);
    replacedertNoProblems(notes, null);
    FixInput fix = new FixInput();
    fix.expectMergedAs = mergedAs.name();
    replacedertProblems(notes, fix, problem("No patch set found for merged commit " + mergedAs.name(), FIXED, "Marked change as merged"), problem("Expected merged commit " + mergedAs.name() + " has no replacedociated patch set", FIXED, "Inserted as patch set 2"));
    notes = reload(notes);
    PatchSet.Id psId2 = new PatchSet.Id(notes.getChangeId(), 2);
    replacedertThat(notes.getChange().currentPatchSetId()).isEqualTo(psId2);
    replacedertThat(psUtil.get(db, notes, psId2).getRevision().get()).isEqualTo(mergedAs.name());
    replacedertNoProblems(notes, null);
}

19 View Complete Implementation : GetCommitIT.java
Copyright Apache License 2.0
Author : GerritCodeReview
@Test
public void getNonExistingCommit_NotFound() throws Exception {
    replacedertNotFound(ObjectId.fromString("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
}

19 View Complete Implementation : Build.java
Copyright MIT License
Author : theonedev
public Collection<RevCommit> getCommits(@Nullable Build.Status sincePrevStatus) {
    if (commitsCache == null)
        commitsCache = new HashMap<>();
    if (!commitsCache.containsKey(sincePrevStatus)) {
        Collection<RevCommit> commits = new ArrayList<>();
        Build prevBuild = getStreamPrevious(sincePrevStatus);
        if (prevBuild != null) {
            Repository repository = project.getRepository();
            try (RevWalk revWalk = new RevWalk(repository)) {
                revWalk.markStart(revWalk.parseCommit(ObjectId.fromString(getCommitHash())));
                revWalk.markUninteresting(revWalk.parseCommit(prevBuild.getCommitId()));
                RevCommit commit;
                while ((commit = revWalk.next()) != null) commits.add(commit);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        commitsCache.put(sincePrevStatus, commits);
    }
    return commitsCache.get(sincePrevStatus);
}

19 View Complete Implementation : DefaultIssueChangeManager.java
Copyright MIT License
Author : theonedev
private void checkBuild(TransitionSpec transition, Build build) {
    if (transition.getTrigger() instanceof BuildSuccessfulTrigger) {
        Project project = build.getProject();
        BuildSuccessfulTrigger trigger = (BuildSuccessfulTrigger) transition.getTrigger();
        String branches = trigger.getBranches();
        ObjectId commitId = ObjectId.fromString(build.getCommitHash());
        if ((trigger.getJobNames() == null || PatternSet.parse(trigger.getJobNames()).matches(new StringMatcher(), build.getJobName())) && build.getStatus() == Build.Status.SUCCESSFUL && (branches == null || project.isCommitOnBranches(commitId, branches))) {
            IssueQuery query = IssueQuery.parse(project, trigger.getIssueQuery(), true, false, true, false, false);
            List<IssueCriteria> criterias = new ArrayList<>();
            for (String fromState : transition.getFromStates()) criterias.add(new StateCriteria(fromState));
            criterias.add(query.getCriteria());
            query = new IssueQuery(IssueCriteria.of(criterias), new ArrayList<>());
            Build.push(build);
            try {
                for (Issue issue : issueManager.query(project, query, 0, Integer.MAX_VALUE)) {
                    issue.removeFields(transition.getRemoveFields());
                    changeState(issue, transition.getToState(), new HashMap<>(), null);
                }
            } finally {
                Build.pop();
            }
        }
    }
}

19 View Complete Implementation : Submit.java
Copyright Apache License 2.0
Author : gerrit-review
private HashMap<Change.Id, RevCommit> findCommits(Collection<ChangeData> changes, Project.NameKey project) throws IOException, OrmException {
    HashMap<Change.Id, RevCommit> commits = new HashMap<>();
    try (Repository repo = repoManager.openRepository(project);
        RevWalk walk = new RevWalk(repo)) {
        for (ChangeData change : changes) {
            RevCommit commit = walk.parseCommit(ObjectId.fromString(psUtil.current(dbProvider.get(), change.notes()).getRevision().get()));
            commits.put(change.getId(), commit);
        }
    }
    return commits;
}

19 View Complete Implementation : Rebase.java
Copyright Apache License 2.0
Author : gerrit-review
private boolean isMergedInto(RevWalk rw, PatchSet base, PatchSet tip) throws IOException {
    ObjectId baseId = ObjectId.fromString(base.getRevision().get());
    ObjectId tipId = ObjectId.fromString(tip.getRevision().get());
    return rw.isMergedInto(rw.parseCommit(baseId), rw.parseCommit(tipId));
}

19 View Complete Implementation : GetCommitIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void getNonExistingCommit_NotFound() throws Exception {
    replacedertNotFound(ObjectId.fromString("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
}

19 View Complete Implementation : EventFactory.java
Copyright Apache License 2.0
Author : gerrit-review
private void addNeededBy(RevWalk rw, ChangeAttribute ca, Change change, PatchSet currentPs) throws OrmException, IOException {
    if (currentPs.getGroups().isEmpty()) {
        return;
    }
    String rev = currentPs.getRevision().get();
    // Find changes in the same related group as this patch set, having a patch
    // set whose parent matches this patch set's revision.
    for (ChangeData cd : queryProvider.get().byProjectGroups(change.getProject(), currentPs.getGroups())) {
        PATCH_SETS: for (PatchSet ps : cd.patchSets()) {
            RevCommit commit = rw.parseCommit(ObjectId.fromString(ps.getRevision().get()));
            for (RevCommit p : commit.getParents()) {
                if (!p.name().equals(rev)) {
                    continue;
                }
                ca.neededBy.add(newNeededBy(checkNotNull(cd.change()), ps));
                continue PATCH_SETS;
            }
        }
    }
}

19 View Complete Implementation : GetRelatedIT.java
Copyright Apache License 2.0
Author : GerritCodeReview
@Test
public void getRelatedEdit() throws Exception {
    // 1,1---2,1---3,1
    // \---2,E---/
    RevCommit c1_1 = commitBuilder().add("a.txt", "1").message("subject: 1").create();
    RevCommit c2_1 = commitBuilder().add("b.txt", "2").message("subject: 2").create();
    RevCommit c3_1 = commitBuilder().add("c.txt", "3").message("subject: 3").create();
    pushHead(testRepo, "refs/for/master", false);
    Change ch2 = getChange(c2_1).change();
    String changeId2 = ch2.getKey().get();
    gApi.changes().id(changeId2).edit().create();
    gApi.changes().id(changeId2).edit().modifyFile("a.txt", RawInputUtil.create(new byte[] { 'a' }));
    Optional<EditInfo> edit = getEdit(changeId2);
    replacedertThat(edit).isPresent();
    ObjectId editRev = ObjectId.fromString(edit.get().commit.commit);
    PatchSet.Id ps1_1 = getPatchSetId(c1_1);
    PatchSet.Id ps2_1 = getPatchSetId(c2_1);
    PatchSet.Id ps2_edit = PatchSet.id(ch2.getId(), 0);
    PatchSet.Id ps3_1 = getPatchSetId(c3_1);
    for (PatchSet.Id ps : ImmutableList.of(ps1_1, ps2_1, ps3_1)) {
        replacedertRelated(ps, changeAndCommit(ps3_1, c3_1, 1), changeAndCommit(ps2_1, c2_1, 1), changeAndCommit(ps1_1, c1_1, 1));
    }
    replacedertRelated(ps2_edit, changeAndCommit(ps3_1, c3_1, 1), changeAndCommit(PatchSet.id(ch2.getId(), 0), editRev, 1), changeAndCommit(ps1_1, c1_1, 1));
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
private ChangeNotes mergeChange(ChangeNotes notes) throws Exception {
    final ObjectId oldId = getDestRef(notes);
    final ObjectId newId = ObjectId.fromString(psUtil.current(db, notes).getRevision().get());
    final String dest = notes.getChange().getDest().get();
    try (BatchUpdate bu = newUpdate(adminId)) {
        bu.addOp(notes.getChangeId(), new BatchUpdateOp() {

            @Override
            public void updateRepo(RepoContext ctx) throws IOException {
                ctx.addRefUpdate(oldId, newId, dest);
            }

            @Override
            public boolean updateChange(ChangeContext ctx) throws OrmException {
                ctx.getChange().setStatus(Change.Status.MERGED);
                ctx.getUpdate(ctx.getChange().currentPatchSetId()).fixStatus(Change.Status.MERGED);
                return true;
            }
        });
        bu.execute();
    }
    return reload(notes);
}

19 View Complete Implementation : GroupCollector.java
Copyright Apache License 2.0
Author : GerritCodeReview
private ObjectId parseGroup(ObjectId forCommit, String group) {
    try {
        return ObjectId.fromString(group);
    } catch (IllegalArgumentException e) {
        // Shouldn't happen; some sort of corruption or manual tinkering?
        logger.atWarning().log("group for commit %s is not a SHA-1: %s", forCommit.name(), group);
        return null;
    }
}

19 View Complete Implementation : PatchScriptFactory.java
Copyright Apache License 2.0
Author : gerrit-review
private ObjectId toObjectId(PatchSet ps) throws AuthException, IOException, OrmException {
    if (ps.getId().get() == 0) {
        return getEditRev();
    }
    if (ps.getRevision() == null || ps.getRevision().get() == null) {
        throw new NoSuchChangeException(changeId);
    }
    try {
        return ObjectId.fromString(ps.getRevision().get());
    } catch (IllegalArgumentException e) {
        log.error("Patch set " + ps.getId() + " has invalid revision");
        throw new NoSuchChangeException(changeId, e);
    }
}

19 View Complete Implementation : PullRequest.java
Copyright MIT License
Author : theonedev
/**
 * Merged commits represent commits already merged to target branch since base commit.
 *
 * @return
 * 			commits already merged to target branch since base commit
 */
public Collection<RevCommit> getMergedCommits() {
    if (mergedCommits == null) {
        mergedCommits = new HashSet<>();
        Project project = getTargetProject();
        try (RevWalk revWalk = new RevWalk(project.getRepository())) {
            revWalk.markStart(revWalk.parseCommit(getTarget().getObjectId(false)));
            revWalk.markUninteresting(revWalk.parseCommit(ObjectId.fromString(getBaseCommitHash())));
            revWalk.forEach(c -> mergedCommits.add(c));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    return mergedCommits;
}

19 View Complete Implementation : DeleteChangeOp.java
Copyright Apache License 2.0
Author : gerrit-review
private boolean isPatchSetMerged(ChangeContext ctx, PatchSet patchSet) throws IOException {
    Optional<ObjectId> destId = ctx.getRepoView().getRef(ctx.getChange().getDest().get());
    if (!destId.isPresent()) {
        return false;
    }
    RevWalk revWalk = ctx.getRevWalk();
    ObjectId objectId = ObjectId.fromString(patchSet.getRevision().get());
    return revWalk.isMergedInto(revWalk.parseCommit(objectId), revWalk.parseCommit(destId.get()));
}

19 View Complete Implementation : PullRequest.java
Copyright MIT License
Author : theonedev
/**
 * Get commits pending merge.
 *
 * @return
 * 			commits pending merge
 */
public Collection<RevCommit> getPendingCommits() {
    if (pendingCommits == null) {
        pendingCommits = new HashSet<>();
        Project project = getTargetProject();
        try (RevWalk revWalk = new RevWalk(project.getRepository())) {
            revWalk.markStart(revWalk.parseCommit(ObjectId.fromString(getHeadCommitHash())));
            revWalk.markUninteresting(revWalk.parseCommit(getTarget().getObjectId()));
            revWalk.forEach(c -> pendingCommits.add(c));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    return pendingCommits;
}

19 View Complete Implementation : ChangeUpdate.java
Copyright Apache License 2.0
Author : gerrit-review
@VisibleForTesting
ObjectId getCommit() {
    return ObjectId.fromString(commit);
}

19 View Complete Implementation : ConsistencyChecker.java
Copyright Apache License 2.0
Author : gerrit-review
private ObjectId parseObjectId(String objIdStr, String desc) {
    try {
        return ObjectId.fromString(objIdStr);
    } catch (IllegalArgumentException e) {
        problem(String.format("Invalid revision on %s: %s", desc, objIdStr));
        return null;
    }
}

19 View Complete Implementation : PatchListCacheIT.java
Copyright Apache License 2.0
Author : gerrit-review
private ObjectId getCurrentRevisionId(String changeId) throws Exception {
    return ObjectId.fromString(gApi.changes().id(changeId).get().currentRevision);
}

19 View Complete Implementation : ChangeEditModifier.java
Copyright Apache License 2.0
Author : gerrit-review
private static ObjectId getPatchSetCommitId(PatchSet patchSet) {
    return ObjectId.fromString(patchSet.getRevision().get());
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void expectedMergedCommitWithMismatchedChangeId() throws Exception {
    ChangeNotes notes = insertChange();
    String dest = notes.getChange().getDest().get();
    RevCommit parent = testRepo.branch(dest).commit().message("parent").create();
    String rev = psUtil.current(db, notes).getRevision().get();
    RevCommit commit = testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev));
    testRepo.branch(dest).update(commit);
    String badId = "I0000000000000000000000000000000000000000";
    RevCommit mergedAs = testRepo.commit().parent(parent).message(commit.getShortMessage() + "\n\nChange-Id: " + badId + "\n").create();
    testRepo.getRevWalk().parseBody(mergedAs);
    replacedertThat(mergedAs.getFooterLines(FooterConstants.CHANGE_ID)).containsExactly(badId);
    testRepo.update(dest, mergedAs);
    replacedertNoProblems(notes, null);
    FixInput fix = new FixInput();
    fix.expectMergedAs = mergedAs.name();
    replacedertProblems(notes, fix, problem("Expected merged commit " + mergedAs.name() + " has Change-Id: " + badId + ", but expected " + notes.getChange().getKey().get()));
}

19 View Complete Implementation : GroupCollector.java
Copyright Apache License 2.0
Author : gerrit-review
private ObjectId parseGroup(ObjectId forCommit, String group) {
    try {
        return ObjectId.fromString(group);
    } catch (IllegalArgumentException e) {
        // Shouldn't happen; some sort of corruption or manual tinkering?
        log.warn("group for commit {} is not a SHA-1: {}", forCommit.name(), group);
        return null;
    }
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void patchSetRefMissing() throws Exception {
    ChangeNotes notes = insertChange();
    testRepo.update("refs/other/foo", ObjectId.fromString(psUtil.current(db, notes).getRevision().get()));
    String refName = notes.getChange().currentPatchSetId().toRefName();
    deleteRef(refName);
    replacedertProblems(notes, null, problem("Ref missing: " + refName));
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void expectedMergedCommitIsLatestPatchSet() throws Exception {
    ChangeNotes notes = insertChange();
    String rev = psUtil.current(db, notes).getRevision().get();
    testRepo.branch(notes.getChange().getDest().get()).update(testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev)));
    FixInput fix = new FixInput();
    fix.expectMergedAs = rev;
    replacedertProblems(notes, fix, problem("Patch set 1 (" + rev + ") is merged into destination ref" + " refs/heads/master (" + rev + "), but change status is NEW", FIXED, "Marked change as merged"));
    notes = reload(notes);
    replacedertThat(notes.getChange().getStatus()).isEqualTo(Change.Status.MERGED);
    replacedertNoProblems(notes, null);
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void newChangeIsMerged() throws Exception {
    ChangeNotes notes = insertChange();
    String rev = psUtil.current(db, notes).getRevision().get();
    testRepo.branch(notes.getChange().getDest().get()).update(testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev)));
    replacedertProblems(notes, null, problem("Patch set 1 (" + rev + ") is merged into destination ref" + " refs/heads/master (" + rev + "), but change status is NEW"));
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void newChangeIsMergedWithFix() throws Exception {
    ChangeNotes notes = insertChange();
    String rev = psUtil.current(db, notes).getRevision().get();
    testRepo.branch(notes.getChange().getDest().get()).update(testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev)));
    replacedertProblems(notes, new FixInput(), problem("Patch set 1 (" + rev + ") is merged into destination ref" + " refs/heads/master (" + rev + "), but change status is NEW", FIXED, "Marked change as merged"));
    notes = reload(notes);
    replacedertThat(notes.getChange().getStatus()).isEqualTo(Change.Status.MERGED);
    replacedertNoProblems(notes, null);
}

19 View Complete Implementation : ChangeNotesStateTest.java
Copyright Apache License 2.0
Author : GerritCodeReview
@Test
public void serializePatchSets() throws Exception {
    PatchSet ps1 = PatchSet.builder().id(PatchSet.id(ID, 1)).commitId(ObjectId.fromString("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")).uploader(Account.id(2000)).createdOn(cols.createdOn()).build();
    ByteString ps1Bytes = toByteString(ps1, PatchSetProtoConverter.INSTANCE);
    replacedertThat(ps1Bytes.size()).isEqualTo(66);
    PatchSet ps2 = PatchSet.builder().id(PatchSet.id(ID, 2)).commitId(ObjectId.fromString("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")).uploader(Account.id(3000)).createdOn(cols.lastUpdatedOn()).build();
    ByteString ps2Bytes = toByteString(ps2, PatchSetProtoConverter.INSTANCE);
    replacedertThat(ps2Bytes.size()).isEqualTo(66);
    replacedertThat(ps2Bytes).isNotEqualTo(ps1Bytes);
    replacedertRoundTrip(newBuilder().patchSets(ImmutableMap.of(ps2.id(), ps2, ps1.id(), ps1).entrySet()).build(), ChangeNotesStateProto.newBuilder().setMetaId(SHA_BYTES).setChangeId(ID.get()).setColumns(colsProto).addPatchSet(ps2Bytes).addPatchSet(ps1Bytes).build());
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void expectedMergedCommitMatchesMultiplePatchSets() throws Exception {
    ChangeNotes notes1 = insertChange();
    PatchSet.Id psId1 = psUtil.current(db, notes1).getId();
    String dest = notes1.getChange().getDest().get();
    String rev = psUtil.current(db, notes1).getRevision().get();
    RevCommit commit = testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev));
    testRepo.branch(dest).update(commit);
    ChangeNotes notes2 = insertChange();
    notes2 = incrementPatchSet(notes2, commit);
    PatchSet.Id psId2 = psUtil.current(db, notes2).getId();
    ChangeNotes notes3 = insertChange();
    notes3 = incrementPatchSet(notes3, commit);
    PatchSet.Id psId3 = psUtil.current(db, notes3).getId();
    FixInput fix = new FixInput();
    fix.expectMergedAs = commit.name();
    replacedertProblems(notes1, fix, problem("Multiple patch sets for expected merged commit " + commit.name() + ": [" + psId1 + ", " + psId2 + ", " + psId3 + "]"));
}

19 View Complete Implementation : ExternalIdCacheLoader.java
Copyright Apache License 2.0
Author : GerritCodeReview
private static ObjectId fileNameToObjectId(String path) {
    return ObjectId.fromString(CharMatcher.is('/').removeFrom(path));
}

19 View Complete Implementation : ChangeData.java
Copyright Apache License 2.0
Author : gerrit-review
private boolean loadCommitData() throws OrmException, RepositoryNotFoundException, IOException, MissingObjectException, IncorrectObjectTypeException {
    PatchSet ps = currentPatchSet();
    if (ps == null) {
        return false;
    }
    String sha1 = ps.getRevision().get();
    try (Repository repo = repoManager.openRepository(project());
        RevWalk walk = new RevWalk(repo)) {
        RevCommit c = walk.parseCommit(ObjectId.fromString(sha1));
        commitMessage = c.getFullMessage();
        commitFooters = c.getFooterLines();
        author = c.getAuthorIdent();
        committer = c.getCommitterIdent();
        parentCount = c.getParentCount();
    }
    return true;
}

19 View Complete Implementation : ChangeUpdate.java
Copyright Apache License 2.0
Author : GerritCodeReview
@VisibleForTesting
ObjectId getCommit() {
    return ObjectId.fromString(commit);
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void createNewPatchSetForExpectedMergeCommitWithChangeId() throws Exception {
    ChangeNotes notes = insertChange();
    String dest = notes.getChange().getDest().get();
    String rev = psUtil.current(db, notes).getRevision().get();
    RevCommit commit = testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev));
    RevCommit mergedAs = testRepo.commit().parent(commit.getParent(0)).message(commit.getShortMessage() + "\n" + "\n" + "Change-Id: " + notes.getChange().getKey().get() + "\n").create();
    testRepo.getRevWalk().parseBody(mergedAs);
    replacedertThat(mergedAs.getFooterLines(FooterConstants.CHANGE_ID)).containsExactly(notes.getChange().getKey().get());
    testRepo.update(dest, mergedAs);
    replacedertNoProblems(notes, null);
    FixInput fix = new FixInput();
    fix.expectMergedAs = mergedAs.name();
    replacedertProblems(notes, fix, problem("No patch set found for merged commit " + mergedAs.name(), FIXED, "Marked change as merged"), problem("Expected merged commit " + mergedAs.name() + " has no replacedociated patch set", FIXED, "Inserted as patch set 2"));
    notes = reload(notes);
    PatchSet.Id psId2 = new PatchSet.Id(notes.getChangeId(), 2);
    replacedertThat(notes.getChange().currentPatchSetId()).isEqualTo(psId2);
    replacedertThat(psUtil.get(db, notes, psId2).getRevision().get()).isEqualTo(mergedAs.name());
    replacedertNoProblems(notes, null);
}

19 View Complete Implementation : TestChanges.java
Copyright Apache License 2.0
Author : GerritCodeReview
public static PatchSet newPatchSet(PatchSet.Id id, String revision, Account.Id userId) {
    return PatchSet.builder().id(id).commitId(ObjectId.fromString(revision)).uploader(userId).createdOn(TimeUtil.nowTs()).build();
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void expectedMergedCommitNotMergedIntoDestination() throws Exception {
    ChangeNotes notes = insertChange();
    String rev = psUtil.current(db, notes).getRevision().get();
    RevCommit commit = testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev));
    testRepo.branch(notes.getChange().getDest().get()).update(commit);
    FixInput fix = new FixInput();
    RevCommit other = testRepo.commit().message(commit.getFullMessage()).create();
    fix.expectMergedAs = other.name();
    replacedertProblems(notes, fix, problem("Expected merged commit " + other.name() + " is not merged into destination ref refs/heads/master" + " (" + commit.name() + ")"));
}

19 View Complete Implementation : ConsistencyChecker.java
Copyright Apache License 2.0
Author : GerritCodeReview
private void checkExpectMergedAs() {
    if (!ObjectId.isId(fix.expectMergedAs)) {
        problem("Invalid revision on expected merged commit: " + fix.expectMergedAs);
        return;
    }
    ObjectId objId = ObjectId.fromString(fix.expectMergedAs);
    RevCommit commit = parseCommit(objId, "expected merged commit");
    if (commit == null) {
        return;
    }
    try {
        if (!rw.isMergedInto(commit, tip)) {
            problem(String.format("Expected merged commit %s is not merged into destination ref %s (%s)", commit.name(), change().getDest().branch(), tip.name()));
            return;
        }
        List<PatchSet.Id> thisCommitPsIds = new ArrayList<>();
        for (Ref ref : repo.getRefDatabase().getRefsByPrefix(REFS_CHANGES)) {
            if (!ref.getObjectId().equals(commit)) {
                continue;
            }
            PatchSet.Id psId = PatchSet.Id.fromRef(ref.getName());
            if (psId == null) {
                continue;
            }
            try {
                Change c = notesFactory.createChecked(change().getProject(), psId.changeId()).getChange();
                if (!c.getDest().equals(change().getDest())) {
                    continue;
                }
            } catch (StorageException e) {
                logger.atWarning().withCause(e).log("Error in consistency check of change %s", notes.getChangeId());
            // Include this patch set; should cause an error below, which is good.
            }
            thisCommitPsIds.add(psId);
        }
        switch(thisCommitPsIds.size()) {
            case 0:
                // No patch set for this commit; insert one.
                rw.parseBody(commit);
                String changeId = Iterables.getFirst(commit.getFooterLines(FooterConstants.CHANGE_ID), null);
                // Missing Change-Id footer is ok, but mismatched is not.
                if (changeId != null && !changeId.equals(change().getKey().get())) {
                    problem(String.format("Expected merged commit %s has Change-Id: %s, but expected %s", commit.name(), changeId, change().getKey().get()));
                    return;
                }
                insertMergedPatchSet(commit, null, false);
                break;
            case 1:
                // Existing patch set ref pointing to this commit.
                PatchSet.Id id = thisCommitPsIds.get(0);
                if (id.equals(change().currentPatchSetId())) {
                    // If it's the current patch set, we can just fix the status.
                    fixMerged(wrongChangeStatus(id, commit));
                } else if (id.get() > change().currentPatchSetId().get()) {
                    // If it's newer than the current patch set, reuse this patch set
                    // ID when inserting a new merged patch set.
                    insertMergedPatchSet(commit, id, true);
                } else {
                    // If it's older than the current patch set, just delete the old
                    // ref, and use a new ID when inserting a new merged patch set.
                    insertMergedPatchSet(commit, id, false);
                }
                break;
            default:
                problem(String.format("Multiple patch sets for expected merged commit %s: %s", commit.name(), thisCommitPsIds.stream().sorted(comparing(PatchSet.Id::get)).collect(toImmutableList())));
                break;
        }
    } catch (IOException e) {
        ProblemInfo problem = problem("Error looking up expected merged commit " + fix.expectMergedAs);
        logger.atWarning().withCause(e).log("Error in consistency check of change %s: %s", notes.getChangeId(), problem);
    }
}

19 View Complete Implementation : PullRequestTrigger.java
Copyright MIT License
Author : theonedev
private boolean touchedFile(PullRequest request) {
    if (getPaths() != null) {
        Collection<String> changedFiles = GitUtils.getChangedFiles(request.getTargetProject().getRepository(), request.getTarget().getObjectId(), ObjectId.fromString(request.getLastMergePreview().getMerged()));
        PatternSet patternSet = PatternSet.parse(getPaths());
        Matcher matcher = new PathMatcher();
        for (String changedFile : changedFiles) {
            if (patternSet.matches(matcher, changedFile))
                return true;
        }
        return false;
    } else {
        return true;
    }
}

19 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void patchSetRefMissingWithFix() throws Exception {
    ChangeNotes notes = insertChange();
    String rev = psUtil.current(db, notes).getRevision().get();
    testRepo.update("refs/other/foo", ObjectId.fromString(rev));
    String refName = notes.getChange().currentPatchSetId().toRefName();
    deleteRef(refName);
    replacedertProblems(notes, new FixInput(), problem("Ref missing: " + refName, FIXED, "Repaired patch set ref"));
    replacedertThat(testRepo.getRepository().exactRef(refName).getObjectId().name()).isEqualTo(rev);
}

19 View Complete Implementation : ReceiveCommitsAdvertiseRefsHook.java
Copyright Apache License 2.0
Author : gerrit-review
private Set<ObjectId> advertiseOpenChanges(Set<ObjectId> allPatchSets) {
    // Advertise some recent open changes, in case a commit is based on one.
    int limit = 32;
    try {
        Set<ObjectId> r = Sets.newHashSetWithExpectedSize(limit);
        for (ChangeData cd : queryProvider.get().setRequestedFields(// Required for ChangeIsVisibleToPrdicate.
        ChangeField.CHANGE, ChangeField.REVIEWER, // Required during advertiseOpenChanges.
        ChangeField.PATCH_SET).enforceVisibility(true).setLimit(limit).byProjectOpen(projectName)) {
            PatchSet ps = cd.currentPatchSet();
            if (ps != null) {
                ObjectId id = ObjectId.fromString(ps.getRevision().get());
                // Ensure we actually observed a patch set ref pointing to this
                // object, in case the database is out of sync with the repo and the
                // object doesn't actually exist.
                if (allPatchSets.contains(id)) {
                    r.add(id);
                }
            }
        }
        return r;
    } catch (OrmException err) {
        log.error("Cannot list open changes of " + projectName, err);
        return Collections.emptySet();
    }
}

19 View Complete Implementation : RefAdvertisementIT.java
Copyright Apache License 2.0
Author : gerrit-review
private static ObjectId obj(ChangeData cd, int psNum) throws Exception {
    PatchSet.Id psId = new PatchSet.Id(cd.getId(), psNum);
    PatchSet ps = cd.patchSet(psId);
    replacedertWithMessage("%s not found in %s", psId, cd.patchSets()).that(ps).isNotNull();
    return ObjectId.fromString(ps.getRevision().get());
}

18 View Complete Implementation : ChangeUpdate.java
Copyright Apache License 2.0
Author : gerrit-review
/**
 * @return the tree id for the updated tree
 */
private ObjectId storeRevisionNotes(RevWalk rw, ObjectInserter inserter, ObjectId curr) throws ConfigInvalidException, OrmException, IOException {
    if (comments.isEmpty() && pushCert == null) {
        return null;
    }
    RevisionNoteMap<ChangeRevisionNote> rnm = getRevisionNoteMap(rw, curr);
    RevisionNoteBuilder.Cache cache = new RevisionNoteBuilder.Cache(rnm);
    for (Comment c : comments) {
        c.tag = tag;
        cache.get(new RevId(c.revId)).putComment(c);
    }
    if (pushCert != null) {
        checkState(commit != null);
        cache.get(new RevId(commit)).setPushCertificate(pushCert);
    }
    Map<RevId, RevisionNoteBuilder> builders = cache.getBuilders();
    checkComments(rnm.revisionNotes, builders);
    for (Map.Entry<RevId, RevisionNoteBuilder> e : builders.entrySet()) {
        ObjectId data = inserter.insert(OBJ_BLOB, e.getValue().build(noteUtil, noteUtil.getWriteJson()));
        rnm.noteMap.set(ObjectId.fromString(e.getKey().get()), data);
    }
    return rnm.noteMap.writeTree(inserter);
}

18 View Complete Implementation : EventFactory.java
Copyright Apache License 2.0
Author : gerrit-review
private void addDependsOn(RevWalk rw, ChangeAttribute ca, Change change, PatchSet currentPs) throws OrmException, IOException {
    RevCommit commit = rw.parseCommit(ObjectId.fromString(currentPs.getRevision().get()));
    final List<String> parentNames = new ArrayList<>(commit.getParentCount());
    for (RevCommit p : commit.getParents()) {
        parentNames.add(p.name());
    }
    // Find changes in this project having a patch set matching any parent of
    // this patch set's revision.
    for (ChangeData cd : queryProvider.get().byProjectCommits(change.getProject(), parentNames)) {
        for (PatchSet ps : cd.patchSets()) {
            for (String p : parentNames) {
                if (!ps.getRevision().get().equals(p)) {
                    continue;
                }
                ca.dependsOn.add(newDependsOn(checkNotNull(cd.change()), ps));
            }
        }
    }
    // Sort by original parent order.
    Collections.sort(ca.dependsOn, comparing((DependencyAttribute d) -> {
        for (int i = 0; i < parentNames.size(); i++) {
            if (parentNames.get(i).equals(d.revision)) {
                return i;
            }
        }
        return parentNames.size() + 1;
    }));
}

18 View Complete Implementation : ChangeData.java
Copyright Apache License 2.0
Author : gerrit-review
private Optional<DiffSummary> getDiffSummary() throws OrmException, IOException {
    if (diffSummary == null) {
        if (!lazyLoad) {
            return Optional.empty();
        }
        Change c = change();
        PatchSet ps = currentPatchSet();
        if (c == null || ps == null || !loadCommitData()) {
            return Optional.empty();
        }
        ObjectId id = ObjectId.fromString(ps.getRevision().get());
        Whitespace ws = Whitespace.IGNORE_NONE;
        PatchListKey pk = parentCount > 1 ? PatchListKey.againstParentNum(1, id, ws) : PatchListKey.againstDefaultBase(id, ws);
        DiffSummaryKey key = DiffSummaryKey.fromPatchListKey(pk);
        try {
            diffSummary = Optional.of(patchListCache.getDiffSummary(key, c.getProject()));
        } catch (PatchListNotAvailableException e) {
            diffSummary = Optional.empty();
        }
    }
    return diffSummary;
}

18 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void expectedMergedCommitIsOldPatchSetOfSameChange() throws Exception {
    ChangeNotes notes = insertChange();
    PatchSet ps1 = psUtil.current(db, notes);
    String rev1 = ps1.getRevision().get();
    notes = incrementPatchSet(notes);
    PatchSet ps2 = psUtil.current(db, notes);
    testRepo.branch(notes.getChange().getDest().get()).update(testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev1)));
    FixInput fix = new FixInput();
    fix.expectMergedAs = rev1;
    replacedertProblems(notes, fix, problem("No patch set found for merged commit " + rev1, FIXED, "Marked change as merged"), problem("Expected merge commit " + rev1 + " corresponds to patch set 1," + " not the current patch set 2", FIXED, "Deleted patch set"), problem("Expected merge commit " + rev1 + " corresponds to patch set 1," + " not the current patch set 2", FIXED, "Inserted as patch set 3"));
    notes = reload(notes);
    PatchSet.Id psId3 = new PatchSet.Id(notes.getChangeId(), 3);
    replacedertThat(notes.getChange().currentPatchSetId()).isEqualTo(psId3);
    replacedertThat(notes.getChange().getStatus()).isEqualTo(Change.Status.MERGED);
    replacedertThat(psUtil.byChangeAsMap(db, notes).keySet()).containsExactly(ps2.getId(), psId3);
    replacedertThat(psUtil.get(db, notes, psId3).getRevision().get()).isEqualTo(rev1);
}

18 View Complete Implementation : ConsistencyCheckerIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void expectedMergedCommitIsDanglingPatchSetOlderThanCurrent() throws Exception {
    ChangeNotes notes = insertChange();
    PatchSet ps1 = psUtil.current(db, notes);
    // Create dangling ref so next ID in the database becomes 3.
    PatchSet.Id psId2 = new PatchSet.Id(notes.getChangeId(), 2);
    RevCommit commit2 = patchSetCommit(psId2);
    String rev2 = commit2.name();
    testRepo.branch(psId2.toRefName()).update(commit2);
    notes = incrementPatchSet(notes);
    PatchSet ps3 = psUtil.current(db, notes);
    replacedertThat(ps3.getId().get()).isEqualTo(3);
    testRepo.branch(notes.getChange().getDest().get()).update(testRepo.getRevWalk().parseCommit(ObjectId.fromString(rev2)));
    FixInput fix = new FixInput();
    fix.expectMergedAs = rev2;
    replacedertProblems(notes, fix, problem("No patch set found for merged commit " + rev2, FIXED, "Marked change as merged"), problem("Expected merge commit " + rev2 + " corresponds to patch set 2," + " not the current patch set 3", FIXED, "Deleted patch set"), problem("Expected merge commit " + rev2 + " corresponds to patch set 2," + " not the current patch set 3", FIXED, "Inserted as patch set 4"));
    notes = reload(notes);
    PatchSet.Id psId4 = new PatchSet.Id(notes.getChangeId(), 4);
    replacedertThat(notes.getChange().currentPatchSetId()).isEqualTo(psId4);
    replacedertThat(notes.getChange().getStatus()).isEqualTo(Change.Status.MERGED);
    replacedertThat(psUtil.byChangeAsMap(db, notes).keySet()).containsExactly(ps1.getId(), ps3.getId(), psId4);
    replacedertThat(psUtil.get(db, notes, psId4).getRevision().get()).isEqualTo(rev2);
}

18 View Complete Implementation : SubmitByCherryPickIT.java
Copyright Apache License 2.0
Author : gerrit-review
@Test
public void changeMessageOnSubmit() throws Exception {
    PushOneCommit.Result change = createChange();
    RegistrationHandle handle = changeMessageModifiers.add(new ChangeMessageModifier() {

        @Override
        public String onSubmit(String newCommitMessage, RevCommit original, RevCommit mergeTip, Branch.NameKey destination) {
            return newCommitMessage + "Custom: " + destination.get();
        }
    });
    try {
        submit(change.getChangeId());
    } finally {
        handle.remove();
    }
    testRepo.git().fetch().setRemote("origin").call();
    ChangeInfo info = get(change.getChangeId(), CURRENT_REVISION);
    RevCommit c = testRepo.getRevWalk().parseCommit(ObjectId.fromString(info.currentRevision));
    testRepo.getRevWalk().parseBody(c);
    replacedertThat(c.getFooterLines("Custom")).containsExactly("refs/heads/master");
    replacedertThat(c.getFooterLines(FooterConstants.REVIEWED_ON)).hreplacedize(1);
}

18 View Complete Implementation : ChangeNotesParser.java
Copyright Apache License 2.0
Author : gerrit-review
private ObjectId parseRevision(ChangeNotesCommit commit) throws ConfigInvalidException {
    String sha = parseOneFooter(commit, FOOTER_COMMIT);
    if (sha == null) {
        return null;
    }
    try {
        return ObjectId.fromString(sha);
    } catch (InvalidObjectIdException e) {
        ConfigInvalidException cie = invalidFooter(FOOTER_COMMIT, sha);
        cie.initCause(e);
        throw cie;
    }
}