Don't use patches/<branch>/current

[stgit] / stgit / stack.py

diff --git a/stgit/stack.py b/stgit/stack.py
index 46d6ee5fc7ba3b1df835f53934354c7777c42366..8292b105a32c37321332cfce221dd8c9712890f3 100644 (file)
--- a/stgit/stack.py
+++ b/stgit/stack.py
@@ -18,21 +18,33 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 

-import sys, os
+import sys, os, re

 
 from stgit.utils import *
 
 from stgit.utils import *

-from stgit import git
+from stgit import git, basedir, templates

 from stgit.config import config
 from stgit.config import config

+from shutil import copyfile

 
 
 # stack exception class
 class StackException(Exception):
     pass
 
 
 
 # stack exception class
 class StackException(Exception):
     pass
 

+class FilterUntil:
+    def __init__(self):
+        self.should_print = True
+    def __call__(self, x, until_test, prefix):
+        if until_test(x):
+            self.should_print = False
+        if self.should_print:
+            return x[0:len(prefix)] != prefix
+        return False
+

 #
 # Functions
 #
 __comment_prefix = 'STG:'
 #
 # Functions
 #
 __comment_prefix = 'STG:'

+__patch_prefix = 'STG_PATCH:'

 
 def __clean_comments(f):
     """Removes lines marked for status in a commit file
 
 def __clean_comments(f):
     """Removes lines marked for status in a commit file


@@ -40,8 +52,12 @@ def __clean_comments(f):
     f.seek(0)
 
     # remove status-prefixed lines
     f.seek(0)
 
     # remove status-prefixed lines

-    lines = filter(lambda x: x[0:len(__comment_prefix)] != __comment_prefix,
-                   f.readlines())
+    lines = f.readlines()
+
+    patch_filter = FilterUntil()
+    until_test = lambda t: t == (__patch_prefix + '\n')
+    lines = [l for l in lines if patch_filter(l, until_test, __comment_prefix)]
+

     # remove empty lines at the end
     while len(lines) != 0 and lines[-1] == '\n':
         del lines[-1]
     # remove empty lines at the end
     while len(lines) != 0 and lines[-1] == '\n':
         del lines[-1]


@@ -49,15 +65,15 @@ def __clean_comments(f):
     f.seek(0); f.truncate()
     f.writelines(lines)
 
     f.seek(0); f.truncate()
     f.writelines(lines)
 

-def edit_file(string, comment):
-    fname = '.stgit.msg'
-    tmpl = os.path.join(git.base_dir, 'patchdescr.tmpl')
+def edit_file(series, line, comment, show_patch = True):
+    fname = '.stgitmsg.txt'
+    tmpl = templates.get_template('patchdescr.tmpl')

 
     f = file(fname, 'w+')
 
     f = file(fname, 'w+')

-    if string:
-        print >> f, string
-    elif os.path.isfile(tmpl):
-        print >> f, file(tmpl).read().rstrip()
+    if line:
+        print >> f, line
+    elif tmpl:
+        print >> f, tmpl,

     else:
         print >> f
     print >> f, __comment_prefix, comment
     else:
         print >> f
     print >> f, __comment_prefix, comment


@@ -66,278 +82,620 @@ def edit_file(string, comment):
           % __comment_prefix
     print >> f, __comment_prefix, \
           'Trailing empty lines will be automatically removed.'
           % __comment_prefix
     print >> f, __comment_prefix, \
           'Trailing empty lines will be automatically removed.'

-    f.close()

 
 

-    # the editor
-    if 'EDITOR' in os.environ:
-        editor = os.environ['EDITOR']
-    else:
-        editor = 'vi'
-    editor += ' %s' % fname
+    if show_patch:
+       print >> f, __patch_prefix
+       # series.get_patch(series.get_current()).get_top()
+       git.diff([], series.get_patch(series.get_current()).get_bottom(), None, f)

 
 

-    print 'Invoking the editor: "%s"...' % editor,
-    sys.stdout.flush()
-    print 'done (exit code: %d)' % os.system(editor)
+    #Vim modeline must be near the end.
+    print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:'
+    f.close()
+
+    call_editor(fname)

 
     f = file(fname, 'r+')
 
     __clean_comments(f)
     f.seek(0)
 
     f = file(fname, 'r+')
 
     __clean_comments(f)
     f.seek(0)

-    string = f.read()
+    result = f.read()

 
     f.close()
     os.remove(fname)
 
 
     f.close()
     os.remove(fname)
 

-    return string
+    return result

 
 #
 # Classes
 #
 
 
 #
 # Classes
 #
 

-class Patch:
+class StgitObject:
+    """An object with stgit-like properties stored as files in a directory
+    """
+    def _set_dir(self, dir):
+        self.__dir = dir
+    def _dir(self):
+        return self.__dir
+
+    def create_empty_field(self, name):
+        create_empty_file(os.path.join(self.__dir, name))
+
+    def _get_field(self, name, multiline = False):
+        id_file = os.path.join(self.__dir, name)
+        if os.path.isfile(id_file):
+            line = read_string(id_file, multiline)
+            if line == '':
+                return None
+            else:
+                return line
+        else:
+            return None
+
+    def _set_field(self, name, value, multiline = False):
+        fname = os.path.join(self.__dir, name)
+        if value and value != '':
+            write_string(fname, value, multiline)
+        elif os.path.isfile(fname):
+            os.remove(fname)
+
+    
+class Patch(StgitObject):

     """Basic patch implementation
     """
     """Basic patch implementation
     """

-    def __init__(self, name, patch_dir):
-        self.__patch_dir = patch_dir
+    def __init__(self, name, series_dir, refs_dir):
+        self.__series_dir = series_dir

         self.__name = name
         self.__name = name

-        self.__dir = os.path.join(self.__patch_dir, self.__name)
+        self._set_dir(os.path.join(self.__series_dir, self.__name))
+        self.__refs_dir = refs_dir
+        self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
+        self.__log_ref_file = os.path.join(self.__refs_dir,
+                                           self.__name + '.log')

 
     def create(self):
 
     def create(self):

-        os.mkdir(self.__dir)
-        create_empty_file(os.path.join(self.__dir, 'bottom'))
-        create_empty_file(os.path.join(self.__dir, 'top'))
+        os.mkdir(self._dir())
+        self.create_empty_field('bottom')
+        self.create_empty_field('top')

 
     def delete(self):
 
     def delete(self):

-        for f in os.listdir(self.__dir):
-            os.remove(os.path.join(self.__dir, f))
-        os.rmdir(self.__dir)
+        for f in os.listdir(self._dir()):
+            os.remove(os.path.join(self._dir(), f))
+        os.rmdir(self._dir())
+        os.remove(self.__top_ref_file)
+        if os.path.exists(self.__log_ref_file):
+            os.remove(self.__log_ref_file)

 
     def get_name(self):
         return self.__name
 
     def rename(self, newname):
 
     def get_name(self):
         return self.__name
 
     def rename(self, newname):

-        olddir = self.__dir
+        olddir = self._dir()
+        old_top_ref_file = self.__top_ref_file
+        old_log_ref_file = self.__log_ref_file

         self.__name = newname
         self.__name = newname

-        self.__dir = os.path.join(self.__patch_dir, self.__name)
+        self._set_dir(os.path.join(self.__series_dir, self.__name))
+        self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
+        self.__log_ref_file = os.path.join(self.__refs_dir,
+                                           self.__name + '.log')

 
 

-        os.rename(olddir, self.__dir)
+        os.rename(olddir, self._dir())
+        os.rename(old_top_ref_file, self.__top_ref_file)
+        if os.path.exists(old_log_ref_file):
+            os.rename(old_log_ref_file, self.__log_ref_file)

 
 

-    def __get_field(self, name, multiline = False):
-        id_file = os.path.join(self.__dir, name)
-        if os.path.isfile(id_file):
-            string = read_string(id_file, multiline)
-            if string == '':
-                return None
-            else:
-                return string
-        else:
-            return None
+    def __update_top_ref(self, ref):
+        write_string(self.__top_ref_file, ref)

 
 

-    def __set_field(self, name, string, multiline = False):
-        fname = os.path.join(self.__dir, name)
-        if string and string != '':
-            write_string(fname, string, multiline)
-        elif os.path.isfile(fname):
-            os.remove(fname)
+    def __update_log_ref(self, ref):
+        write_string(self.__log_ref_file, ref)
+
+    def update_top_ref(self):
+        top = self.get_top()
+        if top:
+            self.__update_top_ref(top)
+
+    def get_old_bottom(self):
+        return self._get_field('bottom.old')

 
     def get_bottom(self):
 
     def get_bottom(self):

-        return self.__get_field('bottom')
+        return self._get_field('bottom')

 
 

-    def set_bottom(self, string, backup = False):
+    def set_bottom(self, value, backup = False):

         if backup:
         if backup:

-            self.__set_field('bottom.old', self.__get_field('bottom'))
-        self.__set_field('bottom', string)
+            curr = self._get_field('bottom')
+            self._set_field('bottom.old', curr)
+        self._set_field('bottom', value)
+
+    def get_old_top(self):
+        return self._get_field('top.old')

 
     def get_top(self):
 
     def get_top(self):

-        return self.__get_field('top')
+        return self._get_field('top')

 
 

-    def set_top(self, string, backup = False):
+    def set_top(self, value, backup = False):

         if backup:
         if backup:

-            self.__set_field('top.old', self.__get_field('top'))
-        self.__set_field('top', string)
+            curr = self._get_field('top')
+            self._set_field('top.old', curr)
+        self._set_field('top', value)
+        self.__update_top_ref(value)

 
     def restore_old_boundaries(self):
 
     def restore_old_boundaries(self):

-        bottom = self.__get_field('bottom.old')
-        top = self.__get_field('top.old')
+        bottom = self._get_field('bottom.old')
+        top = self._get_field('top.old')

 
         if top and bottom:
 
         if top and bottom:

-            self.__set_field('bottom', bottom)
-            self.__set_field('top', top)
+            self._set_field('bottom', bottom)
+            self._set_field('top', top)
+            self.__update_top_ref(top)
+            return True

         else:
         else:

-            raise StackException, 'No patch undo information'
+            return False

 
     def get_description(self):
 
     def get_description(self):

-        return self.__get_field('description', True)
+        return self._get_field('description', True)

 
 

-    def set_description(self, string):
-        self.__set_field('description', string, True)
+    def set_description(self, line):
+        self._set_field('description', line, True)

 
     def get_authname(self):
 
     def get_authname(self):

-        return self.__get_field('authname')
+        return self._get_field('authname')

 
 

-    def set_authname(self, string):
-        if not string and config.has_option('stgit', 'authname'):
-            string = config.get('stgit', 'authname')
-        self.__set_field('authname', string)
+    def set_authname(self, name):
+        self._set_field('authname', name or git.author().name)

 
     def get_authemail(self):
 
     def get_authemail(self):

-        return self.__get_field('authemail')
+        return self._get_field('authemail')

 
 

-    def set_authemail(self, string):
-        if not string and config.has_option('stgit', 'authemail'):
-            string = config.get('stgit', 'authemail')
-        self.__set_field('authemail', string)
+    def set_authemail(self, email):
+        self._set_field('authemail', email or git.author().email)

 
     def get_authdate(self):
 
     def get_authdate(self):

-        return self.__get_field('authdate')
+        return self._get_field('authdate')

 
 

-    def set_authdate(self, string):
-        self.__set_field('authdate', string)
+    def set_authdate(self, date):
+        self._set_field('authdate', date or git.author().date)

 
     def get_commname(self):
 
     def get_commname(self):

-        return self.__get_field('commname')
+        return self._get_field('commname')

 
 

-    def set_commname(self, string):
-        if not string and config.has_option('stgit', 'commname'):
-            string = config.get('stgit', 'commname')
-        self.__set_field('commname', string)
+    def set_commname(self, name):
+        self._set_field('commname', name or git.committer().name)

 
     def get_commemail(self):
 
     def get_commemail(self):

-        return self.__get_field('commemail')
+        return self._get_field('commemail')
+
+    def set_commemail(self, email):
+        self._set_field('commemail', email or git.committer().email)

 
 

-    def set_commemail(self, string):
-        if not string and config.has_option('stgit', 'commemail'):
-            string = config.get('stgit', 'commemail')
-        self.__set_field('commemail', string)
+    def get_log(self):
+        return self._get_field('log')

 
 

+    def set_log(self, value, backup = False):
+        self._set_field('log', value)
+        self.__update_log_ref(value)

 
 

-class Series:
+
+class Series(StgitObject):

     """Class including the operations on series
     """
     def __init__(self, name = None):
     """Class including the operations on series
     """
     def __init__(self, name = None):

-        """Takes a series name as the parameter. A valid .git/patches/name
-        directory should exist
+        """Takes a series name as the parameter.

         """
         """

-        if name:
-            self.__name = name
-        else:
-            self.__name = git.get_head_file()
-
-        if self.__name:
-            self.__patch_dir = os.path.join(git.base_dir, 'patches',
-                                            self.__name)
-            self.__base_file = os.path.join(git.base_dir, 'refs', 'bases',
-                                            self.__name)
-            self.__applied_file = os.path.join(self.__patch_dir, 'applied')
-            self.__unapplied_file = os.path.join(self.__patch_dir, 'unapplied')
-            self.__current_file = os.path.join(self.__patch_dir, 'current')
-
-    def __set_current(self, name):
-        """Sets the topmost patch
+        try:
+            if name:
+                self.__name = name
+            else:
+                self.__name = git.get_head_file()
+            self.__base_dir = basedir.get()
+        except git.GitException, ex:
+            raise StackException, 'GIT tree not initialised: %s' % ex
+
+        self._set_dir(os.path.join(self.__base_dir, 'patches', self.__name))
+        self.__refs_dir = os.path.join(self.__base_dir, 'refs', 'patches',
+                                       self.__name)
+
+        self.__applied_file = os.path.join(self._dir(), 'applied')
+        self.__unapplied_file = os.path.join(self._dir(), 'unapplied')
+        self.__hidden_file = os.path.join(self._dir(), 'hidden')
+        self.__descr_file = os.path.join(self._dir(), 'description')
+
+        # where this series keeps its patches
+        self.__patch_dir = os.path.join(self._dir(), 'patches')
+        if not os.path.isdir(self.__patch_dir):
+            self.__patch_dir = self._dir()
+
+        # if no __refs_dir, create and populate it (upgrade old repositories)
+        if self.is_initialised() and not os.path.isdir(self.__refs_dir):
+            os.makedirs(self.__refs_dir)
+            for patch in self.get_applied() + self.get_unapplied():
+                self.get_patch(patch).update_top_ref()
+
+        # trash directory
+        self.__trash_dir = os.path.join(self._dir(), 'trash')
+        if self.is_initialised() and not os.path.isdir(self.__trash_dir):
+            os.makedirs(self.__trash_dir)
+
+    def __patch_name_valid(self, name):
+        """Raise an exception if the patch name is not valid.

         """
         """

-        if name:
-            write_string(self.__current_file, name)
-        else:
-            create_empty_file(self.__current_file)
+        if not name or re.search('[^\w.-]', name):
+            raise StackException, 'Invalid patch name: "%s"' % name
+
+    def get_branch(self):
+        """Return the branch name for the Series object
+        """
+        return self.__name

 
     def get_patch(self, name):
         """Return a Patch object for the given name
         """
 
     def get_patch(self, name):
         """Return a Patch object for the given name
         """

-        return Patch(name, self.__patch_dir)
+        return Patch(name, self.__patch_dir, self.__refs_dir)
+
+    def get_current_patch(self):
+        """Return a Patch object representing the topmost patch, or
+        None if there is no such patch."""
+        crt = self.get_current()
+        if not crt:
+            return None
+        return Patch(crt, self.__patch_dir, self.__refs_dir)

 
     def get_current(self):
 
     def get_current(self):

-        """Return a Patch object representing the topmost patch
-        """
-        if os.path.isfile(self.__current_file):
-            name = read_string(self.__current_file)
-        else:
+        """Return the name of the topmost patch, or None if there is
+        no such patch."""
+        try:
+            applied = self.get_applied()
+        except StackException:
+            # No "applied" file: branch is not initialized.

             return None
             return None

-        if name == '':
+        try:
+            return applied[-1]
+        except IndexError:
+            # No patches applied.

             return None
             return None

-        else:
-            return name

 
     def get_applied(self):
 
     def get_applied(self):

+        if not os.path.isfile(self.__applied_file):
+            raise StackException, 'Branch "%s" not initialised' % self.__name

         f = file(self.__applied_file)
         names = [line.strip() for line in f.readlines()]
         f.close()
         return names
 
     def get_unapplied(self):
         f = file(self.__applied_file)
         names = [line.strip() for line in f.readlines()]
         f.close()
         return names
 
     def get_unapplied(self):

+        if not os.path.isfile(self.__unapplied_file):
+            raise StackException, 'Branch "%s" not initialised' % self.__name

         f = file(self.__unapplied_file)
         names = [line.strip() for line in f.readlines()]
         f.close()
         return names
 
         f = file(self.__unapplied_file)
         names = [line.strip() for line in f.readlines()]
         f.close()
         return names
 

-    def get_base_file(self):
-        return self.__base_file
+    def get_hidden(self):
+        if not os.path.isfile(self.__hidden_file):
+            return []
+        f = file(self.__hidden_file)
+        names = [line.strip() for line in f.readlines()]
+        f.close()
+        return names
+
+    def get_base(self):
+        # Return the parent of the bottommost patch, if there is one.
+        if os.path.isfile(self.__applied_file):
+            bottommost = file(self.__applied_file).readline().strip()
+            if bottommost:
+                return self.get_patch(bottommost).get_bottom()
+        # No bottommost patch, so just return HEAD
+        return git.get_head()
+
+    def get_head(self):
+        """Return the head of the branch
+        """
+        crt = self.get_current_patch()
+        if crt:
+            return crt.get_top()
+        else:
+            return self.get_base()
+
+    def get_protected(self):
+        return os.path.isfile(os.path.join(self._dir(), 'protected'))
+
+    def protect(self):
+        protect_file = os.path.join(self._dir(), 'protected')
+        if not os.path.isfile(protect_file):
+            create_empty_file(protect_file)
+
+    def unprotect(self):
+        protect_file = os.path.join(self._dir(), 'protected')
+        if os.path.isfile(protect_file):
+            os.remove(protect_file)
+
+    def get_description(self):
+        return self._get_field('description') or ''
+
+    def set_description(self, line):
+        self._set_field('description', line)
+
+    def get_parent_remote(self):
+        value = config.get('branch.%s.remote' % self.__name)
+        if value:
+            return value
+        elif 'origin' in git.remotes_list():
+            print 'Notice: no parent remote declared for stack "%s", ' \
+                  'defaulting to "origin". Consider setting "branch.%s.remote" ' \
+                  'and "branch.%s.merge" with "git repo-config".' \
+                  % (self.__name, self.__name, self.__name)
+            return 'origin'
+        else:
+            raise StackException, 'Cannot find a parent remote for "%s"' % self.__name
+
+    def __set_parent_remote(self, remote):
+        value = config.set('branch.%s.remote' % self.__name, remote)
+
+    def get_parent_branch(self):
+        value = config.get('branch.%s.stgit.parentbranch' % self.__name)
+        if value:
+            return value
+        elif git.rev_parse('heads/origin'):
+            print 'Notice: no parent branch declared for stack "%s", ' \
+                  'defaulting to "heads/origin". Consider setting ' \
+                  '"branch.%s.stgit.parentbranch" with "git repo-config".' \
+                  % (self.__name, self.__name)
+            return 'heads/origin'
+        else:
+            raise StackException, 'Cannot find a parent branch for "%s"' % self.__name
+
+    def __set_parent_branch(self, name):
+        if config.get('branch.%s.remote' % self.__name):
+            # Never set merge if remote is not set to avoid
+            # possibly-erroneous lookups into 'origin'
+            config.set('branch.%s.merge' % self.__name, name)
+        config.set('branch.%s.stgit.parentbranch' % self.__name, name)
+
+    def set_parent(self, remote, localbranch):
+        # policy: record local branches as remote='.'
+        recordremote = remote or '.'
+        if localbranch:
+            self.__set_parent_remote(recordremote)
+            self.__set_parent_branch(localbranch)
+        # We'll enforce this later
+#         else:
+#             raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.__name

 
     def __patch_is_current(self, patch):
 
     def __patch_is_current(self, patch):

-        return patch.get_name() == read_string(self.__current_file)
+        return patch.get_name() == self.get_current()

 
 

-    def __patch_applied(self, name):
+    def patch_applied(self, name):

         """Return true if the patch exists in the applied list
         """
         return name in self.get_applied()
 
         """Return true if the patch exists in the applied list
         """
         return name in self.get_applied()
 

-    def __patch_unapplied(self, name):
+    def patch_unapplied(self, name):

         """Return true if the patch exists in the unapplied list
         """
         return name in self.get_unapplied()
 
         """Return true if the patch exists in the unapplied list
         """
         return name in self.get_unapplied()
 

-    def __begin_stack_check(self):
-        """Save the current HEAD into .git/refs/heads/base if the stack
-        is empty
+    def patch_hidden(self, name):
+        """Return true if the patch is hidden.

         """
         """

-        if len(self.get_applied()) == 0:
-            head = git.get_head()
-            write_string(self.__base_file, head)
+        return name in self.get_hidden()

 
 

-    def __end_stack_check(self):
-        """Remove .git/refs/heads/base if the stack is empty.
-        This warning should never happen
-        """
-        if len(self.get_applied()) == 0 \
-           and read_string(self.__base_file) != git.get_head():
-            print 'Warning: stack empty but the HEAD and base are different'
+    def patch_exists(self, name):
+        """Return true if there is a patch with the given name, false
+        otherwise."""
+        return self.patch_applied(name) or self.patch_unapplied(name)

 
     def head_top_equal(self):
         """Return true if the head and the top are the same
         """
 
     def head_top_equal(self):
         """Return true if the head and the top are the same
         """

-        crt = self.get_current()
+        crt = self.get_current_patch()

         if not crt:
             # we don't care, no patches applied
             return True
         if not crt:
             # we don't care, no patches applied
             return True

-        return git.get_head() == Patch(crt, self.__patch_dir).get_top()
+        return git.get_head() == crt.get_top()

 
 

-    def init(self):
-        """Initialises the stgit series
+    def is_initialised(self):
+        """Checks if series is already initialised

         """
         """

-        bases_dir = os.path.join(git.base_dir, 'refs', 'bases')
+        return os.path.isdir(self.__patch_dir)

 
 

-        if os.path.isdir(self.__patch_dir):
+    def init(self, create_at=False, parent_remote=None, parent_branch=None):
+        """Initialises the stgit series
+        """
+        if os.path.exists(self.__patch_dir):

             raise StackException, self.__patch_dir + ' already exists'
             raise StackException, self.__patch_dir + ' already exists'

+        if os.path.exists(self.__refs_dir):
+            raise StackException, self.__refs_dir + ' already exists'
+
+        if (create_at!=False):
+            git.create_branch(self.__name, create_at)
+

         os.makedirs(self.__patch_dir)
 
         os.makedirs(self.__patch_dir)
 

-        if not os.path.isdir(bases_dir):
-            os.makedirs(bases_dir)
+        self.set_parent(parent_remote, parent_branch)
+
+        self.create_empty_field('applied')
+        self.create_empty_field('unapplied')
+        self.create_empty_field('description')
+        os.makedirs(os.path.join(self._dir(), 'patches'))
+        os.makedirs(self.__refs_dir)
+        self._set_field('orig-base', git.get_head())
+
+    def convert(self):
+        """Either convert to use a separate patch directory, or
+        unconvert to place the patches in the same directory with
+        series control files
+        """
+        if self.__patch_dir == self._dir():
+            print 'Converting old-style to new-style...',
+            sys.stdout.flush()
+
+            self.__patch_dir = os.path.join(self._dir(), 'patches')
+            os.makedirs(self.__patch_dir)
+
+            for p in self.get_applied() + self.get_unapplied():
+                src = os.path.join(self._dir(), p)
+                dest = os.path.join(self.__patch_dir, p)
+                os.rename(src, dest)
+
+            print 'done'
+
+        else:
+            print 'Converting new-style to old-style...',
+            sys.stdout.flush()
+
+            for p in self.get_applied() + self.get_unapplied():
+                src = os.path.join(self.__patch_dir, p)
+                dest = os.path.join(self._dir(), p)
+                os.rename(src, dest)
+
+            if not os.listdir(self.__patch_dir):
+                os.rmdir(self.__patch_dir)
+                print 'done'
+            else:
+                print 'Patch directory %s is not empty.' % self.__patch_dir
+
+            self.__patch_dir = self._dir()
+
+    def rename(self, to_name):
+        """Renames a series
+        """
+        to_stack = Series(to_name)
+
+        if to_stack.is_initialised():
+            raise StackException, '"%s" already exists' % to_stack.get_branch()
+
+        git.rename_branch(self.__name, to_name)
+
+        if os.path.isdir(self._dir()):
+            rename(os.path.join(self.__base_dir, 'patches'),
+                   self.__name, to_stack.__name)
+        if os.path.exists(self.__refs_dir):
+            rename(os.path.join(self.__base_dir, 'refs', 'patches'),
+                   self.__name, to_stack.__name)
+
+        # Rename the config section
+        config.rename_section("branch.%s" % self.__name,
+                              "branch.%s" % to_name)
+
+        self.__init__(to_name)
+
+    def clone(self, target_series):
+        """Clones a series
+        """
+        try:
+            # allow cloning of branches not under StGIT control
+            base = self.get_base()
+        except:
+            base = git.get_head()
+        Series(target_series).init(create_at = base)
+        new_series = Series(target_series)
+
+        # generate an artificial description file
+        new_series.set_description('clone of "%s"' % self.__name)
+
+        # clone self's entire series as unapplied patches
+        try:
+            # allow cloning of branches not under StGIT control
+            applied = self.get_applied()
+            unapplied = self.get_unapplied()
+            patches = applied + unapplied
+            patches.reverse()
+        except:
+            patches = applied = unapplied = []
+        for p in patches:
+            patch = self.get_patch(p)
+            newpatch = new_series.new_patch(p, message = patch.get_description(),
+                                            can_edit = False, unapplied = True,
+                                            bottom = patch.get_bottom(),
+                                            top = patch.get_top(),
+                                            author_name = patch.get_authname(),
+                                            author_email = patch.get_authemail(),
+                                            author_date = patch.get_authdate())
+            if patch.get_log():
+                print "setting log to %s" %  patch.get_log()
+                newpatch.set_log(patch.get_log())
+            else:
+                print "no log for %s" % patchname
+
+        # fast forward the cloned series to self's top
+        new_series.forward_patches(applied)
+
+        # Clone parent informations
+        value = config.get('branch.%s.remote' % self.__name)
+        if value:
+            config.set('branch.%s.remote' % target_series, value)

 
 

-        create_empty_file(self.__applied_file)
-        create_empty_file(self.__unapplied_file)
-        self.__begin_stack_check()
+        value = config.get('branch.%s.merge' % self.__name)
+        if value:
+            config.set('branch.%s.merge' % target_series, value)

 
 

-    def refresh_patch(self, message = None, edit = False, cache_update = True,
+        value = config.get('branch.%s.stgit.parentbranch' % self.__name)
+        if value:
+            config.set('branch.%s.stgit.parentbranch' % target_series, value)
+
+    def delete(self, force = False):
+        """Deletes an stgit series
+        """
+        if self.is_initialised():
+            patches = self.get_unapplied() + self.get_applied()
+            if not force and patches:
+                raise StackException, \
+                      'Cannot delete: the series still contains patches'
+            for p in patches:
+                Patch(p, self.__patch_dir, self.__refs_dir).delete()
+
+            # remove the trash directory
+            for fname in os.listdir(self.__trash_dir):
+                os.remove(os.path.join(self.__trash_dir, fname))
+            os.rmdir(self.__trash_dir)
+
+            # FIXME: find a way to get rid of those manual removals
+            # (move functionality to StgitObject ?)
+            if os.path.exists(self.__applied_file):
+                os.remove(self.__applied_file)
+            if os.path.exists(self.__unapplied_file):
+                os.remove(self.__unapplied_file)
+            if os.path.exists(self.__hidden_file):
+                os.remove(self.__hidden_file)
+            if os.path.exists(self.__descr_file):
+                os.remove(self.__descr_file)
+            if os.path.exists(self._dir()+'/orig-base'):
+                os.remove(self._dir()+'/orig-base')
+
+            if not os.listdir(self.__patch_dir):
+                os.rmdir(self.__patch_dir)
+            else:
+                print 'Patch directory %s is not empty.' % self.__patch_dir
+
+            try:
+                os.removedirs(self._dir())
+            except OSError:
+                raise StackException, 'Series directory %s is not empty.' % self._dir()
+
+            try:
+                os.removedirs(self.__refs_dir)
+            except OSError:
+                print 'Refs directory %s is not empty.' % self.__refs_dir
+
+        # Cleanup parent informations
+        # FIXME: should one day make use of git-config --section-remove,
+        # scheduled for 1.5.1
+        config.unset('branch.%s.remote' % self.__name)
+        config.unset('branch.%s.merge' % self.__name)
+        config.unset('branch.%s.stgit.parentbranch' % self.__name)
+
+    def refresh_patch(self, files = None, message = None, edit = False,
+                      show_patch = False,
+                      cache_update = True,

                       author_name = None, author_email = None,
                       author_date = None,
                       committer_name = None, committer_email = None,
                       author_name = None, author_email = None,
                       author_date = None,
                       committer_name = None, committer_email = None,

-                      commit_only = False):
+                      backup = False, sign_str = None, log = 'refresh'):

         """Generates a new commit for the given patch
         """
         name = self.get_current()
         if not name:
             raise StackException, 'No patches applied'
 
         """Generates a new commit for the given patch
         """
         name = self.get_current()
         if not name:
             raise StackException, 'No patches applied'
 

-        patch = Patch(name, self.__patch_dir)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)

 
         descr = patch.get_description()
         if not (message or descr):
 
         descr = patch.get_description()
         if not (message or descr):


@@ -347,9 +705,9 @@ class Series:
             descr = message
 
         if not message and edit:
             descr = message
 
         if not message and edit:

-            descr = edit_file(descr.rstrip(), \
+            descr = edit_file(self, descr.rstrip(), \

                               'Please edit the description for patch "%s" ' \
                               'Please edit the description for patch "%s" ' \

-                              'above.' % name)
+                              'above.' % name, show_patch)

 
         if not author_name:
             author_name = patch.get_authname()
 
         if not author_name:
             author_name = patch.get_authname()


@@ -362,7 +720,19 @@ class Series:
         if not committer_email:
             committer_email = patch.get_commemail()
 
         if not committer_email:
             committer_email = patch.get_commemail()
 

-        commit_id = git.commit(message = descr, parents = [patch.get_bottom()],
+        if sign_str:
+            descr = descr.rstrip()
+            if descr.find("\nSigned-off-by:") < 0 \
+               and descr.find("\nAcked-by:") < 0:
+                descr = descr + "\n"
+
+            descr = '%s\n%s: %s <%s>\n' % (descr, sign_str,
+                                           committer_name, committer_email)
+
+        bottom = patch.get_bottom()
+
+        commit_id = git.commit(files = files,
+                               message = descr, parents = [bottom],

                                cache_update = cache_update,
                                allowempty = True,
                                author_name = author_name,
                                cache_update = cache_update,
                                allowempty = True,
                                author_name = author_name,


@@ -371,40 +741,74 @@ class Series:
                                committer_name = committer_name,
                                committer_email = committer_email)
 
                                committer_name = committer_name,
                                committer_email = committer_email)
 

-        if not commit_only:
-            patch.set_top(commit_id)
-            patch.set_description(descr)
-            patch.set_authname(author_name)
-            patch.set_authemail(author_email)
-            patch.set_authdate(author_date)
-            patch.set_commname(committer_name)
-            patch.set_commemail(committer_email)
+        patch.set_bottom(bottom, backup = backup)
+        patch.set_top(commit_id, backup = backup)
+        patch.set_description(descr)
+        patch.set_authname(author_name)
+        patch.set_authemail(author_email)
+        patch.set_authdate(author_date)
+        patch.set_commname(committer_name)
+        patch.set_commemail(committer_email)
+
+        if log:
+            self.log_patch(patch, log)

 
         return commit_id
 
 
         return commit_id
 

-    def new_patch(self, name, message = None, edit = False,
+    def undo_refresh(self):
+        """Undo the patch boundaries changes caused by 'refresh'
+        """
+        name = self.get_current()
+        assert(name)
+
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)
+        old_bottom = patch.get_old_bottom()
+        old_top = patch.get_old_top()
+
+        # the bottom of the patch is not changed by refresh. If the
+        # old_bottom is different, there wasn't any previous 'refresh'
+        # command (probably only a 'push')
+        if old_bottom != patch.get_bottom() or old_top == patch.get_top():
+            raise StackException, 'No undo information available'
+
+        git.reset(tree_id = old_top, check_out = False)
+        if patch.restore_old_boundaries():
+            self.log_patch(patch, 'undo')
+
+    def new_patch(self, name, message = None, can_edit = True,
+                  unapplied = False, show_patch = False,
+                  top = None, bottom = None,

                   author_name = None, author_email = None, author_date = None,
                   author_name = None, author_email = None, author_date = None,

-                  committer_name = None, committer_email = None):
+                  committer_name = None, committer_email = None,
+                  before_existing = False, refresh = True):

         """Creates a new patch
         """
         """Creates a new patch
         """

-        if self.__patch_applied(name) or self.__patch_unapplied(name):
+        self.__patch_name_valid(name)
+
+        if self.patch_applied(name) or self.patch_unapplied(name):

             raise StackException, 'Patch "%s" already exists' % name
 
             raise StackException, 'Patch "%s" already exists' % name
 

-        if not message:
-            descr = edit_file(None, \
+        if not message and can_edit:
+            descr = edit_file(self, None, \

                               'Please enter the description for patch "%s" ' \
                               'Please enter the description for patch "%s" ' \

-                              'above.' % name)
+                              'above.' % name, show_patch)

         else:
             descr = message
 
         head = git.get_head()
 
         else:
             descr = message
 
         head = git.get_head()
 

-        self.__begin_stack_check()
-
-        patch = Patch(name, self.__patch_dir)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)

         patch.create()
         patch.create()

-        patch.set_bottom(head)
-        patch.set_top(head)
+
+        if bottom:
+            patch.set_bottom(bottom)
+        else:
+            patch.set_bottom(head)
+        if top:
+            patch.set_top(top)
+        else:
+            patch.set_top(head)
+

         patch.set_description(descr)
         patch.set_authname(author_name)
         patch.set_authemail(author_email)
         patch.set_description(descr)
         patch.set_authname(author_name)
         patch.set_authemail(author_email)


@@ -412,22 +816,42 @@ class Series:
         patch.set_commname(committer_name)
         patch.set_commemail(committer_email)
 
         patch.set_commname(committer_name)
         patch.set_commemail(committer_email)
 

-        append_string(self.__applied_file, patch.get_name())
-        self.__set_current(name)
+        if unapplied:
+            self.log_patch(patch, 'new')
+
+            patches = [patch.get_name()] + self.get_unapplied()
+
+            f = file(self.__unapplied_file, 'w+')
+            f.writelines([line + '\n' for line in patches])
+            f.close()
+        elif before_existing:
+            self.log_patch(patch, 'new')
+
+            insert_string(self.__applied_file, patch.get_name())
+        else:
+            append_string(self.__applied_file, patch.get_name())
+            if refresh:
+                self.refresh_patch(cache_update = False, log = 'new')
+
+        return patch

 
     def delete_patch(self, name):
         """Deletes a patch
         """
 
     def delete_patch(self, name):
         """Deletes a patch
         """

-        patch = Patch(name, self.__patch_dir)
+        self.__patch_name_valid(name)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)

 
         if self.__patch_is_current(patch):
             self.pop_patch(name)
 
         if self.__patch_is_current(patch):
             self.pop_patch(name)

-        elif self.__patch_applied(name):
+        elif self.patch_applied(name):

             raise StackException, 'Cannot remove an applied patch, "%s", ' \
                   'which is not current' % name
         elif not name in self.get_unapplied():
             raise StackException, 'Unknown patch "%s"' % name
 
             raise StackException, 'Cannot remove an applied patch, "%s", ' \
                   'which is not current' % name
         elif not name in self.get_unapplied():
             raise StackException, 'Unknown patch "%s"' % name
 

+        # save the commit id to a trash file
+        write_string(os.path.join(self.__trash_dir, name), patch.get_top())
+

         patch.delete()
 
         unapplied = self.get_unapplied()
         patch.delete()
 
         unapplied = self.get_unapplied()


@@ -436,25 +860,132 @@ class Series:
         f.writelines([line + '\n' for line in unapplied])
         f.close()
 
         f.writelines([line + '\n' for line in unapplied])
         f.close()
 

-    def push_patch(self, name):
+        if self.patch_hidden(name):
+            self.unhide_patch(name)
+
+    def forward_patches(self, names):
+        """Try to fast-forward an array of patches.
+
+        On return, patches in names[0:returned_value] have been pushed on the
+        stack. Apply the rest with push_patch
+        """
+        unapplied = self.get_unapplied()
+
+        forwarded = 0
+        top = git.get_head()
+
+        for name in names:
+            assert(name in unapplied)
+
+            patch = Patch(name, self.__patch_dir, self.__refs_dir)
+
+            head = top
+            bottom = patch.get_bottom()
+            top = patch.get_top()
+
+            # top != bottom always since we have a commit for each patch
+            if head == bottom:
+                # reset the backup information. No logging since the
+                # patch hasn't changed
+                patch.set_bottom(head, backup = True)
+                patch.set_top(top, backup = True)
+
+            else:
+                head_tree = git.get_commit(head).get_tree()
+                bottom_tree = git.get_commit(bottom).get_tree()
+                if head_tree == bottom_tree:
+                    # We must just reparent this patch and create a new commit
+                    # for it
+                    descr = patch.get_description()
+                    author_name = patch.get_authname()
+                    author_email = patch.get_authemail()
+                    author_date = patch.get_authdate()
+                    committer_name = patch.get_commname()
+                    committer_email = patch.get_commemail()
+
+                    top_tree = git.get_commit(top).get_tree()
+
+                    top = git.commit(message = descr, parents = [head],
+                                     cache_update = False,
+                                     tree_id = top_tree,
+                                     allowempty = True,
+                                     author_name = author_name,
+                                     author_email = author_email,
+                                     author_date = author_date,
+                                     committer_name = committer_name,
+                                     committer_email = committer_email)
+
+                    patch.set_bottom(head, backup = True)
+                    patch.set_top(top, backup = True)
+
+                    self.log_patch(patch, 'push(f)')
+                else:
+                    top = head
+                    # stop the fast-forwarding, must do a real merge
+                    break
+
+            forwarded+=1
+            unapplied.remove(name)
+
+        if forwarded == 0:
+            return 0
+
+        git.switch(top)
+
+        append_strings(self.__applied_file, names[0:forwarded])
+
+        f = file(self.__unapplied_file, 'w+')
+        f.writelines([line + '\n' for line in unapplied])
+        f.close()
+
+        return forwarded
+
+    def merged_patches(self, names):
+        """Test which patches were merged upstream by reverse-applying
+        them in reverse order. The function returns the list of
+        patches detected to have been applied. The state of the tree
+        is restored to the original one
+        """
+        patches = [Patch(name, self.__patch_dir, self.__refs_dir)
+                   for name in names]
+        patches.reverse()
+
+        merged = []
+        for p in patches:
+            if git.apply_diff(p.get_top(), p.get_bottom()):
+                merged.append(p.get_name())
+        merged.reverse()
+
+        git.reset()
+
+        return merged
+
+    def push_patch(self, name, empty = False):

         """Pushes a patch on the stack
         """
         unapplied = self.get_unapplied()
         assert(name in unapplied)
 
         """Pushes a patch on the stack
         """
         unapplied = self.get_unapplied()
         assert(name in unapplied)
 

-        self.__begin_stack_check()
-
-        patch = Patch(name, self.__patch_dir)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)

 
         head = git.get_head()
         bottom = patch.get_bottom()
         top = patch.get_top()
 
         ex = None
 
         head = git.get_head()
         bottom = patch.get_bottom()
         top = patch.get_top()
 
         ex = None

+        modified = False

 
         # top != bottom always since we have a commit for each patch
 
         # top != bottom always since we have a commit for each patch

-        if head == bottom:
-            # reset the backup information
+        if empty:
+            # just make an empty patch (top = bottom = HEAD). This
+            # option is useful to allow undoing already merged
+            # patches. The top is updated by refresh_patch since we
+            # need an empty commit
+            patch.set_bottom(head, backup = True)
+            patch.set_top(head, backup = True)
+            modified = True
+        elif head == bottom:
+            # reset the backup information. No need for logging

             patch.set_bottom(bottom, backup = True)
             patch.set_top(top, backup = True)
 
             patch.set_bottom(bottom, backup = True)
             patch.set_top(top, backup = True)
 


@@ -464,14 +995,22 @@ class Series:
             # The current patch is empty after merge.
             patch.set_bottom(head, backup = True)
             patch.set_top(head, backup = True)
             # The current patch is empty after merge.
             patch.set_bottom(head, backup = True)
             patch.set_top(head, backup = True)

-            # merge/refresh can fail but the patch needs to be pushed
-            try:
-                git.merge(bottom, head, top)
-            except git.GitException, ex:
-                print >> sys.stderr, \
-                      'The merge failed during "push". ' \
-                      'Use "refresh" after fixing the conflicts'
-                pass
+
+            # Try the fast applying first. If this fails, fall back to the
+            # three-way merge
+            if not git.apply_diff(bottom, top):
+                # if git.apply_diff() fails, the patch requires a diff3
+                # merge and can be reported as modified
+                modified = True
+
+                # merge can fail but the patch needs to be pushed
+                try:
+                    git.merge(bottom, head, top, recursive = True)
+                except git.GitException, ex:
+                    print >> sys.stderr, \
+                          'The merge failed during "push". ' \
+                          'Use "refresh" after fixing the conflicts or ' \
+                          'revert the operation with "push --undo".'

 
         append_string(self.__applied_file, name)
 
 
         append_string(self.__applied_file, name)
 


@@ -480,35 +1019,64 @@ class Series:
         f.writelines([line + '\n' for line in unapplied])
         f.close()
 
         f.writelines([line + '\n' for line in unapplied])
         f.close()
 

-        self.__set_current(name)
-

         # head == bottom case doesn't need to refresh the patch
         # head == bottom case doesn't need to refresh the patch

-        if head != bottom:
+        if empty or head != bottom:

             if not ex:
                 # if the merge was OK and no conflicts, just refresh the patch
                 # The GIT cache was already updated by the merge operation
             if not ex:
                 # if the merge was OK and no conflicts, just refresh the patch
                 # The GIT cache was already updated by the merge operation

-                self.refresh_patch(cache_update = False)
+                if modified:
+                    log = 'push(m)'
+                else:
+                    log = 'push'
+                self.refresh_patch(cache_update = False, log = log)

             else:
             else:

+                # we store the correctly merged files only for
+                # tracking the conflict history. Note that the
+                # git.merge() operations should always leave the index
+                # in a valid state (i.e. only stage 0 files)
+                self.refresh_patch(cache_update = False, log = 'push(c)')

                 raise StackException, str(ex)
 
                 raise StackException, str(ex)
 

+        return modified
+

     def undo_push(self):
         name = self.get_current()
         assert(name)
 
     def undo_push(self):
         name = self.get_current()
         assert(name)
 

-        patch = Patch(name, self.__patch_dir)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)
+        old_bottom = patch.get_old_bottom()
+        old_top = patch.get_old_top()
+
+        # the top of the patch is changed by a push operation only
+        # together with the bottom (otherwise the top was probably
+        # modified by 'refresh'). If they are both unchanged, there
+        # was a fast forward
+        if old_bottom == patch.get_bottom() and old_top != patch.get_top():
+            raise StackException, 'No undo information available'
+
+        git.reset()

         self.pop_patch(name)
         self.pop_patch(name)

-        patch.restore_old_boundaries()
+        ret = patch.restore_old_boundaries()
+        if ret:
+            self.log_patch(patch, 'undo')

 
 

-    def pop_patch(self, name):
+        return ret
+
+    def pop_patch(self, name, keep = False):

         """Pops the top patch from the stack
         """
         applied = self.get_applied()
         applied.reverse()
         assert(name in applied)
 
         """Pops the top patch from the stack
         """
         applied = self.get_applied()
         applied.reverse()
         assert(name in applied)
 

-        patch = Patch(name, self.__patch_dir)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)
+
+        # only keep the local changes
+        if keep and not git.apply_diff(git.get_head(), patch.get_bottom()):
+            raise StackException, \
+                  'Failed to pop patches while preserving the local changes'

 
 

-        git.switch(patch.get_bottom())
+        git.switch(patch.get_bottom(), keep)

 
         # save the new applied list
         idx = applied.index(name) + 1
 
         # save the new applied list
         idx = applied.index(name) + 1


@@ -528,17 +1096,11 @@ class Series:
         f.writelines([line + '\n' for line in applied])
         f.close()
 
         f.writelines([line + '\n' for line in applied])
         f.close()
 

-        if applied == []:
-            self.__set_current(None)
-        else:
-            self.__set_current(applied[-1])
-
-        self.__end_stack_check()
-

     def empty_patch(self, name):
         """Returns True if the patch is empty
         """
     def empty_patch(self, name):
         """Returns True if the patch is empty
         """

-        patch = Patch(name, self.__patch_dir)
+        self.__patch_name_valid(name)
+        patch = Patch(name, self.__patch_dir, self.__refs_dir)

         bottom = patch.get_bottom()
         top = patch.get_top()
 
         bottom = patch.get_bottom()
         top = patch.get_top()
 


@@ -551,23 +1113,30 @@ class Series:
         return False
 
     def rename_patch(self, oldname, newname):
         return False
 
     def rename_patch(self, oldname, newname):

+        self.__patch_name_valid(newname)
+

         applied = self.get_applied()
         unapplied = self.get_unapplied()
 
         applied = self.get_applied()
         unapplied = self.get_unapplied()
 

+        if oldname == newname:
+            raise StackException, '"To" name and "from" name are the same'
+

         if newname in applied or newname in unapplied:
             raise StackException, 'Patch "%s" already exists' % newname
 
         if newname in applied or newname in unapplied:
             raise StackException, 'Patch "%s" already exists' % newname
 

+        if self.patch_hidden(oldname):
+            self.unhide_patch(oldname)
+            self.hide_patch(newname)
+

         if oldname in unapplied:
         if oldname in unapplied:

-            Patch(oldname, self.__patch_dir).rename(newname)
+            Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)

             unapplied[unapplied.index(oldname)] = newname
 
             f = file(self.__unapplied_file, 'w+')
             f.writelines([line + '\n' for line in unapplied])
             f.close()
         elif oldname in applied:
             unapplied[unapplied.index(oldname)] = newname
 
             f = file(self.__unapplied_file, 'w+')
             f.writelines([line + '\n' for line in unapplied])
             f.close()
         elif oldname in applied:

-            Patch(oldname, self.__patch_dir).rename(newname)
-            if oldname == self.get_current():
-                self.__set_current(newname)
+            Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)

 
             applied[applied.index(oldname)] = newname
 
 
             applied[applied.index(oldname)] = newname
 


@@ -576,3 +1145,45 @@ class Series:
             f.close()
         else:
             raise StackException, 'Unknown patch "%s"' % oldname
             f.close()
         else:
             raise StackException, 'Unknown patch "%s"' % oldname

+
+    def log_patch(self, patch, message):
+        """Generate a log commit for a patch
+        """
+        top = git.get_commit(patch.get_top())
+        msg = '%s\t%s' % (message, top.get_id_hash())
+
+        old_log = patch.get_log()
+        if old_log:
+            parents = [old_log]
+        else:
+            parents = []
+
+        log = git.commit(message = msg, parents = parents,
+                         cache_update = False, tree_id = top.get_tree(),
+                         allowempty = True)
+        patch.set_log(log)
+
+    def hide_patch(self, name):
+        """Add the patch to the hidden list.
+        """
+        if not self.patch_exists(name):
+            raise StackException, 'Unknown patch "%s"' % name
+        elif self.patch_hidden(name):
+            raise StackException, 'Patch "%s" already hidden' % name
+
+        append_string(self.__hidden_file, name)
+
+    def unhide_patch(self, name):
+        """Add the patch to the hidden list.
+        """
+        if not self.patch_exists(name):
+            raise StackException, 'Unknown patch "%s"' % name
+        hidden = self.get_hidden()
+        if not name in hidden:
+            raise StackException, 'Patch "%s" not hidden' % name
+
+        hidden.remove(name)
+
+        f = file(self.__hidden_file, 'w+')
+        f.writelines([line + '\n' for line in hidden])
+        f.close()