RepoProject.java

/*
 * Copyright (C) 2015, Google Inc. 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.gitrepo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.jgit.lib.Repository;

/**
 * The representation of a repo sub project.
 *
 * @see <a href="https://code.google.com/p/git-repo/">git-repo project page</a>
 * @since 4.0
 */
public class RepoProject implements Comparable<RepoProject> {
    private final String name;
    private final String path;
    private final String revision;
    private final String remote;
    private final Set<String> groups;
    private final List<CopyFile> copyfiles;
    private final List<LinkFile> linkfiles;
    private String recommendShallow;
    private String url;
    private String defaultRevision;

    /**
     * The representation of a reference file configuration.
     *
     * @since 4.8
     */
    public static class ReferenceFile {
        final Repository repo;
        final String path;
        final String src;
        final String dest;

        /**
         * @param repo
         *            the super project.
         * @param path
         *            the path of the project containing this copyfile config.
         * @param src
         *            the source path relative to the sub repo.
         * @param dest
         *            the destination path relative to the super project.
         */
        public ReferenceFile(Repository repo, String path, String src, String dest) {
            this.repo = repo;
            this.path = path;
            this.src = src;
            this.dest = dest;
        }
    }

    /**
     * The representation of a copy file configuration.
     */
    public static class CopyFile extends ReferenceFile {
        /**
         * @param repo
         *            the super project.
         * @param path
         *            the path of the project containing this copyfile config.
         * @param src
         *            the source path relative to the sub repo.
         * @param dest
         *            the destination path relative to the super project.
         */
        public CopyFile(Repository repo, String path, String src, String dest) {
            super(repo, path, src, dest);
        }

        /**
         * Do the copy file action.
         *
         * @throws IOException
         */
        public void copy() throws IOException {
            File srcFile = new File(repo.getWorkTree(),
                    path + "/" + src); //$NON-NLS-1$
            File destFile = new File(repo.getWorkTree(), dest);
            try (FileInputStream input = new FileInputStream(srcFile);
                    FileOutputStream output = new FileOutputStream(destFile)) {
                FileChannel channel = input.getChannel();
                output.getChannel().transferFrom(channel, 0, channel.size());
            }
            destFile.setExecutable(srcFile.canExecute());
        }
    }

    /**
     * The representation of a link file configuration.
     *
     * @since 4.8
     */
    public static class LinkFile extends ReferenceFile {
        /**
         * @param repo
         *            the super project.
         * @param path
         *            the path of the project containing this linkfile config.
         * @param src
         *            the source path relative to the sub repo.
         * @param dest
         *            the destination path relative to the super project.
         */
        public LinkFile(Repository repo, String path, String src, String dest) {
            super(repo, path, src, dest);
        }
    }

    /**
     * Constructor for RepoProject
     *
     * @param name
     *            the relative path to the {@code remote}
     * @param path
     *            the relative path to the super project
     * @param revision
     *            a SHA-1 or branch name or tag name
     * @param remote
     *            name of the remote definition
     * @param groups
     *            set of groups
     * @param recommendShallow
     *            recommendation for shallowness
     * @since 4.4
     */
    public RepoProject(String name, String path, String revision,
            String remote, Set<String> groups,
            String recommendShallow) {
        if (name == null) {
            throw new NullPointerException();
        }
        this.name = name;
        if (path != null)
            this.path = path;
        else
            this.path = name;
        this.revision = revision;
        this.remote = remote;
        this.groups = groups;
        this.recommendShallow = recommendShallow;
        copyfiles = new ArrayList<>();
        linkfiles = new ArrayList<>();
    }

    /**
     * Constructor for RepoProject
     *
     * @param name
     *            the relative path to the {@code remote}
     * @param path
     *            the relative path to the super project
     * @param revision
     *            a SHA-1 or branch name or tag name
     * @param remote
     *            name of the remote definition
     * @param groupsParam
     *            comma separated group list
     */
    public RepoProject(String name, String path, String revision,
            String remote, String groupsParam) {
        this(name, path, revision, remote, new HashSet<String>(), null);
        if (groupsParam != null && groupsParam.length() > 0)
            this.setGroups(groupsParam);
    }

    /**
     * Set the url of the sub repo.
     *
     * @param url
     *            project url
     * @return this for chaining.
     */
    public RepoProject setUrl(String url) {
        this.url = url;
        return this;
    }

    /**
     * Set the url of the sub repo.
     *
     * @param groupsParam
     *            comma separated group list
     * @return this for chaining.
     * @since 4.4
     */
    public RepoProject setGroups(String groupsParam) {
        this.groups.clear();
        this.groups.addAll(Arrays.asList(groupsParam.split(","))); //$NON-NLS-1$
        return this;
    }

    /**
     * Set the default revision for the sub repo.
     *
     * @param defaultRevision
     *            the name of the default revision
     * @return this for chaining.
     */
    public RepoProject setDefaultRevision(String defaultRevision) {
        this.defaultRevision = defaultRevision;
        return this;
    }

    /**
     * Get the name (relative path to the {@code remote}) of this sub repo.
     *
     * @return {@code name}
     */
    public String getName() {
        return name;
    }

    /**
     * Get the path (relative path to the super project) of this sub repo.
     *
     * @return {@code path}
     */
    public String getPath() {
        return path;
    }

    /**
     * Get the revision of the sub repo.
     *
     * @return {@code revision} if set, or {@code defaultRevision}.
     */
    public String getRevision() {
        return revision == null ? defaultRevision : revision;
    }

    /**
     * Getter for the copyfile configurations.
     *
     * @return Immutable copy of {@code copyfiles}
     */
    public List<CopyFile> getCopyFiles() {
        return Collections.unmodifiableList(copyfiles);
    }

    /**
     * Getter for the linkfile configurations.
     *
     * @return Immutable copy of {@code linkfiles}
     * @since 4.8
     */
    public List<LinkFile> getLinkFiles() {
        return Collections.unmodifiableList(linkfiles);
    }

    /**
     * Get the url of the sub repo.
     *
     * @return {@code url}
     */
    public String getUrl() {
        return url;
    }

    /**
     * Get the name of the remote definition of the sub repo.
     *
     * @return {@code remote}
     */
    public String getRemote() {
        return remote;
    }

    /**
     * Test whether this sub repo belongs to a specified group.
     *
     * @param group
     *            a group
     * @return true if {@code group} is present.
     */
    public boolean inGroup(String group) {
        return groups.contains(group);
    }

    /**
     * Return the set of groups.
     *
     * @return a Set of groups.
     * @since 4.4
     */
    public Set<String> getGroups() {
        return groups;
    }

    /**
     * Return the recommendation for shallowness.
     *
     * @return the String of "clone-depth"
     * @since 4.4
     */
    public String getRecommendShallow() {
        return recommendShallow;
    }

    /**
     * Sets the recommendation for shallowness.
     *
     * @param recommendShallow
     *            recommendation for shallowness
     * @since 4.4
     */
    public void setRecommendShallow(String recommendShallow) {
        this.recommendShallow = recommendShallow;
    }

    /**
     * Add a copy file configuration.
     *
     * @param copyfile a {@link org.eclipse.jgit.gitrepo.RepoProject.CopyFile} object.
     */
    public void addCopyFile(CopyFile copyfile) {
        copyfiles.add(copyfile);
    }

    /**
     * Add a bunch of copyfile configurations.
     *
     * @param copyFiles
     *            a collection of
     *            {@link org.eclipse.jgit.gitrepo.RepoProject.CopyFile} objects
     */
    public void addCopyFiles(Collection<CopyFile> copyFiles) {
        this.copyfiles.addAll(copyFiles);
    }

    /**
     * Clear all the copyfiles.
     *
     * @since 4.2
     */
    public void clearCopyFiles() {
        this.copyfiles.clear();
    }

    /**
     * Add a link file configuration.
     *
     * @param linkfile a {@link org.eclipse.jgit.gitrepo.RepoProject.LinkFile} object.
     * @since 4.8
     */
    public void addLinkFile(LinkFile linkfile) {
        linkfiles.add(linkfile);
    }

    /**
     * Add a bunch of linkfile configurations.
     *
     * @param linkFiles
     *            a collection of {@link LinkFile}s
     * @since 4.8
     */
    public void addLinkFiles(Collection<LinkFile> linkFiles) {
        this.linkfiles.addAll(linkFiles);
    }

    /**
     * Clear all the linkfiles.
     *
     * @since 4.8
     */
    public void clearLinkFiles() {
        this.linkfiles.clear();
    }

    private String getPathWithSlash() {
        if (path.endsWith("/")) { //$NON-NLS-1$
            return path;
        }
        return path + "/"; //$NON-NLS-1$
    }

    /**
     * Check if this sub repo is the ancestor of given sub repo.
     *
     * @param that
     *            non null
     * @return true if this sub repo is the ancestor of given sub repo.
     */
    public boolean isAncestorOf(RepoProject that) {
        return isAncestorOf(that.getPathWithSlash());
    }

    /**
     * Check if this sub repo is an ancestor of the given path.
     *
     * @param thatPath
     *            path to be checked to see if it is within this repository
     * @return true if this sub repo is an ancestor of the given path.
     * @since 4.2
     */
    public boolean isAncestorOf(String thatPath) {
        return thatPath.startsWith(getPathWithSlash());
    }

    /** {@inheritDoc} */
    @Override
    public boolean equals(Object o) {
        if (o instanceof RepoProject) {
            RepoProject that = (RepoProject) o;
            return this.getPathWithSlash().equals(that.getPathWithSlash());
        }
        return false;
    }

    /** {@inheritDoc} */
    @Override
    public int hashCode() {
        return this.getPathWithSlash().hashCode();
    }

    /** {@inheritDoc} */
    @Override
    public int compareTo(RepoProject that) {
        return this.getPathWithSlash().compareTo(that.getPathWithSlash());
    }
}