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

Introduction

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

Prototype

public final ObjectId getId() 

Source Link

Document

Get the name of this object.

Usage

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

License:Educational Community License

@Override
public final void execute() throws IOException {

    onBeforeExecute();//  ww w .ja va  2  s  .  c  o  m

    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();

}

---