Examples of org.eclipse.jgit.revwalk.RevWalk

org.eclipse.jgit.revwalk.RevWalk
Walks a commit graph and produces the matching commits in order.
A RevWalk instance can only be used once to generate results. Running a second time requires creating a new RevWalk instance, or invoking {@link #reset()} before starting again. Resetting an existing instance may befaster for some applications as commit body parsing can be avoided on the later invocations.
RevWalk instances are not thread-safe. Applications must either restrict usage of a RevWalk instance to a single thread, or implement their own synchronization at a higher level.
Multiple simultaneous RevWalk instances per {@link Repository} are permitted,even from concurrent threads. Equality of {@link RevCommit}s from two different RevWalk instances is never true, even if their {@link ObjectId}s are equal (and thus they describe the same commit).
The offered iterator is over the list of RevCommits described by the configuration of this instance. Applications should restrict themselves to using either the provided Iterator or {@link #next()}, but never use both on the same RevWalk at the same time. The Iterator may buffer RevCommits, while {@link #next()} does not.

   */
  public RevCommit call() throws GitAPIException {
    RevCommit newHead = null;
    checkCallable();


    RevWalk revWalk = new RevWalk(repo);
    try {


      // get the head commit
      Ref headRef = repo.getRef(Constants.HEAD);
      if (headRef == null)
        throw new NoHeadException(
            JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
      RevCommit headCommit = revWalk.parseCommit(headRef.getObjectId());


      newHead = headCommit;


      // loop through all refs to be reverted
      for (Ref src : commits) {
        // get the commit to be reverted
        // handle annotated tags
        ObjectId srcObjectId = src.getPeeledObjectId();
        if (srcObjectId == null)
          srcObjectId = src.getObjectId();
        RevCommit srcCommit = revWalk.parseCommit(srcObjectId);


        // get the parent of the commit to revert
        if (srcCommit.getParentCount() != 1) {
          throw new MultipleParentsNotAllowedException(
              JGitText.get().canOnlyRevertCommitsWithOneParent);
        }
        RevCommit srcParent = srcCommit.getParent(0);
        revWalk.parseHeaders(srcParent);


        ResolveMerger merger = (ResolveMerger) MergeStrategy.RESOLVE
            .newMerger(repo);
        merger.setWorkingTreeIterator(new FileTreeIterator(repo));
        merger.setBase(srcCommit.getTree());


        if (merger.merge(headCommit, srcParent)) {
          if (AnyObjectId.equals(headCommit.getTree().getId(), merger
              .getResultTreeId()))
            continue;
          DirCacheCheckout dco = new DirCacheCheckout(repo,
              headCommit.getTree(), repo.lockDirCache(),
              merger.getResultTreeId());
          dco.setFailOnConflict(true);
          dco.checkout();
          String shortMessage = "Revert \"" + srcCommit.getShortMessage() + "\"";
          String newMessage = shortMessage + "\n\n"
              + "This reverts commit "
              + srcCommit.getId().getName() + ".\n";
          newHead = new Git(getRepository()).commit()
              .setMessage(newMessage)
              .setReflogComment("revert: " + shortMessage).call();
          revertedRefs.add(src);
        } else {
          unmergedPaths = merger.getUnmergedPaths();
          Map<String, MergeFailureReason> failingPaths = merger
              .getFailingPaths();
          if (failingPaths != null)
            failingResult = new MergeResult(null,
                merger.getBaseCommit(0, 1),
                new ObjectId[] { headCommit.getId(),
                    srcParent.getId() },
                MergeStatus.FAILED, MergeStrategy.RESOLVE,
                merger.getMergeResults(), failingPaths, null);
          return null;
        }
      }
    } catch (IOException e) {
      throw new JGitInternalException(
          MessageFormat.format(
                  JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
              e), e);
    } finally {
      revWalk.release();
    }
    return newHead;
  }

View Full Code Here

   */
  public List<DiffEntry> scan(AnyObjectId a, AnyObjectId b)
      throws IOException {
    assertHaveRepository();


    RevWalk rw = new RevWalk(reader);
    return scan(rw.parseTree(a), rw.parseTree(b));
  }

View Full Code Here

  /**
   * @param repo
   */
  protected RebaseCommand(Repository repo) {
    super(repo);
    walk = new RevWalk(repo);
    rebaseDir = new File(repo.getDirectory(), REBASE_MERGE);
  }

View Full Code Here

        }
      }
    } finally {
      dc.unlock();
    }
    RevWalk rw = new RevWalk(repo);
    RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
    rw.release();
    return commit;
  }

View Full Code Here

   */
  public List<RevTag> call() throws JGitInternalException {
    checkCallable();
    Map<String, Ref> refList;
    List<RevTag> tags = new ArrayList<RevTag>();
    RevWalk revWalk = new RevWalk(repo);
    try {
      refList = repo.getRefDatabase().getRefs(Constants.R_TAGS);
      for (Ref ref : refList.values()) {
        RevTag tag = revWalk.parseTag(ref.getObjectId());
        tags.add(tag);
      }
    } catch (IOException e) {
      throw new JGitInternalException(e.getMessage(), e);
    } finally {
      revWalk.release();
    }
    Collections.sort(tags, new Comparator<RevTag>() {
      public int compare(RevTag o1, RevTag o2) {
        return o1.getTagName().compareTo(o2.getTagName());
      }

View Full Code Here

      Repository repo = git.getRepository();


      RevCommit newHead = null;
      List<Ref> cherryPickedRefs = new LinkedList<Ref>();


      RevWalk revWalk = new RevWalk(repo);
      try
      {
         // get the head commit
         Ref headRef = repo.getRef(Constants.HEAD);
         if (headRef == null)
            throw new NoHeadException(
                     JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
         RevCommit headCommit = revWalk.parseCommit(headRef.getObjectId());


         newHead = headCommit;


         // get the commit to be cherry-picked
         // handle annotated tags
         ObjectId srcObjectId = src.getPeeledObjectId();
         if (srcObjectId == null)
            srcObjectId = src.getObjectId();
         RevCommit srcCommit = revWalk.parseCommit(srcObjectId);


         // get the parent of the commit to cherry-pick
         if (srcCommit.getParentCount() == 0)
            throw new CantMergeCommitWithZeroParentsException("Commit with zero parents cannot be merged");


         if (srcCommit.getParentCount() > 1)
            throw new MultipleParentsNotAllowedException(
                     MessageFormat.format(
                              JGitText.get().canOnlyCherryPickCommitsWithOneParent,
                              srcCommit.name(),
                              Integer.valueOf(srcCommit.getParentCount())));


         RevCommit srcParent = srcCommit.getParent(0);
         revWalk.parseHeaders(srcParent);


         ResolveMerger merger = (ResolveMerger) MergeStrategy.RESOLVE
                  .newMerger(repo);
         merger.setWorkingTreeIterator(new FileTreeIterator(repo));
         merger.setBase(srcParent.getTree());
         if (merger.merge(headCommit, srcCommit))
         {
            DirCacheCheckout dco = new DirCacheCheckout(repo,
                     headCommit.getTree(), repo.lockDirCache(),
                     merger.getResultTreeId());
            dco.setFailOnConflict(true);
            dco.checkout();


            cherryPickedRefs.add(src);
         }
         else
         {
            if (merger.failed())
               return new CherryPickResult(merger.getFailingPaths());


            // there are merge conflicts
            String message = new MergeMessageFormatter()
                     .formatWithConflicts(srcCommit.getFullMessage(),
                              merger.getUnmergedPaths());


            repo.writeCherryPickHead(srcCommit.getId());
            repo.writeMergeCommitMsg(message);


            return CherryPickResult.CONFLICT;
         }
      }
      catch (IOException e)
      {
         throw new JGitInternalException(
                  MessageFormat.format(
                           JGitText.get().exceptionCaughtDuringExecutionOfCherryPickCommand,
                           e), e);
      }
      finally
      {
         revWalk.release();
      }


      return new CherryPickResult(newHead, cherryPickedRefs);
   }

View Full Code Here


   private RevCommit parseCommit(final Ref branch)
            throws MissingObjectException, IncorrectObjectTypeException,
            IOException
   {
      final RevWalk rw = new RevWalk(db);
      final RevCommit commit;
      try
      {
         commit = rw.parseCommit(branch.getObjectId());
      }
      finally
      {
         rw.release();
      }
      return commit;
   }

View Full Code Here

      public int compare(DfsPackFile a, DfsPackFile b) {
        return a.getPackDescription().compareTo(b.getPackDescription());
      }
    });


    RevWalk rw = new RevWalk(ctx);
    RevFlag added = rw.newFlag("ADDED");


    pm.beginTask(JGitText.get().countingObjects, ProgressMonitor.UNKNOWN);
    for (DfsPackFile src : srcPacks) {
      List<ObjectIdWithOffset> want = new BlockList<ObjectIdWithOffset>();
      for (PackIndex.MutableEntry ent : src.getPackIndex(ctx)) {
        ObjectId id = ent.toObjectId();
        RevObject obj = rw.lookupOrNull(id);
        if (obj == null || !obj.has(added))
          want.add(new ObjectIdWithOffset(id, ent.getOffset()));
      }


      // Sort objects by the order they appear in the pack file, for
      // two benefits. Scanning object type information is faster when
      // the pack is traversed in order, and this allows the PackWriter
      // to be given the new objects in a relatively sane newest-first
      // ordering without additional logic, like unpacking commits and
      // walking a commit queue.
      Collections.sort(want, new Comparator<ObjectIdWithOffset>() {
        public int compare(ObjectIdWithOffset a, ObjectIdWithOffset b) {
          return Long.signum(a.offset - b.offset);
        }
      });


      // Only pack each object at most once into the output file. The
      // PackWriter will later select a representation to reuse, which
      // may be the version in this pack, or may be from another pack if
      // the object was copied here to complete a thin pack and is larger
      // than a delta from another pack. This is actually somewhat common
      // if an object is modified frequently, such as the top level tree.
      for (ObjectIdWithOffset id : want) {
        int type = src.getObjectType(ctx, id.offset);
        RevObject obj = rw.lookupAny(id, type);
        if (!obj.has(added)) {
          pm.update(1);
          pw.addObject(obj);
          obj.add(added);
        }

View Full Code Here

    return recreate(ref, newLeaf);
  }


  private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
      IOException {
    RevWalk rw = new RevWalk(getRepository());
    try {
      RevObject obj = rw.parseAny(leaf.getObjectId());
      if (obj instanceof RevTag) {
        return new ObjectIdRef.PeeledTag(leaf.getStorage(), leaf
            .getName(), leaf.getObjectId(), rw.peel(obj).copy());
      } else {
        return new ObjectIdRef.PeeledNonTag(leaf.getStorage(), leaf
            .getName(), leaf.getObjectId());
      }
    } finally {
      rw.release();
    }
  }

View Full Code Here


      // determine the current HEAD and the commit it is referring to
      ObjectId headId = repo.resolve(Constants.HEAD + "^{commit}");
      if (headId != null)
        if (amend) {
          RevCommit previousCommit = new RevWalk(repo)
              .parseCommit(headId);
          RevCommit[] p = previousCommit.getParents();
          for (int i = 0; i < p.length; i++)
            parents.add(0, p[i].getId());
        } else {
          parents.add(0, headId);
        }


      // lock the index
      DirCache index = repo.lockDirCache();
      try {
        if (!only.isEmpty())
          index = createTemporaryIndex(headId, index);


        ObjectInserter odi = repo.newObjectInserter();
        try {
          // Write the index as tree to the object database. This may
          // fail for example when the index contains unmerged paths
          // (unresolved conflicts)
          ObjectId indexTreeId = index.writeTree(odi);


          if (insertChangeId)
            insertChangeId(indexTreeId);


          // Create a Commit object, populate it and write it
          CommitBuilder commit = new CommitBuilder();
          commit.setCommitter(committer);
          commit.setAuthor(author);
          commit.setMessage(message);


          commit.setParentIds(parents);
          commit.setTreeId(indexTreeId);
          ObjectId commitId = odi.insert(commit);
          odi.flush();


          RevWalk revWalk = new RevWalk(repo);
          try {
            RevCommit revCommit = revWalk.parseCommit(commitId);
            RefUpdate ru = repo.updateRef(Constants.HEAD);
            ru.setNewObjectId(commitId);
            String prefix = amend ? "commit (amend): " : "commit: ";
            ru.setRefLogMessage(
                prefix + revCommit.getShortMessage(), false);


            ru.setExpectedOldObjectId(headId);
            Result rc = ru.forceUpdate();
            switch (rc) {
            case NEW:
            case FORCED:
            case FAST_FORWARD: {
              setCallable(false);
              if (state == RepositoryState.MERGING_RESOLVED) {
                // Commit was successful. Now delete the files
                // used for merge commits
                repo.writeMergeCommitMsg(null);
                repo.writeMergeHeads(null);
              } else if (state == RepositoryState.CHERRY_PICKING_RESOLVED) {
                repo.writeMergeCommitMsg(null);
                repo.writeCherryPickHead(null);
              }
              return revCommit;
            }
            case REJECTED:
            case LOCK_FAILURE:
              throw new ConcurrentRefUpdateException(JGitText
                  .get().couldNotLockHEAD, ru.getRef(), rc);
            default:
              throw new JGitInternalException(MessageFormat
                  .format(JGitText.get().updatingRefFailed,
                      Constants.HEAD,
                      commitId.toString(), rc));
            }
          } finally {
            revWalk.release();
          }
        } finally {
          odi.release();
        }
      } finally {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.eclipse.jgit.revwalk.RevWalk

com.atlassian.jgitflow.core.AbstractGitFlowCommand

com.atlassian.jgitflow.core.JGitFlowInitCommand

com.atlassian.jgitflow.core.util.GitHelper

com.gitblit.git.PatchsetReceivePack

com.gitblit.tickets.BranchTicketService

com.gitblit.utils.CompressionUtils

com.gitblit.utils.DiffUtils

com.gitblit.utils.JGitUtils

com.gitblit.utils.MetricUtils

com.gitblit.utils.RefLogUtils

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.