Don't use patches/<branch>/current

[stgit] / stgit / stack.py

diff --git a/stgit/stack.py b/stgit/stack.py
index ee1bf1f6ea3583ad05fd0329c483ea5055cffe92..8292b105a32c37321332cfce221dd8c9712890f3 100644 (file)
--- a/stgit/stack.py
+++ b/stgit/stack.py
@@ -23,6 +23,7 @@ import sys, os, re
 from stgit.utils import *
 from stgit import git, basedir, templates
 from stgit.config import config
 from stgit.utils import *
 from stgit import git, basedir, templates
 from stgit.config import config

+from shutil import copyfile

 
 
 # stack exception class
 
 
 # stack exception class


@@ -91,19 +92,7 @@ def edit_file(series, line, comment, show_patch = True):
     print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:'
     f.close()
 
     print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:'
     f.close()
 

-    # the editor
-    editor = config.get('stgit.editor')
-    if editor:
-        pass
-    elif 'EDITOR' in os.environ:
-        editor = os.environ['EDITOR']
-    else:
-        editor = 'vi'
-    editor += ' %s' % fname
-
-    print 'Invoking the editor: "%s"...' % editor,
-    sys.stdout.flush()
-    print 'done (exit code: %d)' % os.system(editor)
+    call_editor(fname)

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


@@ -303,13 +292,10 @@ class Series(StgitObject):
         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._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.__base_file = os.path.join(self.__base_dir, 'refs', 'bases',
-                                        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.__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.__current_file = os.path.join(self._dir(), 'current')

         self.__descr_file = os.path.join(self._dir(), 'description')
 
         # where this series keeps its patches
         self.__descr_file = os.path.join(self._dir(), 'description')
 
         # where this series keeps its patches


@@ -339,11 +325,6 @@ class Series(StgitObject):
         """
         return self.__name
 
         """
         return self.__name
 

-    def __set_current(self, name):
-        """Sets the topmost patch
-        """
-        self._set_field('current', 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
         """


@@ -360,11 +341,16 @@ class Series(StgitObject):
     def get_current(self):
         """Return the name of the topmost patch, or None if there is
         no such patch."""
     def get_current(self):
         """Return the name of the topmost patch, or None if there is
         no such patch."""

-        name = self._get_field('current')
-        if name == '':
+        try:
+            applied = self.get_applied()
+        except StackException:
+            # No "applied" file: branch is not initialized.
+            return None
+        try:
+            return applied[-1]
+        except IndexError:
+            # No patches applied.

             return None
             return None

-        else:
-            return name

 
     def get_applied(self):
         if not os.path.isfile(self.__applied_file):
 
     def get_applied(self):
         if not os.path.isfile(self.__applied_file):


@@ -390,9 +376,23 @@ class Series(StgitObject):
         f.close()
         return names
 
         f.close()
         return names
 

-    def get_base_file(self):
-        self.__begin_stack_check()
-        return self.__base_file
+    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 get_protected(self):
         return os.path.isfile(os.path.join(self._dir(), 'protected'))


@@ -418,9 +418,10 @@ class Series(StgitObject):
         if value:
             return value
         elif 'origin' in git.remotes_list():
         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" with "git repo-config".' \
-                  % (self.__name, self.__name)
+            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
             return 'origin'
         else:
             raise StackException, 'Cannot find a parent remote for "%s"' % self.__name


@@ -429,27 +430,34 @@ class Series(StgitObject):
         value = config.set('branch.%s.remote' % self.__name, remote)
 
     def get_parent_branch(self):
         value = config.set('branch.%s.remote' % self.__name, remote)
 
     def get_parent_branch(self):

-        value = config.get('branch.%s.merge' % self.__name)
+        value = config.get('branch.%s.stgit.parentbranch' % self.__name)

         if value:
             return value
         elif git.rev_parse('heads/origin'):
         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.merge" with "git repo-config".' \
+            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):
                   % (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):

-        config.set('branch.%s.merge' % self.__name, 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):
 
     def set_parent(self, remote, localbranch):

+        # policy: record local branches as remote='.'
+        recordremote = remote or '.'

         if localbranch:
         if localbranch:

+            self.__set_parent_remote(recordremote)

             self.__set_parent_branch(localbranch)
             self.__set_parent_branch(localbranch)

-            if remote:
-                self.__set_parent_remote(remote)
-        elif remote:
-            raise StackException, 'Remote "%s" without a branch cannot be used as parent' % remote
+        # 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):
         return patch.get_name() == self.get_current()
 
     def __patch_is_current(self, patch):
         return patch.get_name() == self.get_current()


@@ -474,22 +482,6 @@ class Series(StgitObject):
         otherwise."""
         return self.patch_applied(name) or self.patch_unapplied(name)
 
         otherwise."""
         return self.patch_applied(name) or self.patch_unapplied(name)
 

-    def __begin_stack_check(self):
-        """Save the current HEAD into .git/refs/heads/base if the stack
-        is empty
-        """
-        if len(self.get_applied()) == 0:
-            head = git.get_head()
-            write_string(self.__base_file, head)
-
-    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 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
         """


@@ -507,14 +499,10 @@ class Series(StgitObject):
     def init(self, create_at=False, parent_remote=None, parent_branch=None):
         """Initialises the stgit series
         """
     def init(self, create_at=False, parent_remote=None, parent_branch=None):
         """Initialises the stgit series
         """

-        bases_dir = os.path.join(self.__base_dir, 'refs', 'bases')
-

         if os.path.exists(self.__patch_dir):
             raise StackException, self.__patch_dir + ' already exists'
         if os.path.exists(self.__refs_dir):
             raise StackException, self.__refs_dir + ' already exists'
         if os.path.exists(self.__patch_dir):
             raise StackException, self.__patch_dir + ' already exists'
         if os.path.exists(self.__refs_dir):
             raise StackException, self.__refs_dir + ' already exists'

-        if os.path.exists(self.__base_file):
-            raise StackException, self.__base_file + ' already exists'

 
         if (create_at!=False):
             git.create_branch(self.__name, create_at)
 
         if (create_at!=False):
             git.create_branch(self.__name, create_at)


@@ -522,15 +510,13 @@ class Series(StgitObject):
         os.makedirs(self.__patch_dir)
 
         self.set_parent(parent_remote, parent_branch)
         os.makedirs(self.__patch_dir)
 
         self.set_parent(parent_remote, parent_branch)

-        
-        create_dirs(bases_dir)

 
         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.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.__begin_stack_check()
+        self._set_field('orig-base', git.get_head())

 
     def convert(self):
         """Either convert to use a separate patch directory, or
 
     def convert(self):
         """Either convert to use a separate patch directory, or


@@ -564,7 +550,7 @@ class Series(StgitObject):
                 os.rmdir(self.__patch_dir)
                 print 'done'
             else:
                 os.rmdir(self.__patch_dir)
                 print 'done'
             else:

-                print 'Patch directory %s is not empty.' % self.__name
+                print 'Patch directory %s is not empty.' % self.__patch_dir

 
             self.__patch_dir = self._dir()
 
 
             self.__patch_dir = self._dir()
 


@@ -575,17 +561,12 @@ class Series(StgitObject):
 
         if to_stack.is_initialised():
             raise StackException, '"%s" already exists' % to_stack.get_branch()
 
         if to_stack.is_initialised():
             raise StackException, '"%s" already exists' % to_stack.get_branch()

-        if os.path.exists(to_stack.__base_file):
-            os.remove(to_stack.__base_file)

 
         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)
 
         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.__base_file):
-            rename(os.path.join(self.__base_dir, 'refs', 'bases'),
-                   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)
         if os.path.exists(self.__refs_dir):
             rename(os.path.join(self.__base_dir, 'refs', 'patches'),
                    self.__name, to_stack.__name)


@@ -601,7 +582,7 @@ class Series(StgitObject):
         """
         try:
             # allow cloning of branches not under StGIT control
         """
         try:
             # allow cloning of branches not under StGIT control

-            base = read_string(self.get_base_file())
+            base = self.get_base()

         except:
             base = git.get_head()
         Series(target_series).init(create_at = base)
         except:
             base = git.get_head()
         Series(target_series).init(create_at = base)


@@ -621,18 +602,23 @@ class Series(StgitObject):
             patches = applied = unapplied = []
         for p in patches:
             patch = self.get_patch(p)
             patches = applied = unapplied = []
         for p in patches:
             patch = self.get_patch(p)

-            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())
+            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)
 
 
         # fast forward the cloned series to self's top
         new_series.forward_patches(applied)
 

-        # Clone remote and merge settings
+        # Clone parent informations

         value = config.get('branch.%s.remote' % self.__name)
         if value:
             config.set('branch.%s.remote' % target_series, value)
         value = config.get('branch.%s.remote' % self.__name)
         if value:
             config.set('branch.%s.remote' % target_series, value)


@@ -641,6 +627,10 @@ class Series(StgitObject):
         if value:
             config.set('branch.%s.merge' % target_series, value)
 
         if value:
             config.set('branch.%s.merge' % target_series, value)
 

+        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
         """
     def delete(self, force = False):
         """Deletes an stgit series
         """


@@ -654,7 +644,7 @@ class Series(StgitObject):
 
             # remove the trash directory
             for fname in os.listdir(self.__trash_dir):
 
             # remove the trash directory
             for fname in os.listdir(self.__trash_dir):

-                os.remove(fname)
+                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
             os.rmdir(self.__trash_dir)
 
             # FIXME: find a way to get rid of those manual removals


@@ -665,28 +655,32 @@ class Series(StgitObject):
                 os.remove(self.__unapplied_file)
             if os.path.exists(self.__hidden_file):
                 os.remove(self.__hidden_file)
                 os.remove(self.__unapplied_file)
             if os.path.exists(self.__hidden_file):
                 os.remove(self.__hidden_file)

-            if os.path.exists(self.__current_file):
-                os.remove(self.__current_file)

             if os.path.exists(self.__descr_file):
                 os.remove(self.__descr_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:
             if not os.listdir(self.__patch_dir):
                 os.rmdir(self.__patch_dir)
             else:

-                print 'Patch directory %s is not empty.' % self.__name
-            if not os.listdir(self._dir()):
-                remove_dirs(os.path.join(self.__base_dir, 'patches'),
-                            self.__name)
-            else:
-                print 'Series directory %s is not empty.' % self.__name
-            if not os.listdir(self.__refs_dir):
-                remove_dirs(os.path.join(self.__base_dir, 'refs', 'patches'),
-                            self.__name)
-            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
 
                 print 'Refs directory %s is not empty.' % self.__refs_dir
 

-        if os.path.exists(self.__base_file):
-            remove_file_and_dirs(
-                os.path.join(self.__base_dir, 'refs', 'bases'), self.__name)
+        # 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,
 
     def refresh_patch(self, files = None, message = None, edit = False,
                       show_patch = False,


@@ -727,7 +721,12 @@ class Series(StgitObject):
             committer_email = patch.get_commemail()
 
         if sign_str:
             committer_email = patch.get_commemail()
 
         if sign_str:

-            descr = '%s\n%s: %s <%s>\n' % (descr.rstrip(), 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()
                                            committer_name, committer_email)
 
         bottom = patch.get_bottom()


@@ -798,8 +797,6 @@ class Series(StgitObject):
 
         head = git.get_head()
 
 
         head = git.get_head()
 

-        self.__begin_stack_check()
-

         patch = Patch(name, self.__patch_dir, self.__refs_dir)
         patch.create()
 
         patch = Patch(name, self.__patch_dir, self.__refs_dir)
         patch.create()
 


@@ -831,14 +828,13 @@ class Series(StgitObject):
             self.log_patch(patch, 'new')
 
             insert_string(self.__applied_file, patch.get_name())
             self.log_patch(patch, 'new')
 
             insert_string(self.__applied_file, patch.get_name())

-            if not self.get_current():
-                self.__set_current(name)

         else:
             append_string(self.__applied_file, patch.get_name())
         else:
             append_string(self.__applied_file, patch.get_name())

-            self.__set_current(name)

             if refresh:
                 self.refresh_patch(cache_update = False, log = 'new')
 
             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
         """


@@ -867,8 +863,6 @@ class Series(StgitObject):
         if self.patch_hidden(name):
             self.unhide_patch(name)
 
         if self.patch_hidden(name):
             self.unhide_patch(name)
 

-        self.__begin_stack_check()
-

     def forward_patches(self, names):
         """Try to fast-forward an array of patches.
 
     def forward_patches(self, names):
         """Try to fast-forward an array of patches.
 


@@ -876,7 +870,6 @@ class Series(StgitObject):
         stack. Apply the rest with push_patch
         """
         unapplied = self.get_unapplied()
         stack. Apply the rest with push_patch
         """
         unapplied = self.get_unapplied()

-        self.__begin_stack_check()

 
         forwarded = 0
         top = git.get_head()
 
         forwarded = 0
         top = git.get_head()


@@ -945,8 +938,6 @@ class Series(StgitObject):
         f.writelines([line + '\n' for line in unapplied])
         f.close()
 
         f.writelines([line + '\n' for line in unapplied])
         f.close()
 

-        self.__set_current(name)
-

         return forwarded
 
     def merged_patches(self, names):
         return forwarded
 
     def merged_patches(self, names):


@@ -975,8 +966,6 @@ class Series(StgitObject):
         unapplied = self.get_unapplied()
         assert(name in unapplied)
 
         unapplied = self.get_unapplied()
         assert(name in unapplied)
 

-        self.__begin_stack_check()
-

         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 
         head = git.get_head()
         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 
         head = git.get_head()


@@ -1020,7 +1009,8 @@ class Series(StgitObject):
                 except git.GitException, ex:
                     print >> sys.stderr, \
                           'The merge failed during "push". ' \
                 except git.GitException, ex:
                     print >> sys.stderr, \
                           'The merge failed during "push". ' \

-                          'Use "refresh" after fixing the conflicts'
+                          '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)
 


@@ -1029,8 +1019,6 @@ class Series(StgitObject):
         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
         if empty or head != bottom:
             if not ex:
         # head == bottom case doesn't need to refresh the patch
         if empty or head != bottom:
             if not ex:


@@ -1108,13 +1096,6 @@ class Series(StgitObject):
         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
         """


@@ -1156,8 +1137,6 @@ class Series(StgitObject):
             f.close()
         elif oldname in applied:
             Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
             f.close()
         elif oldname in applied:
             Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)

-            if oldname == self.get_current():
-                self.__set_current(newname)

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