Example usage for org.eclipse.jgit.revwalk RevTag getTagName

List of usage examples for org.eclipse.jgit.revwalk RevTag getTagName

  1. HOME
  2. Java
  3. org.eclipse.jgit
  4. org.eclipse.jgit.revwalk.*
  5. RevTag
  6. getTagName

Introduction

In this page you can find the example usage for org.eclipse.jgit.revwalk RevTag getTagName.

Prototype

public final String getTagName()

Source Link

Document

Get the name of this tag, from the tag header.

Usage

From source file:com.google.gerrit.server.project.ListTags.java

License:Apache License

private static TagInfo createTagInfo(Ref ref, RevWalk rw) throws MissingObjectException, IOException {
    RevObject object = rw.parseAny(ref.getObjectId());
    if (object instanceof RevTag) {
        RevTag tag = (RevTag) object;
        // Annotated or signed tag
        return new TagInfo(Constants.R_TAGS + tag.getTagName(), tag.getName(), tag.getObject().getName(),
                tag.getFullMessage().trim(), CommonConverters.toGitPerson(tag.getTaggerIdent()));
    } else {//from  w  w w.  j av  a2 s . c  o m
        // Lightweight tag
        return new TagInfo(ref.getName(), ref.getObjectId().getName());
    }
}

From source file:com.meltmedia.cadmium.core.git.GitService.java

License:Apache License

public boolean tag(String tagname, String comment) throws Exception {
    try {//from   w  w  w  .ja  va2  s  .  co m
        git.fetch().setTagOpt(TagOpt.FETCH_TAGS).call();
    } catch (Exception e) {
        log.debug("Fetch from origin failed.", e);
    }
    List<RevTag> tags = git.tagList().call();
    if (tags != null && tags.size() > 0) {
        for (RevTag tag : tags) {
            if (tag.getTagName().equals(tagname)) {
                throw new Exception("Tag already exists.");
            }
        }
    }
    boolean success = git.tag().setMessage(comment).setName(tagname).call() != null;
    try {
        git.push().setPushTags().call();
    } catch (Exception e) {
        log.debug("Failed to push changes.", e);
    }
    return success;
}

From source file:org.eclipse.che.git.impl.jgit.JGitConnection.java

License:Open Source License

@Override
public Tag tagCreate(TagCreateRequest request) throws GitException {
    String commit = request.getCommit();
    if (commit == null) {
        commit = Constants.HEAD;//from   w ww  . ja  v  a  2s.  c  o m
    }

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

        TagCommand tagCommand = getGit().tag().setName(request.getName()).setObjectId(revObject)
                .setMessage(request.getMessage()).setForceUpdate(request.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);
    }
}

From source file:org.eclipse.egit.ui.internal.dialogs.CreateTagDialog.java

License:Open Source License

private void createExistingTagsSection(Composite parent) {
    Composite right = new Composite(parent, SWT.NORMAL);
    right.setLayout(GridLayoutFactory.swtDefaults().create());
    right.setLayoutData(GridLayoutFactory.fillDefaults().create());

    new Label(right, SWT.WRAP).setText(UIText.CreateTagDialog_existingTags);

    Table table = new Table(right, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.SINGLE);
    table.setLayoutData(GridDataFactory.fillDefaults().grab(true, true).hint(80, 100).create());

    TableLayout layout = new TableLayout();
    layout.addColumnData(new ColumnWeightData(100, 20));
    table.setLayout(layout);// w w w .  jav  a 2s .c  o  m

    tagViewer = new TableViewer(table);
    tagViewer.setLabelProvider(new TagLabelProvider());
    tagViewer.setContentProvider(ArrayContentProvider.getInstance());
    tagViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent event) {
            fillTagDialog();
        }
    });
    tagViewer.addFilter(new ViewerFilter() {

        @Override
        public boolean select(Viewer viewer, Object parentElement, Object element) {
            if (element instanceof String)
                return true;
            RevTag actTag = (RevTag) element;

            if (tagNamePattern != null)
                return tagNamePattern.matcher(actTag.getTagName()).find();
            else
                return true;
        }
    });
    // let's set the table inactive initially and display a "Loading..."
    // message and fill the list asynchronously during create() in order to
    // improve UI responsiveness
    tagViewer.setInput(new String[] { UIText.CreateTagDialog_LoadingMessageText });
    tagViewer.getTable().setEnabled(false);
    applyDialogFont(parent);
}

From source file:org.eclipse.orion.server.git.servlets.GitTagHandlerV1.java

License:Open Source License

private boolean handlePost(HttpServletRequest request, HttpServletResponse response, String path)
        throws IOException, JSONException, CoreException, JGitInternalException, GitAPIException {
    IPath p = new Path(path);
    File gitDir = GitUtils.getGitDir(p);
    Repository db = new FileRepository(gitDir);
    Git git = new Git(db);
    JSONObject toPut = OrionServlet.readJSONRequest(request);
    String tagName = toPut.getString(ProtocolConstants.KEY_NAME);
    String commitId = toPut.getString(GitConstants.KEY_TAG_COMMIT);
    ObjectId objectId = db.resolve(commitId);

    RevWalk walk = new RevWalk(db);
    RevCommit revCommit = walk.lookupCommit(objectId);

    RevTag revTag = tag(git, revCommit, tagName);
    JSONObject result = new JSONObject();
    result.put(ProtocolConstants.KEY_NAME, revTag.getTagName());
    result.put(ProtocolConstants.KEY_CONTENT_LOCATION, OrionServlet.getURI(request));
    OrionServlet.writeJSONResponse(request, response, result);
    walk.dispose();//from  ww w  .j av  a  2 s  . c o m
    return true;
}

From source file:org.jboss.as.controller.persistence.AbstractGitPersistenceResourceTestCase.java

License:Apache License

private List<String> listTags(Git git) throws IOException, GitAPIException {
    List<String> tags = new ArrayList<>();
    for (Ref tag : git.tagList().call()) {
        RevWalk revWalk = new RevWalk(git.getRepository());
        revWalk.sort(RevSort.COMMIT_TIME_DESC, true);
        try {//w  ww . j  av a2s. co  m
            RevTag annotatedTag = revWalk.parseTag(tag.getObjectId());
            tags.add(annotatedTag.getTagName() + " : " + annotatedTag.getFullMessage());
        } catch (IncorrectObjectTypeException ex) {
            tags.add(tag.getName().substring("refs/tags/".length()));
        }
    }
    return tags;
}

From source file:org.jboss.as.server.controller.git.GitConfigurationPersister.java

License:Apache License

@Override
public SnapshotInfo listSnapshots() {
    try (Git git = gitRepository.getGit()) {
        final List<String> snapshots = new ArrayList<>();
        for (Ref ref : git.tagList().call()) {
            RevWalk revWalk = new RevWalk(git.getRepository());
            revWalk.sort(RevSort.COMMIT_TIME_DESC, true);
            try {
                RevTag annotatedTag = revWalk.parseTag(ref.getObjectId());
                snapshots.add(annotatedTag.getTagName() + " : " + annotatedTag.getFullMessage());
            } catch (IncorrectObjectTypeException ex) {
                snapshots.add(ref.getName());
            }/*  w  ww . j a  v  a  2 s. c  om*/
            snapshots.add(ref.getName());
        }
        return new SnapshotInfo() {
            @Override
            public String getSnapshotDirectory() {
                return "";
            }

            @Override
            public List<String> names() {
                return snapshots;
            }
        };
    } catch (GitAPIException ex) {
        MGMT_OP_LOGGER.failedToListConfigurationSnapshot(ex, mainFile.getName());
    } catch (IOException ex) {
        MGMT_OP_LOGGER.failedToListConfigurationSnapshot(ex, mainFile.getName());
    }
    return NULL_SNAPSHOT_INFO;
}

From source file:org.jboss.as.test.manualmode.management.persistence.AbstractGitRepositoryTestCase.java

License:Apache License

protected List<String> listTags(Repository repository) throws IOException, GitAPIException {
    List<String> tags = new ArrayList<>();
    try (Git git = new Git(repository)) {
        for (Ref tag : git.tagList().call()) {
            RevWalk revWalk = new RevWalk(repository);
            try {
                RevTag annotatedTag = revWalk.parseTag(tag.getObjectId());
                tags.add(annotatedTag.getTagName());
            } catch (IncorrectObjectTypeException ex) {
                tags.add(tag.getName().substring("refs/tags/".length()));
            }//  w  w  w  .  j  a  v  a  2  s. c  om
        }
    }
    Collections.sort(tags);
    return tags;
}

From source file:org.kuali.student.git.cleaner.AbstractRepositoryCleaner.java

License:Educational Community License

@Override
public final void execute() throws IOException {

    onBeforeExecute();//w ww.jav a2 s .  c  om

    inserter = getRepo().newObjectInserter();

    boolean localBranchSource = true;

    if (!getBranchRefSpec().equals(Constants.R_HEADS))
        localBranchSource = false;

    dateString = formatter.print(new DateTime());

    /*
     * Track the commits that are rewritten.
     * 
     * This is important so that we can update the grafts file to relate to
     * the current parent object ids.
     */
    PrintWriter objectTranslationWriter = new PrintWriter(
            "object-translations-" + getFileNameSuffix() + "-" + dateString + ".txt");

    branchHeads = getRepo().getRefDatabase().getRefs(getBranchRefSpec());

    commitToBranchMap = new HashMap<ObjectId, Set<Ref>>();

    walkRepo = new RevWalk(getRepo());

    for (Ref branchRef : branchHeads.values()) {

        ObjectId branchObjectId = branchRef.getObjectId();

        Set<Ref> refs = commitToBranchMap.get(branchObjectId);

        if (refs == null) {
            refs = new HashSet<>();
            commitToBranchMap.put(branchObjectId, refs);
        }

        refs.add(branchRef);

        walkRepo.markStart(walkRepo.parseCommit(branchObjectId));

        onBranchHead(branchRef, branchObjectId);

    }

    if (includeTagsInRevWalk()) {

        tagHeads = getRepo().getRefDatabase().getRefs(Constants.R_TAGS);
    } else {
        tagHeads = new HashMap<String, Ref>();
    }

    commitToTagMap = new HashMap<ObjectId, Set<Ref>>();

    for (Ref tagRef : tagHeads.values()) {

        RevTag tag = walkRepo.parseTag(tagRef.getObjectId());

        ObjectId commitId = tag.getObject().getId();

        Set<Ref> refs = commitToTagMap.get(commitId);

        if (refs == null) {
            refs = new HashSet<>();
            commitToTagMap.put(commitId, refs);
        }

        refs.add(tagRef);

        walkRepo.markStart(walkRepo.parseCommit(commitId));

        onTag(tag.getId(), commitId);
    }

    onBeforeRevWalk();

    walkRepo.sort(RevSort.TOPO, true);
    walkRepo.sort(RevSort.REVERSE, true);

    Iterator<RevCommit> it = provideRevCommitIterator(walkRepo.iterator());

    deferredReferenceDeletes = new LinkedList<>();
    deferredReferenceCreates = new LinkedList<>();

    objectTranslationWriter.println("# new-object-id <space> original-object-id");

    originalCommitIdToNewCommitIdMap = new HashMap<>();

    GitTreeProcessor treeProcessor = new GitTreeProcessor(getRepo());

    processedCommits = new HashSet<ObjectId>();

    while (it.hasNext()) {

        RevCommit commit = it.next();

        boolean recreateCommitByTranslatedParent = determineIfRecreateByTranslatedParent(commit);

        GitTreeData tree = treeProcessor.extractExistingTreeDataFromCommit(commit.getId());

        boolean recreate = processCommitTree(commit, tree);

        if (!recreateCommitByTranslatedParent && !recreate) {
            processedCommits.add(commit.getId());
            continue;
        }

        /*
         * Process in reverse order from old to new.
         */
        CommitBuilder builder = new CommitBuilder();

        builder.setAuthor(commit.getAuthorIdent());
        builder.setMessage(commit.getFullMessage());

        builder.setCommitter(commit.getCommitterIdent());

        if (tree.isTreeDirty()) {

            ObjectId newTreeId = tree.buildTree(inserter);

            builder.setTreeId(newTreeId);
        } else {
            builder.setTreeId(commit.getTree().getId());
        }

        builder.setEncoding("UTF-8");

        Set<ObjectId> newParents = processParents(commit);

        builder.setParentIds(new ArrayList<>(newParents));

        ObjectId newCommitId = inserter.insert(builder);

        onNewCommit(commit, newCommitId);

        originalCommitIdToNewCommitIdMap.put(commit.getId(), newCommitId);

        objectTranslationWriter.println(newCommitId.name() + " " + commit.getId().getName());

        RevWalk commitWalk = new RevWalk(getRepo());

        RevCommit newCommit = commitWalk.parseCommit(newCommitId);

        processedCommits.add(newCommitId);

        // check if any tags need to be moved
        if (commitToTagMap.containsKey(commit.getId())) {

            Set<Ref> tags = commitToTagMap.get(commit.getId());

            Set<TagBuilder> newTagSet = new HashSet<>();

            for (Ref tagRef : tags) {

                RevTag tag = commitWalk.parseTag(tagRef.getObjectId());

                TagBuilder tb = new TagBuilder();

                tb.setMessage(tag.getFullMessage());
                tb.setObjectId(newCommit);
                tb.setTag(tag.getTagName());
                tb.setTagger(tag.getTaggerIdent());

                newTagSet.add(tb);

                deferDelete(tagRef.getName(), tagRef.getObjectId());

            }

            for (TagBuilder tagBuilder : newTagSet) {

                ObjectId tagId = inserter.insert(tagBuilder);

                String tagName = Constants.R_TAGS + tagBuilder.getTag();

                deferCreate(tagName, tagId);

                onTagRefCreate(tagName, tagId);

            }

        }

        // check if any branches need to be moved
        if (commitToBranchMap.containsKey(commit.getId())) {

            Set<Ref> refs = commitToBranchMap.get(commit.getId());

            for (Ref branchRef : refs) {

                if (localBranchSource) {

                    deferDelete(branchRef.getName(), branchRef.getObjectId());

                }

                String adjustedBranchName = Constants.R_HEADS
                        + branchRef.getName().substring(getBranchRefSpec().length());

                deferCreate(adjustedBranchName, newCommitId);

                onBranchRefCreate(adjustedBranchName, newCommitId);

            }

        }

        commitWalk.release();
    }

    inserter.flush();

    getRepo().getRefDatabase().refresh();

    log.info("Applying updates: " + deferredReferenceDeletes.size() + " deletes, "
            + deferredReferenceCreates.size() + " creates.");

    if (getExternalGitCommandPath() != null) {
        ExternalGitUtils.batchRefUpdate(getExternalGitCommandPath(), getRepo(), deferredReferenceDeletes,
                System.out);
    } else {
        GitRefUtils.batchRefUpdate(getRepo(), deferredReferenceDeletes, NullProgressMonitor.INSTANCE);
    }

    getRepo().getRefDatabase().refresh();

    if (getExternalGitCommandPath() != null) {
        ExternalGitUtils.batchRefUpdate(getExternalGitCommandPath(), getRepo(), deferredReferenceCreates,
                System.out);
    } else {

        GitRefUtils.batchRefUpdate(getRepo(), deferredReferenceCreates, NullProgressMonitor.INSTANCE);

    }

    log.info("Completed.");

    walkRepo.release();

    inserter.release();

    close();

    objectTranslationWriter.close();

}

From source file:pl.project13.jgit.DescribeCommand.java

License:Open Source License

private Map<ObjectId, List<String>> findTagObjectIds(@NotNull Repository repo, boolean tagsFlag) {
    Map<ObjectId, List<DatedRevTag>> commitIdsToTags = newHashMap();

    RevWalk walk = new RevWalk(repo);
    try {//from w w  w  . j  a v  a2  s  .  c o m
        walk.markStart(walk.parseCommit(repo.resolve("HEAD")));

        List<Ref> tagRefs = Git.wrap(repo).tagList().call();
        String matchPattern = createMatchPattern();
        Pattern regex = Pattern.compile(matchPattern);
        log("Tag refs [", tagRefs, "]");

        for (Ref tagRef : tagRefs) {
            walk.reset();
            String name = tagRef.getName();
            if (!regex.matcher(name).matches()) {
                log("Skipping tagRef with name [", name, "] as it doesn't match [", matchPattern, "]");
                continue;
            }
            ObjectId resolvedCommitId = repo.resolve(name);

            // todo that's a bit of a hack...
            try {
                final RevTag revTag = walk.parseTag(resolvedCommitId);
                ObjectId taggedCommitId = revTag.getObject().getId();
                log("Resolved tag [", revTag.getTagName(), "] [", revTag.getTaggerIdent(), "], points at [",
                        taggedCommitId, "] ");

                // sometimes a tag, may point to another tag, so we need to unpack it
                while (isTagId(taggedCommitId)) {
                    taggedCommitId = walk.parseTag(taggedCommitId).getObject().getId();
                }

                if (commitIdsToTags.containsKey(taggedCommitId)) {
                    commitIdsToTags.get(taggedCommitId).add(new DatedRevTag(revTag));
                } else {
                    commitIdsToTags.put(taggedCommitId, newArrayList(new DatedRevTag(revTag)));
                }

            } catch (IncorrectObjectTypeException ex) {
                // it's an lightweight tag! (yeah, really)
                if (tagsFlag) {
                    // --tags means "include lightweight tags"
                    log("Including lightweight tag [", name, "]");

                    DatedRevTag datedRevTag = new DatedRevTag(resolvedCommitId, name);

                    if (commitIdsToTags.containsKey(resolvedCommitId)) {
                        commitIdsToTags.get(resolvedCommitId).add(datedRevTag);
                    } else {
                        commitIdsToTags.put(resolvedCommitId, newArrayList(datedRevTag));
                    }
                }
            } catch (Exception ignored) {
                error("Failed while parsing [", tagRef, "] -- ", Throwables.getStackTraceAsString(ignored));
            }
        }

        for (Map.Entry<ObjectId, List<DatedRevTag>> entry : commitIdsToTags.entrySet()) {
            log("key [", entry.getKey(), "], tags => [", entry.getValue(), "] ");
        }

        Map<ObjectId, List<String>> commitIdsToTagNames = transformRevTagsMapToDateSortedTagNames(
                commitIdsToTags);

        log("Created map: [", commitIdsToTagNames, "] ");

        return commitIdsToTagNames;
    } catch (Exception e) {
        log("Unable to locate tags\n[", Throwables.getStackTraceAsString(e), "]");
    } finally {
        walk.release();
    }

    return Collections.emptyMap();
}