AddCommand.java

/*
 * Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>
 * Copyright (C) 2010, Stefan Lay <stefan.lay@sap.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 static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
import static org.eclipse.jgit.lib.FileMode.GITLINK;
import static org.eclipse.jgit.lib.FileMode.TYPE_GITLINK;
import static org.eclipse.jgit.lib.FileMode.TYPE_TREE;

import java.io.IOException;
import java.io.InputStream;
import java.time.Instant;
import java.util.Collection;
import java.util.LinkedList;

import org.eclipse.jgit.api.errors.FilterFailedException;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.api.errors.JGitInternalException;
import org.eclipse.jgit.api.errors.NoFilepatternException;
import org.eclipse.jgit.dircache.DirCache;
import org.eclipse.jgit.dircache.DirCacheBuildIterator;
import org.eclipse.jgit.dircache.DirCacheBuilder;
import org.eclipse.jgit.dircache.DirCacheEntry;
import org.eclipse.jgit.dircache.DirCacheIterator;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.lib.FileMode;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.treewalk.FileTreeIterator;
import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
import org.eclipse.jgit.treewalk.TreeWalk.OperationType;
import org.eclipse.jgit.treewalk.WorkingTreeIterator;
import org.eclipse.jgit.treewalk.filter.PathFilterGroup;

/**
 * A class used to execute a {@code Add} command. It has setters for all
 * supported options and arguments of this command and a {@link #call()} method
 * to finally execute the command. Each instance of this class should only be
 * used for one invocation of the command (means: one call to {@link #call()})
 *
 * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-add.html"
 *      >Git documentation about Add</a>
 */
public class AddCommand extends GitCommand<DirCache> {

    private Collection<String> filepatterns;

    private WorkingTreeIterator workingTreeIterator;

    private boolean update = false;

    /**
     * Constructor for AddCommand
     *
     * @param repo
     *            the {@link org.eclipse.jgit.lib.Repository}
     */
    public AddCommand(Repository repo) {
        super(repo);
        filepatterns = new LinkedList<>();
    }

    /**
     * Add a path to a file/directory whose content should be added.
     * <p>
     * A directory name (e.g. <code>dir</code> to add <code>dir/file1</code> and
     * <code>dir/file2</code>) can also be given to add all files in the
     * directory, recursively. Fileglobs (e.g. *.c) are not yet supported.
     *
     * @param filepattern
     *            repository-relative path of file/directory to add (with
     *            <code>/</code> as separator)
     * @return {@code this}
     */
    public AddCommand addFilepattern(String filepattern) {
        checkCallable();
        filepatterns.add(filepattern);
        return this;
    }

    /**
     * Allow clients to provide their own implementation of a FileTreeIterator
     *
     * @param f
     *            a {@link org.eclipse.jgit.treewalk.WorkingTreeIterator}
     *            object.
     * @return {@code this}
     */
    public AddCommand setWorkingTreeIterator(WorkingTreeIterator f) {
        workingTreeIterator = f;
        return this;
    }

    /**
     * {@inheritDoc}
     * <p>
     * Executes the {@code Add} command. Each instance of this class should only
     * be used for one invocation of the command. Don't call this method twice
     * on an instance.
     */
    @Override
    public DirCache call() throws GitAPIException, NoFilepatternException {

        if (filepatterns.isEmpty())
            throw new NoFilepatternException(JGitText.get().atLeastOnePatternIsRequired);
        checkCallable();
        DirCache dc = null;
        boolean addAll = filepatterns.contains("."); //$NON-NLS-1$

        try (ObjectInserter inserter = repo.newObjectInserter();
                NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
            tw.setOperationType(OperationType.CHECKIN_OP);
            dc = repo.lockDirCache();

            DirCacheBuilder builder = dc.builder();
            tw.addTree(new DirCacheBuildIterator(builder));
            if (workingTreeIterator == null)
                workingTreeIterator = new FileTreeIterator(repo);
            workingTreeIterator.setDirCacheIterator(tw, 0);
            tw.addTree(workingTreeIterator);
            if (!addAll)
                tw.setFilter(PathFilterGroup.createFromStrings(filepatterns));

            byte[] lastAdded = null;

            while (tw.next()) {
                DirCacheIterator c = tw.getTree(0, DirCacheIterator.class);
                WorkingTreeIterator f = tw.getTree(1, WorkingTreeIterator.class);
                if (c == null && f != null && f.isEntryIgnored()) {
                    // file is not in index but is ignored, do nothing
                    continue;
                } else if (c == null && update) {
                    // Only update of existing entries was requested.
                    continue;
                }

                DirCacheEntry entry = c != null ? c.getDirCacheEntry() : null;
                if (entry != null && entry.getStage() > 0
                        && lastAdded != null
                        && lastAdded.length == tw.getPathLength()
                        && tw.isPathPrefix(lastAdded, lastAdded.length) == 0) {
                    // In case of an existing merge conflict the
                    // DirCacheBuildIterator iterates over all stages of
                    // this path, we however want to add only one
                    // new DirCacheEntry per path.
                    continue;
                }

                if (tw.isSubtree() && !tw.isDirectoryFileConflict()) {
                    tw.enterSubtree();
                    continue;
                }

                if (f == null) { // working tree file does not exist
                    if (entry != null
                            && (!update || GITLINK == entry.getFileMode())) {
                        builder.add(entry);
                    }
                    continue;
                }

                if (entry != null && entry.isAssumeValid()) {
                    // Index entry is marked assume valid. Even though
                    // the user specified the file to be added JGit does
                    // not consider the file for addition.
                    builder.add(entry);
                    continue;
                }

                if ((f.getEntryRawMode() == TYPE_TREE
                        && f.getIndexFileMode(c) != FileMode.GITLINK) ||
                        (f.getEntryRawMode() == TYPE_GITLINK
                                && f.getIndexFileMode(c) == FileMode.TREE)) {
                    // Index entry exists and is symlink, gitlink or file,
                    // otherwise the tree would have been entered above.
                    // Replace the index entry by diving into tree of files.
                    tw.enterSubtree();
                    continue;
                }

                byte[] path = tw.getRawPath();
                if (entry == null || entry.getStage() > 0) {
                    entry = new DirCacheEntry(path);
                }
                FileMode mode = f.getIndexFileMode(c);
                entry.setFileMode(mode);

                if (GITLINK != mode) {
                    entry.setLength(f.getEntryLength());
                    entry.setLastModified(f.getEntryLastModifiedInstant());
                    long len = f.getEntryContentLength();
                    // We read and filter the content multiple times.
                    // f.getEntryContentLength() reads and filters the input and
                    // inserter.insert(...) does it again. That's because an
                    // ObjectInserter needs to know the length before it starts
                    // inserting. TODO: Fix this by using Buffers.
                    try (InputStream in = f.openEntryStream()) {
                        ObjectId id = inserter.insert(OBJ_BLOB, len, in);
                        entry.setObjectId(id);
                    }
                } else {
                    entry.setLength(0);
                    entry.setLastModified(Instant.ofEpochSecond(0));
                    entry.setObjectId(f.getEntryObjectId());
                }
                builder.add(entry);
                lastAdded = path;
            }
            inserter.flush();
            builder.commit();
            setCallable(false);
        } catch (IOException e) {
            Throwable cause = e.getCause();
            if (cause != null && cause instanceof FilterFailedException)
                throw (FilterFailedException) cause;
            throw new JGitInternalException(
                    JGitText.get().exceptionCaughtDuringExecutionOfAddCommand, e);
        } finally {
            if (dc != null)
                dc.unlock();
        }

        return dc;
    }

    /**
     * Set whether to only match against already tracked files
     *
     * @param update
     *            If set to true, the command only matches {@code filepattern}
     *            against already tracked files in the index rather than the
     *            working tree. That means that it will never stage new files,
     *            but that it will stage modified new contents of tracked files
     *            and that it will remove files from the index if the
     *            corresponding files in the working tree have been removed. In
     *            contrast to the git command line a {@code filepattern} must
     *            exist also if update is set to true as there is no concept of
     *            a working directory here.
     * @return {@code this}
     */
    public AddCommand setUpdate(boolean update) {
        this.update = update;
        return this;
    }

    /**
     * Whether to only match against already tracked files
     *
     * @return whether to only match against already tracked files
     */
    public boolean isUpdate() {
        return update;
    }
}