X-Git-Url: https://git.distorted.org.uk/~mdw/stgit/blobdiff_plain/337a07433f7aa7b6f3d0bf96696b4bc6092506d2..ec29b673aa06bfce4c45e1339deb820f517fbfef:/stgit/stack.py diff --git a/stgit/stack.py b/stgit/stack.py index 9c15b3f..9958e7a 100644 --- a/stgit/stack.py +++ b/stgit/stack.py @@ -19,15 +19,19 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ import sys, os, re +from email.Utils import formatdate +from stgit.exception import * from stgit.utils import * +from stgit.out import * +from stgit.run import * from stgit import git, basedir, templates from stgit.config import config from shutil import copyfile - +from stgit.lib import git as libgit, stackupgrade # stack exception class -class StackException(Exception): +class StackException(StgException): pass class FilterUntil: @@ -65,6 +69,8 @@ def __clean_comments(f): f.seek(0); f.truncate() f.writelines(lines) +# TODO: move this out of the stgit.stack module, it is really for +# higher level commands to handle the user interaction def edit_file(series, line, comment, show_patch = True): fname = '.stgitmsg.txt' tmpl = templates.get_template('patchdescr.tmpl') @@ -86,7 +92,8 @@ def edit_file(series, line, comment, show_patch = True): 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) + diff_str = git.diff(rev1 = series.get_patch(series.get_current()).get_bottom()) + f.write(diff_str) #Vim modeline must be near the end. print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:' @@ -138,93 +145,86 @@ class StgitObject: elif os.path.isfile(fname): os.remove(fname) - + class Patch(StgitObject): """Basic patch implementation """ - def __init__(self, name, series_dir, refs_dir): + def __init_refs(self): + self.__top_ref = self.__refs_base + '/' + self.__name + self.__log_ref = self.__top_ref + '.log' + + def __init__(self, name, series_dir, refs_base): self.__series_dir = series_dir self.__name = 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') + self.__refs_base = refs_base + self.__init_refs() def create(self): 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()) - os.remove(self.__top_ref_file) - if os.path.exists(self.__log_ref_file): - os.remove(self.__log_ref_file) + def delete(self, keep_log = False): + if os.path.isdir(self._dir()): + for f in os.listdir(self._dir()): + os.remove(os.path.join(self._dir(), f)) + os.rmdir(self._dir()) + else: + out.warn('Patch directory "%s" does not exist' % self._dir()) + try: + # the reference might not exist if the repository was corrupted + git.delete_ref(self.__top_ref) + except git.GitException, e: + out.warn(str(e)) + if not keep_log and git.ref_exists(self.__log_ref): + git.delete_ref(self.__log_ref) def get_name(self): return self.__name def rename(self, newname): olddir = self._dir() - old_top_ref_file = self.__top_ref_file - old_log_ref_file = self.__log_ref_file + old_top_ref = self.__top_ref + old_log_ref = self.__log_ref self.__name = newname 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') + self.__init_refs() + git.rename_ref(old_top_ref, self.__top_ref) + if git.ref_exists(old_log_ref): + git.rename_ref(old_log_ref, self.__log_ref) 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 __update_top_ref(self, ref): - write_string(self.__top_ref_file, ref) + git.set_ref(self.__top_ref, ref) + self._set_field('top', ref) + self._set_field('bottom', git.get_commit(ref).get_parent()) 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) + git.set_ref(self.__log_ref, ref) def get_old_bottom(self): - return self._get_field('bottom.old') + return git.get_commit(self.get_old_top()).get_parent() def get_bottom(self): - 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) + return git.get_commit(self.get_top()).get_parent() def get_old_top(self): return self._get_field('top.old') def get_top(self): - return self._get_field('top') + return git.rev_parse(self.__top_ref) 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_top = self.get_top() + self._set_field('top.old', curr_top) + self._set_field('bottom.old', git.get_commit(curr_top).get_parent()) self.__update_top_ref(value) def restore_old_boundaries(self): - 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) + if top: self.__update_top_ref(top) return True else: @@ -249,7 +249,16 @@ class Patch(StgitObject): self._set_field('authemail', email or git.author().email) def get_authdate(self): - return self._get_field('authdate') + date = self._get_field('authdate') + if not date: + return date + + if re.match('[0-9]+\s+[+-][0-9]+', date): + # Unix time (seconds) + time zone + secs_tz = date.split() + date = formatdate(int(secs_tz[0]))[:-5] + secs_tz[1] + + return date def set_authdate(self, date): self._set_field('authdate', date or git.author().date) @@ -273,9 +282,6 @@ class Patch(StgitObject): self._set_field('log', value) self.__update_log_ref(value) -# The current StGIT metadata format version. -FORMAT_VERSION = 2 - class PatchSet(StgitObject): def __init__(self, name = None): try: @@ -343,8 +349,15 @@ class PatchSet(StgitObject): def is_initialised(self): """Checks if series is already initialised """ - return bool(config.get(self.format_version_key())) + return config.get(stackupgrade.format_version_key(self.get_name()) + ) != None + +def shortlog(patches): + log = ''.join(Run('git', 'log', '--pretty=short', + p.get_top(), '^%s' % p.get_bottom()).raw_output() + for p in patches) + return Run('git', 'shortlog').raw_input(log).raw_output() class Series(PatchSet): """Class including the operations on series @@ -356,10 +369,10 @@ class Series(PatchSet): # Update the branch to the latest format version if it is # initialized, but don't touch it if it isn't. - self.update_to_current_format_version() + stackupgrade.update_to_current_format_version( + libgit.Repository.default(), self.get_name()) - self.__refs_dir = os.path.join(self._basedir(), 'refs', 'patches', - self.get_name()) + self.__refs_base = 'refs/patches/%s' % self.get_name() self.__applied_file = os.path.join(self._dir(), 'applied') self.__unapplied_file = os.path.join(self._dir(), 'unapplied') @@ -371,84 +384,6 @@ class Series(PatchSet): # trash directory self.__trash_dir = os.path.join(self._dir(), 'trash') - def format_version_key(self): - return 'branch.%s.stgit.stackformatversion' % self.get_name() - - def update_to_current_format_version(self): - """Update a potentially older StGIT directory structure to the - latest version. Note: This function should depend as little as - possible on external functions that may change during a format - version bump, since it must remain able to process older formats.""" - - branch_dir = os.path.join(self._basedir(), 'patches', self.get_name()) - def get_format_version(): - """Return the integer format version number, or None if the - branch doesn't have any StGIT metadata at all, of any version.""" - fv = config.get(self.format_version_key()) - ofv = config.get('branch.%s.stgitformatversion' % self.get_name()) - if fv: - # Great, there's an explicitly recorded format version - # number, which means that the branch is initialized and - # of that exact version. - return int(fv) - elif ofv: - # Old name for the version info, upgrade it - config.set(self.format_version_key(), ofv) - config.unset('branch.%s.stgitformatversion' % self.get_name()) - return int(ofv) - elif os.path.isdir(os.path.join(branch_dir, 'patches')): - # There's a .git/patches//patches dirctory, which - # means this is an initialized version 1 branch. - return 1 - elif os.path.isdir(branch_dir): - # There's a .git/patches/ directory, which means - # this is an initialized version 0 branch. - return 0 - else: - # The branch doesn't seem to be initialized at all. - return None - def set_format_version(v): - out.info('Upgraded branch %s to format version %d' % (self.get_name(), v)) - config.set(self.format_version_key(), '%d' % v) - def mkdir(d): - if not os.path.isdir(d): - os.makedirs(d) - def rm(f): - if os.path.exists(f): - os.remove(f) - - # Update 0 -> 1. - if get_format_version() == 0: - mkdir(os.path.join(branch_dir, 'trash')) - patch_dir = os.path.join(branch_dir, 'patches') - mkdir(patch_dir) - refs_dir = os.path.join(self._basedir(), 'refs', 'patches', self.get_name()) - mkdir(refs_dir) - for patch in (file(os.path.join(branch_dir, 'unapplied')).readlines() - + file(os.path.join(branch_dir, 'applied')).readlines()): - patch = patch.strip() - os.rename(os.path.join(branch_dir, patch), - os.path.join(patch_dir, patch)) - Patch(patch, patch_dir, refs_dir).update_top_ref() - set_format_version(1) - - # Update 1 -> 2. - if get_format_version() == 1: - desc_file = os.path.join(branch_dir, 'description') - if os.path.isfile(desc_file): - desc = read_string(desc_file) - if desc: - config.set('branch.%s.description' % self.get_name(), desc) - rm(desc_file) - rm(os.path.join(branch_dir, 'current')) - rm(os.path.join(self._basedir(), 'refs', 'bases', self.get_name())) - set_format_version(2) - - # Make sure we're at the latest version. - if not get_format_version() in [None, FORMAT_VERSION]: - raise StackException('Branch %s is at format version %d, expected %d' - % (self.get_name(), get_format_version(), FORMAT_VERSION)) - def __patch_name_valid(self, name): """Raise an exception if the patch name is not valid. """ @@ -458,7 +393,7 @@ class Series(PatchSet): def get_patch(self, name): """Return a Patch object for the given name """ - return Patch(name, self.__patch_dir, self.__refs_dir) + return Patch(name, self.__patch_dir, self.__refs_base) def get_current_patch(self): """Return a Patch object representing the topmost patch, or @@ -466,7 +401,7 @@ class Series(PatchSet): crt = self.get_current() if not crt: return None - return Patch(crt, self.__patch_dir, self.__refs_dir) + return self.get_patch(crt) def get_current(self): """Return the name of the topmost patch, or None if there is @@ -487,11 +422,17 @@ class Series(PatchSet): raise StackException, 'Branch "%s" not initialised' % self.get_name() return read_strings(self.__applied_file) + def set_applied(self, applied): + write_strings(self.__applied_file, applied) + def get_unapplied(self): if not os.path.isfile(self.__unapplied_file): raise StackException, 'Branch "%s" not initialised' % self.get_name() return read_strings(self.__unapplied_file) + def set_unapplied(self, unapplied): + write_strings(self.__unapplied_file, unapplied) + def get_hidden(self): if not os.path.isfile(self.__hidden_file): return [] @@ -514,7 +455,7 @@ class Series(PatchSet): out.note(('No parent remote declared for stack "%s",' ' defaulting to "origin".' % self.get_name()), ('Consider setting "branch.%s.remote" and' - ' "branch.%s.merge" with "git repo-config".' + ' "branch.%s.merge" with "git config".' % (self.get_name(), self.get_name()))) return 'origin' else: @@ -531,7 +472,7 @@ class Series(PatchSet): out.note(('No parent branch declared for stack "%s",' ' defaulting to "heads/origin".' % self.get_name()), ('Consider setting "branch.%s.stgit.parentbranch"' - ' with "git repo-config".' % self.get_name())) + ' with "git config".' % self.get_name())) return 'heads/origin' else: raise StackException, 'Cannot find a parent branch for "%s"' % self.get_name() @@ -545,7 +486,8 @@ class Series(PatchSet): def set_parent(self, remote, localbranch): if localbranch: - self.__set_parent_remote(remote) + if remote: + self.__set_parent_remote(remote) self.__set_parent_branch(localbranch) # We'll enforce this later # else: @@ -580,7 +522,7 @@ class Series(PatchSet): """ if self.is_initialised(): raise StackException, '%s already initialized' % self.get_name() - for d in [self._dir(), self.__refs_dir]: + for d in [self._dir()]: if os.path.exists(d): raise StackException, '%s already exists' % d @@ -593,10 +535,9 @@ class Series(PatchSet): self.create_empty_field('applied') self.create_empty_field('unapplied') - os.makedirs(self.__refs_dir) - self._set_field('orig-base', git.get_head()) - config.set(self.format_version_key(), str(FORMAT_VERSION)) + config.set(stackupgrade.format_version_key(self.get_name()), + str(stackupgrade.FORMAT_VERSION)) def rename(self, to_name): """Renames a series @@ -606,14 +547,18 @@ class Series(PatchSet): if to_stack.is_initialised(): raise StackException, '"%s" already exists' % to_stack.get_name() + patches = self.get_applied() + self.get_unapplied() + git.rename_branch(self.get_name(), to_name) + for patch in patches: + git.rename_ref('refs/patches/%s/%s' % (self.get_name(), patch), + 'refs/patches/%s/%s' % (to_name, patch)) + git.rename_ref('refs/patches/%s/%s.log' % (self.get_name(), patch), + 'refs/patches/%s/%s.log' % (to_name, patch)) if os.path.isdir(self._dir()): rename(os.path.join(self._basedir(), 'patches'), self.get_name(), to_stack.get_name()) - if os.path.exists(self.__refs_dir): - rename(os.path.join(self._basedir(), 'refs', 'patches'), - self.get_name(), to_stack.get_name()) # Rename the config section for k in ['branch.%s', 'branch.%s.stgit']: @@ -684,7 +629,7 @@ class Series(PatchSet): raise StackException, \ 'Cannot delete: the series still contains patches' for p in patches: - Patch(p, self.__patch_dir, self.__refs_dir).delete() + self.get_patch(p).delete() # remove the trash directory if any if os.path.exists(self.__trash_dir): @@ -714,35 +659,29 @@ class Series(PatchSet): raise StackException('Series directory %s is not empty' % self._dir()) - try: - os.removedirs(self.__refs_dir) - except OSError: - out.warn('Refs directory %s is not empty' % self.__refs_dir) + try: + git.delete_branch(self.get_name()) + except git.GitException: + out.warn('Could not delete branch "%s"' % self.get_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.get_name()) - config.unset('branch.%s.merge' % self.get_name()) - config.unset('branch.%s.stgit.parentbranch' % self.get_name()) - config.unset(self.format_version_key()) + config.remove_section('branch.%s' % self.get_name()) + config.remove_section('branch.%s.stgit' % self.get_name()) def refresh_patch(self, files = None, message = None, edit = False, + empty = False, show_patch = False, cache_update = True, author_name = None, author_email = None, author_date = None, committer_name = None, committer_email = None, - backup = False, sign_str = None, log = 'refresh', - notes = None): - """Generates a new commit for the given patch + backup = True, sign_str = None, log = 'refresh', + notes = None, bottom = None): + """Generates a new commit for the topmost patch """ - name = self.get_current() - if not name: + patch = self.get_current_patch() + if not patch: raise StackException, 'No patches applied' - patch = Patch(name, self.__patch_dir, self.__refs_dir) - descr = patch.get_description() if not (message or descr): edit = True @@ -750,36 +689,37 @@ class Series(PatchSet): elif message: descr = message + # TODO: move this out of the stgit.stack module, it is really + # for higher level commands to handle the user interaction if not message and edit: descr = edit_file(self, descr.rstrip(), \ 'Please edit the description for patch "%s" ' \ - 'above.' % name, show_patch) + 'above.' % patch.get_name(), show_patch) if not author_name: author_name = patch.get_authname() if not author_email: author_email = patch.get_authemail() - if not author_date: - author_date = patch.get_authdate() if not committer_name: committer_name = patch.get_commname() if not committer_email: committer_email = patch.get_commemail() - if sign_str: - descr = descr.rstrip() - if descr.find("\nSigned-off-by:") < 0 \ - and descr.find("\nAcked-by:") < 0: - descr = descr + "\n" + descr = add_sign_line(descr, sign_str, committer_name, committer_email) - descr = '%s\n%s: %s <%s>\n' % (descr, sign_str, - committer_name, committer_email) + if not bottom: + bottom = patch.get_bottom() - bottom = patch.get_bottom() + if empty: + tree_id = git.get_commit(bottom).get_tree() + else: + tree_id = None commit_id = git.commit(files = files, message = descr, parents = [bottom], cache_update = cache_update, + tree_id = tree_id, + set_head = True, allowempty = True, author_name = author_name, author_email = author_email, @@ -787,7 +727,6 @@ class Series(PatchSet): committer_name = committer_name, committer_email = committer_email) - patch.set_bottom(bottom, backup = backup) patch.set_top(commit_id, backup = backup) patch.set_description(descr) patch.set_authname(author_name) @@ -801,63 +740,49 @@ class Series(PatchSet): 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 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, commit = True, author_name = None, author_email = None, author_date = None, committer_name = None, committer_email = None, - before_existing = False): - """Creates a new patch + before_existing = False, sign_str = None): + """Creates a new patch, either pointing to an existing commit object, + or by creating a new commit object. """ + assert commit or (top and bottom) + assert not before_existing or (top and bottom) + assert not (commit and before_existing) + assert (top and bottom) or (not top and not bottom) + assert commit or (not top or (bottom == git.get_commit(top).get_parent())) + if name != None: self.__patch_name_valid(name) if self.patch_exists(name): raise StackException, 'Patch "%s" already exists' % name + # TODO: move this out of the stgit.stack module, it is really + # for higher level commands to handle the user interaction + def sign(msg): + return add_sign_line(msg, sign_str, + committer_name or git.committer().name, + committer_email or git.committer().email) if not message and can_edit: descr = edit_file( - self, None, + self, sign(''), 'Please enter the description for the patch above.', show_patch) else: - descr = message + descr = sign(message) head = git.get_head() if name == None: name = make_patch_name(descr, self.patch_exists) - patch = Patch(name, self.__patch_dir, self.__refs_dir) + patch = self.get_patch(name) patch.create() - if not bottom: - bottom = head - if not top: - top = head - - patch.set_bottom(bottom) - patch.set_top(top) patch.set_description(descr) patch.set_authname(author_name) patch.set_authemail(author_email) @@ -867,9 +792,6 @@ class Series(PatchSet): if before_existing: insert_string(self.__applied_file, patch.get_name()) - # no need to commit anything as the object is already - # present (mainly used by 'uncommit') - commit = False elif unapplied: patches = [patch.get_name()] + self.get_unapplied() write_strings(self.__unapplied_file, patches) @@ -879,10 +801,15 @@ class Series(PatchSet): set_head = True if commit: + if top: + top_commit = git.get_commit(top) + else: + bottom = head + top_commit = git.get_commit(head) + # create a commit for the patch (may be empty if top == bottom); # only commit on top of the current branch assert(unapplied or bottom == head) - top_commit = git.get_commit(top) commit_id = git.commit(message = descr, parents = [bottom], cache_update = False, tree_id = top_commit.get_tree(), @@ -894,16 +821,18 @@ class Series(PatchSet): committer_email = committer_email) # set the patch top to the new commit patch.set_top(commit_id) + else: + patch.set_top(top) self.log_patch(patch, 'new') return patch - def delete_patch(self, name): + def delete_patch(self, name, keep_log = False): """Deletes a patch """ self.__patch_name_valid(name) - patch = Patch(name, self.__patch_dir, self.__refs_dir) + patch = self.get_patch(name) if self.__patch_is_current(patch): self.pop_patch(name) @@ -916,7 +845,7 @@ class Series(PatchSet): # save the commit id to a trash file write_string(os.path.join(self.__trash_dir, name), patch.get_top()) - patch.delete() + patch.delete(keep_log = keep_log) unapplied = self.get_unapplied() unapplied.remove(name) @@ -936,7 +865,7 @@ class Series(PatchSet): for name in names: assert(name in unapplied) - patch = Patch(name, self.__patch_dir, self.__refs_dir) + patch = self.get_patch(name) head = top bottom = patch.get_bottom() @@ -946,7 +875,6 @@ class Series(PatchSet): 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: @@ -974,7 +902,6 @@ class Series(PatchSet): 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)') @@ -1002,8 +929,7 @@ class Series(PatchSet): 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 = [self.get_patch(name) for name in names] patches.reverse() merged = [] @@ -1016,105 +942,87 @@ class Series(PatchSet): return merged - def push_patch(self, name, empty = False): + def push_empty_patch(self, name): + """Pushes an empty patch on the stack + """ + unapplied = self.get_unapplied() + assert(name in unapplied) + + # patch = self.get_patch(name) + head = git.get_head() + + append_string(self.__applied_file, name) + + unapplied.remove(name) + write_strings(self.__unapplied_file, unapplied) + + self.refresh_patch(bottom = head, cache_update = False, log = 'push(m)') + + def push_patch(self, name): """Pushes a patch on the stack """ unapplied = self.get_unapplied() assert(name in unapplied) - patch = Patch(name, self.__patch_dir, self.__refs_dir) + patch = self.get_patch(name) head = git.get_head() bottom = patch.get_bottom() top = patch.get_top() + # top != bottom always since we have a commit for each patch + + if head == bottom: + # A fast-forward push. Just reset the backup + # information. No need for logging + patch.set_top(top, backup = True) + git.switch(top) + append_string(self.__applied_file, name) + + unapplied.remove(name) + write_strings(self.__unapplied_file, unapplied) + return False + + # Need to create a new commit an merge in the old patch ex = None modified = False - # top != bottom always since we have a commit for each patch - 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) + # 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 - elif head == bottom: - # reset the backup information. No need for logging - patch.set_bottom(bottom, backup = True) - patch.set_top(top, backup = True) - git.switch(top) - else: - # new patch needs to be refreshed. - # The current patch is empty after merge. - patch.set_bottom(head, backup = True) - patch.set_top(head, backup = True) - - # 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: - out.error('The merge failed during "push".', - 'Use "refresh" after fixing the conflicts or' - ' revert the operation with "push --undo".') + # merge can fail but the patch needs to be pushed + try: + git.merge_recursive(bottom, head, top) + except git.GitException, ex: + out.error('The merge failed during "push".', + 'Revert the operation with "stg undo".') append_string(self.__applied_file, name) unapplied.remove(name) write_strings(self.__unapplied_file, unapplied) - # head == bottom case doesn't need to refresh the patch - 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 modified: - log = 'push(m)' - else: - log = 'push' - self.refresh_patch(cache_update = False, log = log) + 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 modified: + log = 'push(m)' 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) + log = 'push' + self.refresh_patch(bottom = head, cache_update = False, log = log) + else: + # we make the patch empty, with the merged state in the + # working tree. + self.refresh_patch(bottom = head, cache_update = False, + empty = True, log = 'push(c)') + raise StackException, str(ex) return modified - def undo_push(self): - 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 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) - ret = patch.restore_old_boundaries() - if ret: - self.log_patch(patch, 'undo') - - return ret - def pop_patch(self, name, keep = False): """Pops the top patch from the stack """ @@ -1122,10 +1030,11 @@ class Series(PatchSet): applied.reverse() assert(name in applied) - patch = Patch(name, self.__patch_dir, self.__refs_dir) + patch = self.get_patch(name) if git.get_head_file() == self.get_name(): - if keep and not git.apply_diff(git.get_head(), patch.get_bottom()): + if keep and not git.apply_diff(git.get_head(), patch.get_bottom(), + check_index = False): raise StackException( 'Failed to pop patches while preserving the local changes') git.switch(patch.get_bottom(), keep) @@ -1148,7 +1057,7 @@ class Series(PatchSet): """Returns True if the patch is empty """ self.__patch_name_valid(name) - patch = Patch(name, self.__patch_dir, self.__refs_dir) + patch = self.get_patch(name) bottom = patch.get_bottom() top = patch.get_top() @@ -1173,11 +1082,11 @@ class Series(PatchSet): raise StackException, 'Patch "%s" already exists' % newname if oldname in unapplied: - Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname) + self.get_patch(oldname).rename(newname) unapplied[unapplied.index(oldname)] = newname write_strings(self.__unapplied_file, unapplied) elif oldname in applied: - Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname) + self.get_patch(oldname).rename(newname) applied[applied.index(oldname)] = newname write_strings(self.__applied_file, applied)