StashDropCommand.java

/*
 * Copyright (C) 2012, GitHub 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.api;

import static org.eclipse.jgit.lib.Constants.R_STASH;

import java.io.File;
import java.io.IOException;
import java.nio.file.StandardCopyOption;
import java.text.MessageFormat;
import java.util.List;

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.api.errors.RefNotFoundException;
import org.eclipse.jgit.errors.LockFailedException;
import org.eclipse.jgit.internal.JGitText;
import org.eclipse.jgit.internal.storage.file.RefDirectory;
import org.eclipse.jgit.internal.storage.file.ReflogWriter;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.Ref;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.eclipse.jgit.lib.ReflogEntry;
import org.eclipse.jgit.lib.ReflogReader;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.util.FileUtils;

/**
 * Command class to delete a stashed commit reference
 * <p>
 * Currently only supported on a traditional file repository using
 * one-file-per-ref reflogs.
 *
 * @see <a href="http://www.kernel.org/pub/software/scm/git/docs/git-stash.html"
 *      >Git documentation about Stash</a>
 * @since 2.0
 */
public class StashDropCommand extends GitCommand<ObjectId> {

    private int stashRefEntry;

    private boolean all;

    /**
     * Constructor for StashDropCommand.
     *
     * @param repo
     *            a {@link org.eclipse.jgit.lib.Repository} object.
     */
    public StashDropCommand(Repository repo) {
        super(repo);
        if (!(repo.getRefDatabase() instanceof RefDirectory)) {
            throw new UnsupportedOperationException(
                    JGitText.get().stashDropNotSupported);
        }
    }

    /**
     * Set the stash reference to drop (0-based).
     * <p>
     * This will default to drop the latest stashed commit (stash@{0}) if
     * unspecified
     *
     * @param stashRef
     *            the 0-based index of the stash reference
     * @return {@code this}
     */
    public StashDropCommand setStashRef(int stashRef) {
        if (stashRef < 0)
            throw new IllegalArgumentException();

        stashRefEntry = stashRef;
        return this;
    }

    /**
     * Set whether to drop all stashed commits
     *
     * @param all
     *            {@code true} to drop all stashed commits, {@code false} to
     *            drop only the stashed commit set via calling
     *            {@link #setStashRef(int)}
     * @return {@code this}
     */
    public StashDropCommand setAll(boolean all) {
        this.all = all;
        return this;
    }

    private Ref getRef() throws GitAPIException {
        try {
            return repo.exactRef(R_STASH);
        } catch (IOException e) {
            throw new InvalidRefNameException(MessageFormat.format(
                    JGitText.get().cannotRead, R_STASH), e);
        }
    }

    private RefUpdate createRefUpdate(Ref stashRef) throws IOException {
        RefUpdate update = repo.updateRef(R_STASH);
        update.disableRefLog();
        update.setExpectedOldObjectId(stashRef.getObjectId());
        update.setForceUpdate(true);
        return update;
    }

    private void deleteRef(Ref stashRef) {
        try {
            Result result = createRefUpdate(stashRef).delete();
            if (Result.FORCED != result)
                throw new JGitInternalException(MessageFormat.format(
                        JGitText.get().stashDropDeleteRefFailed, result));
        } catch (IOException e) {
            throw new JGitInternalException(JGitText.get().stashDropFailed, e);
        }
    }

    private void updateRef(Ref stashRef, ObjectId newId) {
        try {
            RefUpdate update = createRefUpdate(stashRef);
            update.setNewObjectId(newId);
            Result result = update.update();
            switch (result) {
            case FORCED:
            case NEW:
            case NO_CHANGE:
                return;
            default:
                throw new JGitInternalException(MessageFormat.format(
                        JGitText.get().updatingRefFailed, R_STASH, newId,
                        result));
            }
        } catch (IOException e) {
            throw new JGitInternalException(JGitText.get().stashDropFailed, e);
        }
    }

    /**
     * {@inheritDoc}
     * <p>
     * Drop the configured entry from the stash reflog and return value of the
     * stash reference after the drop occurs
     */
    @Override
    public ObjectId call() throws GitAPIException {
        checkCallable();

        Ref stashRef = getRef();
        if (stashRef == null)
            return null;

        if (all) {
            deleteRef(stashRef);
            return null;
        }

        List<ReflogEntry> entries;
        try {
            ReflogReader reader = repo.getReflogReader(R_STASH);
            if (reader == null) {
                throw new RefNotFoundException(MessageFormat
                        .format(JGitText.get().refNotResolved, stashRef));
            }
            entries = reader.getReverseEntries();
        } catch (IOException e) {
            throw new JGitInternalException(JGitText.get().stashDropFailed, e);
        }

        if (stashRefEntry >= entries.size())
            throw new JGitInternalException(
                    JGitText.get().stashDropMissingReflog);

        if (entries.size() == 1) {
            deleteRef(stashRef);
            return null;
        }

        RefDirectory refdb = (RefDirectory) repo.getRefDatabase();
        ReflogWriter writer = new ReflogWriter(refdb, true);
        String stashLockRef = ReflogWriter.refLockFor(R_STASH);
        File stashLockFile = refdb.logFor(stashLockRef);
        File stashFile = refdb.logFor(R_STASH);
        if (stashLockFile.exists())
            throw new JGitInternalException(JGitText.get().stashDropFailed,
                    new LockFailedException(stashFile));

        entries.remove(stashRefEntry);
        ObjectId entryId = ObjectId.zeroId();
        try {
            for (int i = entries.size() - 1; i >= 0; i--) {
                ReflogEntry entry = entries.get(i);
                writer.log(stashLockRef, entryId, entry.getNewId(),
                        entry.getWho(), entry.getComment());
                entryId = entry.getNewId();
            }
            try {
                FileUtils.rename(stashLockFile, stashFile,
                        StandardCopyOption.ATOMIC_MOVE);
            } catch (IOException e) {
                    throw new JGitInternalException(MessageFormat.format(
                            JGitText.get().renameFileFailed,
                                stashLockFile.getPath(), stashFile.getPath()),
                        e);
            }
        } catch (IOException e) {
            throw new JGitInternalException(JGitText.get().stashDropFailed, e);
        }
        updateRef(stashRef, entryId);

        try {
            Ref newStashRef = repo.exactRef(R_STASH);
            return newStashRef != null ? newStashRef.getObjectId() : null;
        } catch (IOException e) {
            throw new InvalidRefNameException(MessageFormat.format(
                    JGitText.get().cannotRead, R_STASH), e);
        }
    }
}