--- /dev/null
+# -*- coding: utf-8 -*-
+
+__copyright__ = """
+Copyright (C) 2008, Karl Hasselström <kha@treskal.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 2 as
+published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+"""
+
+from stgit.commands import common
+from stgit.lib import git, log, transaction
+from stgit.out import out
+
+help = 'Reset the patch stack to an earlier state'
+kind = 'stack'
+usage = ['<state> [<patchnames>]']
+description = """
+Reset the patch stack to an earlier state. The state is specified with
+a commit from a stack log; for a branch foo, StGit stores the stack
+log in foo.stgit^. So to undo the last N StGit commands (or rather,
+the last N log entries; there is not an exact one-to-one
+relationship), you would say
+
+ stg reset foo.stgit^~N
+
+or, if you are not sure how many steps to undo, you can view the log
+with "git log" or gitk
+
+ gitk foo.stgit^
+
+and then reset to any sha1 you see in the log.
+
+If one or more patch names are given, reset only those patches, and
+leave the rest alone."""
+
+options = []
+
+directory = common.DirectoryHasRepositoryLib()
+
+def reset_stack(stack, iw, state, only_patches):
+ only_patches = set(only_patches)
+ def mask(s):
+ if only_patches:
+ return s & only_patches
+ else:
+ return s
+ patches_to_reset = mask(set(state.applied + state.unapplied + state.hidden))
+ existing_patches = set(stack.patchorder.all)
+ to_delete = mask(existing_patches - patches_to_reset)
+ trans = transaction.StackTransaction(stack, 'reset')
+
+ # If we have to change the stack base, we need to pop all patches
+ # first.
+ if not only_patches and trans.base != state.base:
+ trans.pop_patches(lambda pn: True)
+ out.info('Setting stack base to %s' % state.base.sha1)
+ trans.base = state.base
+
+ # In one go, do all the popping we have to in order to pop the
+ # patches we're going to delete or modify.
+ def mod(pn):
+ if only_patches and not pn in only_patches:
+ return False
+ if pn in to_delete:
+ return True
+ if stack.patches.get(pn).commit != state.patches.get(pn, None):
+ return True
+ return False
+ trans.pop_patches(mod)
+
+ # Delete and modify/create patches. We've previously popped all
+ # patches that we touch in this step.
+ trans.delete_patches(lambda pn: pn in to_delete)
+ for pn in patches_to_reset:
+ if pn in existing_patches:
+ if trans.patches[pn] == state.patches[pn]:
+ continue
+ else:
+ out.info('Resetting %s' % pn)
+ else:
+ if pn in state.hidden:
+ trans.hidden.append(pn)
+ else:
+ trans.unapplied.append(pn)
+ out.info('Resurrecting %s' % pn)
+ trans.patches[pn] = state.patches[pn]
+
+ # Push/pop patches as necessary.
+ try:
+ if only_patches:
+ # Push all the patches that we've popped, if they still
+ # exist.
+ pushable = set(trans.unapplied)
+ for pn in stack.patchorder.applied:
+ if pn in pushable:
+ trans.push_patch(pn, iw)
+ else:
+ # Recreate the exact order specified by the goal state.
+ trans.reorder_patches(state.applied, state.unapplied,
+ state.hidden, iw)
+ except transaction.TransactionHalted:
+ pass
+ return trans.run(iw)
+
+def func(parser, options, args):
+ stack = directory.repository.current_stack
+ if len(args) >= 1:
+ ref, patches = args[0], args[1:]
+ state = log.get_log_entry(stack.repository, ref)
+ else:
+ raise common.CmdException('Wrong number of arguments')
+ return reset_stack(stack, stack.repository.default_iw, state, patches)
if self.__prev != None and not isinstance(self.__prev, LogEntry):
self.__prev = self.from_commit(self.__repo, self.__prev)
return self.__prev
+ @property
+ def base(self):
+ if self.applied:
+ return self.patches[self.applied[0]].data.parent
+ else:
+ return self.head
@classmethod
def from_stack(cls, prev, stack, message):
return cls(
tree = tree, message = self.message,
parents = [self.simplified] + parents))
+def get_log_entry(repo, ref):
+ try:
+ return LogEntry.from_commit(repo, repo.rev_parse(ref))
+ except LogException, e:
+ raise LogException('While reading log from %s: %s' % (ref, e))
+
def log_entry(stack, msg):
"""Write a new log entry for the stack."""
ref = log_ref(stack.name)
--- /dev/null
+#!/bin/sh
+
+test_description='Simple test cases for "stg reset"'
+
+. ./test-lib.sh
+
+# Ignore our own output files.
+cat > .git/info/exclude <<EOF
+/expected.txt
+EOF
+
+test_expect_success 'Initialize StGit stack with three patches' '
+ stg init &&
+ echo 000 >> a &&
+ git add a &&
+ git commit -m a &&
+ echo 111 >> a &&
+ git commit -a -m p1 &&
+ echo 222 >> a &&
+ git commit -a -m p2 &&
+ echo 333 >> a &&
+ git commit -a -m p3 &&
+ stg uncommit -n 3 &&
+ stg pop
+'
+
+cat > expected.txt <<EOF
+000
+111
+EOF
+test_expect_success 'Pop one patch ...' '
+ stg pop &&
+ test "$(echo $(stg series --all))" = "> p1 - p2 - p3" &&
+ test_cmp expected.txt a
+'
+
+cat > expected.txt <<EOF
+000
+111
+222
+EOF
+test_expect_success '... and undo it' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 - p3" &&
+ test_cmp expected.txt a
+'
+
+cat > expected.txt <<EOF
+000
+111
+222
+333
+EOF
+test_expect_success 'Push one patch ...' '
+ stg push &&
+ test "$(echo $(stg series --all))" = "+ p1 + p2 > p3" &&
+ test_cmp expected.txt a
+'
+
+cat > expected.txt <<EOF
+000
+111
+222
+EOF
+test_expect_success '... and undo it' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 - p3" &&
+ test_cmp expected.txt a
+'
+
+test_expect_success 'Commit one patch ...' '
+ stg commit &&
+ test "$(echo $(stg series --all))" = "> p2 - p3"
+'
+
+test_expect_success '... and undo it' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 - p3"
+'
+
+test_expect_success 'Hide a patch ...' '
+ stg hide p3 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 ! p3"
+'
+
+test_expect_success '... undo the hiding ...' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 - p3"
+'
+
+test_expect_success '... unhide the patch ...' '
+ stg hide p3 && stg unhide p3 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 - p3"
+'
+
+test_expect_success '... and undo the unhiding' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2 ! p3" &&
+ stg unhide p3
+'
+
+cat > expected.txt <<EOF
+000
+111
+EOF
+test_expect_success 'Delete two patches ...' '
+ stg delete p2 p3 &&
+ test "$(echo $(stg series --all))" = "> p1" &&
+ test_cmp expected.txt a
+'
+
+test_expect_success '... and undo one of the deletions ...' '
+ stg reset master.stgit^~1 p3 &&
+ test "$(echo $(stg series --all))" = "> p1 - p3" &&
+ test_cmp expected.txt a
+'
+
+test_expect_success '... then undo the first undo ...' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "> p1" &&
+ test_cmp expected.txt a
+'
+
+cat > expected.txt <<EOF
+000
+111
+222
+EOF
+test_expect_success '... and undo the other deletion' '
+ stg reset master.stgit^~3 p2 &&
+ stg push p2 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2" &&
+ test_cmp expected.txt a
+'
+
+cat > expected.txt <<EOF
+000
+111
+222
+ggg
+EOF
+test_expect_success 'Refresh a patch ...' '
+ echo ggg >> a &&
+ stg refresh &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2" &&
+ test_cmp expected.txt a
+'
+
+cat > expected.txt <<EOF
+000
+111
+222
+EOF
+test_expect_success '... and undo the refresh' '
+ stg reset master.stgit^~1 &&
+ test "$(echo $(stg series --all))" = "+ p1 > p2" &&
+ test_cmp expected.txt a
+'
+
+test_done
~mdw / stgit / commitdiff