f57e4f033bf5616c932d1d360b92ddbf40164700
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:'
95 editor
= config
.get('stgit.editor')
98 elif 'EDITOR' in os
.environ
:
99 editor
= os
.environ
['EDITOR']
102 editor
+= ' %s' % fname
104 print 'Invoking the editor: "%s"...' % editor
,
106 print 'done (exit code: %d)' % os
.system(editor
)
108 f
= file(fname
, 'r+')
124 """An object with stgit-like properties stored as files in a directory
126 def _set_dir(self
, dir):
131 def create_empty_field(self
, name
):
132 create_empty_file(os
.path
.join(self
.__dir
, name
))
134 def _get_field(self
, name
, multiline
= False):
135 id_file
= os
.path
.join(self
.__dir
, name
)
136 if os
.path
.isfile(id_file
):
137 line
= read_string(id_file
, multiline
)
145 def _set_field(self
, name
, value
, multiline
= False):
146 fname
= os
.path
.join(self
.__dir
, name
)
147 if value
and value
!= '':
148 write_string(fname
, value
, multiline
)
149 elif os
.path
.isfile(fname
):
153 class Patch(StgitObject
):
154 """Basic patch implementation
156 def __init__(self
, name
, series_dir
, refs_dir
):
157 self
.__series_dir
= series_dir
159 self
._set_dir(os
.path
.join(self
.__series_dir
, self
.__name
))
160 self
.__refs_dir
= refs_dir
161 self
.__top_ref_file
= os
.path
.join(self
.__refs_dir
, self
.__name
)
162 self
.__log_ref_file
= os
.path
.join(self
.__refs_dir
,
163 self
.__name
+ '.log')
166 os
.mkdir(self
._dir())
167 self
.create_empty_field('bottom')
168 self
.create_empty_field('top')
171 for f
in os
.listdir(self
._dir()):
172 os
.remove(os
.path
.join(self
._dir(), f
))
173 os
.rmdir(self
._dir())
174 os
.remove(self
.__top_ref_file
)
175 if os
.path
.exists(self
.__log_ref_file
):
176 os
.remove(self
.__log_ref_file
)
181 def rename(self
, newname
):
183 old_top_ref_file
= self
.__top_ref_file
184 old_log_ref_file
= self
.__log_ref_file
185 self
.__name
= newname
186 self
._set_dir(os
.path
.join(self
.__series_dir
, self
.__name
))
187 self
.__top_ref_file
= os
.path
.join(self
.__refs_dir
, self
.__name
)
188 self
.__log_ref_file
= os
.path
.join(self
.__refs_dir
,
189 self
.__name
+ '.log')
191 os
.rename(olddir
, self
._dir())
192 os
.rename(old_top_ref_file
, self
.__top_ref_file
)
193 if os
.path
.exists(old_log_ref_file
):
194 os
.rename(old_log_ref_file
, self
.__log_ref_file
)
196 def __update_top_ref(self
, ref
):
197 write_string(self
.__top_ref_file
, ref
)
199 def __update_log_ref(self
, ref
):
200 write_string(self
.__log_ref_file
, ref
)
202 def update_top_ref(self
):
205 self
.__update_top_ref(top
)
207 def get_old_bottom(self
):
208 return self
._get_field('bottom.old')
210 def get_bottom(self
):
211 return self
._get_field('bottom')
213 def set_bottom(self
, value
, backup
= False):
215 curr
= self
._get_field('bottom')
216 self
._set_field('bottom.old', curr
)
217 self
._set_field('bottom', value
)
219 def get_old_top(self
):
220 return self
._get_field('top.old')
223 return self
._get_field('top')
225 def set_top(self
, value
, backup
= False):
227 curr
= self
._get_field('top')
228 self
._set_field('top.old', curr
)
229 self
._set_field('top', value
)
230 self
.__update_top_ref(value
)
232 def restore_old_boundaries(self
):
233 bottom
= self
._get_field('bottom.old')
234 top
= self
._get_field('top.old')
237 self
._set_field('bottom', bottom
)
238 self
._set_field('top', top
)
239 self
.__update_top_ref(top
)
244 def get_description(self
):
245 return self
._get_field('description', True)
247 def set_description(self
, line
):
248 self
._set_field('description', line
, True)
250 def get_authname(self
):
251 return self
._get_field('authname')
253 def set_authname(self
, name
):
254 self
._set_field('authname', name
or git
.author().name
)
256 def get_authemail(self
):
257 return self
._get_field('authemail')
259 def set_authemail(self
, email
):
260 self
._set_field('authemail', email
or git
.author().email
)
262 def get_authdate(self
):
263 return self
._get_field('authdate')
265 def set_authdate(self
, date
):
266 self
._set_field('authdate', date
or git
.author().date
)
268 def get_commname(self
):
269 return self
._get_field('commname')
271 def set_commname(self
, name
):
272 self
._set_field('commname', name
or git
.committer().name
)
274 def get_commemail(self
):
275 return self
._get_field('commemail')
277 def set_commemail(self
, email
):
278 self
._set_field('commemail', email
or git
.committer().email
)
281 return self
._get_field('log')
283 def set_log(self
, value
, backup
= False):
284 self
._set_field('log', value
)
285 self
.__update_log_ref(value
)
288 class Series(StgitObject
):
289 """Class including the operations on series
291 def __init__(self
, name
= None):
292 """Takes a series name as the parameter.
298 self
.__name
= git
.get_head_file()
299 self
.__base_dir
= basedir
.get()
300 except git
.GitException
, ex
:
301 raise StackException
, 'GIT tree not initialised: %s' % ex
303 self
._set_dir(os
.path
.join(self
.__base_dir
, 'patches', self
.__name
))
304 self
.__refs_dir
= os
.path
.join(self
.__base_dir
, 'refs', 'patches',
306 self
.__base_file
= os
.path
.join(self
.__base_dir
, 'refs', 'bases',
309 self
.__applied_file
= os
.path
.join(self
._dir(), 'applied')
310 self
.__unapplied_file
= os
.path
.join(self
._dir(), 'unapplied')
311 self
.__hidden_file
= os
.path
.join(self
._dir(), 'hidden')
312 self
.__current_file
= os
.path
.join(self
._dir(), 'current')
313 self
.__descr_file
= os
.path
.join(self
._dir(), 'description')
315 # where this series keeps its patches
316 self
.__patch_dir
= os
.path
.join(self
._dir(), 'patches')
317 if not os
.path
.isdir(self
.__patch_dir
):
318 self
.__patch_dir
= self
._dir()
320 # if no __refs_dir, create and populate it (upgrade old repositories)
321 if self
.is_initialised() and not os
.path
.isdir(self
.__refs_dir
):
322 os
.makedirs(self
.__refs_dir
)
323 for patch
in self
.get_applied() + self
.get_unapplied():
324 self
.get_patch(patch
).update_top_ref()
327 self
.__trash_dir
= os
.path
.join(self
._dir(), 'trash')
328 if self
.is_initialised() and not os
.path
.isdir(self
.__trash_dir
):
329 os
.makedirs(self
.__trash_dir
)
331 def __patch_name_valid(self
, name
):
332 """Raise an exception if the patch name is not valid.
334 if not name
or re
.search('[^\w.-]', name
):
335 raise StackException
, 'Invalid patch name: "%s"' % name
337 def get_branch(self
):
338 """Return the branch name for the Series object
342 def __set_current(self
, name
):
343 """Sets the topmost patch
345 self
._set_field('current', name
)
347 def get_patch(self
, name
):
348 """Return a Patch object for the given name
350 return Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
352 def get_current_patch(self
):
353 """Return a Patch object representing the topmost patch, or
354 None if there is no such patch."""
355 crt
= self
.get_current()
358 return Patch(crt
, self
.__patch_dir
, self
.__refs_dir
)
360 def get_current(self
):
361 """Return the name of the topmost patch, or None if there is
363 name
= self
._get_field('current')
369 def get_applied(self
):
370 if not os
.path
.isfile(self
.__applied_file
):
371 raise StackException
, 'Branch "%s" not initialised' % self
.__name
372 f
= file(self
.__applied_file
)
373 names
= [line
.strip() for line
in f
.readlines()]
377 def get_unapplied(self
):
378 if not os
.path
.isfile(self
.__unapplied_file
):
379 raise StackException
, 'Branch "%s" not initialised' % self
.__name
380 f
= file(self
.__unapplied_file
)
381 names
= [line
.strip() for line
in f
.readlines()]
385 def get_hidden(self
):
386 if not os
.path
.isfile(self
.__hidden_file
):
388 f
= file(self
.__hidden_file
)
389 names
= [line
.strip() for line
in f
.readlines()]
393 def get_base_file(self
):
394 self
.__begin_stack_check()
395 return self
.__base_file
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 return config
.get('branch.%s.remote' % self
.__name
) or 'origin'
419 def __set_parent_remote(self
, remote
):
420 value
= config
.set('branch.%s.remote' % self
.__name
, remote
)
422 def get_parent_branch(self
):
423 value
= config
.get('branch.%s.merge' % self
.__name
)
426 elif git
.rev_parse('heads/origin'):
427 return 'heads/origin'
429 raise StackException
, 'Cannot find a parent branch for "%s"' % self
.__name
431 def __set_parent_branch(self
, name
):
432 config
.set('branch.%s.merge' % self
.__name
, name
)
434 def set_parent(self
, remote
, localbranch
):
436 self
.__set_parent_branch(localbranch
)
438 self
.__set_parent_remote(remote
)
440 raise StackException
, 'Remote "%s" without a branch cannot be used as parent' % remote
442 def __patch_is_current(self
, patch
):
443 return patch
.get_name() == self
.get_current()
445 def patch_applied(self
, name
):
446 """Return true if the patch exists in the applied list
448 return name
in self
.get_applied()
450 def patch_unapplied(self
, name
):
451 """Return true if the patch exists in the unapplied list
453 return name
in self
.get_unapplied()
455 def patch_hidden(self
, name
):
456 """Return true if the patch is hidden.
458 return name
in self
.get_hidden()
460 def patch_exists(self
, name
):
461 """Return true if there is a patch with the given name, false
463 return self
.patch_applied(name
) or self
.patch_unapplied(name
)
465 def __begin_stack_check(self
):
466 """Save the current HEAD into .git/refs/heads/base if the stack
469 if len(self
.get_applied()) == 0:
470 head
= git
.get_head()
471 write_string(self
.__base_file
, head
)
473 def __end_stack_check(self
):
474 """Remove .git/refs/heads/base if the stack is empty.
475 This warning should never happen
477 if len(self
.get_applied()) == 0 \
478 and read_string(self
.__base_file
) != git
.get_head():
479 print 'Warning: stack empty but the HEAD and base are different'
481 def head_top_equal(self
):
482 """Return true if the head and the top are the same
484 crt
= self
.get_current_patch()
486 # we don't care, no patches applied
488 return git
.get_head() == crt
.get_top()
490 def is_initialised(self
):
491 """Checks if series is already initialised
493 return os
.path
.isdir(self
.__patch_dir
)
495 def init(self
, create_at
=False, parent_remote
=None, parent_branch
=None):
496 """Initialises the stgit series
498 bases_dir
= os
.path
.join(self
.__base_dir
, 'refs', 'bases')
500 if os
.path
.exists(self
.__patch_dir
):
501 raise StackException
, self
.__patch_dir
+ ' already exists'
502 if os
.path
.exists(self
.__refs_dir
):
503 raise StackException
, self
.__refs_dir
+ ' already exists'
504 if os
.path
.exists(self
.__base_file
):
505 raise StackException
, self
.__base_file
+ ' already exists'
507 if (create_at
!=False):
508 git
.create_branch(self
.__name
, create_at
)
510 os
.makedirs(self
.__patch_dir
)
512 self
.set_parent(parent_remote
, parent_branch
)
514 create_dirs(bases_dir
)
516 self
.create_empty_field('applied')
517 self
.create_empty_field('unapplied')
518 self
.create_empty_field('description')
519 os
.makedirs(os
.path
.join(self
._dir(), 'patches'))
520 os
.makedirs(self
.__refs_dir
)
521 self
.__begin_stack_check()
524 """Either convert to use a separate patch directory, or
525 unconvert to place the patches in the same directory with
528 if self
.__patch_dir
== self
._dir():
529 print 'Converting old-style to new-style...',
532 self
.__patch_dir
= os
.path
.join(self
._dir(), 'patches')
533 os
.makedirs(self
.__patch_dir
)
535 for p
in self
.get_applied() + self
.get_unapplied():
536 src
= os
.path
.join(self
._dir(), p
)
537 dest
= os
.path
.join(self
.__patch_dir
, p
)
543 print 'Converting new-style to old-style...',
546 for p
in self
.get_applied() + self
.get_unapplied():
547 src
= os
.path
.join(self
.__patch_dir
, p
)
548 dest
= os
.path
.join(self
._dir(), p
)
551 if not os
.listdir(self
.__patch_dir
):
552 os
.rmdir(self
.__patch_dir
)
555 print 'Patch directory %s is not empty.' % self
.__name
557 self
.__patch_dir
= self
._dir()
559 def rename(self
, to_name
):
562 to_stack
= Series(to_name
)
564 if to_stack
.is_initialised():
565 raise StackException
, '"%s" already exists' % to_stack
.get_branch()
566 if os
.path
.exists(to_stack
.__base_file
):
567 os
.remove(to_stack
.__base_file
)
569 git
.rename_branch(self
.__name
, to_name
)
571 if os
.path
.isdir(self
._dir()):
572 rename(os
.path
.join(self
.__base_dir
, 'patches'),
573 self
.__name
, to_stack
.__name
)
574 if os
.path
.exists(self
.__base_file
):
575 rename(os
.path
.join(self
.__base_dir
, 'refs', 'bases'),
576 self
.__name
, to_stack
.__name
)
577 if os
.path
.exists(self
.__refs_dir
):
578 rename(os
.path
.join(self
.__base_dir
, 'refs', 'patches'),
579 self
.__name
, to_stack
.__name
)
581 self
.__init__(to_name
)
583 def clone(self
, target_series
):
587 # allow cloning of branches not under StGIT control
588 base
= read_string(self
.get_base_file())
590 base
= git
.get_head()
591 Series(target_series
).init(create_at
= base
)
592 new_series
= Series(target_series
)
594 # generate an artificial description file
595 new_series
.set_description('clone of "%s"' % self
.__name
)
597 # clone self's entire series as unapplied patches
599 # allow cloning of branches not under StGIT control
600 applied
= self
.get_applied()
601 unapplied
= self
.get_unapplied()
602 patches
= applied
+ unapplied
605 patches
= applied
= unapplied
= []
607 patch
= self
.get_patch(p
)
608 new_series
.new_patch(p
, message
= patch
.get_description(),
609 can_edit
= False, unapplied
= True,
610 bottom
= patch
.get_bottom(),
611 top
= patch
.get_top(),
612 author_name
= patch
.get_authname(),
613 author_email
= patch
.get_authemail(),
614 author_date
= patch
.get_authdate())
616 # fast forward the cloned series to self's top
617 new_series
.forward_patches(applied
)
619 def delete(self
, force
= False):
620 """Deletes an stgit series
622 if self
.is_initialised():
623 patches
= self
.get_unapplied() + self
.get_applied()
624 if not force
and patches
:
625 raise StackException
, \
626 'Cannot delete: the series still contains patches'
628 Patch(p
, self
.__patch_dir
, self
.__refs_dir
).delete()
630 # remove the trash directory
631 for fname
in os
.listdir(self
.__trash_dir
):
633 os
.rmdir(self
.__trash_dir
)
635 # FIXME: find a way to get rid of those manual removals
636 # (move functionnality to StgitObject ?)
637 if os
.path
.exists(self
.__applied_file
):
638 os
.remove(self
.__applied_file
)
639 if os
.path
.exists(self
.__unapplied_file
):
640 os
.remove(self
.__unapplied_file
)
641 if os
.path
.exists(self
.__hidden_file
):
642 os
.remove(self
.__hidden_file
)
643 if os
.path
.exists(self
.__current_file
):
644 os
.remove(self
.__current_file
)
645 if os
.path
.exists(self
.__descr_file
):
646 os
.remove(self
.__descr_file
)
647 if not os
.listdir(self
.__patch_dir
):
648 os
.rmdir(self
.__patch_dir
)
650 print 'Patch directory %s is not empty.' % self
.__name
651 if not os
.listdir(self
._dir()):
652 remove_dirs(os
.path
.join(self
.__base_dir
, 'patches'),
655 print 'Series directory %s is not empty.' % self
.__name
656 if not os
.listdir(self
.__refs_dir
):
657 remove_dirs(os
.path
.join(self
.__base_dir
, 'refs', 'patches'),
660 print 'Refs directory %s is not empty.' % self
.__refs_dir
662 if os
.path
.exists(self
.__base_file
):
663 remove_file_and_dirs(
664 os
.path
.join(self
.__base_dir
, 'refs', 'bases'), self
.__name
)
666 def refresh_patch(self
, files
= None, message
= None, edit
= False,
669 author_name
= None, author_email
= None,
671 committer_name
= None, committer_email
= None,
672 backup
= False, sign_str
= None, log
= 'refresh'):
673 """Generates a new commit for the given patch
675 name
= self
.get_current()
677 raise StackException
, 'No patches applied'
679 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
681 descr
= patch
.get_description()
682 if not (message
or descr
):
688 if not message
and edit
:
689 descr
= edit_file(self
, descr
.rstrip(), \
690 'Please edit the description for patch "%s" ' \
691 'above.' % name
, show_patch
)
694 author_name
= patch
.get_authname()
696 author_email
= patch
.get_authemail()
698 author_date
= patch
.get_authdate()
699 if not committer_name
:
700 committer_name
= patch
.get_commname()
701 if not committer_email
:
702 committer_email
= patch
.get_commemail()
705 descr
= '%s\n%s: %s <%s>\n' %
(descr
.rstrip(), sign_str
,
706 committer_name
, committer_email
)
708 bottom
= patch
.get_bottom()
710 commit_id
= git
.commit(files
= files
,
711 message
= descr
, parents
= [bottom
],
712 cache_update
= cache_update
,
714 author_name
= author_name
,
715 author_email
= author_email
,
716 author_date
= author_date
,
717 committer_name
= committer_name
,
718 committer_email
= committer_email
)
720 patch
.set_bottom(bottom
, backup
= backup
)
721 patch
.set_top(commit_id
, backup
= backup
)
722 patch
.set_description(descr
)
723 patch
.set_authname(author_name
)
724 patch
.set_authemail(author_email
)
725 patch
.set_authdate(author_date
)
726 patch
.set_commname(committer_name
)
727 patch
.set_commemail(committer_email
)
730 self
.log_patch(patch
, log
)
734 def undo_refresh(self
):
735 """Undo the patch boundaries changes caused by 'refresh'
737 name
= self
.get_current()
740 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
741 old_bottom
= patch
.get_old_bottom()
742 old_top
= patch
.get_old_top()
744 # the bottom of the patch is not changed by refresh. If the
745 # old_bottom is different, there wasn't any previous 'refresh'
746 # command (probably only a 'push')
747 if old_bottom
!= patch
.get_bottom() or old_top
== patch
.get_top():
748 raise StackException
, 'No undo information available'
750 git
.reset(tree_id
= old_top
, check_out
= False)
751 if patch
.restore_old_boundaries():
752 self
.log_patch(patch
, 'undo')
754 def new_patch(self
, name
, message
= None, can_edit
= True,
755 unapplied
= False, show_patch
= False,
756 top
= None, bottom
= None,
757 author_name
= None, author_email
= None, author_date
= None,
758 committer_name
= None, committer_email
= None,
759 before_existing
= False, refresh
= True):
760 """Creates a new patch
762 self
.__patch_name_valid(name
)
764 if self
.patch_applied(name
) or self
.patch_unapplied(name
):
765 raise StackException
, 'Patch "%s" already exists' % name
767 if not message
and can_edit
:
768 descr
= edit_file(self
, None, \
769 'Please enter the description for patch "%s" ' \
770 'above.' % name
, show_patch
)
774 head
= git
.get_head()
776 self
.__begin_stack_check()
778 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
782 patch
.set_bottom(bottom
)
784 patch
.set_bottom(head
)
790 patch
.set_description(descr
)
791 patch
.set_authname(author_name
)
792 patch
.set_authemail(author_email
)
793 patch
.set_authdate(author_date
)
794 patch
.set_commname(committer_name
)
795 patch
.set_commemail(committer_email
)
798 self
.log_patch(patch
, 'new')
800 patches
= [patch
.get_name()] + self
.get_unapplied()
802 f
= file(self
.__unapplied_file
, 'w+')
803 f
.writelines([line
+ '\n' for line
in patches
])
805 elif before_existing
:
806 self
.log_patch(patch
, 'new')
808 insert_string(self
.__applied_file
, patch
.get_name())
809 if not self
.get_current():
810 self
.__set_current(name
)
812 append_string(self
.__applied_file
, patch
.get_name())
813 self
.__set_current(name
)
815 self
.refresh_patch(cache_update
= False, log
= 'new')
817 def delete_patch(self
, name
):
820 self
.__patch_name_valid(name
)
821 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
823 if self
.__patch_is_current(patch
):
825 elif self
.patch_applied(name
):
826 raise StackException
, 'Cannot remove an applied patch, "%s", ' \
827 'which is not current' % name
828 elif not name
in self
.get_unapplied():
829 raise StackException
, 'Unknown patch "%s"' % name
831 # save the commit id to a trash file
832 write_string(os
.path
.join(self
.__trash_dir
, name
), patch
.get_top())
836 unapplied
= self
.get_unapplied()
837 unapplied
.remove(name
)
838 f
= file(self
.__unapplied_file
, 'w+')
839 f
.writelines([line
+ '\n' for line
in unapplied
])
842 if self
.patch_hidden(name
):
843 self
.unhide_patch(name
)
845 self
.__begin_stack_check()
847 def forward_patches(self
, names
):
848 """Try to fast-forward an array of patches.
850 On return, patches in names[0:returned_value] have been pushed on the
851 stack. Apply the rest with push_patch
853 unapplied
= self
.get_unapplied()
854 self
.__begin_stack_check()
860 assert(name
in unapplied
)
862 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
865 bottom
= patch
.get_bottom()
866 top
= patch
.get_top()
868 # top != bottom always since we have a commit for each patch
870 # reset the backup information. No logging since the
871 # patch hasn't changed
872 patch
.set_bottom(head
, backup
= True)
873 patch
.set_top(top
, backup
= True)
876 head_tree
= git
.get_commit(head
).get_tree()
877 bottom_tree
= git
.get_commit(bottom
).get_tree()
878 if head_tree
== bottom_tree
:
879 # We must just reparent this patch and create a new commit
881 descr
= patch
.get_description()
882 author_name
= patch
.get_authname()
883 author_email
= patch
.get_authemail()
884 author_date
= patch
.get_authdate()
885 committer_name
= patch
.get_commname()
886 committer_email
= patch
.get_commemail()
888 top_tree
= git
.get_commit(top
).get_tree()
890 top
= git
.commit(message
= descr
, parents
= [head
],
891 cache_update
= False,
894 author_name
= author_name
,
895 author_email
= author_email
,
896 author_date
= author_date
,
897 committer_name
= committer_name
,
898 committer_email
= committer_email
)
900 patch
.set_bottom(head
, backup
= True)
901 patch
.set_top(top
, backup
= True)
903 self
.log_patch(patch
, 'push(f)')
906 # stop the fast-forwarding, must do a real merge
910 unapplied
.remove(name
)
917 append_strings(self
.__applied_file
, names
[0:forwarded
])
919 f
= file(self
.__unapplied_file
, 'w+')
920 f
.writelines([line
+ '\n' for line
in unapplied
])
923 self
.__set_current(name
)
927 def merged_patches(self
, names
):
928 """Test which patches were merged upstream by reverse-applying
929 them in reverse order. The function returns the list of
930 patches detected to have been applied. The state of the tree
931 is restored to the original one
933 patches
= [Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
939 if git
.apply_diff(p
.get_top(), p
.get_bottom()):
940 merged
.append(p
.get_name())
947 def push_patch(self
, name
, empty
= False):
948 """Pushes a patch on the stack
950 unapplied
= self
.get_unapplied()
951 assert(name
in unapplied
)
953 self
.__begin_stack_check()
955 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
957 head
= git
.get_head()
958 bottom
= patch
.get_bottom()
959 top
= patch
.get_top()
964 # top != bottom always since we have a commit for each patch
966 # just make an empty patch (top = bottom = HEAD). This
967 # option is useful to allow undoing already merged
968 # patches. The top is updated by refresh_patch since we
969 # need an empty commit
970 patch
.set_bottom(head
, backup
= True)
971 patch
.set_top(head
, backup
= True)
974 # reset the backup information. No need for logging
975 patch
.set_bottom(bottom
, backup
= True)
976 patch
.set_top(top
, backup
= True)
980 # new patch needs to be refreshed.
981 # The current patch is empty after merge.
982 patch
.set_bottom(head
, backup
= True)
983 patch
.set_top(head
, backup
= True)
985 # Try the fast applying first. If this fails, fall back to the
987 if not git
.apply_diff(bottom
, top
):
988 # if git.apply_diff() fails, the patch requires a diff3
989 # merge and can be reported as modified
992 # merge can fail but the patch needs to be pushed
994 git
.merge(bottom
, head
, top
, recursive
= True)
995 except git
.GitException
, ex
:
996 print >> sys
.stderr
, \
997 'The merge failed during "push". ' \
998 'Use "refresh" after fixing the conflicts'
1000 append_string(self
.__applied_file
, name
)
1002 unapplied
.remove(name
)
1003 f
= file(self
.__unapplied_file
, 'w+')
1004 f
.writelines([line
+ '\n' for line
in unapplied
])
1007 self
.__set_current(name
)
1009 # head == bottom case doesn't need to refresh the patch
1010 if empty
or head
!= bottom
:
1012 # if the merge was OK and no conflicts, just refresh the patch
1013 # The GIT cache was already updated by the merge operation
1018 self
.refresh_patch(cache_update
= False, log
= log
)
1020 # we store the correctly merged files only for
1021 # tracking the conflict history. Note that the
1022 # git.merge() operations shouls always leave the index
1023 # in a valid state (i.e. only stage 0 files)
1024 self
.refresh_patch(cache_update
= False, log
= 'push(c)')
1025 raise StackException
, str(ex
)
1029 def undo_push(self
):
1030 name
= self
.get_current()
1033 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
1034 old_bottom
= patch
.get_old_bottom()
1035 old_top
= patch
.get_old_top()
1037 # the top of the patch is changed by a push operation only
1038 # together with the bottom (otherwise the top was probably
1039 # modified by 'refresh'). If they are both unchanged, there
1040 # was a fast forward
1041 if old_bottom
== patch
.get_bottom() and old_top
!= patch
.get_top():
1042 raise StackException
, 'No undo information available'
1045 self
.pop_patch(name
)
1046 ret
= patch
.restore_old_boundaries()
1048 self
.log_patch(patch
, 'undo')
1052 def pop_patch(self
, name
, keep
= False):
1053 """Pops the top patch from the stack
1055 applied
= self
.get_applied()
1057 assert(name
in applied
)
1059 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
1061 # only keep the local changes
1062 if keep
and not git
.apply_diff(git
.get_head(), patch
.get_bottom()):
1063 raise StackException
, \
1064 'Failed to pop patches while preserving the local changes'
1066 git
.switch(patch
.get_bottom(), keep
)
1068 # save the new applied list
1069 idx
= applied
.index(name
) + 1
1071 popped
= applied
[:idx
]
1073 unapplied
= popped
+ self
.get_unapplied()
1075 f
= file(self
.__unapplied_file
, 'w+')
1076 f
.writelines([line
+ '\n' for line
in unapplied
])
1082 f
= file(self
.__applied_file
, 'w+')
1083 f
.writelines([line
+ '\n' for line
in applied
])
1087 self
.__set_current(None)
1089 self
.__set_current(applied
[-1])
1091 self
.__end_stack_check()
1093 def empty_patch(self
, name
):
1094 """Returns True if the patch is empty
1096 self
.__patch_name_valid(name
)
1097 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
1098 bottom
= patch
.get_bottom()
1099 top
= patch
.get_top()
1103 elif git
.get_commit(top
).get_tree() \
1104 == git
.get_commit(bottom
).get_tree():
1109 def rename_patch(self
, oldname
, newname
):
1110 self
.__patch_name_valid(newname
)
1112 applied
= self
.get_applied()
1113 unapplied
= self
.get_unapplied()
1115 if oldname
== newname
:
1116 raise StackException
, '"To" name and "from" name are the same'
1118 if newname
in applied
or newname
in unapplied
:
1119 raise StackException
, 'Patch "%s" already exists' % newname
1121 if self
.patch_hidden(oldname
):
1122 self
.unhide_patch(oldname
)
1123 self
.hide_patch(newname
)
1125 if oldname
in unapplied
:
1126 Patch(oldname
, self
.__patch_dir
, self
.__refs_dir
).rename(newname
)
1127 unapplied
[unapplied
.index(oldname
)] = newname
1129 f
= file(self
.__unapplied_file
, 'w+')
1130 f
.writelines([line
+ '\n' for line
in unapplied
])
1132 elif oldname
in applied
:
1133 Patch(oldname
, self
.__patch_dir
, self
.__refs_dir
).rename(newname
)
1134 if oldname
== self
.get_current():
1135 self
.__set_current(newname
)
1137 applied
[applied
.index(oldname
)] = newname
1139 f
= file(self
.__applied_file
, 'w+')
1140 f
.writelines([line
+ '\n' for line
in applied
])
1143 raise StackException
, 'Unknown patch "%s"' % oldname
1145 def log_patch(self
, patch
, message
):
1146 """Generate a log commit for a patch
1148 top
= git
.get_commit(patch
.get_top())
1149 msg
= '%s\t%s' %
(message
, top
.get_id_hash())
1151 old_log
= patch
.get_log()
1157 log
= git
.commit(message
= msg
, parents
= parents
,
1158 cache_update
= False, tree_id
= top
.get_tree(),
1162 def hide_patch(self
, name
):
1163 """Add the patch to the hidden list.
1165 if not self
.patch_exists(name
):
1166 raise StackException
, 'Unknown patch "%s"' % name
1167 elif self
.patch_hidden(name
):
1168 raise StackException
, 'Patch "%s" already hidden' % name
1170 append_string(self
.__hidden_file
, name
)
1172 def unhide_patch(self
, name
):
1173 """Add the patch to the hidden list.
1175 if not self
.patch_exists(name
):
1176 raise StackException
, 'Unknown patch "%s"' % name
1177 hidden
= self
.get_hidden()
1178 if not name
in hidden
:
1179 raise StackException
, 'Patch "%s" not hidden' % name
1183 f
= file(self
.__hidden_file
, 'w+')
1184 f
.writelines([line
+ '\n' for line
in hidden
])