| /* |
| * 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); |
| } |
| } |
| } |