RevCommit otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else { otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else { otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else {
RevCommit otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else { otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else { otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else {
private Collection<String> getTags(final Git git, final ObjectId objectId, final RevWalk finalWalk) throws GitAPIException { return git.tagList().call() .stream() .filter(tagRef -> { try { final RevCommit tagCommit = finalWalk.parseCommit(tagRef.getObjectId()); final RevCommit objectCommit = finalWalk.parseCommit(objectId); if (finalWalk.isMergedInto(objectCommit, tagCommit)) { return true; } } catch (Exception ignored) { log.debug("Failed while getTags [{}] -- ", tagRef, ignored); } return false; }) .map(tagRef -> trimFullTagName(tagRef.getName())) .collect(Collectors.toList()); }
if (rw.isMergedInto(remote, head)) { return LAGGING; if (rw.isMergedInto(head, remote)) { return AHEAD; } else {
/** * Update the type of this command by checking for fast-forward. * <p> * If the command's current type is UPDATE, a merge test will be performed * using the supplied RevWalk to determine if {@link #getOldId()} is fully * merged into {@link #getNewId()}. If some commits are not merged the * update type is changed to * {@link org.eclipse.jgit.transport.ReceiveCommand.Type#UPDATE_NONFASTFORWARD}. * * @param walk * an instance to perform the merge test with. The caller must * allocate and release this object. * @throws java.io.IOException * either oldId or newId is not accessible in the repository * used by the RevWalk. This usually indicates data corruption, * and the command cannot be processed. */ public void updateType(RevWalk walk) throws IOException { if (typeIsCorrect) return; if (type == Type.UPDATE && !AnyObjectId.equals(oldId, newId)) { RevObject o = walk.parseAny(oldId); RevObject n = walk.parseAny(newId); if (!(o instanceof RevCommit) || !(n instanceof RevCommit) || !walk.isMergedInto((RevCommit) o, (RevCommit) n)) setType(Type.UPDATE_NONFASTFORWARD); } typeIsCorrect = true; }
/** * Check if we can fast-forward and returns the new head if it is possible * * @param newCommit * a {@link org.eclipse.jgit.revwalk.RevCommit} object to check * if we can fast-forward to. * @return the new head, or null * @throws java.io.IOException * @throws org.eclipse.jgit.api.errors.GitAPIException */ public RevCommit tryFastForward(RevCommit newCommit) throws IOException, GitAPIException { Ref head = getHead(); ObjectId headId = head.getObjectId(); if (headId == null) throw new RefNotFoundException(MessageFormat.format( JGitText.get().refNotResolved, Constants.HEAD)); RevCommit headCommit = walk.lookupCommit(headId); if (walk.isMergedInto(newCommit, headCommit)) return newCommit; String headName = getHeadName(head); return tryFastForward(headName, headCommit, newCommit); }
continue; if (revWalk.isMergedInto(commit, headCommit)) result.add(ref);
if (!walk.isMergedInto(base, tip)) { throw new NotMergedException();
@Test public void testFailure() throws IOException { // perform a specific check for things that seem to fail in github/travis checking try (Repository repository = CookbookHelper.openJGitCookbookRepository()) { try (RevWalk revWalk = new RevWalk( repository )) { ObjectId resolve = repository.resolve( "refs/heads/master" ); assertNotNull("Did not find refs/heads/master", resolve); RevCommit masterHead = revWalk.parseCommit( resolve); // first a commit that was merged ObjectId id = repository.resolve("05d18a76875716fbdbd2c200091b40caa06c713d"); System.out.println("Had id: " + id); assertNotNull("Did not find specific commit", resolve); RevCommit otherHead = revWalk.parseCommit( id ); if( revWalk.isMergedInto( otherHead, masterHead ) ) { System.out.println("Commit " + otherHead + " is merged into master"); } else { System.out.println("Commit " + otherHead + " is NOT merged into master"); } } } } }
public boolean apply(RevCommit rev) { try { return revwalk.isMergedInto(ancestor, rev); // wrap IOException so it can propagate } catch (IOException e) { throw Throwables.propagate(e); } }
if (!(oldRev instanceof RevCommit) || !(newRev instanceof RevCommit) || !walker.isMergedInto((RevCommit) oldRev, (RevCommit) newRev)) fastForward = false;
RevCommit upstream = walk.lookupCommit(upstreamCommit.getId()); if (!isInteractive() && walk.isMergedInto(upstream, headCommit)) return RebaseResult.UP_TO_DATE_RESULT; else if (!isInteractive() && walk.isMergedInto(headCommit, upstream)) {
autoStash(); if (stopAfterInitialization || !walk.isMergedInto( walk.parseCommit(repo.resolve(Constants.HEAD)), upstreamCommit)) {
if (walk.isMergedInto((RevCommit) oldObj, (RevCommit) newObj)) { return store.execute(Result.FAST_FORWARD);
Repository repo = new FileRepository(args[0]); RevWalk walk = new RevWalk(repo); RevCommit commit = walk.parseCommit(repo.resolve(args[1] + "^0")); for (Map.Entry<String, Ref> e : repo.getAllRefs().entrySet()) if (e.getKey().startsWith(Constants.R_HEADS)) if (walk.isMergedInto(commit, walk.parseCommit(e.getValue().getObjectId()))) System.out.println("Ref " + e.getValue().getName() + " contains commit " + commit);
if (revWalk.isMergedInto(srcCommit, headCommit)) { setCallable(false); return new MergeResult(headCommit, srcCommit, new ObjectId[] { headCommit, srcCommit }, MergeStatus.ALREADY_UP_TO_DATE, mergeStrategy, null, null); } else if (revWalk.isMergedInto(headCommit, srcCommit) && fastForwardMode != FastForwardMode.NO_FF) { noProblems = merger.merge(headCommit, srcCommit); refLogMessage.append(": Merge made by "); //$NON-NLS-1$ if (!revWalk.isMergedInto(headCommit, srcCommit)) refLogMessage.append(mergeStrategy.getName()); else
public static boolean isMergedInto(AnyObjectId sourceHead, AnyObjectId masterHead, ObjectReader reader) throws IOException { try(RevWalk rw = new RevWalk(reader)) { return rw.isMergedInto(rw.lookupCommit(sourceHead), rw.lookupCommit(masterHead)); } }
public static boolean isMergedInto(AnyObjectId sourceHead, AnyObjectId masterHead, ObjectReader reader) throws IOException { try(RevWalk rw = new RevWalk(reader)) { return rw.isMergedInto(rw.lookupCommit(sourceHead), rw.lookupCommit(masterHead)); } }
private boolean isMergedInto(Ref oldHead, AnyObjectId src) throws IOException { RevWalk revWalk = new RevWalk(db); ObjectId oldHeadObjectId = oldHead.getPeeledObjectId(); if (oldHeadObjectId == null) oldHeadObjectId = oldHead.getObjectId(); RevCommit oldHeadCommit = revWalk.lookupCommit(oldHeadObjectId); RevCommit srcCommit = revWalk.lookupCommit(src); return revWalk.isMergedInto(oldHeadCommit, srcCommit); } }
if (walk.isMergedInto((RevCommit) oldObj, (RevCommit) newObj)) cmd.setTypeFastForwardUpdate();