Java 类org.eclipse.jgit.api.TagCommand 实例源码

@Override
protected void run () throws GitException {
    Repository repository = getRepository();
    try {
        RevObject obj = Utils.findObject(repository, taggedObject);
        TagCommand cmd = new Git(repository).tag();
        cmd.setName(tagName);
        cmd.setForceUpdate(forceUpdate);
        cmd.setObjectId(obj);
        cmd.setAnnotated(message != null && !message.isEmpty() || signed);
        if (cmd.isAnnotated()) {
            cmd.setMessage(message);
            cmd.setSigned(signed);
        }
        cmd.call();
        ListTagCommand tagCmd = new ListTagCommand(repository, getClassFactory(), false, new DelegatingGitProgressMonitor(monitor));
        tagCmd.run();
        Map<String, GitTag> tags = tagCmd.getTags();
        tag = tags.get(tagName);
    } catch (JGitInternalException | GitAPIException ex) {
        throw new GitException(ex);
    }
}

public Result execute(String ref) throws Exception {
  RevCommit c = commitBuilder.create();
  if (changeId == null) {
    changeId = GitUtil.getChangeId(testRepo, c).get();
  }
  if (tag != null) {
    TagCommand tagCommand = testRepo.git().tag().setName(tag.name);
    if (tag instanceof AnnotatedTag) {
      AnnotatedTag annotatedTag = (AnnotatedTag) tag;
      tagCommand
          .setAnnotated(true)
          .setMessage(annotatedTag.message)
          .setTagger(annotatedTag.tagger);
    } else {
      tagCommand.setAnnotated(false);
    }
    tagCommand.call();
  }
  return new Result(ref, pushHead(testRepo, ref, tag != null, force, pushOptions), c, subject);
}

/**
 * creates a tag in a repository
 * 
 * @param repository
 * @param objectId
 *            , the ref the tag points towards
 * @param tagger
 *            , the person tagging the object
 * @param tag
 *            , the string label
 * @param message
 *            , the string message
 * @return boolean, true if operation was successful, otherwise false
 */
public static boolean createTag(Repository repository, String objectId, PersonIdent tagger, String tag, String message) {
    try {
        Git gitClient = Git.open(repository.getDirectory());
        TagCommand tagCommand = gitClient.tag();
        tagCommand.setTagger(tagger);
        tagCommand.setMessage(message);
        if (objectId != null) {
            RevObject revObj = getCommit(repository, objectId);
            tagCommand.setObjectId(revObj);
        }
        tagCommand.setName(tag);
        Ref call = tagCommand.call();
        return call != null ? true : false;
    } catch (Exception e) {
        error(e, repository, "Failed to create tag {1} in repository {0}", objectId, tag);
    }
    return false;
}

public Git call(final GitOperationsStep gitOperationsStep, Git git,
    CredentialsProvider cp, String gitRepoUrl, File gitRepoFolder)
    throws IllegalArgumentException, IOException,
    ConcurrentRefUpdateException, InvalidTagNameException,
    NoHeadException, GitAPIException {
  TagCommand tc = git.tag().setAnnotated(annotated)
      .setForceUpdate(forceUpdate).setSigned(signed);
  if (!Const.isEmpty(this.message)) {
    tc = tc.setMessage(gitOperationsStep
        .environmentSubstitute(this.message));
  }
  if (!Const.isEmpty(this.name)) {
    tc = tc.setName(gitOperationsStep.environmentSubstitute(this.name));
  }
  tc.call();
  return git;
}

/**
 * creates a tag in a repository
 * 
 * @param repository
 * @param objectId, the ref the tag points towards
 * @param tagger, the person tagging the object
 * @param tag, the string label
 * @param message, the string message
 * @return boolean, true if operation was successful, otherwise false
 */
public static boolean createTag(Repository repository, String objectId, PersonIdent tagger, String tag, String message) {
    try {           
        Git gitClient = Git.open(repository.getDirectory());
        TagCommand tagCommand = gitClient.tag();
        tagCommand.setTagger(tagger);
        tagCommand.setMessage(message);
        if (objectId != null) {
            RevObject revObj = getCommit(repository, objectId);
            tagCommand.setObjectId(revObj);
        }
        tagCommand.setName(tag);
        Ref call = tagCommand.call();           
        return call != null ? true : false;
    } catch (Exception e) {
        error(e, repository, "Failed to create tag {1} in repository {0}", objectId, tag);
    }
    return false;
}

/**
 * creates a tag in a repository
 * 
 * @param repository
 * @param objectId, the ref the tag points towards
 * @param tagger, the person tagging the object
 * @param tag, the string label
 * @param message, the string message
 * @return boolean, true if operation was successful, otherwise false
 */
public static boolean createTag(Repository repository, String objectId, PersonIdent tagger, String tag, String message) {
    try {           
        Git gitClient = Git.open(repository.getDirectory());
        TagCommand tagCommand = gitClient.tag();
        tagCommand.setTagger(tagger);
        tagCommand.setMessage(message);
        if (objectId != null) {
            RevObject revObj = getCommit(repository, objectId);
            tagCommand.setObjectId(revObj);
        }
        tagCommand.setName(tag);
        Ref call = tagCommand.call();           
        return call != null ? true : false;
    } catch (Exception e) {
        error(e, repository, "Failed to create tag {1} in repository {0}", objectId, tag);
    }
    return false;
}

@Override
public Tag tagCreate(TagCreateParams params) throws GitException {
  String commit = params.getCommit();
  if (commit == null) {
    commit = HEAD;
  }

  try {
    RevWalk revWalk = new RevWalk(repository);
    RevObject revObject;
    try {
      revObject = revWalk.parseAny(repository.resolve(commit));
    } finally {
      revWalk.close();
    }

    TagCommand tagCommand =
        getGit()
            .tag()
            .setName(params.getName())
            .setObjectId(revObject)
            .setMessage(params.getMessage())
            .setForceUpdate(params.isForce());

    GitUser tagger = getUser();
    if (tagger != null) {
      tagCommand.setTagger(new PersonIdent(tagger.getName(), tagger.getEmail()));
    }

    Ref revTagRef = tagCommand.call();
    RevTag revTag = revWalk.parseTag(revTagRef.getLeaf().getObjectId());
    return newDto(Tag.class).withName(revTag.getTagName());
  } catch (IOException | GitAPIException exception) {
    throw new GitException(exception.getMessage(), exception);
  }
}

/**
 * Create a new tag in the local git repository
 * (git checkout tagname) and finally pushes new branch on the remote repository (git push)
 *
 * @param directory the directory in which the local git repository is located
 * @param username  the username to be used while pushing
 * @param password  the password matching with the provided username to be used
 *                  for authentication
 * @param message   the commit message to be used    
 */
public static void createTag(@NonNull File directory, String tagName, String username,
                             String password, String message) {

    try {
        final Git git = Git.open(directory);

        final UsernamePasswordCredentialsProvider userCredential = new UsernamePasswordCredentialsProvider(
                username, password);

        TagCommand tagCommand = git.tag();
        tagCommand.setName(tagName);
        tagCommand.setMessage(message);
        tagCommand.call();
        log.info("Tag created");

        // and then commit
        final PersonIdent author = new PersonIdent(username, "");
        git.commit().setCommitter(author).setMessage(message)
                .setAuthor(author).call();
        log.info(message);

        git.push().setCredentialsProvider(userCredential).call();
        log.info("Pushed the changes in remote Git repository...");
    } catch (final GitAPIException | IOException e) {
        log.error(e.getMessage(), e);
    }
}

public static Ref createAnnotatedTag(TestRepository<?> testRepo, String name, PersonIdent tagger)
    throws GitAPIException {
  TagCommand cmd =
      testRepo.git().tag().setName(name).setAnnotated(true).setMessage(name).setTagger(tagger);
  return cmd.call();
}

public static Ref updateAnnotatedTag(TestRepository<?> testRepo, String name, PersonIdent tagger)
    throws GitAPIException {
  TagCommand tc = testRepo.git().tag().setName(name);
  return tc.setAnnotated(true).setMessage(name).setTagger(tagger).setForceUpdate(true).call();
}