X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/e45af3d4a0faa3f7c46a0a2a9647ad09f1ba8720..16d69115caef1a194384f0f0f668e6789b838909:/stgit/stack.py diff --git a/stgit/stack.py b/stgit/stack.py index 93a3d4e..2477ac6 100644 --- a/stgit/stack.py +++ b/stgit/stack.py @@ -18,7 +18,7 @@ along with this program; if not, write to the Free Software 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 import git, basedir, templates @@ -91,18 +91,7 @@ def edit_file(series, line, comment, show_patch = True): print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:' f.close() - # the editor - if config.has_option('stgit', 'editor'): - editor = config.get('stgit', 'editor') - 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+') @@ -119,27 +108,57 @@ def edit_file(series, line, comment, show_patch = True): # 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 """ def __init__(self, name, series_dir, refs_dir): self.__series_dir = series_dir self.__name = name - self.__dir = os.path.join(self.__series_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): - 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): - 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) @@ -148,16 +167,16 @@ class Patch: 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.__dir = os.path.join(self.__series_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) @@ -173,128 +192,88 @@ class Patch: if top: self.__update_top_ref(top) - 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) - def get_old_bottom(self): - return self.__get_field('bottom.old') + return self._get_field('bottom.old') def get_bottom(self): - return self.__get_field('bottom') + return self._get_field('bottom') def set_bottom(self, value, backup = False): if backup: - curr = self.__get_field('bottom') - self.__set_field('bottom.old', curr) - self.__set_field('bottom', value) + 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') + return self._get_field('top.old') def get_top(self): - return self.__get_field('top') + return self._get_field('top') def set_top(self, value, backup = False): if backup: - curr = self.__get_field('top') - self.__set_field('top.old', curr) - self.__set_field('top', value) + 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): - 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: - 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: return False def get_description(self): - return self.__get_field('description', True) + return self._get_field('description', True) def set_description(self, line): - self.__set_field('description', line, True) + self._set_field('description', line, True) def get_authname(self): - return self.__get_field('authname') + return self._get_field('authname') def set_authname(self, name): - if not name: - if config.has_option('stgit', 'authname'): - name = config.get('stgit', 'authname') - elif 'GIT_AUTHOR_NAME' in os.environ: - name = os.environ['GIT_AUTHOR_NAME'] - self.__set_field('authname', name) + self._set_field('authname', name or git.author().name) def get_authemail(self): - return self.__get_field('authemail') + return self._get_field('authemail') - def set_authemail(self, address): - if not address: - if config.has_option('stgit', 'authemail'): - address = config.get('stgit', 'authemail') - elif 'GIT_AUTHOR_EMAIL' in os.environ: - address = os.environ['GIT_AUTHOR_EMAIL'] - self.__set_field('authemail', address) + def set_authemail(self, email): + self._set_field('authemail', email or git.author().email) def get_authdate(self): - return self.__get_field('authdate') + return self._get_field('authdate') def set_authdate(self, date): - if not date and 'GIT_AUTHOR_DATE' in os.environ: - date = os.environ['GIT_AUTHOR_DATE'] - self.__set_field('authdate', date) + self._set_field('authdate', date or git.author().date) def get_commname(self): - return self.__get_field('commname') + return self._get_field('commname') def set_commname(self, name): - if not name: - if config.has_option('stgit', 'commname'): - name = config.get('stgit', 'commname') - elif 'GIT_COMMITTER_NAME' in os.environ: - name = os.environ['GIT_COMMITTER_NAME'] - self.__set_field('commname', name) + self._set_field('commname', name or git.committer().name) def get_commemail(self): - return self.__get_field('commemail') + return self._get_field('commemail') - def set_commemail(self, address): - if not address: - if config.has_option('stgit', 'commemail'): - address = config.get('stgit', 'commemail') - elif 'GIT_COMMITTER_EMAIL' in os.environ: - address = os.environ['GIT_COMMITTER_EMAIL'] - self.__set_field('commemail', address) + def set_commemail(self, email): + self._set_field('commemail', email or git.committer().email) def get_log(self): - return self.__get_field('log') + return self._get_field('log') def set_log(self, value, backup = False): - self.__set_field('log', value) + 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): @@ -309,22 +288,20 @@ class Series: except git.GitException, ex: raise StackException, 'GIT tree not initialised: %s' % ex - self.__series_dir = os.path.join(self.__base_dir, '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.__series_dir, 'applied') - self.__unapplied_file = os.path.join(self.__series_dir, 'unapplied') - self.__current_file = os.path.join(self.__series_dir, 'current') - self.__descr_file = os.path.join(self.__series_dir, 'description') + 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.__patch_dir = os.path.join(self.__series_dir, 'patches') + self.__patch_dir = os.path.join(self._dir(), 'patches') if not os.path.isdir(self.__patch_dir): - self.__patch_dir = self.__series_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): @@ -332,6 +309,17 @@ class Series: 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 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 """ @@ -340,23 +328,25 @@ class Series: def __set_current(self, name): """Sets the topmost patch """ - if name: - write_string(self.__current_file, name) - else: - create_empty_file(self.__current_file) + self._set_field('current', name) def get_patch(self, name): """Return a Patch object for the given name """ return Patch(name, self.__patch_dir, self.__refs_dir) - 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: + 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): + """Return the name of the topmost patch, or None if there is + no such patch.""" + name = self._get_field('current') if name == '': return None else: @@ -378,113 +368,170 @@ class Series: f.close() return names - def get_base_file(self): - self.__begin_stack_check() - 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.__series_dir, 'protected')) + return os.path.isfile(os.path.join(self._dir(), 'protected')) def protect(self): - protect_file = os.path.join(self.__series_dir, 'protected') + 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.__series_dir, 'protected') + protect_file = os.path.join(self._dir(), 'protected') if os.path.isfile(protect_file): os.remove(protect_file) def get_description(self): - if os.path.isfile(self.__descr_file): - return read_string(self.__descr_file) + 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: - return '' + 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): - 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() - 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() - 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 """ - crt = self.get_current() + crt = self.get_current_patch() if not crt: # we don't care, no patches applied return True - return git.get_head() == Patch(crt, self.__patch_dir, - self.__refs_dir).get_top() + return git.get_head() == crt.get_top() def is_initialised(self): """Checks if series is already initialised """ return os.path.isdir(self.__patch_dir) - def init(self, create_at=False): + 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.__base_file): - raise StackException, self.__base_file + ' already exists' if (create_at!=False): git.create_branch(self.__name, create_at) os.makedirs(self.__patch_dir) - create_dirs(bases_dir) + self.set_parent(parent_remote, parent_branch) - create_empty_file(self.__applied_file) - create_empty_file(self.__unapplied_file) - create_empty_file(self.__descr_file) - os.makedirs(os.path.join(self.__series_dir, 'patches')) + 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 unconvert to place the patches in the same directory with series control files """ - if self.__patch_dir == self.__series_dir: + if self.__patch_dir == self._dir(): print 'Converting old-style to new-style...', sys.stdout.flush() - self.__patch_dir = os.path.join(self.__series_dir, 'patches') + 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.__series_dir, p) + src = os.path.join(self._dir(), p) dest = os.path.join(self.__patch_dir, p) os.rename(src, dest) @@ -496,16 +543,16 @@ class Series: for p in self.get_applied() + self.get_unapplied(): src = os.path.join(self.__patch_dir, p) - dest = os.path.join(self.__series_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.__name + print 'Patch directory %s is not empty.' % self.__patch_dir - self.__patch_dir = self.__series_dir + self.__patch_dir = self._dir() def rename(self, to_name): """Renames a series @@ -514,36 +561,45 @@ class Series: 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.__series_dir): + 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) + # 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 """ - base = read_string(self.get_base_file()) + 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 - write_string(new_series.__descr_file, 'clone of "%s"' % self.__name) + new_series.set_description('clone of "%s"' % self.__name) # clone self's entire series as unapplied patches - patches = self.get_applied() + self.get_unapplied() - patches.reverse() + 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) new_series.new_patch(p, message = patch.get_description(), @@ -555,7 +611,20 @@ class Series: author_date = patch.get_authdate()) # fast forward the cloned series to self's top - new_series.forward_patches(self.get_applied()) + 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) + + value = config.get('branch.%s.merge' % self.__name) + 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 @@ -568,32 +637,47 @@ class Series: 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(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.__current_file): os.remove(self.__current_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.__name - if not os.listdir(self.__series_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 - 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, @@ -634,7 +718,12 @@ class Series: 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() @@ -677,7 +766,7 @@ class Series: # 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 refresh undo information available' + raise StackException, 'No undo information available' git.reset(tree_id = old_top, check_out = False) if patch.restore_old_boundaries(): @@ -688,10 +777,12 @@ class Series: top = None, bottom = None, author_name = None, author_email = None, author_date = None, committer_name = None, committer_email = None, - before_existing = False): + before_existing = False, refresh = True): """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 if not message and can_edit: @@ -703,8 +794,6 @@ class Series: head = git.get_head() - self.__begin_stack_check() - patch = Patch(name, self.__patch_dir, self.__refs_dir) patch.create() @@ -741,22 +830,26 @@ class Series: else: append_string(self.__applied_file, patch.get_name()) self.__set_current(name) - - self.refresh_patch(cache_update = False, log = 'new') + if refresh: + self.refresh_patch(cache_update = False, log = 'new') def delete_patch(self, name): """Deletes a patch """ + self.__patch_name_valid(name) patch = Patch(name, self.__patch_dir, self.__refs_dir) 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 + # 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() @@ -764,7 +857,9 @@ class Series: f = file(self.__unapplied_file, 'w+') f.writelines([line + '\n' for line in unapplied]) f.close() - self.__begin_stack_check() + + if self.patch_hidden(name): + self.unhide_patch(name) def forward_patches(self, names): """Try to fast-forward an array of patches. @@ -773,7 +868,6 @@ class Series: stack. Apply the rest with push_patch """ unapplied = self.get_unapplied() - self.__begin_stack_check() forwarded = 0 top = git.get_head() @@ -872,8 +966,6 @@ class Series: 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() @@ -913,11 +1005,12 @@ class Series: # merge can fail but the patch needs to be pushed try: - git.merge(bottom, head, top) + 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' + 'Use "refresh" after fixing the conflicts or ' \ + 'revert the operation with "push --undo".' append_string(self.__applied_file, name) @@ -939,6 +1032,11 @@ class Series: log = 'push' self.refresh_patch(cache_update = False, log = log) 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) return modified @@ -956,7 +1054,7 @@ class Series: # 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 push undo information available' + raise StackException, 'No undo information available' git.reset() self.pop_patch(name) @@ -1005,11 +1103,10 @@ class Series: else: self.__set_current(applied[-1]) - self.__end_stack_check() - def empty_patch(self, name): """Returns True if the patch is empty """ + self.__patch_name_valid(name) patch = Patch(name, self.__patch_dir, self.__refs_dir) bottom = patch.get_bottom() top = patch.get_top() @@ -1023,6 +1120,8 @@ class Series: return False def rename_patch(self, oldname, newname): + self.__patch_name_valid(newname) + applied = self.get_applied() unapplied = self.get_unapplied() @@ -1032,6 +1131,10 @@ class Series: 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: Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname) unapplied[unapplied.index(oldname)] = newname @@ -1068,3 +1171,28 @@ class Series: 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()