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 if config
.has_option('stgit', 'editor'):
96 editor
= config
.get('stgit', 'editor')
97 elif 'EDITOR' in os
.environ
:
98 editor
= os
.environ
['EDITOR']
101 editor
+= ' %s' % fname
103 print 'Invoking the editor: "%s"...' % editor
,
105 print 'done (exit code: %d)' % os
.system(editor
)
107 f
= file(fname
, 'r+')
123 """Basic patch implementation
125 def __init__(self
, name
, series_dir
, refs_dir
):
126 self
.__series
_dir
= series_dir
128 self
.__dir
= os
.path
.join(self
.__series
_dir
, self
.__name
)
129 self
.__refs
_dir
= refs_dir
130 self
.__top
_ref
_file
= os
.path
.join(self
.__refs
_dir
, self
.__name
)
134 create_empty_file(os
.path
.join(self
.__dir
, 'bottom'))
135 create_empty_file(os
.path
.join(self
.__dir
, 'top'))
138 for f
in os
.listdir(self
.__dir
):
139 os
.remove(os
.path
.join(self
.__dir
, f
))
141 os
.remove(self
.__top
_ref
_file
)
146 def rename(self
, newname
):
148 old_ref_file
= self
.__top
_ref
_file
149 self
.__name
= newname
150 self
.__dir
= os
.path
.join(self
.__series
_dir
, self
.__name
)
151 self
.__top
_ref
_file
= os
.path
.join(self
.__refs
_dir
, self
.__name
)
153 os
.rename(olddir
, self
.__dir
)
154 os
.rename(old_ref_file
, self
.__top
_ref
_file
)
156 def __update_top_ref(self
, ref
):
157 write_string(self
.__top
_ref
_file
, ref
)
159 def update_top_ref(self
):
162 self
.__update
_top
_ref
(top
)
164 def __get_field(self
, name
, multiline
= False):
165 id_file
= os
.path
.join(self
.__dir
, name
)
166 if os
.path
.isfile(id_file
):
167 line
= read_string(id_file
, multiline
)
175 def __set_field(self
, name
, value
, multiline
= False):
176 fname
= os
.path
.join(self
.__dir
, name
)
177 if value
and value
!= '':
178 write_string(fname
, value
, multiline
)
179 elif os
.path
.isfile(fname
):
182 def get_old_bottom(self
):
183 return self
.__get
_field
('bottom.old')
185 def get_bottom(self
):
186 return self
.__get
_field
('bottom')
188 def set_bottom(self
, value
, backup
= False):
190 curr
= self
.__get
_field
('bottom')
191 self
.__set
_field
('bottom.old', curr
)
192 self
.__set
_field
('bottom', value
)
194 def get_old_top(self
):
195 return self
.__get
_field
('top.old')
198 return self
.__get
_field
('top')
200 def set_top(self
, value
, backup
= False):
202 curr
= self
.__get
_field
('top')
203 self
.__set
_field
('top.old', curr
)
204 self
.__set
_field
('top', value
)
205 self
.__update
_top
_ref
(value
)
207 def restore_old_boundaries(self
):
208 bottom
= self
.__get
_field
('bottom.old')
209 top
= self
.__get
_field
('top.old')
212 self
.__set
_field
('bottom', bottom
)
213 self
.__set
_field
('top', top
)
214 self
.__update
_top
_ref
(top
)
219 def get_description(self
):
220 return self
.__get
_field
('description', True)
222 def set_description(self
, line
):
223 self
.__set
_field
('description', line
, True)
225 def get_authname(self
):
226 return self
.__get
_field
('authname')
228 def set_authname(self
, name
):
230 if config
.has_option('stgit', 'authname'):
231 name
= config
.get('stgit', 'authname')
232 elif 'GIT_AUTHOR_NAME' in os
.environ
:
233 name
= os
.environ
['GIT_AUTHOR_NAME']
234 self
.__set
_field
('authname', name
)
236 def get_authemail(self
):
237 return self
.__get
_field
('authemail')
239 def set_authemail(self
, address
):
241 if config
.has_option('stgit', 'authemail'):
242 address
= config
.get('stgit', 'authemail')
243 elif 'GIT_AUTHOR_EMAIL' in os
.environ
:
244 address
= os
.environ
['GIT_AUTHOR_EMAIL']
245 self
.__set
_field
('authemail', address
)
247 def get_authdate(self
):
248 return self
.__get
_field
('authdate')
250 def set_authdate(self
, date
):
251 if not date
and 'GIT_AUTHOR_DATE' in os
.environ
:
252 date
= os
.environ
['GIT_AUTHOR_DATE']
253 self
.__set
_field
('authdate', date
)
255 def get_commname(self
):
256 return self
.__get
_field
('commname')
258 def set_commname(self
, name
):
260 if config
.has_option('stgit', 'commname'):
261 name
= config
.get('stgit', 'commname')
262 elif 'GIT_COMMITTER_NAME' in os
.environ
:
263 name
= os
.environ
['GIT_COMMITTER_NAME']
264 self
.__set
_field
('commname', name
)
266 def get_commemail(self
):
267 return self
.__get
_field
('commemail')
269 def set_commemail(self
, address
):
271 if config
.has_option('stgit', 'commemail'):
272 address
= config
.get('stgit', 'commemail')
273 elif 'GIT_COMMITTER_EMAIL' in os
.environ
:
274 address
= os
.environ
['GIT_COMMITTER_EMAIL']
275 self
.__set
_field
('commemail', address
)
279 """Class including the operations on series
281 def __init__(self
, name
= None):
282 """Takes a series name as the parameter.
288 self
.__name
= git
.get_head_file()
289 self
.__base
_dir
= basedir
.get()
290 except git
.GitException
, ex
:
291 raise StackException
, 'GIT tree not initialised: %s' % ex
293 self
.__series
_dir
= os
.path
.join(self
.__base
_dir
, 'patches',
295 self
.__refs
_dir
= os
.path
.join(self
.__base
_dir
, 'refs', 'patches',
297 self
.__base
_file
= os
.path
.join(self
.__base
_dir
, 'refs', 'bases',
300 self
.__applied
_file
= os
.path
.join(self
.__series
_dir
, 'applied')
301 self
.__unapplied
_file
= os
.path
.join(self
.__series
_dir
, 'unapplied')
302 self
.__current
_file
= os
.path
.join(self
.__series
_dir
, 'current')
303 self
.__descr
_file
= os
.path
.join(self
.__series
_dir
, 'description')
305 # where this series keeps its patches
306 self
.__patch
_dir
= os
.path
.join(self
.__series
_dir
, 'patches')
307 if not os
.path
.isdir(self
.__patch
_dir
):
308 self
.__patch
_dir
= self
.__series
_dir
310 # if no __refs_dir, create and populate it (upgrade old repositories)
311 if self
.is_initialised() and not os
.path
.isdir(self
.__refs
_dir
):
312 os
.makedirs(self
.__refs
_dir
)
313 for patch
in self
.get_applied() + self
.get_unapplied():
314 self
.get_patch(patch
).update_top_ref()
316 def get_branch(self
):
317 """Return the branch name for the Series object
321 def __set_current(self
, name
):
322 """Sets the topmost patch
325 write_string(self
.__current
_file
, name
)
327 create_empty_file(self
.__current
_file
)
329 def get_patch(self
, name
):
330 """Return a Patch object for the given name
332 return Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
334 def get_current(self
):
335 """Return a Patch object representing the topmost patch
337 if os
.path
.isfile(self
.__current
_file
):
338 name
= read_string(self
.__current
_file
)
346 def get_applied(self
):
347 if not os
.path
.isfile(self
.__applied
_file
):
348 raise StackException
, 'Branch "%s" not initialised' % self
.__name
349 f
= file(self
.__applied
_file
)
350 names
= [line
.strip() for line
in f
.readlines()]
354 def get_unapplied(self
):
355 if not os
.path
.isfile(self
.__unapplied
_file
):
356 raise StackException
, 'Branch "%s" not initialised' % self
.__name
357 f
= file(self
.__unapplied
_file
)
358 names
= [line
.strip() for line
in f
.readlines()]
362 def get_base_file(self
):
363 self
.__begin
_stack
_check
()
364 return self
.__base
_file
366 def get_protected(self
):
367 return os
.path
.isfile(os
.path
.join(self
.__series
_dir
, 'protected'))
370 protect_file
= os
.path
.join(self
.__series
_dir
, 'protected')
371 if not os
.path
.isfile(protect_file
):
372 create_empty_file(protect_file
)
375 protect_file
= os
.path
.join(self
.__series
_dir
, 'protected')
376 if os
.path
.isfile(protect_file
):
377 os
.remove(protect_file
)
379 def get_description(self
):
380 if os
.path
.isfile(self
.__descr
_file
):
381 return read_string(self
.__descr
_file
)
385 def __patch_is_current(self
, patch
):
386 return patch
.get_name() == read_string(self
.__current
_file
)
388 def __patch_applied(self
, name
):
389 """Return true if the patch exists in the applied list
391 return name
in self
.get_applied()
393 def __patch_unapplied(self
, name
):
394 """Return true if the patch exists in the unapplied list
396 return name
in self
.get_unapplied()
398 def __begin_stack_check(self
):
399 """Save the current HEAD into .git/refs/heads/base if the stack
402 if len(self
.get_applied()) == 0:
403 head
= git
.get_head()
404 write_string(self
.__base
_file
, head
)
406 def __end_stack_check(self
):
407 """Remove .git/refs/heads/base if the stack is empty.
408 This warning should never happen
410 if len(self
.get_applied()) == 0 \
411 and read_string(self
.__base
_file
) != git
.get_head():
412 print 'Warning: stack empty but the HEAD and base are different'
414 def head_top_equal(self
):
415 """Return true if the head and the top are the same
417 crt
= self
.get_current()
419 # we don't care, no patches applied
421 return git
.get_head() == Patch(crt
, self
.__patch
_dir
,
422 self
.__refs
_dir
).get_top()
424 def is_initialised(self
):
425 """Checks if series is already initialised
427 return os
.path
.isdir(self
.__patch
_dir
)
429 def init(self
, create_at
=False):
430 """Initialises the stgit series
432 bases_dir
= os
.path
.join(self
.__base
_dir
, 'refs', 'bases')
434 if os
.path
.exists(self
.__patch
_dir
):
435 raise StackException
, self
.__patch
_dir
+ ' already exists'
436 if os
.path
.exists(self
.__refs
_dir
):
437 raise StackException
, self
.__refs
_dir
+ ' already exists'
438 if os
.path
.exists(self
.__base
_file
):
439 raise StackException
, self
.__base
_file
+ ' already exists'
441 if (create_at
!=False):
442 git
.create_branch(self
.__name
, create_at
)
444 os
.makedirs(self
.__patch
_dir
)
446 create_dirs(bases_dir
)
448 create_empty_file(self
.__applied
_file
)
449 create_empty_file(self
.__unapplied
_file
)
450 create_empty_file(self
.__descr
_file
)
451 os
.makedirs(os
.path
.join(self
.__series
_dir
, 'patches'))
452 os
.makedirs(self
.__refs
_dir
)
453 self
.__begin
_stack
_check
()
456 """Either convert to use a separate patch directory, or
457 unconvert to place the patches in the same directory with
460 if self
.__patch
_dir
== self
.__series
_dir
:
461 print 'Converting old-style to new-style...',
464 self
.__patch
_dir
= os
.path
.join(self
.__series
_dir
, 'patches')
465 os
.makedirs(self
.__patch
_dir
)
467 for p
in self
.get_applied() + self
.get_unapplied():
468 src
= os
.path
.join(self
.__series
_dir
, p
)
469 dest
= os
.path
.join(self
.__patch
_dir
, p
)
475 print 'Converting new-style to old-style...',
478 for p
in self
.get_applied() + self
.get_unapplied():
479 src
= os
.path
.join(self
.__patch
_dir
, p
)
480 dest
= os
.path
.join(self
.__series
_dir
, p
)
483 if not os
.listdir(self
.__patch
_dir
):
484 os
.rmdir(self
.__patch
_dir
)
487 print 'Patch directory %s is not empty.' % self
.__name
489 self
.__patch
_dir
= self
.__series
_dir
491 def rename(self
, to_name
):
494 to_stack
= Series(to_name
)
496 if to_stack
.is_initialised():
497 raise StackException
, '"%s" already exists' % to_stack
.get_branch()
498 if os
.path
.exists(to_stack
.__base
_file
):
499 os
.remove(to_stack
.__base
_file
)
501 git
.rename_branch(self
.__name
, to_name
)
503 if os
.path
.isdir(self
.__series
_dir
):
504 rename(os
.path
.join(self
.__base
_dir
, 'patches'),
505 self
.__name
, to_stack
.__name
)
506 if os
.path
.exists(self
.__base
_file
):
507 rename(os
.path
.join(self
.__base
_dir
, 'refs', 'bases'),
508 self
.__name
, to_stack
.__name
)
509 if os
.path
.exists(self
.__refs
_dir
):
510 rename(os
.path
.join(self
.__base
_dir
, 'refs', 'patches'),
511 self
.__name
, to_stack
.__name
)
513 self
.__init
__(to_name
)
515 def clone(self
, target_series
):
518 base
= read_string(self
.get_base_file())
519 Series(target_series
).init(create_at
= base
)
520 new_series
= Series(target_series
)
522 # generate an artificial description file
523 write_string(new_series
.__descr
_file
, 'clone of "%s"' % self
.__name
)
525 # clone self's entire series as unapplied patches
526 patches
= self
.get_applied() + self
.get_unapplied()
529 patch
= self
.get_patch(p
)
530 new_series
.new_patch(p
, message
= patch
.get_description(),
531 can_edit
= False, unapplied
= True,
532 bottom
= patch
.get_bottom(),
533 top
= patch
.get_top(),
534 author_name
= patch
.get_authname(),
535 author_email
= patch
.get_authemail(),
536 author_date
= patch
.get_authdate())
538 # fast forward the cloned series to self's top
539 new_series
.forward_patches(self
.get_applied())
541 def delete(self
, force
= False):
542 """Deletes an stgit series
544 if self
.is_initialised():
545 patches
= self
.get_unapplied() + self
.get_applied()
546 if not force
and patches
:
547 raise StackException
, \
548 'Cannot delete: the series still contains patches'
550 Patch(p
, self
.__patch
_dir
, self
.__refs
_dir
).delete()
552 if os
.path
.exists(self
.__applied
_file
):
553 os
.remove(self
.__applied
_file
)
554 if os
.path
.exists(self
.__unapplied
_file
):
555 os
.remove(self
.__unapplied
_file
)
556 if os
.path
.exists(self
.__current
_file
):
557 os
.remove(self
.__current
_file
)
558 if os
.path
.exists(self
.__descr
_file
):
559 os
.remove(self
.__descr
_file
)
560 if not os
.listdir(self
.__patch
_dir
):
561 os
.rmdir(self
.__patch
_dir
)
563 print 'Patch directory %s is not empty.' % self
.__name
564 if not os
.listdir(self
.__series
_dir
):
565 remove_dirs(os
.path
.join(self
.__base
_dir
, 'patches'),
568 print 'Series directory %s is not empty.' % self
.__name
569 if not os
.listdir(self
.__refs
_dir
):
570 remove_dirs(os
.path
.join(self
.__base
_dir
, 'refs', 'patches'),
573 print 'Refs directory %s is not empty.' % self
.__refs
_dir
575 if os
.path
.exists(self
.__base
_file
):
576 remove_file_and_dirs(
577 os
.path
.join(self
.__base
_dir
, 'refs', 'bases'), self
.__name
)
579 def refresh_patch(self
, files
= None, message
= None, edit
= False,
582 author_name
= None, author_email
= None,
584 committer_name
= None, committer_email
= None,
586 """Generates a new commit for the given patch
588 name
= self
.get_current()
590 raise StackException
, 'No patches applied'
592 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
594 descr
= patch
.get_description()
595 if not (message
or descr
):
601 if not message
and edit
:
602 descr
= edit_file(self
, descr
.rstrip(), \
603 'Please edit the description for patch "%s" ' \
604 'above.' % name
, show_patch
)
607 author_name
= patch
.get_authname()
609 author_email
= patch
.get_authemail()
611 author_date
= patch
.get_authdate()
612 if not committer_name
:
613 committer_name
= patch
.get_commname()
614 if not committer_email
:
615 committer_email
= patch
.get_commemail()
617 bottom
= patch
.get_bottom()
619 commit_id
= git
.commit(files
= files
,
620 message
= descr
, parents
= [bottom
],
621 cache_update
= cache_update
,
623 author_name
= author_name
,
624 author_email
= author_email
,
625 author_date
= author_date
,
626 committer_name
= committer_name
,
627 committer_email
= committer_email
)
629 patch
.set_bottom(bottom
, backup
= backup
)
630 patch
.set_top(commit_id
, backup
= backup
)
631 patch
.set_description(descr
)
632 patch
.set_authname(author_name
)
633 patch
.set_authemail(author_email
)
634 patch
.set_authdate(author_date
)
635 patch
.set_commname(committer_name
)
636 patch
.set_commemail(committer_email
)
640 def undo_refresh(self
):
641 """Undo the patch boundaries changes caused by 'refresh'
643 name
= self
.get_current()
646 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
647 old_bottom
= patch
.get_old_bottom()
648 old_top
= patch
.get_old_top()
650 # the bottom of the patch is not changed by refresh. If the
651 # old_bottom is different, there wasn't any previous 'refresh'
652 # command (probably only a 'push')
653 if old_bottom
!= patch
.get_bottom() or old_top
== patch
.get_top():
654 raise StackException
, 'No refresh undo information available'
656 git
.reset(tree_id
= old_top
, check_out
= False)
657 patch
.restore_old_boundaries()
659 def new_patch(self
, name
, message
= None, can_edit
= True,
660 unapplied
= False, show_patch
= False,
661 top
= None, bottom
= None,
662 author_name
= None, author_email
= None, author_date
= None,
663 committer_name
= None, committer_email
= None,
664 before_existing
= False):
665 """Creates a new patch
667 if self
.__patch
_applied
(name
) or self
.__patch
_unapplied
(name
):
668 raise StackException
, 'Patch "%s" already exists' % name
670 if not message
and can_edit
:
671 descr
= edit_file(self
, None, \
672 'Please enter the description for patch "%s" ' \
673 'above.' % name
, show_patch
)
677 head
= git
.get_head()
679 self
.__begin
_stack
_check
()
681 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
685 patch
.set_bottom(bottom
)
687 patch
.set_bottom(head
)
693 patch
.set_description(descr
)
694 patch
.set_authname(author_name
)
695 patch
.set_authemail(author_email
)
696 patch
.set_authdate(author_date
)
697 patch
.set_commname(committer_name
)
698 patch
.set_commemail(committer_email
)
701 patches
= [patch
.get_name()] + self
.get_unapplied()
703 f
= file(self
.__unapplied
_file
, 'w+')
704 f
.writelines([line
+ '\n' for line
in patches
])
708 insert_string(self
.__applied
_file
, patch
.get_name())
709 if not self
.get_current():
710 self
.__set
_current
(name
)
712 append_string(self
.__applied
_file
, patch
.get_name())
713 self
.__set
_current
(name
)
715 self
.refresh_patch(cache_update
= False)
717 def delete_patch(self
, name
):
720 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
722 if self
.__patch
_is
_current
(patch
):
724 elif self
.__patch
_applied
(name
):
725 raise StackException
, 'Cannot remove an applied patch, "%s", ' \
726 'which is not current' % name
727 elif not name
in self
.get_unapplied():
728 raise StackException
, 'Unknown patch "%s"' % name
732 unapplied
= self
.get_unapplied()
733 unapplied
.remove(name
)
734 f
= file(self
.__unapplied
_file
, 'w+')
735 f
.writelines([line
+ '\n' for line
in unapplied
])
737 self
.__begin
_stack
_check
()
739 def forward_patches(self
, names
):
740 """Try to fast-forward an array of patches.
742 On return, patches in names[0:returned_value] have been pushed on the
743 stack. Apply the rest with push_patch
745 unapplied
= self
.get_unapplied()
746 self
.__begin
_stack
_check
()
752 assert(name
in unapplied
)
754 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
757 bottom
= patch
.get_bottom()
758 top
= patch
.get_top()
760 # top != bottom always since we have a commit for each patch
762 # reset the backup information
763 patch
.set_bottom(head
, backup
= True)
764 patch
.set_top(top
, backup
= True)
767 head_tree
= git
.get_commit(head
).get_tree()
768 bottom_tree
= git
.get_commit(bottom
).get_tree()
769 if head_tree
== bottom_tree
:
770 # We must just reparent this patch and create a new commit
772 descr
= patch
.get_description()
773 author_name
= patch
.get_authname()
774 author_email
= patch
.get_authemail()
775 author_date
= patch
.get_authdate()
776 committer_name
= patch
.get_commname()
777 committer_email
= patch
.get_commemail()
779 top_tree
= git
.get_commit(top
).get_tree()
781 top
= git
.commit(message
= descr
, parents
= [head
],
782 cache_update
= False,
785 author_name
= author_name
,
786 author_email
= author_email
,
787 author_date
= author_date
,
788 committer_name
= committer_name
,
789 committer_email
= committer_email
)
791 patch
.set_bottom(head
, backup
= True)
792 patch
.set_top(top
, backup
= True)
795 # stop the fast-forwarding, must do a real merge
799 unapplied
.remove(name
)
806 append_strings(self
.__applied
_file
, names
[0:forwarded
])
808 f
= file(self
.__unapplied
_file
, 'w+')
809 f
.writelines([line
+ '\n' for line
in unapplied
])
812 self
.__set
_current
(name
)
816 def merged_patches(self
, names
):
817 """Test which patches were merged upstream by reverse-applying
818 them in reverse order. The function returns the list of
819 patches detected to have been applied. The state of the tree
820 is restored to the original one
822 patches
= [Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
828 if git
.apply_diff(p
.get_top(), p
.get_bottom()):
829 merged
.append(p
.get_name())
836 def push_patch(self
, name
, empty
= False):
837 """Pushes a patch on the stack
839 unapplied
= self
.get_unapplied()
840 assert(name
in unapplied
)
842 self
.__begin
_stack
_check
()
844 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
846 head
= git
.get_head()
847 bottom
= patch
.get_bottom()
848 top
= patch
.get_top()
853 # top != bottom always since we have a commit for each patch
855 # just make an empty patch (top = bottom = HEAD). This
856 # option is useful to allow undoing already merged
857 # patches. The top is updated by refresh_patch since we
858 # need an empty commit
859 patch
.set_bottom(head
, backup
= True)
860 patch
.set_top(head
, backup
= True)
863 # reset the backup information
864 patch
.set_bottom(bottom
, backup
= True)
865 patch
.set_top(top
, backup
= True)
869 # new patch needs to be refreshed.
870 # The current patch is empty after merge.
871 patch
.set_bottom(head
, backup
= True)
872 patch
.set_top(head
, backup
= True)
874 # Try the fast applying first. If this fails, fall back to the
876 if not git
.apply_diff(bottom
, top
):
877 # if git.apply_diff() fails, the patch requires a diff3
878 # merge and can be reported as modified
881 # merge can fail but the patch needs to be pushed
883 git
.merge(bottom
, head
, top
)
884 except git
.GitException
, ex
:
885 print >> sys
.stderr
, \
886 'The merge failed during "push". ' \
887 'Use "refresh" after fixing the conflicts'
889 append_string(self
.__applied
_file
, name
)
891 unapplied
.remove(name
)
892 f
= file(self
.__unapplied
_file
, 'w+')
893 f
.writelines([line
+ '\n' for line
in unapplied
])
896 self
.__set
_current
(name
)
898 # head == bottom case doesn't need to refresh the patch
899 if empty
or head
!= bottom
:
901 # if the merge was OK and no conflicts, just refresh the patch
902 # The GIT cache was already updated by the merge operation
903 self
.refresh_patch(cache_update
= False)
905 raise StackException
, str(ex
)
910 name
= self
.get_current()
913 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
914 old_bottom
= patch
.get_old_bottom()
915 old_top
= patch
.get_old_top()
917 # the top of the patch is changed by a push operation only
918 # together with the bottom (otherwise the top was probably
919 # modified by 'refresh'). If they are both unchanged, there
921 if old_bottom
== patch
.get_bottom() and old_top
!= patch
.get_top():
922 raise StackException
, 'No push undo information available'
926 return patch
.restore_old_boundaries()
928 def pop_patch(self
, name
):
929 """Pops the top patch from the stack
931 applied
= self
.get_applied()
933 assert(name
in applied
)
935 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
937 git
.switch(patch
.get_bottom())
939 # save the new applied list
940 idx
= applied
.index(name
) + 1
942 popped
= applied
[:idx
]
944 unapplied
= popped
+ self
.get_unapplied()
946 f
= file(self
.__unapplied
_file
, 'w+')
947 f
.writelines([line
+ '\n' for line
in unapplied
])
953 f
= file(self
.__applied
_file
, 'w+')
954 f
.writelines([line
+ '\n' for line
in applied
])
958 self
.__set
_current
(None)
960 self
.__set
_current
(applied
[-1])
962 self
.__end
_stack
_check
()
964 def empty_patch(self
, name
):
965 """Returns True if the patch is empty
967 patch
= Patch(name
, self
.__patch
_dir
, self
.__refs
_dir
)
968 bottom
= patch
.get_bottom()
969 top
= patch
.get_top()
973 elif git
.get_commit(top
).get_tree() \
974 == git
.get_commit(bottom
).get_tree():
979 def rename_patch(self
, oldname
, newname
):
980 applied
= self
.get_applied()
981 unapplied
= self
.get_unapplied()
983 if oldname
== newname
:
984 raise StackException
, '"To" name and "from" name are the same'
986 if newname
in applied
or newname
in unapplied
:
987 raise StackException
, 'Patch "%s" already exists' % newname
989 if oldname
in unapplied
:
990 Patch(oldname
, self
.__patch
_dir
, self
.__refs
_dir
).rename(newname
)
991 unapplied
[unapplied
.index(oldname
)] = newname
993 f
= file(self
.__unapplied
_file
, 'w+')
994 f
.writelines([line
+ '\n' for line
in unapplied
])
996 elif oldname
in applied
:
997 Patch(oldname
, self
.__patch
_dir
, self
.__refs
_dir
).rename(newname
)
998 if oldname
== self
.get_current():
999 self
.__set
_current
(newname
)
1001 applied
[applied
.index(oldname
)] = newname
1003 f
= file(self
.__applied
_file
, 'w+')
1004 f
.writelines([line
+ '\n' for line
in applied
])
1007 raise StackException
, 'Unknown patch "%s"' % oldname