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
23 from stgit.utils import *
24 from stgit import git, basedir, templates
25 from stgit.config import config
28 # stack exception class
29 class StackException(Exception):
34 self.should_print = True
35 def __call__(self, x, until_test, prefix):
37 self.should_print = False
39 return x[0:len(prefix)] != prefix
45 __comment_prefix = 'STG:'
46 __patch_prefix = 'STG_PATCH:'
48 def __clean_comments(f):
49 """Removes lines marked for status in a commit file
53 # remove status-prefixed lines
56 patch_filter = FilterUntil()
57 until_test = lambda t: t == (__patch_prefix + '\n')
58 lines = [l for l in lines if patch_filter(l, until_test, __comment_prefix)]
60 # remove empty lines at the end
61 while len(lines) != 0 and lines[-1] == '\n':
64 f.seek(0); f.truncate()
67 def edit_file(series, line, comment, show_patch = True):
68 fname = '.stgitmsg.txt'
69 tmpl = templates.get_template('patchdescr.tmpl')
78 print >> f, __comment_prefix, comment
79 print >> f, __comment_prefix, \
80 'Lines prefixed with "%s" will be automatically removed.' \
82 print >> f, __comment_prefix, \
83 'Trailing empty lines will be automatically removed.'
86 print >> f, __patch_prefix
87 # series.get_patch(series.get_current()).get_top()
88 git.diff([], series.get_patch(series.get_current()).get_bottom(), None, f)
90 #Vim modeline must be near the end.
91 print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:'
112 """An object with stgit-like properties stored as files in a directory
114 def _set_dir(self, dir):
119 def create_empty_field(self, name):
120 create_empty_file(os.path.join(self.__dir, name))
122 def _get_field(self, name, multiline = False):
123 id_file = os.path.join(self.__dir, name)
124 if os.path.isfile(id_file):
125 line = read_string(id_file, multiline)
133 def _set_field(self, name, value, multiline = False):
134 fname = os.path.join(self.__dir, name)
135 if value and value != '':
136 write_string(fname, value, multiline)
137 elif os.path.isfile(fname):
141 class Patch(StgitObject):
142 """Basic patch implementation
144 def __init__(self, name, series_dir, refs_dir):
145 self.__series_dir = series_dir
147 self._set_dir(os.path.join(self.__series_dir, self.__name))
148 self.__refs_dir = refs_dir
149 self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
150 self.__log_ref_file = os.path.join(self.__refs_dir,
151 self.__name + '.log')
154 os.mkdir(self._dir())
155 self.create_empty_field('bottom')
156 self.create_empty_field('top')
159 for f in os.listdir(self._dir()):
160 os.remove(os.path.join(self._dir(), f))
161 os.rmdir(self._dir())
162 os.remove(self.__top_ref_file)
163 if os.path.exists(self.__log_ref_file):
164 os.remove(self.__log_ref_file)
169 def rename(self, newname):
171 old_top_ref_file = self.__top_ref_file
172 old_log_ref_file = self.__log_ref_file
173 self.__name = newname
174 self._set_dir(os.path.join(self.__series_dir, self.__name))
175 self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
176 self.__log_ref_file = os.path.join(self.__refs_dir,
177 self.__name + '.log')
179 os.rename(olddir, self._dir())
180 os.rename(old_top_ref_file, self.__top_ref_file)
181 if os.path.exists(old_log_ref_file):
182 os.rename(old_log_ref_file, self.__log_ref_file)
184 def __update_top_ref(self, ref):
185 write_string(self.__top_ref_file, ref)
187 def __update_log_ref(self, ref):
188 write_string(self.__log_ref_file, ref)
190 def update_top_ref(self):
193 self.__update_top_ref(top)
195 def get_old_bottom(self):
196 return self._get_field('bottom.old')
198 def get_bottom(self):
199 return self._get_field('bottom')
201 def set_bottom(self, value, backup = False):
203 curr = self._get_field('bottom')
204 self._set_field('bottom.old', curr)
205 self._set_field('bottom', value)
207 def get_old_top(self):
208 return self._get_field('top.old')
211 return self._get_field('top')
213 def set_top(self, value, backup = False):
215 curr = self._get_field('top')
216 self._set_field('top.old', curr)
217 self._set_field('top', value)
218 self.__update_top_ref(value)
220 def restore_old_boundaries(self):
221 bottom = self._get_field('bottom.old')
222 top = self._get_field('top.old')
225 self._set_field('bottom', bottom)
226 self._set_field('top', top)
227 self.__update_top_ref(top)
232 def get_description(self):
233 return self._get_field('description', True)
235 def set_description(self, line):
236 self._set_field('description', line, True)
238 def get_authname(self):
239 return self._get_field('authname')
241 def set_authname(self, name):
242 self._set_field('authname', name or git.author().name)
244 def get_authemail(self):
245 return self._get_field('authemail')
247 def set_authemail(self, email):
248 self._set_field('authemail', email or git.author().email)
250 def get_authdate(self):
251 return self._get_field('authdate')
253 def set_authdate(self, date):
254 self._set_field('authdate', date or git.author().date)
256 def get_commname(self):
257 return self._get_field('commname')
259 def set_commname(self, name):
260 self._set_field('commname', name or git.committer().name)
262 def get_commemail(self):
263 return self._get_field('commemail')
265 def set_commemail(self, email):
266 self._set_field('commemail', email or git.committer().email)
269 return self._get_field('log')
271 def set_log(self, value, backup = False):
272 self._set_field('log', value)
273 self.__update_log_ref(value)
276 class Series(StgitObject):
277 """Class including the operations on series
279 def __init__(self, name = None):
280 """Takes a series name as the parameter.
286 self.__name = git.get_head_file()
287 self.__base_dir = basedir.get()
288 except git.GitException, ex:
289 raise StackException, 'GIT tree not initialised: %s' % ex
291 self._set_dir(os.path.join(self.__base_dir, 'patches', self.__name))
292 self.__refs_dir = os.path.join(self.__base_dir, 'refs', 'patches',
294 self.__base_file = os.path.join(self.__base_dir, 'refs', 'bases',
297 self.__applied_file = os.path.join(self._dir(), 'applied')
298 self.__unapplied_file = os.path.join(self._dir(), 'unapplied')
299 self.__hidden_file = os.path.join(self._dir(), 'hidden')
300 self.__current_file = os.path.join(self._dir(), 'current')
301 self.__descr_file = os.path.join(self._dir(), 'description')
303 # where this series keeps its patches
304 self.__patch_dir = os.path.join(self._dir(), 'patches')
305 if not os.path.isdir(self.__patch_dir):
306 self.__patch_dir = self._dir()
308 # if no __refs_dir, create and populate it (upgrade old repositories)
309 if self.is_initialised() and not os.path.isdir(self.__refs_dir):
310 os.makedirs(self.__refs_dir)
311 for patch in self.get_applied() + self.get_unapplied():
312 self.get_patch(patch).update_top_ref()
315 self.__trash_dir = os.path.join(self._dir(), 'trash')
316 if self.is_initialised() and not os.path.isdir(self.__trash_dir):
317 os.makedirs(self.__trash_dir)
319 def __patch_name_valid(self, name):
320 """Raise an exception if the patch name is not valid.
322 if not name or re.search('[^\w.-]', name):
323 raise StackException, 'Invalid patch name: "%s"' % name
325 def get_branch(self):
326 """Return the branch name for the Series object
330 def __set_current(self, name):
331 """Sets the topmost patch
333 self._set_field('current', name)
335 def get_patch(self, name):
336 """Return a Patch object for the given name
338 return Patch(name, self.__patch_dir, self.__refs_dir)
340 def get_current_patch(self):
341 """Return a Patch object representing the topmost patch, or
342 None if there is no such patch."""
343 crt = self.get_current()
346 return Patch(crt, self.__patch_dir, self.__refs_dir)
348 def get_current(self):
349 """Return the name of the topmost patch, or None if there is
351 name = self._get_field('current')
357 def get_applied(self):
358 if not os.path.isfile(self.__applied_file):
359 raise StackException, 'Branch "%s" not initialised' % self.__name
360 f = file(self.__applied_file)
361 names = [line.strip() for line in f.readlines()]
365 def get_unapplied(self):
366 if not os.path.isfile(self.__unapplied_file):
367 raise StackException, 'Branch "%s" not initialised' % self.__name
368 f = file(self.__unapplied_file)
369 names = [line.strip() for line in f.readlines()]
373 def get_hidden(self):
374 if not os.path.isfile(self.__hidden_file):
376 f = file(self.__hidden_file)
377 names = [line.strip() for line in f.readlines()]
381 def get_base_file(self):
382 self.__begin_stack_check()
383 return self.__base_file
386 return read_string(self.get_base_file())
389 """Return the head of the branch
391 crt = self.get_current_patch()
395 return self.get_base()
397 def get_protected(self):
398 return os.path.isfile(os.path.join(self._dir(), 'protected'))
401 protect_file = os.path.join(self._dir(), 'protected')
402 if not os.path.isfile(protect_file):
403 create_empty_file(protect_file)
406 protect_file = os.path.join(self._dir(), 'protected')
407 if os.path.isfile(protect_file):
408 os.remove(protect_file)
410 def get_description(self):
411 return self._get_field('description') or ''
413 def set_description(self, line):
414 self._set_field('description', line)
416 def get_parent_remote(self):
417 value = config.get('branch.%s.remote' % self.__name)
420 elif 'origin' in git.remotes_list():
421 print 'Notice: no parent remote declared for stack "%s", ' \
422 'defaulting to "origin". Consider setting "branch.%s.remote" ' \
423 'and "branch.%s.merge" with "git repo-config".' \
424 % (self.__name, self.__name, self.__name)
427 raise StackException, 'Cannot find a parent remote for "%s"' % self.__name
429 def __set_parent_remote(self, remote):
430 value = config.set('branch.%s.remote' % self.__name, remote)
432 def get_parent_branch(self):
433 value = config.get('branch.%s.stgit.parentbranch' % self.__name)
436 elif git.rev_parse('heads/origin'):
437 print 'Notice: no parent branch declared for stack "%s", ' \
438 'defaulting to "heads/origin". Consider setting ' \
439 '"branch.%s.stgit.parentbranch" with "git repo-config".' \
440 % (self.__name, self.__name)
441 return 'heads/origin'
443 raise StackException, 'Cannot find a parent branch for "%s"' % self.__name
445 def __set_parent_branch(self, name):
446 if config.get('branch.%s.remote' % self.__name):
447 # Never set merge if remote is not set to avoid
448 # possibly-erroneous lookups into 'origin'
449 config.set('branch.%s.merge' % self.__name, name)
450 config.set('branch.%s.stgit.parentbranch' % self.__name, name)
452 def set_parent(self, remote, localbranch):
453 # policy: record local branches as remote='.'
454 recordremote = remote or '.'
456 self.__set_parent_remote(recordremote)
457 self.__set_parent_branch(localbranch)
458 # We'll enforce this later
460 # raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.__name
462 def __patch_is_current(self, patch):
463 return patch.get_name() == self.get_current()
465 def patch_applied(self, name):
466 """Return true if the patch exists in the applied list
468 return name in self.get_applied()
470 def patch_unapplied(self, name):
471 """Return true if the patch exists in the unapplied list
473 return name in self.get_unapplied()
475 def patch_hidden(self, name):
476 """Return true if the patch is hidden.
478 return name in self.get_hidden()
480 def patch_exists(self, name):
481 """Return true if there is a patch with the given name, false
483 return self.patch_applied(name) or self.patch_unapplied(name)
485 def __begin_stack_check(self):
486 """Save the current HEAD into .git/refs/heads/base if the stack
489 if len(self.get_applied()) == 0:
490 head = git.get_head()
491 write_string(self.__base_file, head)
493 def __end_stack_check(self):
494 """Remove .git/refs/heads/base if the stack is empty.
495 This warning should never happen
497 if len(self.get_applied()) == 0 \
498 and read_string(self.__base_file) != git.get_head():
499 print 'Warning: stack empty but the HEAD and base are different'
501 def head_top_equal(self):
502 """Return true if the head and the top are the same
504 crt = self.get_current_patch()
506 # we don't care, no patches applied
508 return git.get_head() == crt.get_top()
510 def is_initialised(self):
511 """Checks if series is already initialised
513 return os.path.isdir(self.__patch_dir)
515 def init(self, create_at=False, parent_remote=None, parent_branch=None):
516 """Initialises the stgit series
518 if os.path.exists(self.__patch_dir):
519 raise StackException, self.__patch_dir + ' already exists'
520 if os.path.exists(self.__refs_dir):
521 raise StackException, self.__refs_dir + ' already exists'
522 if os.path.exists(self.__base_file):
523 raise StackException, self.__base_file + ' already exists'
525 if (create_at!=False):
526 git.create_branch(self.__name, create_at)
528 os.makedirs(self.__patch_dir)
530 self.set_parent(parent_remote, parent_branch)
532 create_dirs(os.path.join(self.__base_dir, 'refs', 'bases'))
534 self.create_empty_field('applied')
535 self.create_empty_field('unapplied')
536 self.create_empty_field('description')
537 os.makedirs(os.path.join(self._dir(), 'patches'))
538 os.makedirs(self.__refs_dir)
539 self.__begin_stack_check()
540 self._set_field('orig-base', git.get_head())
543 """Either convert to use a separate patch directory, or
544 unconvert to place the patches in the same directory with
547 if self.__patch_dir == self._dir():
548 print 'Converting old-style to new-style...',
551 self.__patch_dir = os.path.join(self._dir(), 'patches')
552 os.makedirs(self.__patch_dir)
554 for p in self.get_applied() + self.get_unapplied():
555 src = os.path.join(self._dir(), p)
556 dest = os.path.join(self.__patch_dir, p)
562 print 'Converting new-style to old-style...',
565 for p in self.get_applied() + self.get_unapplied():
566 src = os.path.join(self.__patch_dir, p)
567 dest = os.path.join(self._dir(), p)
570 if not os.listdir(self.__patch_dir):
571 os.rmdir(self.__patch_dir)
574 print 'Patch directory %s is not empty.' % self.__name
576 self.__patch_dir = self._dir()
578 def rename(self, to_name):
581 to_stack = Series(to_name)
583 if to_stack.is_initialised():
584 raise StackException, '"%s" already exists' % to_stack.get_branch()
585 if os.path.exists(to_stack.__base_file):
586 os.remove(to_stack.__base_file)
588 git.rename_branch(self.__name, to_name)
590 if os.path.isdir(self._dir()):
591 rename(os.path.join(self.__base_dir, 'patches'),
592 self.__name, to_stack.__name)
593 if os.path.exists(self.__base_file):
594 rename(os.path.join(self.__base_dir, 'refs', 'bases'),
595 self.__name, to_stack.__name)
596 if os.path.exists(self.__refs_dir):
597 rename(os.path.join(self.__base_dir, 'refs', 'patches'),
598 self.__name, to_stack.__name)
600 # Rename the config section
601 config.rename_section("branch.%s" % self.__name,
602 "branch.%s" % to_name)
604 self.__init__(to_name)
606 def clone(self, target_series):
610 # allow cloning of branches not under StGIT control
611 base = self.get_base()
613 base = git.get_head()
614 Series(target_series).init(create_at = base)
615 new_series = Series(target_series)
617 # generate an artificial description file
618 new_series.set_description('clone of "%s"' % self.__name)
620 # clone self's entire series as unapplied patches
622 # allow cloning of branches not under StGIT control
623 applied = self.get_applied()
624 unapplied = self.get_unapplied()
625 patches = applied + unapplied
628 patches = applied = unapplied = []
630 patch = self.get_patch(p)
631 new_series.new_patch(p, message = patch.get_description(),
632 can_edit = False, unapplied = True,
633 bottom = patch.get_bottom(),
634 top = patch.get_top(),
635 author_name = patch.get_authname(),
636 author_email = patch.get_authemail(),
637 author_date = patch.get_authdate())
639 # fast forward the cloned series to self's top
640 new_series.forward_patches(applied)
642 # Clone remote and merge settings
643 value = config.get('branch.%s.remote' % self.__name)
645 config.set('branch.%s.remote' % target_series, value)
647 value = config.get('branch.%s.merge' % self.__name)
649 config.set('branch.%s.merge' % target_series, value)
651 def delete(self, force = False):
652 """Deletes an stgit series
654 if self.is_initialised():
655 patches = self.get_unapplied() + self.get_applied()
656 if not force and patches:
657 raise StackException, \
658 'Cannot delete: the series still contains patches'
660 Patch(p, self.__patch_dir, self.__refs_dir).delete()
662 # remove the trash directory
663 for fname in os.listdir(self.__trash_dir):
665 os.rmdir(self.__trash_dir)
667 # FIXME: find a way to get rid of those manual removals
668 # (move functionality to StgitObject ?)
669 if os.path.exists(self.__applied_file):
670 os.remove(self.__applied_file)
671 if os.path.exists(self.__unapplied_file):
672 os.remove(self.__unapplied_file)
673 if os.path.exists(self.__hidden_file):
674 os.remove(self.__hidden_file)
675 if os.path.exists(self.__current_file):
676 os.remove(self.__current_file)
677 if os.path.exists(self.__descr_file):
678 os.remove(self.__descr_file)
679 if os.path.exists(self._dir()+'/orig-base'):
680 os.remove(self._dir()+'/orig-base')
681 if not os.listdir(self.__patch_dir):
682 os.rmdir(self.__patch_dir)
684 print 'Patch directory %s is not empty.' % self.__name
685 if not os.listdir(self._dir()):
686 remove_dirs(os.path.join(self.__base_dir, 'patches'),
689 print 'Series directory %s is not empty.' % self.__name
690 if not os.listdir(self.__refs_dir):
691 remove_dirs(os.path.join(self.__base_dir, 'refs', 'patches'),
694 print 'Refs directory %s is not empty.' % self.__refs_dir
696 if os.path.exists(self.__base_file):
697 remove_file_and_dirs(
698 os.path.join(self.__base_dir, 'refs', 'bases'), self.__name)
700 def refresh_patch(self, files = None, message = None, edit = False,
703 author_name = None, author_email = None,
705 committer_name = None, committer_email = None,
706 backup = False, sign_str = None, log = 'refresh'):
707 """Generates a new commit for the given patch
709 name = self.get_current()
711 raise StackException, 'No patches applied'
713 patch = Patch(name, self.__patch_dir, self.__refs_dir)
715 descr = patch.get_description()
716 if not (message or descr):
722 if not message and edit:
723 descr = edit_file(self, descr.rstrip(), \
724 'Please edit the description for patch "%s" ' \
725 'above.' % name, show_patch)
728 author_name = patch.get_authname()
730 author_email = patch.get_authemail()
732 author_date = patch.get_authdate()
733 if not committer_name:
734 committer_name = patch.get_commname()
735 if not committer_email:
736 committer_email = patch.get_commemail()
739 descr = descr.rstrip()
740 if descr.find("\nSigned-off-by:") < 0 \
741 and descr.find("\nAcked-by:") < 0:
744 descr = '%s\n%s: %s <%s>\n' % (descr, sign_str,
745 committer_name, committer_email)
747 bottom = patch.get_bottom()
749 commit_id = git.commit(files = files,
750 message = descr, parents = [bottom],
751 cache_update = cache_update,
753 author_name = author_name,
754 author_email = author_email,
755 author_date = author_date,
756 committer_name = committer_name,
757 committer_email = committer_email)
759 patch.set_bottom(bottom, backup = backup)
760 patch.set_top(commit_id, backup = backup)
761 patch.set_description(descr)
762 patch.set_authname(author_name)
763 patch.set_authemail(author_email)
764 patch.set_authdate(author_date)
765 patch.set_commname(committer_name)
766 patch.set_commemail(committer_email)
769 self.log_patch(patch, log)
773 def undo_refresh(self):
774 """Undo the patch boundaries changes caused by 'refresh'
776 name = self.get_current()
779 patch = Patch(name, self.__patch_dir, self.__refs_dir)
780 old_bottom = patch.get_old_bottom()
781 old_top = patch.get_old_top()
783 # the bottom of the patch is not changed by refresh. If the
784 # old_bottom is different, there wasn't any previous 'refresh'
785 # command (probably only a 'push')
786 if old_bottom != patch.get_bottom() or old_top == patch.get_top():
787 raise StackException, 'No undo information available'
789 git.reset(tree_id = old_top, check_out = False)
790 if patch.restore_old_boundaries():
791 self.log_patch(patch, 'undo')
793 def new_patch(self, name, message = None, can_edit = True,
794 unapplied = False, show_patch = False,
795 top = None, bottom = None,
796 author_name = None, author_email = None, author_date = None,
797 committer_name = None, committer_email = None,
798 before_existing = False, refresh = True):
799 """Creates a new patch
801 self.__patch_name_valid(name)
803 if self.patch_applied(name) or self.patch_unapplied(name):
804 raise StackException, 'Patch "%s" already exists' % name
806 if not message and can_edit:
807 descr = edit_file(self, None, \
808 'Please enter the description for patch "%s" ' \
809 'above.' % name, show_patch)
813 head = git.get_head()
815 self.__begin_stack_check()
817 patch = Patch(name, self.__patch_dir, self.__refs_dir)
821 patch.set_bottom(bottom)
823 patch.set_bottom(head)
829 patch.set_description(descr)
830 patch.set_authname(author_name)
831 patch.set_authemail(author_email)
832 patch.set_authdate(author_date)
833 patch.set_commname(committer_name)
834 patch.set_commemail(committer_email)
837 self.log_patch(patch, 'new')
839 patches = [patch.get_name()] + self.get_unapplied()
841 f = file(self.__unapplied_file, 'w+')
842 f.writelines([line + '\n' for line in patches])
844 elif before_existing:
845 self.log_patch(patch, 'new')
847 insert_string(self.__applied_file, patch.get_name())
848 if not self.get_current():
849 self.__set_current(name)
851 append_string(self.__applied_file, patch.get_name())
852 self.__set_current(name)
854 self.refresh_patch(cache_update = False, log = 'new')
856 def delete_patch(self, name):
859 self.__patch_name_valid(name)
860 patch = Patch(name, self.__patch_dir, self.__refs_dir)
862 if self.__patch_is_current(patch):
864 elif self.patch_applied(name):
865 raise StackException, 'Cannot remove an applied patch, "%s", ' \
866 'which is not current' % name
867 elif not name in self.get_unapplied():
868 raise StackException, 'Unknown patch "%s"' % name
870 # save the commit id to a trash file
871 write_string(os.path.join(self.__trash_dir, name), patch.get_top())
875 unapplied = self.get_unapplied()
876 unapplied.remove(name)
877 f = file(self.__unapplied_file, 'w+')
878 f.writelines([line + '\n' for line in unapplied])
881 if self.patch_hidden(name):
882 self.unhide_patch(name)
884 self.__begin_stack_check()
886 def forward_patches(self, names):
887 """Try to fast-forward an array of patches.
889 On return, patches in names[0:returned_value] have been pushed on the
890 stack. Apply the rest with push_patch
892 unapplied = self.get_unapplied()
893 self.__begin_stack_check()
899 assert(name in unapplied)
901 patch = Patch(name, self.__patch_dir, self.__refs_dir)
904 bottom = patch.get_bottom()
905 top = patch.get_top()
907 # top != bottom always since we have a commit for each patch
909 # reset the backup information. No logging since the
910 # patch hasn't changed
911 patch.set_bottom(head, backup = True)
912 patch.set_top(top, backup = True)
915 head_tree = git.get_commit(head).get_tree()
916 bottom_tree = git.get_commit(bottom).get_tree()
917 if head_tree == bottom_tree:
918 # We must just reparent this patch and create a new commit
920 descr = patch.get_description()
921 author_name = patch.get_authname()
922 author_email = patch.get_authemail()
923 author_date = patch.get_authdate()
924 committer_name = patch.get_commname()
925 committer_email = patch.get_commemail()
927 top_tree = git.get_commit(top).get_tree()
929 top = git.commit(message = descr, parents = [head],
930 cache_update = False,
933 author_name = author_name,
934 author_email = author_email,
935 author_date = author_date,
936 committer_name = committer_name,
937 committer_email = committer_email)
939 patch.set_bottom(head, backup = True)
940 patch.set_top(top, backup = True)
942 self.log_patch(patch, 'push(f)')
945 # stop the fast-forwarding, must do a real merge
949 unapplied.remove(name)
956 append_strings(self.__applied_file, names[0:forwarded])
958 f = file(self.__unapplied_file, 'w+')
959 f.writelines([line + '\n' for line in unapplied])
962 self.__set_current(name)
966 def merged_patches(self, names):
967 """Test which patches were merged upstream by reverse-applying
968 them in reverse order. The function returns the list of
969 patches detected to have been applied. The state of the tree
970 is restored to the original one
972 patches = [Patch(name, self.__patch_dir, self.__refs_dir)
978 if git.apply_diff(p.get_top(), p.get_bottom()):
979 merged.append(p.get_name())
986 def push_patch(self, name, empty = False):
987 """Pushes a patch on the stack
989 unapplied = self.get_unapplied()
990 assert(name in unapplied)
992 self.__begin_stack_check()
994 patch = Patch(name, self.__patch_dir, self.__refs_dir)
996 head = git.get_head()
997 bottom = patch.get_bottom()
998 top = patch.get_top()
1003 # top != bottom always since we have a commit for each patch
1005 # just make an empty patch (top = bottom = HEAD). This
1006 # option is useful to allow undoing already merged
1007 # patches. The top is updated by refresh_patch since we
1008 # need an empty commit
1009 patch.set_bottom(head, backup = True)
1010 patch.set_top(head, backup = True)
1012 elif head == bottom:
1013 # reset the backup information. No need for logging
1014 patch.set_bottom(bottom, backup = True)
1015 patch.set_top(top, backup = True)
1019 # new patch needs to be refreshed.
1020 # The current patch is empty after merge.
1021 patch.set_bottom(head, backup = True)
1022 patch.set_top(head, backup = True)
1024 # Try the fast applying first. If this fails, fall back to the
1026 if not git.apply_diff(bottom, top):
1027 # if git.apply_diff() fails, the patch requires a diff3
1028 # merge and can be reported as modified
1031 # merge can fail but the patch needs to be pushed
1033 git.merge(bottom, head, top, recursive = True)
1034 except git.GitException, ex:
1035 print >> sys.stderr, \
1036 'The merge failed during "push". ' \
1037 'Use "refresh" after fixing the conflicts'
1039 append_string(self.__applied_file, name)
1041 unapplied.remove(name)
1042 f = file(self.__unapplied_file, 'w+')
1043 f.writelines([line + '\n' for line in unapplied])
1046 self.__set_current(name)
1048 # head == bottom case doesn't need to refresh the patch
1049 if empty or head != bottom:
1051 # if the merge was OK and no conflicts, just refresh the patch
1052 # The GIT cache was already updated by the merge operation
1057 self.refresh_patch(cache_update = False, log = log)
1059 # we store the correctly merged files only for
1060 # tracking the conflict history. Note that the
1061 # git.merge() operations should always leave the index
1062 # in a valid state (i.e. only stage 0 files)
1063 self.refresh_patch(cache_update = False, log = 'push(c)')
1064 raise StackException, str(ex)
1068 def undo_push(self):
1069 name = self.get_current()
1072 patch = Patch(name, self.__patch_dir, self.__refs_dir)
1073 old_bottom = patch.get_old_bottom()
1074 old_top = patch.get_old_top()
1076 # the top of the patch is changed by a push operation only
1077 # together with the bottom (otherwise the top was probably
1078 # modified by 'refresh'). If they are both unchanged, there
1079 # was a fast forward
1080 if old_bottom == patch.get_bottom() and old_top != patch.get_top():
1081 raise StackException, 'No undo information available'
1084 self.pop_patch(name)
1085 ret = patch.restore_old_boundaries()
1087 self.log_patch(patch, 'undo')
1091 def pop_patch(self, name, keep = False):
1092 """Pops the top patch from the stack
1094 applied = self.get_applied()
1096 assert(name in applied)
1098 patch = Patch(name, self.__patch_dir, self.__refs_dir)
1100 # only keep the local changes
1101 if keep and not git.apply_diff(git.get_head(), patch.get_bottom()):
1102 raise StackException, \
1103 'Failed to pop patches while preserving the local changes'
1105 git.switch(patch.get_bottom(), keep)
1107 # save the new applied list
1108 idx = applied.index(name) + 1
1110 popped = applied[:idx]
1112 unapplied = popped + self.get_unapplied()
1114 f = file(self.__unapplied_file, 'w+')
1115 f.writelines([line + '\n' for line in unapplied])
1121 f = file(self.__applied_file, 'w+')
1122 f.writelines([line + '\n' for line in applied])
1126 self.__set_current(None)
1128 self.__set_current(applied[-1])
1130 self.__end_stack_check()
1132 def empty_patch(self, name):
1133 """Returns True if the patch is empty
1135 self.__patch_name_valid(name)
1136 patch = Patch(name, self.__patch_dir, self.__refs_dir)
1137 bottom = patch.get_bottom()
1138 top = patch.get_top()
1142 elif git.get_commit(top).get_tree() \
1143 == git.get_commit(bottom).get_tree():
1148 def rename_patch(self, oldname, newname):
1149 self.__patch_name_valid(newname)
1151 applied = self.get_applied()
1152 unapplied = self.get_unapplied()
1154 if oldname == newname:
1155 raise StackException, '"To" name and "from" name are the same'
1157 if newname in applied or newname in unapplied:
1158 raise StackException, 'Patch "%s" already exists' % newname
1160 if self.patch_hidden(oldname):
1161 self.unhide_patch(oldname)
1162 self.hide_patch(newname)
1164 if oldname in unapplied:
1165 Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1166 unapplied[unapplied.index(oldname)] = newname
1168 f = file(self.__unapplied_file, 'w+')
1169 f.writelines([line + '\n' for line in unapplied])
1171 elif oldname in applied:
1172 Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1173 if oldname == self.get_current():
1174 self.__set_current(newname)
1176 applied[applied.index(oldname)] = newname
1178 f = file(self.__applied_file, 'w+')
1179 f.writelines([line + '\n' for line in applied])
1182 raise StackException, 'Unknown patch "%s"' % oldname
1184 def log_patch(self, patch, message):
1185 """Generate a log commit for a patch
1187 top = git.get_commit(patch.get_top())
1188 msg = '%s\t%s' % (message, top.get_id_hash())
1190 old_log = patch.get_log()
1196 log = git.commit(message = msg, parents = parents,
1197 cache_update = False, tree_id = top.get_tree(),
1201 def hide_patch(self, name):
1202 """Add the patch to the hidden list.
1204 if not self.patch_exists(name):
1205 raise StackException, 'Unknown patch "%s"' % name
1206 elif self.patch_hidden(name):
1207 raise StackException, 'Patch "%s" already hidden' % name
1209 append_string(self.__hidden_file, name)
1211 def unhide_patch(self, name):
1212 """Add the patch to the hidden list.
1214 if not self.patch_exists(name):
1215 raise StackException, 'Unknown patch "%s"' % name
1216 hidden = self.get_hidden()
1217 if not name in hidden:
1218 raise StackException, 'Patch "%s" not hidden' % name
1222 f = file(self.__hidden_file, 'w+')
1223 f.writelines([line + '\n' for line in hidden])