PlotWalk.java

/*
 * Copyright (C) 2008-2018, Robin Rosenberg <robin.rosenberg@dewire.com>
 * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.revplot;

import static org.eclipse.jgit.lib.Constants.R_HEADS;
import static org.eclipse.jgit.lib.Constants.R_REMOTES;
import static org.eclipse.jgit.lib.Constants.R_TAGS;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.eclipse.jgit.errors.IncorrectObjectTypeException;
import org.eclipse.jgit.errors.MissingObjectException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.AnyObjectId;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.revwalk.RevCommit;
import org.eclipse.jgit.revwalk.RevObject;
import org.eclipse.jgit.revwalk.RevSort;
import org.eclipse.jgit.revwalk.RevTag;
import org.eclipse.jgit.revwalk.RevWalk;

/**
 * Specialized RevWalk for visualization of a commit graph.
 */
public class PlotWalk extends RevWalk {

    private Map<AnyObjectId, Set<Ref>> additionalRefMap;

    private Map<AnyObjectId, Set<Ref>> reverseRefMap;

    private Repository repository;

    /** {@inheritDoc} */
    @Override
    public void dispose() {
        super.dispose();
        if (reverseRefMap != null) {
            reverseRefMap.clear();
            reverseRefMap = null;
        }
        if (additionalRefMap != null) {
            additionalRefMap.clear();
            additionalRefMap = null;
        }
        repository = null;
    }

    /**
     * Create a new revision walker for a given repository.
     *
     * @param repo
     *            the repository the walker will obtain data from.
     */
    public PlotWalk(Repository repo) {
        super(repo);
        super.sort(RevSort.TOPO, true);
        additionalRefMap = new HashMap<>();
        repository = repo;
    }

    /**
     * Add additional refs to the walk
     *
     * @param refs
     *            additional refs
     * @throws java.io.IOException
     */
    public void addAdditionalRefs(Iterable<Ref> refs) throws IOException {
        for (Ref ref : refs) {
            Set<Ref> set = additionalRefMap.get(ref.getObjectId());
            if (set == null)
                set = Collections.singleton(ref);
            else {
                set = new HashSet<>(set);
                set.add(ref);
            }
            additionalRefMap.put(ref.getObjectId(), set);
        }
    }

    /** {@inheritDoc} */
    @Override
    public void sort(RevSort s, boolean use) {
        if (s == RevSort.TOPO && !use)
            throw new IllegalArgumentException(JGitText.get().topologicalSortRequired);
        super.sort(s, use);
    }

    /** {@inheritDoc} */
    @Override
    protected RevCommit createCommit(AnyObjectId id) {
        return new PlotCommit(id);
    }

    /** {@inheritDoc} */
    @Override
    public RevCommit next() throws MissingObjectException,
            IncorrectObjectTypeException, IOException {
        PlotCommit<?> pc = (PlotCommit) super.next();
        if (pc != null)
            pc.refs = getRefs(pc);
        return pc;
    }

    private Ref[] getRefs(AnyObjectId commitId) {
        if (reverseRefMap == null) {
            reverseRefMap = repository.getAllRefsByPeeledObjectId();
            for (Map.Entry<AnyObjectId, Set<Ref>> entry : additionalRefMap
                    .entrySet()) {
                Set<Ref> set = reverseRefMap.get(entry.getKey());
                Set<Ref> additional = entry.getValue();
                if (set != null) {
                    if (additional.size() == 1) {
                        // It's an unmodifiable singleton set...
                        additional = new HashSet<>(additional);
                    }
                    additional.addAll(set);
                }
                reverseRefMap.put(entry.getKey(), additional);
            }
            additionalRefMap.clear();
            additionalRefMap = null;
        }
        Collection<Ref> list = reverseRefMap.get(commitId);
        if (list == null) {
            return PlotCommit.NO_REFS;
        }
        Ref[] tags = list.toArray(new Ref[0]);
        Arrays.sort(tags, new PlotRefComparator());
        return tags;
    }

    class PlotRefComparator implements Comparator<Ref> {
        @Override
        public int compare(Ref o1, Ref o2) {
            try {
                RevObject obj1 = parseAny(o1.getObjectId());
                RevObject obj2 = parseAny(o2.getObjectId());
                long t1 = timeof(obj1);
                long t2 = timeof(obj2);
                if (t1 > t2)
                    return -1;
                if (t1 < t2)
                    return 1;
            } catch (IOException e) {
                // ignore
            }

            int cmp = kind(o1) - kind(o2);
            if (cmp == 0)
                cmp = o1.getName().compareTo(o2.getName());
            return cmp;
        }

        long timeof(RevObject o) {
            if (o instanceof RevCommit)
                return ((RevCommit) o).getCommitTime();
            if (o instanceof RevTag) {
                RevTag tag = (RevTag) o;
                try {
                    parseBody(tag);
                } catch (IOException e) {
                    return 0;
                }
                PersonIdent who = tag.getTaggerIdent();
                return who != null ? who.getWhen().getTime() : 0;
            }
            return 0;
        }

        int kind(Ref r) {
            if (r.getName().startsWith(R_TAGS))
                return 0;
            if (r.getName().startsWith(R_HEADS))
                return 1;
            if (r.getName().startsWith(R_REMOTES))
                return 2;
            return 3;
        }
    }
}