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
.exception
import *
25 from stgit
.utils
import *
26 from stgit
.out
import *
27 from stgit
.run
import *
28 from stgit
import git
, basedir
, templates
29 from stgit
.config
import config
30 from shutil
import copyfile
33 # stack exception class
34 class StackException(StgException
):
39 self
.should_print
= True
40 def __call__(self
, x
, until_test
, prefix
):
42 self
.should_print
= False
44 return x
[0:len(prefix
)] != prefix
50 __comment_prefix
= 'STG:'
51 __patch_prefix
= 'STG_PATCH:'
53 def __clean_comments(f
):
54 """Removes lines marked for status in a commit file
58 # remove status-prefixed lines
61 patch_filter
= FilterUntil()
62 until_test
= lambda t
: t
== (__patch_prefix
+ '\n')
63 lines
= [l
for l
in lines
if patch_filter(l
, until_test
, __comment_prefix
)]
65 # remove empty lines at the end
66 while len(lines
) != 0 and lines
[-1] == '\n':
69 f
.seek(0); f
.truncate()
72 # TODO: move this out of the stgit.stack module, it is really for
73 # higher level commands to handle the user interaction
74 def edit_file(series
, line
, comment
, show_patch
= True):
75 fname
= '.stgitmsg.txt'
76 tmpl
= templates
.get_template('patchdescr.tmpl')
85 print >> f
, __comment_prefix
, comment
86 print >> f
, __comment_prefix
, \
87 'Lines prefixed with "%s" will be automatically removed.' \
89 print >> f
, __comment_prefix
, \
90 'Trailing empty lines will be automatically removed.'
93 print >> f
, __patch_prefix
94 # series.get_patch(series.get_current()).get_top()
95 diff_str
= git
.diff(rev1
= series
.get_patch(series
.get_current()).get_bottom())
98 #Vim modeline must be near the end.
99 print >> f
, __comment_prefix
, 'vi: set textwidth=75 filetype=diff nobackup:'
104 f
= file(fname
, 'r+')
120 """An object with stgit-like properties stored as files in a directory
122 def _set_dir(self
, dir):
127 def create_empty_field(self
, name
):
128 create_empty_file(os
.path
.join(self
.__dir
, name
))
130 def _get_field(self
, name
, multiline
= False):
131 id_file
= os
.path
.join(self
.__dir
, name
)
132 if os
.path
.isfile(id_file
):
133 line
= read_string(id_file
, multiline
)
141 def _set_field(self
, name
, value
, multiline
= False):
142 fname
= os
.path
.join(self
.__dir
, name
)
143 if value
and value
!= '':
144 write_string(fname
, value
, multiline
)
145 elif os
.path
.isfile(fname
):
149 class Patch(StgitObject
):
150 """Basic patch implementation
152 def __init_refs(self
):
153 self
.__top_ref
= self
.__refs_base
+ '/' + self
.__name
154 self
.__log_ref
= self
.__top_ref
+ '.log'
156 def __init__(self
, name
, series_dir
, refs_base
):
157 self
.__series_dir
= series_dir
159 self
._set_dir(os
.path
.join(self
.__series_dir
, self
.__name
))
160 self
.__refs_base
= refs_base
164 os
.mkdir(self
._dir())
165 self
.create_empty_field('bottom')
166 self
.create_empty_field('top')
169 for f
in os
.listdir(self
._dir()):
170 os
.remove(os
.path
.join(self
._dir(), f
))
171 os
.rmdir(self
._dir())
172 git
.delete_ref(self
.__top_ref
)
173 if git
.ref_exists(self
.__log_ref
):
174 git
.delete_ref(self
.__log_ref
)
179 def rename(self
, newname
):
181 old_top_ref
= self
.__top_ref
182 old_log_ref
= self
.__log_ref
183 self
.__name
= newname
184 self
._set_dir(os
.path
.join(self
.__series_dir
, self
.__name
))
187 git
.rename_ref(old_top_ref
, self
.__top_ref
)
188 if git
.ref_exists(old_log_ref
):
189 git
.rename_ref(old_log_ref
, self
.__log_ref
)
190 os
.rename(olddir
, self
._dir())
192 def __update_top_ref(self
, ref
):
193 git
.set_ref(self
.__top_ref
, ref
)
195 def __update_log_ref(self
, ref
):
196 git
.set_ref(self
.__log_ref
, ref
)
198 def update_top_ref(self
):
201 self
.__update_top_ref(top
)
203 def get_old_bottom(self
):
204 return self
._get_field('bottom.old')
206 def get_bottom(self
):
207 return self
._get_field('bottom')
209 def set_bottom(self
, value
, backup
= False):
211 curr
= self
._get_field('bottom')
212 self
._set_field('bottom.old', curr
)
213 self
._set_field('bottom', value
)
215 def get_old_top(self
):
216 return self
._get_field('top.old')
219 return self
._get_field('top')
221 def set_top(self
, value
, backup
= False):
223 curr
= self
._get_field('top')
224 self
._set_field('top.old', curr
)
225 self
._set_field('top', value
)
226 self
.__update_top_ref(value
)
228 def restore_old_boundaries(self
):
229 bottom
= self
._get_field('bottom.old')
230 top
= self
._get_field('top.old')
233 self
._set_field('bottom', bottom
)
234 self
._set_field('top', top
)
235 self
.__update_top_ref(top
)
240 def get_description(self
):
241 return self
._get_field('description', True)
243 def set_description(self
, line
):
244 self
._set_field('description', line
, True)
246 def get_authname(self
):
247 return self
._get_field('authname')
249 def set_authname(self
, name
):
250 self
._set_field('authname', name
or git
.author().name
)
252 def get_authemail(self
):
253 return self
._get_field('authemail')
255 def set_authemail(self
, email
):
256 self
._set_field('authemail', email
or git
.author().email
)
258 def get_authdate(self
):
259 date
= self
._get_field('authdate')
263 if re
.match('[0-9]+\s+[+-][0-9]+', date
):
264 # Unix time (seconds) + time zone
265 secs_tz
= date
.split()
266 date
= formatdate(int(secs_tz
[0]))[:-5] + secs_tz
[1]
270 def set_authdate(self
, date
):
271 self
._set_field('authdate', date
or git
.author().date
)
273 def get_commname(self
):
274 return self
._get_field('commname')
276 def set_commname(self
, name
):
277 self
._set_field('commname', name
or git
.committer().name
)
279 def get_commemail(self
):
280 return self
._get_field('commemail')
282 def set_commemail(self
, email
):
283 self
._set_field('commemail', email
or git
.committer().email
)
286 return self
._get_field('log')
288 def set_log(self
, value
, backup
= False):
289 self
._set_field('log', value
)
290 self
.__update_log_ref(value
)
292 # The current StGIT metadata format version.
295 class PatchSet(StgitObject
):
296 def __init__(self
, name
= None):
301 self
.set_name (git
.get_head_file())
302 self
.__base_dir
= basedir
.get()
303 except git
.GitException
, ex
:
304 raise StackException
, 'GIT tree not initialised: %s' % ex
306 self
._set_dir(os
.path
.join(self
.__base_dir
, 'patches', self
.get_name()))
310 def set_name(self
, name
):
314 return self
.__base_dir
317 """Return the head of the branch
319 crt
= self
.get_current_patch()
323 return self
.get_base()
325 def get_protected(self
):
326 return os
.path
.isfile(os
.path
.join(self
._dir(), 'protected'))
329 protect_file
= os
.path
.join(self
._dir(), 'protected')
330 if not os
.path
.isfile(protect_file
):
331 create_empty_file(protect_file
)
334 protect_file
= os
.path
.join(self
._dir(), 'protected')
335 if os
.path
.isfile(protect_file
):
336 os
.remove(protect_file
)
338 def __branch_descr(self
):
339 return 'branch.%s.description' % self
.get_name()
341 def get_description(self
):
342 return config
.get(self
.__branch_descr()) or ''
344 def set_description(self
, line
):
346 config
.set(self
.__branch_descr(), line
)
348 config
.unset(self
.__branch_descr())
350 def head_top_equal(self
):
351 """Return true if the head and the top are the same
353 crt
= self
.get_current_patch()
355 # we don't care, no patches applied
357 return git
.get_head() == crt
.get_top()
359 def is_initialised(self
):
360 """Checks if series is already initialised
362 return bool(config
.get(self
.format_version_key()))
365 def shortlog(patches
):
366 log
= ''.join(Run('git-log', '--pretty=short',
367 p
.get_top(), '^%s' % p
.get_bottom()).raw_output()
369 return Run('git-shortlog').raw_input(log
).raw_output()
371 class Series(PatchSet
):
372 """Class including the operations on series
374 def __init__(self
, name
= None):
375 """Takes a series name as the parameter.
377 PatchSet
.__init__(self
, name
)
379 # Update the branch to the latest format version if it is
380 # initialized, but don't touch it if it isn't.
381 self
.update_to_current_format_version()
383 self
.__refs_base
= 'refs/patches/%s' % self
.get_name()
385 self
.__applied_file
= os
.path
.join(self
._dir(), 'applied')
386 self
.__unapplied_file
= os
.path
.join(self
._dir(), 'unapplied')
387 self
.__hidden_file
= os
.path
.join(self
._dir(), 'hidden')
389 # where this series keeps its patches
390 self
.__patch_dir
= os
.path
.join(self
._dir(), 'patches')
393 self
.__trash_dir
= os
.path
.join(self
._dir(), 'trash')
395 def format_version_key(self
):
396 return 'branch.%s.stgit.stackformatversion' % self
.get_name()
398 def update_to_current_format_version(self
):
399 """Update a potentially older StGIT directory structure to the
400 latest version. Note: This function should depend as little as
401 possible on external functions that may change during a format
402 version bump, since it must remain able to process older formats."""
404 branch_dir
= os
.path
.join(self
._basedir(), 'patches', self
.get_name())
405 def get_format_version():
406 """Return the integer format version number, or None if the
407 branch doesn't have any StGIT metadata at all, of any version."""
408 fv
= config
.get(self
.format_version_key())
409 ofv
= config
.get('branch.%s.stgitformatversion' % self
.get_name())
411 # Great, there's an explicitly recorded format version
412 # number, which means that the branch is initialized and
413 # of that exact version.
416 # Old name for the version info, upgrade it
417 config
.set(self
.format_version_key(), ofv
)
418 config
.unset('branch.%s.stgitformatversion' % self
.get_name())
420 elif os
.path
.isdir(os
.path
.join(branch_dir
, 'patches')):
421 # There's a .git/patches/<branch>/patches dirctory, which
422 # means this is an initialized version 1 branch.
424 elif os
.path
.isdir(branch_dir
):
425 # There's a .git/patches/<branch> directory, which means
426 # this is an initialized version 0 branch.
429 # The branch doesn't seem to be initialized at all.
431 def set_format_version(v
):
432 out
.info('Upgraded branch %s to format version %d' %
(self
.get_name(), v
))
433 config
.set(self
.format_version_key(), '%d' % v
)
435 if not os
.path
.isdir(d
):
438 if os
.path
.exists(f
):
441 if git
.ref_exists(ref
):
445 if get_format_version() == 0:
446 mkdir(os
.path
.join(branch_dir
, 'trash'))
447 patch_dir
= os
.path
.join(branch_dir
, 'patches')
449 refs_base
= 'refs/patches/%s' % self
.get_name()
450 for patch
in (file(os
.path
.join(branch_dir
, 'unapplied')).readlines()
451 + file(os
.path
.join(branch_dir
, 'applied')).readlines()):
452 patch
= patch
.strip()
453 os
.rename(os
.path
.join(branch_dir
, patch
),
454 os
.path
.join(patch_dir
, patch
))
455 Patch(patch
, patch_dir
, refs_base
).update_top_ref()
456 set_format_version(1)
459 if get_format_version() == 1:
460 desc_file
= os
.path
.join(branch_dir
, 'description')
461 if os
.path
.isfile(desc_file
):
462 desc
= read_string(desc_file
)
464 config
.set('branch.%s.description' % self
.get_name(), desc
)
466 rm(os
.path
.join(branch_dir
, 'current'))
467 rm_ref('refs/bases/%s' % self
.get_name())
468 set_format_version(2)
470 # Make sure we're at the latest version.
471 if not get_format_version() in [None, FORMAT_VERSION
]:
472 raise StackException('Branch %s is at format version %d, expected %d'
473 %
(self
.get_name(), get_format_version(), FORMAT_VERSION
))
475 def __patch_name_valid(self
, name
):
476 """Raise an exception if the patch name is not valid.
478 if not name
or re
.search('[^\w.-]', name
):
479 raise StackException
, 'Invalid patch name: "%s"' % name
481 def get_patch(self
, name
):
482 """Return a Patch object for the given name
484 return Patch(name
, self
.__patch_dir
, self
.__refs_base
)
486 def get_current_patch(self
):
487 """Return a Patch object representing the topmost patch, or
488 None if there is no such patch."""
489 crt
= self
.get_current()
492 return self
.get_patch(crt
)
494 def get_current(self
):
495 """Return the name of the topmost patch, or None if there is
498 applied
= self
.get_applied()
499 except StackException
:
500 # No "applied" file: branch is not initialized.
505 # No patches applied.
508 def get_applied(self
):
509 if not os
.path
.isfile(self
.__applied_file
):
510 raise StackException
, 'Branch "%s" not initialised' % self
.get_name()
511 return read_strings(self
.__applied_file
)
513 def set_applied(self
, applied
):
514 write_strings(self
.__applied_file
, applied
)
516 def get_unapplied(self
):
517 if not os
.path
.isfile(self
.__unapplied_file
):
518 raise StackException
, 'Branch "%s" not initialised' % self
.get_name()
519 return read_strings(self
.__unapplied_file
)
521 def set_unapplied(self
, unapplied
):
522 write_strings(self
.__unapplied_file
, unapplied
)
524 def get_hidden(self
):
525 if not os
.path
.isfile(self
.__hidden_file
):
527 return read_strings(self
.__hidden_file
)
530 # Return the parent of the bottommost patch, if there is one.
531 if os
.path
.isfile(self
.__applied_file
):
532 bottommost
= file(self
.__applied_file
).readline().strip()
534 return self
.get_patch(bottommost
).get_bottom()
535 # No bottommost patch, so just return HEAD
536 return git
.get_head()
538 def get_parent_remote(self
):
539 value
= config
.get('branch.%s.remote' % self
.get_name())
542 elif 'origin' in git
.remotes_list():
543 out
.note(('No parent remote declared for stack "%s",'
544 ' defaulting to "origin".' % self
.get_name()),
545 ('Consider setting "branch.%s.remote" and'
546 ' "branch.%s.merge" with "git config".'
547 %
(self
.get_name(), self
.get_name())))
550 raise StackException
, 'Cannot find a parent remote for "%s"' % self
.get_name()
552 def __set_parent_remote(self
, remote
):
553 value
= config
.set('branch.%s.remote' % self
.get_name(), remote
)
555 def get_parent_branch(self
):
556 value
= config
.get('branch.%s.stgit.parentbranch' % self
.get_name())
559 elif git
.rev_parse('heads/origin'):
560 out
.note(('No parent branch declared for stack "%s",'
561 ' defaulting to "heads/origin".' % self
.get_name()),
562 ('Consider setting "branch.%s.stgit.parentbranch"'
563 ' with "git config".' % self
.get_name()))
564 return 'heads/origin'
566 raise StackException
, 'Cannot find a parent branch for "%s"' % self
.get_name()
568 def __set_parent_branch(self
, name
):
569 if config
.get('branch.%s.remote' % self
.get_name()):
570 # Never set merge if remote is not set to avoid
571 # possibly-erroneous lookups into 'origin'
572 config
.set('branch.%s.merge' % self
.get_name(), name
)
573 config
.set('branch.%s.stgit.parentbranch' % self
.get_name(), name
)
575 def set_parent(self
, remote
, localbranch
):
578 self
.__set_parent_remote(remote
)
579 self
.__set_parent_branch(localbranch
)
580 # We'll enforce this later
582 # raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.get_name()
584 def __patch_is_current(self
, patch
):
585 return patch
.get_name() == self
.get_current()
587 def patch_applied(self
, name
):
588 """Return true if the patch exists in the applied list
590 return name
in self
.get_applied()
592 def patch_unapplied(self
, name
):
593 """Return true if the patch exists in the unapplied list
595 return name
in self
.get_unapplied()
597 def patch_hidden(self
, name
):
598 """Return true if the patch is hidden.
600 return name
in self
.get_hidden()
602 def patch_exists(self
, name
):
603 """Return true if there is a patch with the given name, false
605 return self
.patch_applied(name
) or self
.patch_unapplied(name
) \
606 or self
.patch_hidden(name
)
608 def init(self
, create_at
=False, parent_remote
=None, parent_branch
=None):
609 """Initialises the stgit series
611 if self
.is_initialised():
612 raise StackException
, '%s already initialized' % self
.get_name()
613 for d
in [self
._dir()]:
614 if os
.path
.exists(d
):
615 raise StackException
, '%s already exists' % d
617 if (create_at
!=False):
618 git
.create_branch(self
.get_name(), create_at
)
620 os
.makedirs(self
.__patch_dir
)
622 self
.set_parent(parent_remote
, parent_branch
)
624 self
.create_empty_field('applied')
625 self
.create_empty_field('unapplied')
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 commit
or (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 check_index
= False):
1172 raise StackException(
1173 'Failed to pop patches while preserving the local changes')
1174 git
.switch(patch
.get_bottom(), keep
)
1176 git
.set_branch(self
.get_name(), patch
.get_bottom())
1178 # save the new applied list
1179 idx
= applied
.index(name
) + 1
1181 popped
= applied
[:idx
]
1183 unapplied
= popped
+ self
.get_unapplied()
1184 write_strings(self
.__unapplied_file
, unapplied
)
1188 write_strings(self
.__applied_file
, applied
)
1190 def empty_patch(self
, name
):
1191 """Returns True if the patch is empty
1193 self
.__patch_name_valid(name
)
1194 patch
= self
.get_patch(name
)
1195 bottom
= patch
.get_bottom()
1196 top
= patch
.get_top()
1200 elif git
.get_commit(top
).get_tree() \
1201 == git
.get_commit(bottom
).get_tree():
1206 def rename_patch(self
, oldname
, newname
):
1207 self
.__patch_name_valid(newname
)
1209 applied
= self
.get_applied()
1210 unapplied
= self
.get_unapplied()
1212 if oldname
== newname
:
1213 raise StackException
, '"To" name and "from" name are the same'
1215 if newname
in applied
or newname
in unapplied
:
1216 raise StackException
, 'Patch "%s" already exists' % newname
1218 if oldname
in unapplied
:
1219 self
.get_patch(oldname
).rename(newname
)
1220 unapplied
[unapplied
.index(oldname
)] = newname
1221 write_strings(self
.__unapplied_file
, unapplied
)
1222 elif oldname
in applied
:
1223 self
.get_patch(oldname
).rename(newname
)
1225 applied
[applied
.index(oldname
)] = newname
1226 write_strings(self
.__applied_file
, applied
)
1228 raise StackException
, 'Unknown patch "%s"' % oldname
1230 def log_patch(self
, patch
, message
, notes
= None):
1231 """Generate a log commit for a patch
1233 top
= git
.get_commit(patch
.get_top())
1234 old_log
= patch
.get_log()
1237 # replace the current log entry
1239 raise StackException
, \
1240 'No log entry to annotate for patch "%s"' \
1243 log_commit
= git
.get_commit(old_log
)
1244 msg
= log_commit
.get_log().split('\n')[0]
1245 log_parent
= log_commit
.get_parent()
1247 parents
= [log_parent
]
1251 # generate a new log entry
1253 msg
= '%s\t%s' %
(message
, top
.get_id_hash())
1260 msg
+= '\n\n' + notes
1262 log
= git
.commit(message
= msg
, parents
= parents
,
1263 cache_update
= False, tree_id
= top
.get_tree(),
1267 def hide_patch(self
, name
):
1268 """Add the patch to the hidden list.
1270 unapplied
= self
.get_unapplied()
1271 if name
not in unapplied
:
1272 # keep the checking order for backward compatibility with
1273 # the old hidden patches functionality
1274 if self
.patch_applied(name
):
1275 raise StackException
, 'Cannot hide applied patch "%s"' % name
1276 elif self
.patch_hidden(name
):
1277 raise StackException
, 'Patch "%s" already hidden' % name
1279 raise StackException
, 'Unknown patch "%s"' % name
1281 if not self
.patch_hidden(name
):
1282 # check needed for backward compatibility with the old
1283 # hidden patches functionality
1284 append_string(self
.__hidden_file
, name
)
1286 unapplied
.remove(name
)
1287 write_strings(self
.__unapplied_file
, unapplied
)
1289 def unhide_patch(self
, name
):
1290 """Remove the patch from the hidden list.
1292 hidden
= self
.get_hidden()
1293 if not name
in hidden
:
1294 if self
.patch_applied(name
) or self
.patch_unapplied(name
):
1295 raise StackException
, 'Patch "%s" not hidden' % name
1297 raise StackException
, 'Unknown patch "%s"' % name
1300 write_strings(self
.__hidden_file
, hidden
)
1302 if not self
.patch_applied(name
) and not self
.patch_unapplied(name
):
1303 # check needed for backward compatibility with the old
1304 # hidden patches functionality
1305 append_string(self
.__unapplied_file
, name
)