[StGIT RFC PATCH] Don't use refs/bases/<branchname>

@@ -387,9 +387,6 @@ Layout of the .git directory
     heads/
       master		- the master commit id
       ...
-    bases/
-      master		- the bottom id of the stack (to get a big diff)
-      ...
     tags/
       ...
     branches/

@@ -80,11 +80,9 @@ def func(parser, options, args):
     print 'Uncommitting %d patches...' % patch_nr,
     sys.stdout.flush()
 
-    base_file = crt_series.get_base_file()
-
     for n in xrange(0, patch_nr):
         # retrieve the commit (only commits with a single parent are allowed)
-        commit_id = read_string(base_file)
+        commit_id = crt_series.get_base()
         commit = git.Commit(commit_id)
         try:
             parent, = commit.get_parents()

@@ -107,6 +105,5 @@ def func(parser, options, args):
                              author_name = author_name,
                              author_email = author_email,
                              author_date = author_date)
-        write_string(base_file, parent)
 
     print 'done'

@@ -291,8 +291,6 @@ 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.__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')

@@ -378,12 +376,14 @@ class Series(StgitObject):
         f.close()
         return names
 
-    def get_base_file(self):
-        self.__begin_stack_check()
-        return self.__base_file
-
     def get_base(self):
-        return read_string(self.get_base_file())
+        # 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

@@ -482,22 +482,6 @@ class Series(StgitObject):
         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
         """

@@ -519,8 +503,6 @@ class Series(StgitObject):
             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)

@@ -528,15 +510,12 @@ class Series(StgitObject):
         os.makedirs(self.__patch_dir)
 
         self.set_parent(parent_remote, parent_branch)
-        
-        create_dirs(os.path.join(self.__base_dir, 'refs', 'bases'))
 
         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):

@@ -582,17 +561,12 @@ class Series(StgitObject):
 
         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)
-        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)

@@ -698,10 +672,6 @@ class Series(StgitObject):
             except OSError:
                 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

@@ -824,8 +794,6 @@ class Series(StgitObject):
 
         head = git.get_head()
 
-        self.__begin_stack_check()
-
         patch = Patch(name, self.__patch_dir, self.__refs_dir)
         patch.create()
 

@@ -893,8 +861,6 @@ class Series(StgitObject):
         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.
 

@@ -902,7 +868,6 @@ class Series(StgitObject):
         stack. Apply the rest with push_patch
         """
         unapplied = self.get_unapplied()
-        self.__begin_stack_check()
 
         forwarded = 0
         top = git.get_head()

@@ -1001,8 +966,6 @@ class Series(StgitObject):
         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()

@@ -1140,8 +1103,6 @@ class Series(StgitObject):
         else:
             self.__set_current(applied[-1])
 
-        self.__end_stack_check()
-
     def empty_patch(self, name):
         """Returns True if the patch is empty
         """

@@ -39,20 +39,6 @@ test_expect_success \
 '
 
 test_expect_failure \
-    'Try to create an stgit branch with a spurious refs/bases/ entry' \
-    'find .git -name foo | xargs rm -rf &&
-     touch .git/refs/bases/foo &&
-     stg branch -c foo
-'
-
-test_expect_success \
-    'Check no part of the branch was created' \
-    'test "`find .git -name foo | tee /dev/stderr`" = ".git/refs/bases/foo" &&
-     ( grep foo .git/HEAD; test $? = 1 )
-'
-
-
-test_expect_failure \
     'Try to create an stgit branch with an existing git branch by that name' \
     'find .git -name foo | xargs rm -rf &&
      cp .git/refs/heads/master .git/refs/heads/foo &&

@@ -30,11 +30,12 @@ test_expect_success \
 
 test_expect_success \
     'Port those patches to orig tree' \
-    "(cd foo &&
-      GIT_DIR=../bar/.git git-format-patch --stdout bases/master..HEAD |
+    '(cd foo &&
+      GIT_DIR=../bar/.git git-format-patch --stdout \
+          $(cd ../bar && stg id base@master)..HEAD |
       git-am -3 -k
      )
-"
+    '
 
 test_expect_success \
     'Pull to sync with parent, preparing for the problem' \

@@ -28,11 +28,12 @@ test_expect_success \
 
 test_expect_success \
     'Port those patches to orig tree' \
-    "(cd foo &&
-      GIT_DIR=../bar/.git git-format-patch --stdout bases/master..HEAD |
+    '(cd foo &&
+      GIT_DIR=../bar/.git git-format-patch --stdout \
+          $(cd ../bar && stg id base@master)..HEAD |
       git-am -3 -k
      )
-"
+    '
 
 test_expect_success \
     'Pull those patches applied upstream, without pushing' \

@@ -27,7 +27,7 @@ test_expect_success \
 	'Rebase to previous commit' \
 	'
 	stg rebase master~1 &&
-	test `git rev-parse bases/stack` = `git rev-parse master~1`
+	test `stg id base@stack` = `git rev-parse master~1`
 	'
 
 test_done