1 """Basic quilt-like functionality
5 Copyright (C) 2005, Catalin Marinas <catalin.marinas@gmail.com>
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 from email.Utils import formatdate
24 from stgit.utils import *
25 from stgit.out import *
26 from stgit.run import *
27 from stgit import git, basedir, templates
28 from stgit.config import config
29 from shutil import copyfile
32 # stack exception class
33 class StackException(Exception):
38 self.should_print = True
39 def __call__(self, x, until_test, prefix):
41 self.should_print = False
43 return x[0:len(prefix)] != prefix
49 __comment_prefix = 'STG:'
50 __patch_prefix = 'STG_PATCH:'
52 def __clean_comments(f):
53 """Removes lines marked for status in a commit file
57 # remove status-prefixed lines
60 patch_filter = FilterUntil()
61 until_test = lambda t: t == (__patch_prefix + '\n')
62 lines = [l for l in lines if patch_filter(l, until_test, __comment_prefix)]
64 # remove empty lines at the end
65 while len(lines) != 0 and lines[-1] == '\n':
68 f.seek(0); f.truncate()
71 # TODO: move this out of the stgit.stack module, it is really for
72 # higher level commands to handle the user interaction
73 def edit_file(series, line, comment, show_patch = True):
74 fname = '.stgitmsg.txt'
75 tmpl = templates.get_template('patchdescr.tmpl')
84 print >> f, __comment_prefix, comment
85 print >> f, __comment_prefix, \
86 'Lines prefixed with "%s" will be automatically removed.' \
88 print >> f, __comment_prefix, \
89 'Trailing empty lines will be automatically removed.'
92 print >> f, __patch_prefix
93 # series.get_patch(series.get_current()).get_top()
94 diff_str = git.diff(rev1 = series.get_patch(series.get_current()).get_bottom())
97 #Vim modeline must be near the end.
98 print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:'
103 f = file(fname, 'r+')
119 """An object with stgit-like properties stored as files in a directory
121 def _set_dir(self, dir):
126 def create_empty_field(self, name):
127 create_empty_file(os.path.join(self.__dir, name))
129 def _get_field(self, name, multiline = False):
130 id_file = os.path.join(self.__dir, name)
131 if os.path.isfile(id_file):
132 line = read_string(id_file, multiline)
140 def _set_field(self, name, value, multiline = False):
141 fname = os.path.join(self.__dir, name)
142 if value and value != '':
143 write_string(fname, value, multiline)
144 elif os.path.isfile(fname):
148 class Patch(StgitObject):
149 """Basic patch implementation
151 def __init_refs(self):
152 self.__top_ref = self.__refs_base + '/' + self.__name
153 self.__log_ref = self.__top_ref + '.log'
155 def __init__(self, name, series_dir, refs_base):
156 self.__series_dir = series_dir
158 self._set_dir(os.path.join(self.__series_dir, self.__name))
159 self.__refs_base = refs_base
163 os.mkdir(self._dir())
164 self.create_empty_field('bottom')
165 self.create_empty_field('top')
168 for f in os.listdir(self._dir()):
169 os.remove(os.path.join(self._dir(), f))
170 os.rmdir(self._dir())
171 git.delete_ref(self.__top_ref)
172 if git.ref_exists(self.__log_ref):
173 git.delete_ref(self.__log_ref)
178 def rename(self, newname):
180 old_top_ref = self.__top_ref
181 old_log_ref = self.__log_ref
182 self.__name = newname
183 self._set_dir(os.path.join(self.__series_dir, self.__name))
186 git.rename_ref(old_top_ref, self.__top_ref)
187 if git.ref_exists(old_log_ref):
188 git.rename_ref(old_log_ref, self.__log_ref)
189 os.rename(olddir, self._dir())
191 def __update_top_ref(self, ref):
192 git.set_ref(self.__top_ref, ref)
194 def __update_log_ref(self, ref):
195 git.set_ref(self.__log_ref, ref)
197 def update_top_ref(self):
200 self.__update_top_ref(top)
202 def get_old_bottom(self):
203 return self._get_field('bottom.old')
205 def get_bottom(self):
206 return self._get_field('bottom')
208 def set_bottom(self, value, backup = False):
210 curr = self._get_field('bottom')
211 self._set_field('bottom.old', curr)
212 self._set_field('bottom', value)
214 def get_old_top(self):
215 return self._get_field('top.old')
218 return self._get_field('top')
220 def set_top(self, value, backup = False):
222 curr = self._get_field('top')
223 self._set_field('top.old', curr)
224 self._set_field('top', value)
225 self.__update_top_ref(value)
227 def restore_old_boundaries(self):
228 bottom = self._get_field('bottom.old')
229 top = self._get_field('top.old')
232 self._set_field('bottom', bottom)
233 self._set_field('top', top)
234 self.__update_top_ref(top)
239 def get_description(self):
240 return self._get_field('description', True)
242 def set_description(self, line):
243 self._set_field('description', line, True)
245 def get_authname(self):
246 return self._get_field('authname')
248 def set_authname(self, name):
249 self._set_field('authname', name or git.author().name)
251 def get_authemail(self):
252 return self._get_field('authemail')
254 def set_authemail(self, email):
255 self._set_field('authemail', email or git.author().email)
257 def get_authdate(self):
258 date = self._get_field('authdate')
262 if re.match('[0-9]+\s+[+-][0-9]+', date):
263 # Unix time (seconds) + time zone
264 secs_tz = date.split()
265 date = formatdate(int(secs_tz[0]))[:-5] + secs_tz[1]
269 def set_authdate(self, date):
270 self._set_field('authdate', date or git.author().date)
272 def get_commname(self):
273 return self._get_field('commname')
275 def set_commname(self, name):
276 self._set_field('commname', name or git.committer().name)
278 def get_commemail(self):
279 return self._get_field('commemail')
281 def set_commemail(self, email):
282 self._set_field('commemail', email or git.committer().email)
285 return self._get_field('log')
287 def set_log(self, value, backup = False):
288 self._set_field('log', value)
289 self.__update_log_ref(value)
291 # The current StGIT metadata format version.
294 class PatchSet(StgitObject):
295 def __init__(self, name = None):
300 self.set_name (git.get_head_file())
301 self.__base_dir = basedir.get()
302 except git.GitException, ex:
303 raise StackException, 'GIT tree not initialised: %s' % ex
305 self._set_dir(os.path.join(self.__base_dir, 'patches', self.get_name()))
309 def set_name(self, name):
313 return self.__base_dir
316 """Return the head of the branch
318 crt = self.get_current_patch()
322 return self.get_base()
324 def get_protected(self):
325 return os.path.isfile(os.path.join(self._dir(), 'protected'))
328 protect_file = os.path.join(self._dir(), 'protected')
329 if not os.path.isfile(protect_file):
330 create_empty_file(protect_file)
333 protect_file = os.path.join(self._dir(), 'protected')
334 if os.path.isfile(protect_file):
335 os.remove(protect_file)
337 def __branch_descr(self):
338 return 'branch.%s.description' % self.get_name()
340 def get_description(self):
341 return config.get(self.__branch_descr()) or ''
343 def set_description(self, line):
345 config.set(self.__branch_descr(), line)
347 config.unset(self.__branch_descr())
349 def head_top_equal(self):
350 """Return true if the head and the top are the same
352 crt = self.get_current_patch()
354 # we don't care, no patches applied
356 return git.get_head() == crt.get_top()
358 def is_initialised(self):
359 """Checks if series is already initialised
361 return bool(config.get(self.format_version_key()))
364 def shortlog(patches):
365 log = ''.join(Run('git-log', '--pretty=short',
366 p.get_top(), '^%s' % p.get_bottom()).raw_output()
368 return Run('git-shortlog').raw_input(log).raw_output()
370 class Series(PatchSet):
371 """Class including the operations on series
373 def __init__(self, name = None):
374 """Takes a series name as the parameter.
376 PatchSet.__init__(self, name)
378 # Update the branch to the latest format version if it is
379 # initialized, but don't touch it if it isn't.
380 self.update_to_current_format_version()
382 self.__refs_base = 'refs/patches/%s' % self.get_name()
384 self.__applied_file = os.path.join(self._dir(), 'applied')
385 self.__unapplied_file = os.path.join(self._dir(), 'unapplied')
386 self.__hidden_file = os.path.join(self._dir(), 'hidden')
388 # where this series keeps its patches
389 self.__patch_dir = os.path.join(self._dir(), 'patches')
392 self.__trash_dir = os.path.join(self._dir(), 'trash')
394 def format_version_key(self):
395 return 'branch.%s.stgit.stackformatversion' % self.get_name()
397 def update_to_current_format_version(self):
398 """Update a potentially older StGIT directory structure to the
399 latest version. Note: This function should depend as little as
400 possible on external functions that may change during a format
401 version bump, since it must remain able to process older formats."""
403 branch_dir = os.path.join(self._basedir(), 'patches', self.get_name())
404 def get_format_version():
405 """Return the integer format version number, or None if the
406 branch doesn't have any StGIT metadata at all, of any version."""
407 fv = config.get(self.format_version_key())
408 ofv = config.get('branch.%s.stgitformatversion' % self.get_name())
410 # Great, there's an explicitly recorded format version
411 # number, which means that the branch is initialized and
412 # of that exact version.
415 # Old name for the version info, upgrade it
416 config.set(self.format_version_key(), ofv)
417 config.unset('branch.%s.stgitformatversion' % self.get_name())
419 elif os.path.isdir(os.path.join(branch_dir, 'patches')):
420 # There's a .git/patches/<branch>/patches dirctory, which
421 # means this is an initialized version 1 branch.
423 elif os.path.isdir(branch_dir):
424 # There's a .git/patches/<branch> directory, which means
425 # this is an initialized version 0 branch.
428 # The branch doesn't seem to be initialized at all.
430 def set_format_version(v):
431 out.info('Upgraded branch %s to format version %d' % (self.get_name(), v))
432 config.set(self.format_version_key(), '%d' % v)
434 if not os.path.isdir(d):
437 if os.path.exists(f):
440 if git.ref_exists(ref):
444 if get_format_version() == 0:
445 mkdir(os.path.join(branch_dir, 'trash'))
446 patch_dir = os.path.join(branch_dir, 'patches')
448 refs_base = 'refs/patches/%s' % self.get_name()
449 for patch in (file(os.path.join(branch_dir, 'unapplied')).readlines()
450 + file(os.path.join(branch_dir, 'applied')).readlines()):
451 patch = patch.strip()
452 os.rename(os.path.join(branch_dir, patch),
453 os.path.join(patch_dir, patch))
454 Patch(patch, patch_dir, refs_base).update_top_ref()
455 set_format_version(1)
458 if get_format_version() == 1:
459 desc_file = os.path.join(branch_dir, 'description')
460 if os.path.isfile(desc_file):
461 desc = read_string(desc_file)
463 config.set('branch.%s.description' % self.get_name(), desc)
465 rm(os.path.join(branch_dir, 'current'))
466 rm_ref('refs/bases/%s' % self.get_name())
467 set_format_version(2)
469 # Make sure we're at the latest version.
470 if not get_format_version() in [None, FORMAT_VERSION]:
471 raise StackException('Branch %s is at format version %d, expected %d'
472 % (self.get_name(), get_format_version(), FORMAT_VERSION))
474 def __patch_name_valid(self, name):
475 """Raise an exception if the patch name is not valid.
477 if not name or re.search('[^\w.-]', name):
478 raise StackException, 'Invalid patch name: "%s"' % name
480 def get_patch(self, name):
481 """Return a Patch object for the given name
483 return Patch(name, self.__patch_dir, self.__refs_base)
485 def get_current_patch(self):
486 """Return a Patch object representing the topmost patch, or
487 None if there is no such patch."""
488 crt = self.get_current()
491 return self.get_patch(crt)
493 def get_current(self):
494 """Return the name of the topmost patch, or None if there is
497 applied = self.get_applied()
498 except StackException:
499 # No "applied" file: branch is not initialized.
504 # No patches applied.
507 def get_applied(self):
508 if not os.path.isfile(self.__applied_file):
509 raise StackException, 'Branch "%s" not initialised' % self.get_name()
510 return read_strings(self.__applied_file)
512 def set_applied(self, applied):
513 write_strings(self.__applied_file, applied)
515 def get_unapplied(self):
516 if not os.path.isfile(self.__unapplied_file):
517 raise StackException, 'Branch "%s" not initialised' % self.get_name()
518 return read_strings(self.__unapplied_file)
520 def set_unapplied(self, unapplied):
521 write_strings(self.__unapplied_file, unapplied)
523 def get_hidden(self):
524 if not os.path.isfile(self.__hidden_file):
526 return read_strings(self.__hidden_file)
529 # Return the parent of the bottommost patch, if there is one.
530 if os.path.isfile(self.__applied_file):
531 bottommost = file(self.__applied_file).readline().strip()
533 return self.get_patch(bottommost).get_bottom()
534 # No bottommost patch, so just return HEAD
535 return git.get_head()
537 def get_parent_remote(self):
538 value = config.get('branch.%s.remote' % self.get_name())
541 elif 'origin' in git.remotes_list():
542 out.note(('No parent remote declared for stack "%s",'
543 ' defaulting to "origin".' % self.get_name()),
544 ('Consider setting "branch.%s.remote" and'
545 ' "branch.%s.merge" with "git config".'
546 % (self.get_name(), self.get_name())))
549 raise StackException, 'Cannot find a parent remote for "%s"' % self.get_name()
551 def __set_parent_remote(self, remote):
552 value = config.set('branch.%s.remote' % self.get_name(), remote)
554 def get_parent_branch(self):
555 value = config.get('branch.%s.stgit.parentbranch' % self.get_name())
558 elif git.rev_parse('heads/origin'):
559 out.note(('No parent branch declared for stack "%s",'
560 ' defaulting to "heads/origin".' % self.get_name()),
561 ('Consider setting "branch.%s.stgit.parentbranch"'
562 ' with "git config".' % self.get_name()))
563 return 'heads/origin'
565 raise StackException, 'Cannot find a parent branch for "%s"' % self.get_name()
567 def __set_parent_branch(self, name):
568 if config.get('branch.%s.remote' % self.get_name()):
569 # Never set merge if remote is not set to avoid
570 # possibly-erroneous lookups into 'origin'
571 config.set('branch.%s.merge' % self.get_name(), name)
572 config.set('branch.%s.stgit.parentbranch' % self.get_name(), name)
574 def set_parent(self, remote, localbranch):
577 self.__set_parent_remote(remote)
578 self.__set_parent_branch(localbranch)
579 # We'll enforce this later
581 # raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.get_name()
583 def __patch_is_current(self, patch):
584 return patch.get_name() == self.get_current()
586 def patch_applied(self, name):
587 """Return true if the patch exists in the applied list
589 return name in self.get_applied()
591 def patch_unapplied(self, name):
592 """Return true if the patch exists in the unapplied list
594 return name in self.get_unapplied()
596 def patch_hidden(self, name):
597 """Return true if the patch is hidden.
599 return name in self.get_hidden()
601 def patch_exists(self, name):
602 """Return true if there is a patch with the given name, false
604 return self.patch_applied(name) or self.patch_unapplied(name) \
605 or self.patch_hidden(name)
607 def init(self, create_at=False, parent_remote=None, parent_branch=None):
608 """Initialises the stgit series
610 if self.is_initialised():
611 raise StackException, '%s already initialized' % self.get_name()
612 for d in [self._dir()]:
613 if os.path.exists(d):
614 raise StackException, '%s already exists' % d
616 if (create_at!=False):
617 git.create_branch(self.get_name(), create_at)
619 os.makedirs(self.__patch_dir)
621 self.set_parent(parent_remote, parent_branch)
623 self.create_empty_field('applied')
624 self.create_empty_field('unapplied')
625 self._set_field('orig-base', git.get_head())
627 config.set(self.format_version_key(), str(FORMAT_VERSION))
629 def rename(self, to_name):
632 to_stack = Series(to_name)
634 if to_stack.is_initialised():
635 raise StackException, '"%s" already exists' % to_stack.get_name()
637 patches = self.get_applied() + self.get_unapplied()
639 git.rename_branch(self.get_name(), to_name)
641 for patch in patches:
642 git.rename_ref('refs/patches/%s/%s' % (self.get_name(), patch),
643 'refs/patches/%s/%s' % (to_name, patch))
644 git.rename_ref('refs/patches/%s/%s.log' % (self.get_name(), patch),
645 'refs/patches/%s/%s.log' % (to_name, patch))
646 if os.path.isdir(self._dir()):
647 rename(os.path.join(self._basedir(), 'patches'),
648 self.get_name(), to_stack.get_name())
650 # Rename the config section
651 for k in ['branch.%s', 'branch.%s.stgit']:
652 config.rename_section(k % self.get_name(), k % to_name)
654 self.__init__(to_name)
656 def clone(self, target_series):
660 # allow cloning of branches not under StGIT control
661 base = self.get_base()
663 base = git.get_head()
664 Series(target_series).init(create_at = base)
665 new_series = Series(target_series)
667 # generate an artificial description file
668 new_series.set_description('clone of "%s"' % self.get_name())
670 # clone self's entire series as unapplied patches
672 # allow cloning of branches not under StGIT control
673 applied = self.get_applied()
674 unapplied = self.get_unapplied()
675 patches = applied + unapplied
678 patches = applied = unapplied = []
680 patch = self.get_patch(p)
681 newpatch = new_series.new_patch(p, message = patch.get_description(),
682 can_edit = False, unapplied = True,
683 bottom = patch.get_bottom(),
684 top = patch.get_top(),
685 author_name = patch.get_authname(),
686 author_email = patch.get_authemail(),
687 author_date = patch.get_authdate())
689 out.info('Setting log to %s' % patch.get_log())
690 newpatch.set_log(patch.get_log())
692 out.info('No log for %s' % p)
694 # fast forward the cloned series to self's top
695 new_series.forward_patches(applied)
697 # Clone parent informations
698 value = config.get('branch.%s.remote' % self.get_name())
700 config.set('branch.%s.remote' % target_series, value)
702 value = config.get('branch.%s.merge' % self.get_name())
704 config.set('branch.%s.merge' % target_series, value)
706 value = config.get('branch.%s.stgit.parentbranch' % self.get_name())
708 config.set('branch.%s.stgit.parentbranch' % target_series, value)
710 def delete(self, force = False):
711 """Deletes an stgit series
713 if self.is_initialised():
714 patches = self.get_unapplied() + self.get_applied()
715 if not force and patches:
716 raise StackException, \
717 'Cannot delete: the series still contains patches'
719 self.get_patch(p).delete()
721 # remove the trash directory if any
722 if os.path.exists(self.__trash_dir):
723 for fname in os.listdir(self.__trash_dir):
724 os.remove(os.path.join(self.__trash_dir, fname))
725 os.rmdir(self.__trash_dir)
727 # FIXME: find a way to get rid of those manual removals
728 # (move functionality to StgitObject ?)
729 if os.path.exists(self.__applied_file):
730 os.remove(self.__applied_file)
731 if os.path.exists(self.__unapplied_file):
732 os.remove(self.__unapplied_file)
733 if os.path.exists(self.__hidden_file):
734 os.remove(self.__hidden_file)
735 if os.path.exists(self._dir()+'/orig-base'):
736 os.remove(self._dir()+'/orig-base')
738 if not os.listdir(self.__patch_dir):
739 os.rmdir(self.__patch_dir)
741 out.warn('Patch directory %s is not empty' % self.__patch_dir)
744 os.removedirs(self._dir())
746 raise StackException('Series directory %s is not empty'
750 git.delete_branch(self.get_name())
752 out.warn('Could not delete branch "%s"' % self.get_name())
754 config.remove_section('branch.%s' % self.get_name())
755 config.remove_section('branch.%s.stgit' % self.get_name())
757 def refresh_patch(self, files = None, message = None, edit = False,
760 author_name = None, author_email = None,
762 committer_name = None, committer_email = None,
763 backup = False, sign_str = None, log = 'refresh',
764 notes = None, bottom = None):
765 """Generates a new commit for the topmost patch
767 patch = self.get_current_patch()
769 raise StackException, 'No patches applied'
771 descr = patch.get_description()
772 if not (message or descr):
778 # TODO: move this out of the stgit.stack module, it is really
779 # for higher level commands to handle the user interaction
780 if not message and edit:
781 descr = edit_file(self, descr.rstrip(), \
782 'Please edit the description for patch "%s" ' \
783 'above.' % patch.get_name(), show_patch)
786 author_name = patch.get_authname()
788 author_email = patch.get_authemail()
790 author_date = patch.get_authdate()
791 if not committer_name:
792 committer_name = patch.get_commname()
793 if not committer_email:
794 committer_email = patch.get_commemail()
796 descr = add_sign_line(descr, sign_str, committer_name, committer_email)
799 bottom = patch.get_bottom()
801 commit_id = git.commit(files = files,
802 message = descr, parents = [bottom],
803 cache_update = cache_update,
805 author_name = author_name,
806 author_email = author_email,
807 author_date = author_date,
808 committer_name = committer_name,
809 committer_email = committer_email)
811 patch.set_bottom(bottom, backup = backup)
812 patch.set_top(commit_id, backup = backup)
813 patch.set_description(descr)
814 patch.set_authname(author_name)
815 patch.set_authemail(author_email)
816 patch.set_authdate(author_date)
817 patch.set_commname(committer_name)
818 patch.set_commemail(committer_email)
821 self.log_patch(patch, log, notes)
825 def undo_refresh(self):
826 """Undo the patch boundaries changes caused by 'refresh'
828 name = self.get_current()
831 patch = self.get_patch(name)
832 old_bottom = patch.get_old_bottom()
833 old_top = patch.get_old_top()
835 # the bottom of the patch is not changed by refresh. If the
836 # old_bottom is different, there wasn't any previous 'refresh'
837 # command (probably only a 'push')
838 if old_bottom != patch.get_bottom() or old_top == patch.get_top():
839 raise StackException, 'No undo information available'
841 git.reset(tree_id = old_top, check_out = False)
842 if patch.restore_old_boundaries():
843 self.log_patch(patch, 'undo')
845 def new_patch(self, name, message = None, can_edit = True,
846 unapplied = False, show_patch = False,
847 top = None, bottom = None, commit = True,
848 author_name = None, author_email = None, author_date = None,
849 committer_name = None, committer_email = None,
850 before_existing = False, sign_str = None):
851 """Creates a new patch, either pointing to an existing commit object,
852 or by creating a new commit object.
855 assert commit or (top and bottom)
856 assert not before_existing or (top and bottom)
857 assert not (commit and before_existing)
858 assert (top and bottom) or (not top and not bottom)
859 assert not top or (bottom == git.get_commit(top).get_parent())
862 self.__patch_name_valid(name)
863 if self.patch_exists(name):
864 raise StackException, 'Patch "%s" already exists' % name
866 # TODO: move this out of the stgit.stack module, it is really
867 # for higher level commands to handle the user interaction
869 return add_sign_line(msg, sign_str,
870 committer_name or git.committer().name,
871 committer_email or git.committer().email)
872 if not message and can_edit:
875 'Please enter the description for the patch above.',
878 descr = sign(message)
880 head = git.get_head()
883 name = make_patch_name(descr, self.patch_exists)
885 patch = self.get_patch(name)
888 patch.set_description(descr)
889 patch.set_authname(author_name)
890 patch.set_authemail(author_email)
891 patch.set_authdate(author_date)
892 patch.set_commname(committer_name)
893 patch.set_commemail(committer_email)
896 insert_string(self.__applied_file, patch.get_name())
898 patches = [patch.get_name()] + self.get_unapplied()
899 write_strings(self.__unapplied_file, patches)
902 append_string(self.__applied_file, patch.get_name())
907 top_commit = git.get_commit(top)
910 top_commit = git.get_commit(head)
912 # create a commit for the patch (may be empty if top == bottom);
913 # only commit on top of the current branch
914 assert(unapplied or bottom == head)
915 commit_id = git.commit(message = descr, parents = [bottom],
916 cache_update = False,
917 tree_id = top_commit.get_tree(),
918 allowempty = True, set_head = set_head,
919 author_name = author_name,
920 author_email = author_email,
921 author_date = author_date,
922 committer_name = committer_name,
923 committer_email = committer_email)
924 # set the patch top to the new commit
925 patch.set_bottom(bottom)
926 patch.set_top(commit_id)
929 patch.set_bottom(bottom)
932 self.log_patch(patch, 'new')
936 def delete_patch(self, name):
939 self.__patch_name_valid(name)
940 patch = self.get_patch(name)
942 if self.__patch_is_current(patch):
944 elif self.patch_applied(name):
945 raise StackException, 'Cannot remove an applied patch, "%s", ' \
946 'which is not current' % name
947 elif not name in self.get_unapplied():
948 raise StackException, 'Unknown patch "%s"' % name
950 # save the commit id to a trash file
951 write_string(os.path.join(self.__trash_dir, name), patch.get_top())
955 unapplied = self.get_unapplied()
956 unapplied.remove(name)
957 write_strings(self.__unapplied_file, unapplied)
959 def forward_patches(self, names):
960 """Try to fast-forward an array of patches.
962 On return, patches in names[0:returned_value] have been pushed on the
963 stack. Apply the rest with push_patch
965 unapplied = self.get_unapplied()
971 assert(name in unapplied)
973 patch = self.get_patch(name)
976 bottom = patch.get_bottom()
977 top = patch.get_top()
979 # top != bottom always since we have a commit for each patch
981 # reset the backup information. No logging since the
982 # patch hasn't changed
983 patch.set_bottom(head, backup = True)
984 patch.set_top(top, backup = True)
987 head_tree = git.get_commit(head).get_tree()
988 bottom_tree = git.get_commit(bottom).get_tree()
989 if head_tree == bottom_tree:
990 # We must just reparent this patch and create a new commit
992 descr = patch.get_description()
993 author_name = patch.get_authname()
994 author_email = patch.get_authemail()
995 author_date = patch.get_authdate()
996 committer_name = patch.get_commname()
997 committer_email = patch.get_commemail()
999 top_tree = git.get_commit(top).get_tree()
1001 top = git.commit(message = descr, parents = [head],
1002 cache_update = False,
1005 author_name = author_name,
1006 author_email = author_email,
1007 author_date = author_date,
1008 committer_name = committer_name,
1009 committer_email = committer_email)
1011 patch.set_bottom(head, backup = True)
1012 patch.set_top(top, backup = True)
1014 self.log_patch(patch, 'push(f)')
1017 # stop the fast-forwarding, must do a real merge
1021 unapplied.remove(name)
1028 append_strings(self.__applied_file, names[0:forwarded])
1029 write_strings(self.__unapplied_file, unapplied)
1033 def merged_patches(self, names):
1034 """Test which patches were merged upstream by reverse-applying
1035 them in reverse order. The function returns the list of
1036 patches detected to have been applied. The state of the tree
1037 is restored to the original one
1039 patches = [self.get_patch(name) for name in names]
1044 if git.apply_diff(p.get_top(), p.get_bottom()):
1045 merged.append(p.get_name())
1052 def push_empty_patch(self, name):
1053 """Pushes an empty patch on the stack
1055 unapplied = self.get_unapplied()
1056 assert(name in unapplied)
1058 # patch = self.get_patch(name)
1059 head = git.get_head()
1061 append_string(self.__applied_file, name)
1063 unapplied.remove(name)
1064 write_strings(self.__unapplied_file, unapplied)
1066 self.refresh_patch(bottom = head, cache_update = False, log = 'push(m)')
1068 def push_patch(self, name):
1069 """Pushes a patch on the stack
1071 unapplied = self.get_unapplied()
1072 assert(name in unapplied)
1074 patch = self.get_patch(name)
1076 head = git.get_head()
1077 bottom = patch.get_bottom()
1078 top = patch.get_top()
1079 # top != bottom always since we have a commit for each patch
1082 # A fast-forward push. Just reset the backup
1083 # information. No need for logging
1084 patch.set_bottom(bottom, backup = True)
1085 patch.set_top(top, backup = True)
1088 append_string(self.__applied_file, name)
1090 unapplied.remove(name)
1091 write_strings(self.__unapplied_file, unapplied)
1094 # Need to create a new commit an merge in the old patch
1098 # Try the fast applying first. If this fails, fall back to the
1100 if not git.apply_diff(bottom, top):
1101 # if git.apply_diff() fails, the patch requires a diff3
1102 # merge and can be reported as modified
1105 # merge can fail but the patch needs to be pushed
1107 git.merge(bottom, head, top, recursive = True)
1108 except git.GitException, ex:
1109 out.error('The merge failed during "push".',
1110 'Use "refresh" after fixing the conflicts or'
1111 ' revert the operation with "push --undo".')
1113 append_string(self.__applied_file, name)
1115 unapplied.remove(name)
1116 write_strings(self.__unapplied_file, unapplied)
1119 # if the merge was OK and no conflicts, just refresh the patch
1120 # The GIT cache was already updated by the merge operation
1125 self.refresh_patch(bottom = head, cache_update = False, log = log)
1127 # we store the correctly merged files only for
1128 # tracking the conflict history. Note that the
1129 # git.merge() operations should always leave the index
1130 # in a valid state (i.e. only stage 0 files)
1131 self.refresh_patch(bottom = head, cache_update = False,
1133 raise StackException, str(ex)
1137 def undo_push(self):
1138 name = self.get_current()
1141 patch = self.get_patch(name)
1142 old_bottom = patch.get_old_bottom()
1143 old_top = patch.get_old_top()
1145 # the top of the patch is changed by a push operation only
1146 # together with the bottom (otherwise the top was probably
1147 # modified by 'refresh'). If they are both unchanged, there
1148 # was a fast forward
1149 if old_bottom == patch.get_bottom() and old_top != patch.get_top():
1150 raise StackException, 'No undo information available'
1153 self.pop_patch(name)
1154 ret = patch.restore_old_boundaries()
1156 self.log_patch(patch, 'undo')
1160 def pop_patch(self, name, keep = False):
1161 """Pops the top patch from the stack
1163 applied = self.get_applied()
1165 assert(name in applied)
1167 patch = self.get_patch(name)
1169 if git.get_head_file() == self.get_name():
1170 if keep and not git.apply_diff(git.get_head(), patch.get_bottom()):
1171 raise StackException(
1172 'Failed to pop patches while preserving the local changes')
1173 git.switch(patch.get_bottom(), keep)
1175 git.set_branch(self.get_name(), patch.get_bottom())
1177 # save the new applied list
1178 idx = applied.index(name) + 1
1180 popped = applied[:idx]
1182 unapplied = popped + self.get_unapplied()
1183 write_strings(self.__unapplied_file, unapplied)
1187 write_strings(self.__applied_file, applied)
1189 def empty_patch(self, name):
1190 """Returns True if the patch is empty
1192 self.__patch_name_valid(name)
1193 patch = self.get_patch(name)
1194 bottom = patch.get_bottom()
1195 top = patch.get_top()
1199 elif git.get_commit(top).get_tree() \
1200 == git.get_commit(bottom).get_tree():
1205 def rename_patch(self, oldname, newname):
1206 self.__patch_name_valid(newname)
1208 applied = self.get_applied()
1209 unapplied = self.get_unapplied()
1211 if oldname == newname:
1212 raise StackException, '"To" name and "from" name are the same'
1214 if newname in applied or newname in unapplied:
1215 raise StackException, 'Patch "%s" already exists' % newname
1217 if oldname in unapplied:
1218 self.get_patch(oldname).rename(newname)
1219 unapplied[unapplied.index(oldname)] = newname
1220 write_strings(self.__unapplied_file, unapplied)
1221 elif oldname in applied:
1222 self.get_patch(oldname).rename(newname)
1224 applied[applied.index(oldname)] = newname
1225 write_strings(self.__applied_file, applied)
1227 raise StackException, 'Unknown patch "%s"' % oldname
1229 def log_patch(self, patch, message, notes = None):
1230 """Generate a log commit for a patch
1232 top = git.get_commit(patch.get_top())
1233 old_log = patch.get_log()
1236 # replace the current log entry
1238 raise StackException, \
1239 'No log entry to annotate for patch "%s"' \
1242 log_commit = git.get_commit(old_log)
1243 msg = log_commit.get_log().split('\n')[0]
1244 log_parent = log_commit.get_parent()
1246 parents = [log_parent]
1250 # generate a new log entry
1252 msg = '%s\t%s' % (message, top.get_id_hash())
1259 msg += '\n\n' + notes
1261 log = git.commit(message = msg, parents = parents,
1262 cache_update = False, tree_id = top.get_tree(),
1266 def hide_patch(self, name):
1267 """Add the patch to the hidden list.
1269 unapplied = self.get_unapplied()
1270 if name not in unapplied:
1271 # keep the checking order for backward compatibility with
1272 # the old hidden patches functionality
1273 if self.patch_applied(name):
1274 raise StackException, 'Cannot hide applied patch "%s"' % name
1275 elif self.patch_hidden(name):
1276 raise StackException, 'Patch "%s" already hidden' % name
1278 raise StackException, 'Unknown patch "%s"' % name
1280 if not self.patch_hidden(name):
1281 # check needed for backward compatibility with the old
1282 # hidden patches functionality
1283 append_string(self.__hidden_file, name)
1285 unapplied.remove(name)
1286 write_strings(self.__unapplied_file, unapplied)
1288 def unhide_patch(self, name):
1289 """Remove the patch from the hidden list.
1291 hidden = self.get_hidden()
1292 if not name in hidden:
1293 if self.patch_applied(name) or self.patch_unapplied(name):
1294 raise StackException, 'Patch "%s" not hidden' % name
1296 raise StackException, 'Unknown patch "%s"' % name
1299 write_strings(self.__hidden_file, hidden)
1301 if not self.patch_applied(name) and not self.patch_unapplied(name):
1302 # check needed for backward compatibility with the old
1303 # hidden patches functionality
1304 append_string(self.__unapplied_file, name)