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')
168 def delete(self
, keep_log
= False):
169 if os
.path
.isdir(self
._dir()):
170 for f
in os
.listdir(self
._dir()):
171 os
.remove(os
.path
.join(self
._dir(), f
))
172 os
.rmdir(self
._dir())
174 out
.warn('Patch directory "%s" does not exist' % self
._dir())
176 # the reference might not exist if the repository was corrupted
177 git
.delete_ref(self
.__top_ref
)
178 except git
.GitException
, e
:
180 if not keep_log
and git
.ref_exists(self
.__log_ref
):
181 git
.delete_ref(self
.__log_ref
)
186 def rename(self
, newname
):
188 old_top_ref
= self
.__top_ref
189 old_log_ref
= self
.__log_ref
190 self
.__name
= newname
191 self
._set_dir(os
.path
.join(self
.__series_dir
, self
.__name
))
194 git
.rename_ref(old_top_ref
, self
.__top_ref
)
195 if git
.ref_exists(old_log_ref
):
196 git
.rename_ref(old_log_ref
, self
.__log_ref
)
197 os
.rename(olddir
, self
._dir())
199 def __update_top_ref(self
, ref
):
200 git
.set_ref(self
.__top_ref
, ref
)
202 def __update_log_ref(self
, ref
):
203 git
.set_ref(self
.__log_ref
, ref
)
205 def update_top_ref(self
):
208 self
.__update_top_ref(top
)
210 def get_old_bottom(self
):
211 return self
._get_field('bottom.old')
213 def get_bottom(self
):
214 return self
._get_field('bottom')
216 def set_bottom(self
, value
, backup
= False):
218 curr
= self
._get_field('bottom')
219 self
._set_field('bottom.old', curr
)
220 self
._set_field('bottom', value
)
222 def get_old_top(self
):
223 return self
._get_field('top.old')
226 return self
._get_field('top')
228 def set_top(self
, value
, backup
= False):
230 curr
= self
._get_field('top')
231 self
._set_field('top.old', curr
)
232 self
._set_field('top', value
)
233 self
.__update_top_ref(value
)
235 def restore_old_boundaries(self
):
236 bottom
= self
._get_field('bottom.old')
237 top
= self
._get_field('top.old')
240 self
._set_field('bottom', bottom
)
241 self
._set_field('top', top
)
242 self
.__update_top_ref(top
)
247 def get_description(self
):
248 return self
._get_field('description', True)
250 def set_description(self
, line
):
251 self
._set_field('description', line
, True)
253 def get_authname(self
):
254 return self
._get_field('authname')
256 def set_authname(self
, name
):
257 self
._set_field('authname', name
or git
.author().name
)
259 def get_authemail(self
):
260 return self
._get_field('authemail')
262 def set_authemail(self
, email
):
263 self
._set_field('authemail', email
or git
.author().email
)
265 def get_authdate(self
):
266 date
= self
._get_field('authdate')
270 if re
.match('[0-9]+\s+[+-][0-9]+', date
):
271 # Unix time (seconds) + time zone
272 secs_tz
= date
.split()
273 date
= formatdate(int(secs_tz
[0]))[:-5] + secs_tz
[1]
277 def set_authdate(self
, date
):
278 self
._set_field('authdate', date
or git
.author().date
)
280 def get_commname(self
):
281 return self
._get_field('commname')
283 def set_commname(self
, name
):
284 self
._set_field('commname', name
or git
.committer().name
)
286 def get_commemail(self
):
287 return self
._get_field('commemail')
289 def set_commemail(self
, email
):
290 self
._set_field('commemail', email
or git
.committer().email
)
293 return self
._get_field('log')
295 def set_log(self
, value
, backup
= False):
296 self
._set_field('log', value
)
297 self
.__update_log_ref(value
)
299 # The current StGIT metadata format version.
302 class PatchSet(StgitObject
):
303 def __init__(self
, name
= None):
308 self
.set_name (git
.get_head_file())
309 self
.__base_dir
= basedir
.get()
310 except git
.GitException
, ex
:
311 raise StackException
, 'GIT tree not initialised: %s' % ex
313 self
._set_dir(os
.path
.join(self
.__base_dir
, 'patches', self
.get_name()))
317 def set_name(self
, name
):
321 return self
.__base_dir
324 """Return the head of the branch
326 crt
= self
.get_current_patch()
330 return self
.get_base()
332 def get_protected(self
):
333 return os
.path
.isfile(os
.path
.join(self
._dir(), 'protected'))
336 protect_file
= os
.path
.join(self
._dir(), 'protected')
337 if not os
.path
.isfile(protect_file
):
338 create_empty_file(protect_file
)
341 protect_file
= os
.path
.join(self
._dir(), 'protected')
342 if os
.path
.isfile(protect_file
):
343 os
.remove(protect_file
)
345 def __branch_descr(self
):
346 return 'branch.%s.description' % self
.get_name()
348 def get_description(self
):
349 return config
.get(self
.__branch_descr()) or ''
351 def set_description(self
, line
):
353 config
.set(self
.__branch_descr(), line
)
355 config
.unset(self
.__branch_descr())
357 def head_top_equal(self
):
358 """Return true if the head and the top are the same
360 crt
= self
.get_current_patch()
362 # we don't care, no patches applied
364 return git
.get_head() == crt
.get_top()
366 def is_initialised(self
):
367 """Checks if series is already initialised
369 return bool(config
.get(self
.format_version_key()))
372 def shortlog(patches
):
373 log
= ''.join(Run('git', 'log', '--pretty=short',
374 p
.get_top(), '^%s' % p
.get_bottom()).raw_output()
376 return Run('git', 'shortlog').raw_input(log
).raw_output()
378 class Series(PatchSet
):
379 """Class including the operations on series
381 def __init__(self
, name
= None):
382 """Takes a series name as the parameter.
384 PatchSet
.__init__(self
, name
)
386 # Update the branch to the latest format version if it is
387 # initialized, but don't touch it if it isn't.
388 self
.update_to_current_format_version()
390 self
.__refs_base
= 'refs/patches/%s' % self
.get_name()
392 self
.__applied_file
= os
.path
.join(self
._dir(), 'applied')
393 self
.__unapplied_file
= os
.path
.join(self
._dir(), 'unapplied')
394 self
.__hidden_file
= os
.path
.join(self
._dir(), 'hidden')
396 # where this series keeps its patches
397 self
.__patch_dir
= os
.path
.join(self
._dir(), 'patches')
400 self
.__trash_dir
= os
.path
.join(self
._dir(), 'trash')
402 def format_version_key(self
):
403 return 'branch.%s.stgit.stackformatversion' % self
.get_name()
405 def update_to_current_format_version(self
):
406 """Update a potentially older StGIT directory structure to the
407 latest version. Note: This function should depend as little as
408 possible on external functions that may change during a format
409 version bump, since it must remain able to process older formats."""
411 branch_dir
= os
.path
.join(self
._basedir(), 'patches', self
.get_name())
412 def get_format_version():
413 """Return the integer format version number, or None if the
414 branch doesn't have any StGIT metadata at all, of any version."""
415 fv
= config
.get(self
.format_version_key())
416 ofv
= config
.get('branch.%s.stgitformatversion' % self
.get_name())
418 # Great, there's an explicitly recorded format version
419 # number, which means that the branch is initialized and
420 # of that exact version.
423 # Old name for the version info, upgrade it
424 config
.set(self
.format_version_key(), ofv
)
425 config
.unset('branch.%s.stgitformatversion' % self
.get_name())
427 elif os
.path
.isdir(os
.path
.join(branch_dir
, 'patches')):
428 # There's a .git/patches/<branch>/patches dirctory, which
429 # means this is an initialized version 1 branch.
431 elif os
.path
.isdir(branch_dir
):
432 # There's a .git/patches/<branch> directory, which means
433 # this is an initialized version 0 branch.
436 # The branch doesn't seem to be initialized at all.
438 def set_format_version(v
):
439 out
.info('Upgraded branch %s to format version %d' %
(self
.get_name(), v
))
440 config
.set(self
.format_version_key(), '%d' % v
)
442 if not os
.path
.isdir(d
):
445 if os
.path
.exists(f
):
448 if git
.ref_exists(ref
):
452 if get_format_version() == 0:
453 mkdir(os
.path
.join(branch_dir
, 'trash'))
454 patch_dir
= os
.path
.join(branch_dir
, 'patches')
456 refs_base
= 'refs/patches/%s' % self
.get_name()
457 for patch
in (file(os
.path
.join(branch_dir
, 'unapplied')).readlines()
458 + file(os
.path
.join(branch_dir
, 'applied')).readlines()):
459 patch
= patch
.strip()
460 os
.rename(os
.path
.join(branch_dir
, patch
),
461 os
.path
.join(patch_dir
, patch
))
462 Patch(patch
, patch_dir
, refs_base
).update_top_ref()
463 set_format_version(1)
466 if get_format_version() == 1:
467 desc_file
= os
.path
.join(branch_dir
, 'description')
468 if os
.path
.isfile(desc_file
):
469 desc
= read_string(desc_file
)
471 config
.set('branch.%s.description' % self
.get_name(), desc
)
473 rm(os
.path
.join(branch_dir
, 'current'))
474 rm_ref('refs/bases/%s' % self
.get_name())
475 set_format_version(2)
477 # Make sure we're at the latest version.
478 if not get_format_version() in [None, FORMAT_VERSION
]:
479 raise StackException('Branch %s is at format version %d, expected %d'
480 %
(self
.get_name(), get_format_version(), FORMAT_VERSION
))
482 def __patch_name_valid(self
, name
):
483 """Raise an exception if the patch name is not valid.
485 if not name
or re
.search('[^\w.-]', name
):
486 raise StackException
, 'Invalid patch name: "%s"' % name
488 def get_patch(self
, name
):
489 """Return a Patch object for the given name
491 return Patch(name
, self
.__patch_dir
, self
.__refs_base
)
493 def get_current_patch(self
):
494 """Return a Patch object representing the topmost patch, or
495 None if there is no such patch."""
496 crt
= self
.get_current()
499 return self
.get_patch(crt
)
501 def get_current(self
):
502 """Return the name of the topmost patch, or None if there is
505 applied
= self
.get_applied()
506 except StackException
:
507 # No "applied" file: branch is not initialized.
512 # No patches applied.
515 def get_applied(self
):
516 if not os
.path
.isfile(self
.__applied_file
):
517 raise StackException
, 'Branch "%s" not initialised' % self
.get_name()
518 return read_strings(self
.__applied_file
)
520 def set_applied(self
, applied
):
521 write_strings(self
.__applied_file
, applied
)
523 def get_unapplied(self
):
524 if not os
.path
.isfile(self
.__unapplied_file
):
525 raise StackException
, 'Branch "%s" not initialised' % self
.get_name()
526 return read_strings(self
.__unapplied_file
)
528 def set_unapplied(self
, unapplied
):
529 write_strings(self
.__unapplied_file
, unapplied
)
531 def get_hidden(self
):
532 if not os
.path
.isfile(self
.__hidden_file
):
534 return read_strings(self
.__hidden_file
)
537 # Return the parent of the bottommost patch, if there is one.
538 if os
.path
.isfile(self
.__applied_file
):
539 bottommost
= file(self
.__applied_file
).readline().strip()
541 return self
.get_patch(bottommost
).get_bottom()
542 # No bottommost patch, so just return HEAD
543 return git
.get_head()
545 def get_parent_remote(self
):
546 value
= config
.get('branch.%s.remote' % self
.get_name())
549 elif 'origin' in git
.remotes_list():
550 out
.note(('No parent remote declared for stack "%s",'
551 ' defaulting to "origin".' % self
.get_name()),
552 ('Consider setting "branch.%s.remote" and'
553 ' "branch.%s.merge" with "git config".'
554 %
(self
.get_name(), self
.get_name())))
557 raise StackException
, 'Cannot find a parent remote for "%s"' % self
.get_name()
559 def __set_parent_remote(self
, remote
):
560 value
= config
.set('branch.%s.remote' % self
.get_name(), remote
)
562 def get_parent_branch(self
):
563 value
= config
.get('branch.%s.stgit.parentbranch' % self
.get_name())
566 elif git
.rev_parse('heads/origin'):
567 out
.note(('No parent branch declared for stack "%s",'
568 ' defaulting to "heads/origin".' % self
.get_name()),
569 ('Consider setting "branch.%s.stgit.parentbranch"'
570 ' with "git config".' % self
.get_name()))
571 return 'heads/origin'
573 raise StackException
, 'Cannot find a parent branch for "%s"' % self
.get_name()
575 def __set_parent_branch(self
, name
):
576 if config
.get('branch.%s.remote' % self
.get_name()):
577 # Never set merge if remote is not set to avoid
578 # possibly-erroneous lookups into 'origin'
579 config
.set('branch.%s.merge' % self
.get_name(), name
)
580 config
.set('branch.%s.stgit.parentbranch' % self
.get_name(), name
)
582 def set_parent(self
, remote
, localbranch
):
585 self
.__set_parent_remote(remote
)
586 self
.__set_parent_branch(localbranch
)
587 # We'll enforce this later
589 # raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.get_name()
591 def __patch_is_current(self
, patch
):
592 return patch
.get_name() == self
.get_current()
594 def patch_applied(self
, name
):
595 """Return true if the patch exists in the applied list
597 return name
in self
.get_applied()
599 def patch_unapplied(self
, name
):
600 """Return true if the patch exists in the unapplied list
602 return name
in self
.get_unapplied()
604 def patch_hidden(self
, name
):
605 """Return true if the patch is hidden.
607 return name
in self
.get_hidden()
609 def patch_exists(self
, name
):
610 """Return true if there is a patch with the given name, false
612 return self
.patch_applied(name
) or self
.patch_unapplied(name
) \
613 or self
.patch_hidden(name
)
615 def init(self
, create_at
=False, parent_remote
=None, parent_branch
=None):
616 """Initialises the stgit series
618 if self
.is_initialised():
619 raise StackException
, '%s already initialized' % self
.get_name()
620 for d
in [self
._dir()]:
621 if os
.path
.exists(d
):
622 raise StackException
, '%s already exists' % d
624 if (create_at
!=False):
625 git
.create_branch(self
.get_name(), create_at
)
627 os
.makedirs(self
.__patch_dir
)
629 self
.set_parent(parent_remote
, parent_branch
)
631 self
.create_empty_field('applied')
632 self
.create_empty_field('unapplied')
634 config
.set(self
.format_version_key(), str(FORMAT_VERSION
))
636 def rename(self
, to_name
):
639 to_stack
= Series(to_name
)
641 if to_stack
.is_initialised():
642 raise StackException
, '"%s" already exists' % to_stack
.get_name()
644 patches
= self
.get_applied() + self
.get_unapplied()
646 git
.rename_branch(self
.get_name(), to_name
)
648 for patch
in patches
:
649 git
.rename_ref('refs/patches/%s/%s' %
(self
.get_name(), patch
),
650 'refs/patches/%s/%s' %
(to_name
, patch
))
651 git
.rename_ref('refs/patches/%s/%s.log' %
(self
.get_name(), patch
),
652 'refs/patches/%s/%s.log' %
(to_name
, patch
))
653 if os
.path
.isdir(self
._dir()):
654 rename(os
.path
.join(self
._basedir(), 'patches'),
655 self
.get_name(), to_stack
.get_name())
657 # Rename the config section
658 for k
in ['branch.%s', 'branch.%s.stgit']:
659 config
.rename_section(k % self
.get_name(), k % to_name
)
661 self
.__init__(to_name
)
663 def clone(self
, target_series
):
667 # allow cloning of branches not under StGIT control
668 base
= self
.get_base()
670 base
= git
.get_head()
671 Series(target_series
).init(create_at
= base
)
672 new_series
= Series(target_series
)
674 # generate an artificial description file
675 new_series
.set_description('clone of "%s"' % self
.get_name())
677 # clone self's entire series as unapplied patches
679 # allow cloning of branches not under StGIT control
680 applied
= self
.get_applied()
681 unapplied
= self
.get_unapplied()
682 patches
= applied
+ unapplied
685 patches
= applied
= unapplied
= []
687 patch
= self
.get_patch(p
)
688 newpatch
= new_series
.new_patch(p
, message
= patch
.get_description(),
689 can_edit
= False, unapplied
= True,
690 bottom
= patch
.get_bottom(),
691 top
= patch
.get_top(),
692 author_name
= patch
.get_authname(),
693 author_email
= patch
.get_authemail(),
694 author_date
= patch
.get_authdate())
696 out
.info('Setting log to %s' % patch
.get_log())
697 newpatch
.set_log(patch
.get_log())
699 out
.info('No log for %s' % p
)
701 # fast forward the cloned series to self's top
702 new_series
.forward_patches(applied
)
704 # Clone parent informations
705 value
= config
.get('branch.%s.remote' % self
.get_name())
707 config
.set('branch.%s.remote' % target_series
, value
)
709 value
= config
.get('branch.%s.merge' % self
.get_name())
711 config
.set('branch.%s.merge' % target_series
, value
)
713 value
= config
.get('branch.%s.stgit.parentbranch' % self
.get_name())
715 config
.set('branch.%s.stgit.parentbranch' % target_series
, value
)
717 def delete(self
, force
= False):
718 """Deletes an stgit series
720 if self
.is_initialised():
721 patches
= self
.get_unapplied() + self
.get_applied()
722 if not force
and patches
:
723 raise StackException
, \
724 'Cannot delete: the series still contains patches'
726 self
.get_patch(p
).delete()
728 # remove the trash directory if any
729 if os
.path
.exists(self
.__trash_dir
):
730 for fname
in os
.listdir(self
.__trash_dir
):
731 os
.remove(os
.path
.join(self
.__trash_dir
, fname
))
732 os
.rmdir(self
.__trash_dir
)
734 # FIXME: find a way to get rid of those manual removals
735 # (move functionality to StgitObject ?)
736 if os
.path
.exists(self
.__applied_file
):
737 os
.remove(self
.__applied_file
)
738 if os
.path
.exists(self
.__unapplied_file
):
739 os
.remove(self
.__unapplied_file
)
740 if os
.path
.exists(self
.__hidden_file
):
741 os
.remove(self
.__hidden_file
)
742 if os
.path
.exists(self
._dir()+'/orig-base'):
743 os
.remove(self
._dir()+'/orig-base')
745 if not os
.listdir(self
.__patch_dir
):
746 os
.rmdir(self
.__patch_dir
)
748 out
.warn('Patch directory %s is not empty' % self
.__patch_dir
)
751 os
.removedirs(self
._dir())
753 raise StackException('Series directory %s is not empty'
757 git
.delete_branch(self
.get_name())
758 except git
.GitException
:
759 out
.warn('Could not delete branch "%s"' % self
.get_name())
761 config
.remove_section('branch.%s' % self
.get_name())
762 config
.remove_section('branch.%s.stgit' % self
.get_name())
764 def refresh_patch(self
, files
= None, message
= None, edit
= False,
767 author_name
= None, author_email
= None,
769 committer_name
= None, committer_email
= None,
770 backup
= True, sign_str
= None, log
= 'refresh',
771 notes
= None, bottom
= None):
772 """Generates a new commit for the topmost patch
774 patch
= self
.get_current_patch()
776 raise StackException
, 'No patches applied'
778 descr
= patch
.get_description()
779 if not (message
or descr
):
785 # TODO: move this out of the stgit.stack module, it is really
786 # for higher level commands to handle the user interaction
787 if not message
and edit
:
788 descr
= edit_file(self
, descr
.rstrip(), \
789 'Please edit the description for patch "%s" ' \
790 'above.' % patch
.get_name(), show_patch
)
793 author_name
= patch
.get_authname()
795 author_email
= patch
.get_authemail()
796 if not committer_name
:
797 committer_name
= patch
.get_commname()
798 if not committer_email
:
799 committer_email
= patch
.get_commemail()
801 descr
= add_sign_line(descr
, sign_str
, committer_name
, committer_email
)
804 bottom
= patch
.get_bottom()
806 commit_id
= git
.commit(files
= files
,
807 message
= descr
, parents
= [bottom
],
808 cache_update
= cache_update
,
810 author_name
= author_name
,
811 author_email
= author_email
,
812 author_date
= author_date
,
813 committer_name
= committer_name
,
814 committer_email
= committer_email
)
816 patch
.set_bottom(bottom
, backup
= backup
)
817 patch
.set_top(commit_id
, backup
= backup
)
818 patch
.set_description(descr
)
819 patch
.set_authname(author_name
)
820 patch
.set_authemail(author_email
)
821 patch
.set_authdate(author_date
)
822 patch
.set_commname(committer_name
)
823 patch
.set_commemail(committer_email
)
826 self
.log_patch(patch
, log
, notes
)
830 def undo_refresh(self
):
831 """Undo the patch boundaries changes caused by 'refresh'
833 name
= self
.get_current()
836 patch
= self
.get_patch(name
)
837 old_bottom
= patch
.get_old_bottom()
838 old_top
= patch
.get_old_top()
840 # the bottom of the patch is not changed by refresh. If the
841 # old_bottom is different, there wasn't any previous 'refresh'
842 # command (probably only a 'push')
843 if old_bottom
!= patch
.get_bottom() or old_top
== patch
.get_top():
844 raise StackException
, 'No undo information available'
846 git
.reset(tree_id
= old_top
, check_out
= False)
847 if patch
.restore_old_boundaries():
848 self
.log_patch(patch
, 'undo')
850 def new_patch(self
, name
, message
= None, can_edit
= True,
851 unapplied
= False, show_patch
= False,
852 top
= None, bottom
= None, commit
= True,
853 author_name
= None, author_email
= None, author_date
= None,
854 committer_name
= None, committer_email
= None,
855 before_existing
= False, sign_str
= None):
856 """Creates a new patch, either pointing to an existing commit object,
857 or by creating a new commit object.
860 assert commit
or (top
and bottom
)
861 assert not before_existing
or (top
and bottom
)
862 assert not (commit
and before_existing
)
863 assert (top
and bottom
) or (not top
and not bottom
)
864 assert commit
or (not top
or (bottom
== git
.get_commit(top
).get_parent()))
867 self
.__patch_name_valid(name
)
868 if self
.patch_exists(name
):
869 raise StackException
, 'Patch "%s" already exists' % name
871 # TODO: move this out of the stgit.stack module, it is really
872 # for higher level commands to handle the user interaction
874 return add_sign_line(msg
, sign_str
,
875 committer_name
or git
.committer().name
,
876 committer_email
or git
.committer().email
)
877 if not message
and can_edit
:
880 'Please enter the description for the patch above.',
883 descr
= sign(message
)
885 head
= git
.get_head()
888 name
= make_patch_name(descr
, self
.patch_exists
)
890 patch
= self
.get_patch(name
)
893 patch
.set_description(descr
)
894 patch
.set_authname(author_name
)
895 patch
.set_authemail(author_email
)
896 patch
.set_authdate(author_date
)
897 patch
.set_commname(committer_name
)
898 patch
.set_commemail(committer_email
)
901 insert_string(self
.__applied_file
, patch
.get_name())
903 patches
= [patch
.get_name()] + self
.get_unapplied()
904 write_strings(self
.__unapplied_file
, patches
)
907 append_string(self
.__applied_file
, patch
.get_name())
912 top_commit
= git
.get_commit(top
)
915 top_commit
= git
.get_commit(head
)
917 # create a commit for the patch (may be empty if top == bottom);
918 # only commit on top of the current branch
919 assert(unapplied
or bottom
== head
)
920 commit_id
= git
.commit(message
= descr
, parents
= [bottom
],
921 cache_update
= False,
922 tree_id
= top_commit
.get_tree(),
923 allowempty
= True, set_head
= set_head
,
924 author_name
= author_name
,
925 author_email
= author_email
,
926 author_date
= author_date
,
927 committer_name
= committer_name
,
928 committer_email
= committer_email
)
929 # set the patch top to the new commit
930 patch
.set_bottom(bottom
)
931 patch
.set_top(commit_id
)
934 patch
.set_bottom(bottom
)
937 self
.log_patch(patch
, 'new')
941 def delete_patch(self
, name
, keep_log
= False):
944 self
.__patch_name_valid(name
)
945 patch
= self
.get_patch(name
)
947 if self
.__patch_is_current(patch
):
949 elif self
.patch_applied(name
):
950 raise StackException
, 'Cannot remove an applied patch, "%s", ' \
951 'which is not current' % name
952 elif not name
in self
.get_unapplied():
953 raise StackException
, 'Unknown patch "%s"' % name
955 # save the commit id to a trash file
956 write_string(os
.path
.join(self
.__trash_dir
, name
), patch
.get_top())
958 patch
.delete(keep_log
= keep_log
)
960 unapplied
= self
.get_unapplied()
961 unapplied
.remove(name
)
962 write_strings(self
.__unapplied_file
, unapplied
)
964 def forward_patches(self
, names
):
965 """Try to fast-forward an array of patches.
967 On return, patches in names[0:returned_value] have been pushed on the
968 stack. Apply the rest with push_patch
970 unapplied
= self
.get_unapplied()
976 assert(name
in unapplied
)
978 patch
= self
.get_patch(name
)
981 bottom
= patch
.get_bottom()
982 top
= patch
.get_top()
984 # top != bottom always since we have a commit for each patch
986 # reset the backup information. No logging since the
987 # patch hasn't changed
988 patch
.set_bottom(head
, backup
= True)
989 patch
.set_top(top
, backup
= True)
992 head_tree
= git
.get_commit(head
).get_tree()
993 bottom_tree
= git
.get_commit(bottom
).get_tree()
994 if head_tree
== bottom_tree
:
995 # We must just reparent this patch and create a new commit
997 descr
= patch
.get_description()
998 author_name
= patch
.get_authname()
999 author_email
= patch
.get_authemail()
1000 author_date
= patch
.get_authdate()
1001 committer_name
= patch
.get_commname()
1002 committer_email
= patch
.get_commemail()
1004 top_tree
= git
.get_commit(top
).get_tree()
1006 top
= git
.commit(message
= descr
, parents
= [head
],
1007 cache_update
= False,
1010 author_name
= author_name
,
1011 author_email
= author_email
,
1012 author_date
= author_date
,
1013 committer_name
= committer_name
,
1014 committer_email
= committer_email
)
1016 patch
.set_bottom(head
, backup
= True)
1017 patch
.set_top(top
, backup
= True)
1019 self
.log_patch(patch
, 'push(f)')
1022 # stop the fast-forwarding, must do a real merge
1026 unapplied
.remove(name
)
1033 append_strings(self
.__applied_file
, names
[0:forwarded
])
1034 write_strings(self
.__unapplied_file
, unapplied
)
1038 def merged_patches(self
, names
):
1039 """Test which patches were merged upstream by reverse-applying
1040 them in reverse order. The function returns the list of
1041 patches detected to have been applied. The state of the tree
1042 is restored to the original one
1044 patches
= [self
.get_patch(name
) for name
in names
]
1049 if git
.apply_diff(p
.get_top(), p
.get_bottom()):
1050 merged
.append(p
.get_name())
1057 def push_empty_patch(self
, name
):
1058 """Pushes an empty patch on the stack
1060 unapplied
= self
.get_unapplied()
1061 assert(name
in unapplied
)
1063 # patch = self.get_patch(name)
1064 head
= git
.get_head()
1066 append_string(self
.__applied_file
, name
)
1068 unapplied
.remove(name
)
1069 write_strings(self
.__unapplied_file
, unapplied
)
1071 self
.refresh_patch(bottom
= head
, cache_update
= False, log
= 'push(m)')
1073 def push_patch(self
, name
):
1074 """Pushes a patch on the stack
1076 unapplied
= self
.get_unapplied()
1077 assert(name
in unapplied
)
1079 patch
= self
.get_patch(name
)
1081 head
= git
.get_head()
1082 bottom
= patch
.get_bottom()
1083 top
= patch
.get_top()
1084 # top != bottom always since we have a commit for each patch
1087 # A fast-forward push. Just reset the backup
1088 # information. No need for logging
1089 patch
.set_bottom(bottom
, backup
= True)
1090 patch
.set_top(top
, backup
= True)
1093 append_string(self
.__applied_file
, name
)
1095 unapplied
.remove(name
)
1096 write_strings(self
.__unapplied_file
, unapplied
)
1099 # Need to create a new commit an merge in the old patch
1103 # Try the fast applying first. If this fails, fall back to the
1105 if not git
.apply_diff(bottom
, top
):
1106 # if git.apply_diff() fails, the patch requires a diff3
1107 # merge and can be reported as modified
1110 # merge can fail but the patch needs to be pushed
1112 git
.merge(bottom
, head
, top
, recursive
= True)
1113 except git
.GitException
, ex
:
1114 out
.error('The merge failed during "push".',
1115 'Use "refresh" after fixing the conflicts or'
1116 ' revert the operation with "push --undo".')
1118 append_string(self
.__applied_file
, name
)
1120 unapplied
.remove(name
)
1121 write_strings(self
.__unapplied_file
, unapplied
)
1124 # if the merge was OK and no conflicts, just refresh the patch
1125 # The GIT cache was already updated by the merge operation
1130 self
.refresh_patch(bottom
= head
, cache_update
= False, log
= log
)
1132 # we store the correctly merged files only for
1133 # tracking the conflict history. Note that the
1134 # git.merge() operations should always leave the index
1135 # in a valid state (i.e. only stage 0 files)
1136 self
.refresh_patch(bottom
= head
, cache_update
= False,
1138 raise StackException
, str(ex
)
1142 def undo_push(self
):
1143 name
= self
.get_current()
1146 patch
= self
.get_patch(name
)
1147 old_bottom
= patch
.get_old_bottom()
1148 old_top
= patch
.get_old_top()
1150 # the top of the patch is changed by a push operation only
1151 # together with the bottom (otherwise the top was probably
1152 # modified by 'refresh'). If they are both unchanged, there
1153 # was a fast forward
1154 if old_bottom
== patch
.get_bottom() and old_top
!= patch
.get_top():
1155 raise StackException
, 'No undo information available'
1158 self
.pop_patch(name
)
1159 ret
= patch
.restore_old_boundaries()
1161 self
.log_patch(patch
, 'undo')
1165 def pop_patch(self
, name
, keep
= False):
1166 """Pops the top patch from the stack
1168 applied
= self
.get_applied()
1170 assert(name
in applied
)
1172 patch
= self
.get_patch(name
)
1174 if git
.get_head_file() == self
.get_name():
1175 if keep
and not git
.apply_diff(git
.get_head(), patch
.get_bottom(),
1176 check_index
= False):
1177 raise StackException(
1178 'Failed to pop patches while preserving the local changes')
1179 git
.switch(patch
.get_bottom(), keep
)
1181 git
.set_branch(self
.get_name(), patch
.get_bottom())
1183 # save the new applied list
1184 idx
= applied
.index(name
) + 1
1186 popped
= applied
[:idx
]
1188 unapplied
= popped
+ self
.get_unapplied()
1189 write_strings(self
.__unapplied_file
, unapplied
)
1193 write_strings(self
.__applied_file
, applied
)
1195 def empty_patch(self
, name
):
1196 """Returns True if the patch is empty
1198 self
.__patch_name_valid(name
)
1199 patch
= self
.get_patch(name
)
1200 bottom
= patch
.get_bottom()
1201 top
= patch
.get_top()
1205 elif git
.get_commit(top
).get_tree() \
1206 == git
.get_commit(bottom
).get_tree():
1211 def rename_patch(self
, oldname
, newname
):
1212 self
.__patch_name_valid(newname
)
1214 applied
= self
.get_applied()
1215 unapplied
= self
.get_unapplied()
1217 if oldname
== newname
:
1218 raise StackException
, '"To" name and "from" name are the same'
1220 if newname
in applied
or newname
in unapplied
:
1221 raise StackException
, 'Patch "%s" already exists' % newname
1223 if oldname
in unapplied
:
1224 self
.get_patch(oldname
).rename(newname
)
1225 unapplied
[unapplied
.index(oldname
)] = newname
1226 write_strings(self
.__unapplied_file
, unapplied
)
1227 elif oldname
in applied
:
1228 self
.get_patch(oldname
).rename(newname
)
1230 applied
[applied
.index(oldname
)] = newname
1231 write_strings(self
.__applied_file
, applied
)
1233 raise StackException
, 'Unknown patch "%s"' % oldname
1235 def log_patch(self
, patch
, message
, notes
= None):
1236 """Generate a log commit for a patch
1238 top
= git
.get_commit(patch
.get_top())
1239 old_log
= patch
.get_log()
1242 # replace the current log entry
1244 raise StackException
, \
1245 'No log entry to annotate for patch "%s"' \
1248 log_commit
= git
.get_commit(old_log
)
1249 msg
= log_commit
.get_log().split('\n')[0]
1250 log_parent
= log_commit
.get_parent()
1252 parents
= [log_parent
]
1256 # generate a new log entry
1258 msg
= '%s\t%s' %
(message
, top
.get_id_hash())
1265 msg
+= '\n\n' + notes
1267 log
= git
.commit(message
= msg
, parents
= parents
,
1268 cache_update
= False, tree_id
= top
.get_tree(),
1272 def hide_patch(self
, name
):
1273 """Add the patch to the hidden list.
1275 unapplied
= self
.get_unapplied()
1276 if name
not in unapplied
:
1277 # keep the checking order for backward compatibility with
1278 # the old hidden patches functionality
1279 if self
.patch_applied(name
):
1280 raise StackException
, 'Cannot hide applied patch "%s"' % name
1281 elif self
.patch_hidden(name
):
1282 raise StackException
, 'Patch "%s" already hidden' % name
1284 raise StackException
, 'Unknown patch "%s"' % name
1286 if not self
.patch_hidden(name
):
1287 # check needed for backward compatibility with the old
1288 # hidden patches functionality
1289 append_string(self
.__hidden_file
, name
)
1291 unapplied
.remove(name
)
1292 write_strings(self
.__unapplied_file
, unapplied
)
1294 def unhide_patch(self
, name
):
1295 """Remove the patch from the hidden list.
1297 hidden
= self
.get_hidden()
1298 if not name
in hidden
:
1299 if self
.patch_applied(name
) or self
.patch_unapplied(name
):
1300 raise StackException
, 'Patch "%s" not hidden' % name
1302 raise StackException
, 'Unknown patch "%s"' % name
1305 write_strings(self
.__hidden_file
, hidden
)
1307 if not self
.patch_applied(name
) and not self
.patch_unapplied(name
):
1308 # check needed for backward compatibility with the old
1309 # hidden patches functionality
1310 append_string(self
.__unapplied_file
, name
)