Package org.eclipse.jgit.lib

Examples of org.eclipse.jgit.lib.Ref


      {
         ShellMessages.info(out, "Checking out plugin source files to [" + buildDir.getFullyQualifiedName()
                  + "] via 'git'");
         Git repo = GitUtils.clone(buildDir, gitRepo);

         Ref ref = null;
         String targetRef = refName;
         if (targetRef == null)
         {
            // Default to Forge runtime version if no Ref name is supplied.
            targetRef = environment.getRuntimeVersion();
         }

         if (targetRef != null)
         {
            // Try to find a Tag matching the given Ref name or runtime version
            Map<String, Ref> tags = repo.getRepository().getTags();
            ref = tags.get(targetRef);

            // Now try to find a matching Branch
            if (ref == null)
            {
               List<Ref> refs = GitUtils.getRemoteBranches(repo);
               for (Ref branchRef : refs)
               {
                  String branchName = branchRef.getName();
                  if (branchName != null && branchName.endsWith(targetRef))
                  {
                     ref = repo.branchCreate().setName(targetRef).setUpstreamMode(SetupUpstreamMode.TRACK)
                              .setStartPoint("origin/" + targetRef).call();
                  }
               }
            }

            // Now try to find a tag or branch with same Major.Minor.(x) version.
            if (ref == null)
            {
               // All
               List<String> sortedVersions = new ArrayList<String>();

               // Branches
               for (Ref branchRef : GitUtils.getRemoteBranches(repo))
               {
                  String branchName = branchRef.getName();
                  branchName = branchName.replaceFirst("refs/heads/", "");
                  if (InstalledPluginRegistry.isApiCompatible(targetRef, branchName))
                     sortedVersions.add(branchName);
               }

               // Tags

               // Branches
               for (String tag : tags.keySet())
               {
                  if (InstalledPluginRegistry.isApiCompatible(targetRef, tag))
                     sortedVersions.add(tag);
               }

               // Sort
               Collections.sort(sortedVersions);

               if (!sortedVersions.isEmpty())
               {
                  String version = sortedVersions.get(sortedVersions.size() - 1);
                  if (InstalledPluginRegistry.isApiCompatible(targetRef, version))
                  {
                     ref = tags.get(version);

                     if (ref == null)
                     {
                        ref = repo.branchCreate().setName(version).setUpstreamMode(SetupUpstreamMode.TRACK)
                                 .setStartPoint("origin/" + version).call();
                     }
                  }
               }
            }
         }

         if (ref == null)
         {
            ref = repo.getRepository().getRef("master");
         }

         if (ref != null)
         {
            ShellMessages.info(out, "Switching to branch/tag [" + ref.getName() + "]");
            GitUtils.checkout(repo, ref, false, SetupUpstreamMode.TRACK, false);
         }
         else if (refName != null)
         {
            throw new RuntimeException("Could not locate ref [" + targetRef + "] in repository ["
View Full Code Here


        rru.setStatus(Status.REJECTED_NODELETE);
        continue;
      }

      final StringBuilder sb = new StringBuilder();
      final Ref advertisedRef = getRef(rru.getRemoteName());
      final ObjectId oldId = (advertisedRef == null ? ObjectId.zeroId()
          : advertisedRef.getObjectId());
      sb.append(oldId.name());
      sb.append(' ');
      sb.append(rru.getNewObjectId().name());
      sb.append(' ');
      sb.append(rru.getRemoteName());
View Full Code Here

      }
    }
  }

  private void deleteCommand(final RemoteRefUpdate u) {
    final Ref r = newRefs.remove(u.getRemoteName());
    if (r == null) {
      // Already gone.
      //
      u.setStatus(Status.OK);
      return;
    }

    if (r.getStorage().isPacked())
      packedRefUpdates.add(u);

    if (r.getStorage().isLoose()) {
      try {
        dest.deleteRef(u.getRemoteName());
        u.setStatus(Status.OK);
      } catch (IOException e) {
        u.setStatus(Status.REJECTED_OTHER_REASON);
View Full Code Here

        br = toBufferedReader(openInputStream(conn));
        try {
          String line = br.readLine();
          if (line != null && line.startsWith(RefDirectory.SYMREF)) {
            String target = line.substring(RefDirectory.SYMREF.length());
            Ref r = refs.get(target);
            if (r == null)
              r = new ObjectIdRef.Unpeeled(Ref.Storage.NEW, target, null);
            r = new SymbolicRef(Constants.HEAD, r);
            refs.put(r.getName(), r);
          } else if (line != null && ObjectId.isId(line)) {
            Ref r = new ObjectIdRef.Unpeeled(Ref.Storage.NETWORK,
                Constants.HEAD, ObjectId.fromString(line));
            refs.put(r.getName(), r);
          }
        } finally {
          br.close();
        }
        break;
View Full Code Here

        name = line.substring(tab + 1);
        id = ObjectId.fromString(line.substring(0, tab));
        if (name.endsWith("^{}")) { //$NON-NLS-1$
          name = name.substring(0, name.length() - 3);
          final Ref prior = avail.get(name);
          if (prior == null)
            throw outOfOrderAdvertisement(name);

          if (prior.getPeeledObjectId() != null)
            throw duplicateAdvertisement(name + "^{}"); //$NON-NLS-1$

          avail.put(name, new ObjectIdRef.PeeledTag(
              Ref.Storage.NETWORK, name,
              prior.getObjectId(), id));
        } else {
          Ref prior = avail.put(name, new ObjectIdRef.PeeledNonTag(
              Ref.Storage.NETWORK, name, id));
          if (prior != null)
            throw duplicateAdvertisement(name);
        }
      }
View Full Code Here

    try {
      setCallable(false);
      for (String tagName : tags) {
        if (tagName == null)
          continue;
        Ref currentRef = repo.getRef(tagName);
        if (currentRef == null)
          continue;
        String fullName = currentRef.getName();
        RefUpdate update = repo.updateRef(fullName);
        update.setForceUpdate(true);
        Result deleteResult = update.delete();

        boolean ok = true;
View Full Code Here

      RefNotFoundException, InvalidRefNameException {
    checkCallable();
    processOptions();
    RevWalk revWalk = new RevWalk(repo);
    try {
      Ref refToCheck = repo.getRef(name);
      boolean exists = refToCheck != null
          && refToCheck.getName().startsWith(Constants.R_HEADS);
      if (!force && exists)
        throw new RefAlreadyExistsException(MessageFormat.format(
            JGitText.get().refAlreadyExists, name));

      ObjectId startAt = getStartPoint();
      String startPointFullName = null;
      if (startPoint != null) {
        Ref baseRef = repo.getRef(startPoint);
        if (baseRef != null)
          startPointFullName = baseRef.getName();
      }

      // determine whether we are based on a commit,
      // a branch, or a tag and compose the reflog message
      String refLogMessage;
      String baseBranch = "";
      if (startPointFullName == null) {
        String baseCommit;
        if (startCommit != null)
          baseCommit = startCommit.getShortMessage();
        else {
          RevCommit commit = revWalk.parseCommit(repo
              .resolve(startPoint));
          baseCommit = commit.getShortMessage();
        }
        if (exists)
          refLogMessage = "branch: Reset start-point to commit "
              + baseCommit;
        else
          refLogMessage = "branch: Created from commit " + baseCommit;

      } else if (startPointFullName.startsWith(Constants.R_HEADS)
          || startPointFullName.startsWith(Constants.R_REMOTES)) {
        baseBranch = startPointFullName;
        if (exists)
          refLogMessage = "branch: Reset start-point to branch "
              + startPointFullName; // TODO
        else
          refLogMessage = "branch: Created from branch " + baseBranch;
      } else {
        startAt = revWalk.peel(revWalk.parseAny(startAt));
        if (exists)
          refLogMessage = "branch: Reset start-point to tag "
              + startPointFullName;
        else
          refLogMessage = "branch: Created from tag "
              + startPointFullName;
      }

      RefUpdate updateRef = repo.updateRef(Constants.R_HEADS + name);
      updateRef.setNewObjectId(startAt);
      updateRef.setRefLogMessage(refLogMessage, false);
      Result updateResult;
      if (exists && force)
        updateResult = updateRef.forceUpdate();
      else
        updateResult = updateRef.update();

      setCallable(false);

      boolean ok = false;
      switch (updateResult) {
      case NEW:
        ok = !exists;
        break;
      case NO_CHANGE:
      case FAST_FORWARD:
      case FORCED:
        ok = exists;
        break;
      default:
        break;
      }

      if (!ok)
        throw new JGitInternalException(MessageFormat.format(JGitText
            .get().createBranchUnexpectedResult, updateResult
            .name()));

      Ref result = repo.getRef(name);
      if (result == null)
        throw new JGitInternalException(
            JGitText.get().createBranchFailedUnknownReason);

      if (baseBranch.length() == 0) {
View Full Code Here

                  Integer.valueOf(commits.size())));

    RevWalk revWalk = null;
    DirCacheCheckout dco = null;
    try {
      Ref head = repo.getRef(Constants.HEAD);
      if (head == null)
        throw new NoHeadException(
            JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
      StringBuilder refLogMessage = new StringBuilder("merge ");

      // Check for FAST_FORWARD, ALREADY_UP_TO_DATE
      revWalk = new RevWalk(repo);

      // we know for now there is only one commit
      Ref ref = commits.get(0);

      refLogMessage.append(ref.getName());

      // handle annotated tags
      ObjectId objectId = ref.getPeeledObjectId();
      if (objectId == null)
        objectId = ref.getObjectId();

      RevCommit srcCommit = revWalk.lookupCommit(objectId);

      ObjectId headId = head.getObjectId();
      if (headId == null) {
        revWalk.parseHeaders(srcCommit);
        dco = new DirCacheCheckout(repo,
            repo.lockDirCache(), srcCommit.getTree());
        dco.setFailOnConflict(true);
        dco.checkout();
        RefUpdate refUpdate = repo
            .updateRef(head.getTarget().getName());
        refUpdate.setNewObjectId(objectId);
        refUpdate.setExpectedOldObjectId(null);
        refUpdate.setRefLogMessage("initial pull", false);
        if (refUpdate.update() != Result.NEW)
          throw new NoHeadException(
              JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
        setCallable(false);
        return new MergeResult(srcCommit, srcCommit, new ObjectId[] {
            null, srcCommit }, MergeStatus.FAST_FORWARD,
            mergeStrategy, null, null);
      }

      RevCommit headCommit = revWalk.lookupCommit(headId);

      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)) {
        // FAST_FORWARD detected: skip doing a real merge but only
        // update HEAD
        refLogMessage.append(": " + MergeStatus.FAST_FORWARD);
        dco = new DirCacheCheckout(repo,
            headCommit.getTree(), repo.lockDirCache(),
            srcCommit.getTree());
        dco.setFailOnConflict(true);
        dco.checkout();

        updateHead(refLogMessage, srcCommit, headId);
        setCallable(false);
        return new MergeResult(srcCommit, srcCommit, new ObjectId[] {
            headCommit, srcCommit }, MergeStatus.FAST_FORWARD,
            mergeStrategy, null, null);
      } else {

        String mergeMessage = new MergeMessageFormatter().format(
            commits, head);
        repo.writeMergeCommitMsg(mergeMessage);
        repo.writeMergeHeads(Arrays.asList(ref.getObjectId()));
        Merger merger = mergeStrategy.newMerger(repo);
        boolean noProblems;
        Map<String, org.eclipse.jgit.merge.MergeResult<?>> lowLevelResults = null;
        Map<String, MergeFailureReason> failingPaths = null;
        List<String> unmergedPaths = null;
        if (merger instanceof ResolveMerger) {
          ResolveMerger resolveMerger = (ResolveMerger) merger;
          resolveMerger.setCommitNames(new String[] {
              "BASE", "HEAD", ref.getName() });
          resolveMerger.setWorkingTreeIterator(new FileTreeIterator(repo));
          noProblems = merger.merge(headCommit, srcCommit);
          lowLevelResults = resolveMerger
              .getMergeResults();
          failingPaths = resolveMerger.getFailingPaths();
View Full Code Here

   * @return the Ref after reset
   */
  public Ref call() throws IOException {
    checkCallable();

    Ref r;
    RevCommit commit;

    try {
      RepositoryState state = repo.getRepositoryState();
      final boolean merging = state.equals(RepositoryState.MERGING)
View Full Code Here

  /** @return all refs which were advertised to the client. */
  public final Map<String, Ref> getAdvertisedRefs() {
    if (refs == null) {
      refs = refFilter.filter(db.getAllRefs());

      Ref head = refs.get(Constants.HEAD);
      if (head != null && head.isSymbolic())
        refs.remove(Constants.HEAD);

      for (Ref ref : refs.values()) {
        if (ref.getObjectId() != null)
          advertisedHaves.add(ref.getObjectId());
View Full Code Here

TOP

Related Classes of org.eclipse.jgit.lib.Ref

Copyright © 2018 www.massapicom. All rights reserved.
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.