X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/73e2d98ea8bb1cae1c8d8b0cbdede66b26a05da6..99c529152847b7e20e48dc477925e315918eed5d:/stgit/stack.py diff --git a/stgit/stack.py b/stgit/stack.py index e1c55f0..a477e7d 100644 --- a/stgit/stack.py +++ b/stgit/stack.py @@ -21,7 +21,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import sys, os from stgit.utils import * -from stgit import git +from stgit import git, basedir, templates from stgit.config import config @@ -65,14 +65,14 @@ def __clean_comments(f): f.writelines(lines) def edit_file(series, line, comment, show_patch = True): - fname = '.stgit.msg' - tmpl = os.path.join(git.get_base_dir(), 'patchdescr.tmpl') + fname = '.stgitmsg.txt' + tmpl = templates.get_template('patchdescr.tmpl') f = file(fname, 'w+') if line: print >> f, line - elif os.path.isfile(tmpl): - print >> f, file(tmpl).read().rstrip() + elif tmpl: + print >> f, tmpl, else: print >> f print >> f, __comment_prefix, comment @@ -128,6 +128,8 @@ class Patch: self.__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) @@ -139,23 +141,33 @@ class Patch: 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): olddir = self.__dir - old_ref_file = self.__top_ref_file + 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.__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(old_ref_file, self.__top_ref_file) + 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 __update_top_ref(self, ref): write_string(self.__top_ref_file, ref) + def __update_log_ref(self, ref): + write_string(self.__log_ref_file, ref) + def update_top_ref(self): top = self.get_top() if top: @@ -188,10 +200,7 @@ class Patch: def set_bottom(self, value, backup = False): if backup: curr = self.__get_field('bottom') - if curr != value: - self.__set_field('bottom.old', curr) - else: - self.__set_field('bottom.old', None) + self.__set_field('bottom.old', curr) self.__set_field('bottom', value) def get_old_top(self): @@ -203,10 +212,7 @@ class Patch: def set_top(self, value, backup = False): if backup: curr = self.__get_field('top') - if curr != value: - self.__set_field('top.old', curr) - else: - self.__set_field('top.old', None) + self.__set_field('top.old', curr) self.__set_field('top', value) self.__update_top_ref(value) @@ -280,6 +286,13 @@ class Patch: address = os.environ['GIT_COMMITTER_EMAIL'] self.__set_field('commemail', address) + 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 including the operations on series @@ -292,7 +305,7 @@ class Series: self.__name = name else: self.__name = git.get_head_file() - self.__base_dir = git.get_base_dir() + self.__base_dir = basedir.get() except git.GitException, ex: raise StackException, 'GIT tree not initialised: %s' % ex @@ -319,6 +332,11 @@ 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.__series_dir, 'trash') + if self.is_initialised() and not os.path.isdir(self.__trash_dir): + os.makedirs(self.__trash_dir) + def get_branch(self): """Return the branch name for the Series object """ @@ -337,9 +355,17 @@ class Series: """ 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): - """Return a Patch object representing the topmost patch - """ + """Return the name of the topmost patch, or None if there is + no such patch.""" if os.path.isfile(self.__current_file): name = read_string(self.__current_file) else: @@ -401,6 +427,11 @@ class Series: """ return name in self.get_unapplied() + 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 __begin_stack_check(self): """Save the current HEAD into .git/refs/heads/base if the stack is empty @@ -420,29 +451,35 @@ class Series: 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): + def init(self, create_at=False): """Initialises the stgit series """ bases_dir = os.path.join(self.__base_dir, 'refs', 'bases') - if self.is_initialised(): + 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) - if not os.path.isdir(bases_dir): - os.makedirs(bases_dir) + create_dirs(bases_dir) create_empty_file(self.__applied_file) create_empty_file(self.__unapplied_file) @@ -500,9 +537,14 @@ class Series: git.rename_branch(self.__name, to_name) if os.path.isdir(self.__series_dir): - os.rename(self.__series_dir, to_stack.__series_dir) + rename(os.path.join(self.__base_dir, 'patches'), + self.__name, to_stack.__name) if os.path.exists(self.__base_file): - os.rename(self.__base_file, to_stack.__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) self.__init__(to_name) @@ -510,8 +552,7 @@ class Series: """Clones a series """ base = read_string(self.get_base_file()) - git.create_branch(target_series, tree_id = base) - Series(target_series).init() + Series(target_series).init(create_at = base) new_series = Series(target_series) # generate an artificial description file @@ -544,6 +585,11 @@ 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) + if os.path.exists(self.__applied_file): os.remove(self.__applied_file) if os.path.exists(self.__unapplied_file): @@ -557,23 +603,27 @@ class Series: else: print 'Patch directory %s is not empty.' % self.__name if not os.listdir(self.__series_dir): - os.rmdir(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): - os.rmdir(self.__refs_dir) + remove_dirs(os.path.join(self.__base_dir, 'refs', 'patches'), + self.__name) else: print 'Refs directory %s is not empty.' % self.__refs_dir if os.path.exists(self.__base_file): - os.remove(self.__base_file) + remove_file_and_dirs( + os.path.join(self.__base_dir, 'refs', 'bases'), 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): + committer_name = None, committer_email = None, + backup = False, sign_str = None, log = 'refresh'): """Generates a new commit for the given patch """ name = self.get_current() @@ -605,8 +655,14 @@ class Series: if not committer_email: committer_email = patch.get_commemail() + if sign_str: + descr = '%s\n%s: %s <%s>\n' % (descr.rstrip(), sign_str, + committer_name, committer_email) + + bottom = patch.get_bottom() + commit_id = git.commit(files = files, - message = descr, parents = [patch.get_bottom()], + message = descr, parents = [bottom], cache_update = cache_update, allowempty = True, author_name = author_name, @@ -615,7 +671,8 @@ class Series: committer_name = committer_name, committer_email = committer_email) - patch.set_top(commit_id) + 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) @@ -623,14 +680,37 @@ class Series: patch.set_commname(committer_name) patch.set_commemail(committer_email) + if log: + self.log_patch(patch, log) + return commit_id + 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 refresh 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, 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): @@ -667,19 +747,24 @@ class Series: patch.set_commemail(committer_email) 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() - else: - if before_existing: - 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()) + elif before_existing: + 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()) + self.__set_current(name) + if refresh: + self.refresh_patch(cache_update = False, log = 'new') def delete_patch(self, name): """Deletes a patch @@ -694,6 +779,9 @@ class Series: 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() @@ -726,7 +814,8 @@ class Series: # top != bottom always since we have a commit for each patch if head == bottom: - # reset the backup information + # reset the backup information. No logging since the + # patch hasn't changed patch.set_bottom(head, backup = True) patch.set_top(top, backup = True) @@ -757,6 +846,8 @@ class Series: 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 @@ -780,7 +871,27 @@ class Series: return forwarded - def push_patch(self, name): + 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() @@ -798,8 +909,16 @@ class Series: modified = False # 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) @@ -835,11 +954,15 @@ class Series: self.__set_current(name) # 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 - self.refresh_patch(cache_update = False) + if modified: + log = 'push(m)' + else: + log = 'push' + self.refresh_patch(cache_update = False, log = log) else: raise StackException, str(ex) @@ -850,11 +973,25 @@ class Series: assert(name) 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 push undo information available' + git.reset() self.pop_patch(name) - return 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() @@ -863,7 +1000,12 @@ class Series: patch = Patch(name, self.__patch_dir, self.__refs_dir) - git.switch(patch.get_bottom()) + # 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(), keep) # save the new applied list idx = applied.index(name) + 1 @@ -934,3 +1076,20 @@ class Series: 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)