InitCommand.java

/*
 * Copyright (C) 2010, Chris Aniszczyk <caniszczyk@gmail.com> 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.api;

import java.io.File;
import java.io.IOException;
import java.text.MessageFormat;
import java.util.concurrent.Callable;

import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.InvalidRefNameException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.ConfigConstants;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryBuilder;
import org.eclipse.jgit.util.FS;
import org.eclipse.jgit.util.StringUtils;
import org.eclipse.jgit.util.SystemReader;

/**
 * Create an empty git repository or reinitalize an existing one
 *
 * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-init.html"
 *      >Git documentation about init</a>
 */
public class InitCommand implements Callable<Git> {
    private File directory;

    private File gitDir;

    private boolean bare;

    private FS fs;

    private String initialBranch;

    /**
     * {@inheritDoc}
     * <p>
     * Executes the {@code Init} command.
     *
     * @return a {@code Git} instance that owns the {@code Repository} that it
     *         wraps.
     */
    @Override
    public Git call() throws GitAPIException {
        try {
            RepositoryBuilder builder = new RepositoryBuilder();
            if (bare)
                builder.setBare();
            if (fs != null) {
                builder.setFS(fs);
            }
            builder.readEnvironment();
            if (gitDir != null)
                builder.setGitDir(gitDir);
            else
                gitDir = builder.getGitDir();
            if (directory != null) {
                if (bare)
                    builder.setGitDir(directory);
                else {
                    builder.setWorkTree(directory);
                    if (gitDir == null)
                        builder.setGitDir(new File(directory, Constants.DOT_GIT));
                }
            } else if (builder.getGitDir() == null) {
                String dStr = SystemReader.getInstance()
                        .getProperty("user.dir"); //$NON-NLS-1$
                if (dStr == null)
                    dStr = "."; //$NON-NLS-1$
                File d = new File(dStr);
                if (!bare)
                    d = new File(d, Constants.DOT_GIT);
                builder.setGitDir(d);
            } else {
                // directory was not set but gitDir was set
                if (!bare) {
                    String dStr = SystemReader.getInstance().getProperty(
                            "user.dir"); //$NON-NLS-1$
                    if (dStr == null)
                        dStr = "."; //$NON-NLS-1$
                    builder.setWorkTree(new File(dStr));
                }
            }
            builder.setInitialBranch(StringUtils.isEmptyOrNull(initialBranch)
                    ? SystemReader.getInstance().getUserConfig().getString(
                            ConfigConstants.CONFIG_INIT_SECTION, null,
                            ConfigConstants.CONFIG_KEY_DEFAULT_BRANCH)
                    : initialBranch);
            Repository repository = builder.build();
            if (!repository.getObjectDatabase().exists())
                repository.create(bare);
            return new Git(repository, true);
        } catch (IOException | ConfigInvalidException e) {
            throw new JGitInternalException(e.getMessage(), e);
        }
    }

    /**
     * The optional directory associated with the init operation. If no
     * directory is set, we'll use the current directory
     *
     * @param directory
     *            the directory to init to
     * @return this instance
     * @throws java.lang.IllegalStateException
     *             if the combination of directory, gitDir and bare is illegal.
     *             E.g. if for a non-bare repository directory and gitDir point
     *             to the same directory of if for a bare repository both
     *             directory and gitDir are specified
     */
    public InitCommand setDirectory(File directory)
            throws IllegalStateException {
        validateDirs(directory, gitDir, bare);
        this.directory = directory;
        return this;
    }

    /**
     * Set the repository meta directory (.git)
     *
     * @param gitDir
     *            the repository meta directory
     * @return this instance
     * @throws java.lang.IllegalStateException
     *             if the combination of directory, gitDir and bare is illegal.
     *             E.g. if for a non-bare repository directory and gitDir point
     *             to the same directory of if for a bare repository both
     *             directory and gitDir are specified
     * @since 3.6
     */
    public InitCommand setGitDir(File gitDir)
            throws IllegalStateException {
        validateDirs(directory, gitDir, bare);
        this.gitDir = gitDir;
        return this;
    }

    private static void validateDirs(File directory, File gitDir, boolean bare)
            throws IllegalStateException {
        if (directory != null) {
            if (bare) {
                if (gitDir != null && !gitDir.equals(directory))
                    throw new IllegalStateException(MessageFormat.format(
                            JGitText.get().initFailedBareRepoDifferentDirs,
                            gitDir, directory));
            } else {
                if (gitDir != null && gitDir.equals(directory))
                    throw new IllegalStateException(MessageFormat.format(
                            JGitText.get().initFailedNonBareRepoSameDirs,
                            gitDir, directory));
            }
        }
    }

    /**
     * Set whether the repository is bare or not
     *
     * @param bare
     *            whether the repository is bare or not
     * @throws java.lang.IllegalStateException
     *             if the combination of directory, gitDir and bare is illegal.
     *             E.g. if for a non-bare repository directory and gitDir point
     *             to the same directory of if for a bare repository both
     *             directory and gitDir are specified
     * @return this instance
     */
    public InitCommand setBare(boolean bare) {
        validateDirs(directory, gitDir, bare);
        this.bare = bare;
        return this;
    }

    /**
     * Set the file system abstraction to be used for repositories created by
     * this command.
     *
     * @param fs
     *            the abstraction.
     * @return {@code this} (for chaining calls).
     * @since 4.10
     */
    public InitCommand setFs(FS fs) {
        this.fs = fs;
        return this;
    }

    /**
     * Set the initial branch of the new repository. If not specified
     * ({@code null} or empty), fall back to the default name (currently
     * master).
     *
     * @param branch
     *            initial branch name of the new repository
     * @return {@code this}
     * @throws InvalidRefNameException
     *             if the branch name is not valid
     *
     * @since 5.11
     */
    public InitCommand setInitialBranch(String branch)
            throws InvalidRefNameException {
        this.initialBranch = branch;
        return this;
    }
}