6281f368b2b3668bcec21f7ca7124052e1cee6f1
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 get_branch(self
):
332 """Return the branch name for the Series object
336 def __set_current(self
, name
):
337 """Sets the topmost patch
339 self
._set_field('current', name
)
341 def get_patch(self
, name
):
342 """Return a Patch object for the given name
344 return Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
346 def get_current_patch(self
):
347 """Return a Patch object representing the topmost patch, or
348 None if there is no such patch."""
349 crt
= self
.get_current()
352 return Patch(crt
, self
.__patch_dir
, self
.__refs_dir
)
354 def get_current(self
):
355 """Return the name of the topmost patch, or None if there is
357 name
= self
._get_field('current')
363 def get_applied(self
):
364 if not os
.path
.isfile(self
.__applied_file
):
365 raise StackException
, 'Branch "%s" not initialised' % self
.__name
366 f
= file(self
.__applied_file
)
367 names
= [line
.strip() for line
in f
.readlines()]
371 def get_unapplied(self
):
372 if not os
.path
.isfile(self
.__unapplied_file
):
373 raise StackException
, 'Branch "%s" not initialised' % self
.__name
374 f
= file(self
.__unapplied_file
)
375 names
= [line
.strip() for line
in f
.readlines()]
379 def get_hidden(self
):
380 if not os
.path
.isfile(self
.__hidden_file
):
382 f
= file(self
.__hidden_file
)
383 names
= [line
.strip() for line
in f
.readlines()]
387 def get_base_file(self
):
388 self
.__begin_stack_check()
389 return self
.__base_file
391 def get_protected(self
):
392 return os
.path
.isfile(os
.path
.join(self
._dir(), 'protected'))
395 protect_file
= os
.path
.join(self
._dir(), 'protected')
396 if not os
.path
.isfile(protect_file
):
397 create_empty_file(protect_file
)
400 protect_file
= os
.path
.join(self
._dir(), 'protected')
401 if os
.path
.isfile(protect_file
):
402 os
.remove(protect_file
)
404 def get_description(self
):
405 return self
._get_field('description') or ''
407 def set_description(self
, line
):
408 self
._set_field('description', line
)
410 def __patch_is_current(self
, patch
):
411 return patch
.get_name() == self
.get_current()
413 def patch_applied(self
, name
):
414 """Return true if the patch exists in the applied list
416 return name
in self
.get_applied()
418 def patch_unapplied(self
, name
):
419 """Return true if the patch exists in the unapplied list
421 return name
in self
.get_unapplied()
423 def patch_hidden(self
, name
):
424 """Return true if the patch is hidden.
426 return name
in self
.get_hidden()
428 def patch_exists(self
, name
):
429 """Return true if there is a patch with the given name, false
431 return self
.patch_applied(name
) or self
.patch_unapplied(name
)
433 def __begin_stack_check(self
):
434 """Save the current HEAD into .git/refs/heads/base if the stack
437 if len(self
.get_applied()) == 0:
438 head
= git
.get_head()
439 write_string(self
.__base_file
, head
)
441 def __end_stack_check(self
):
442 """Remove .git/refs/heads/base if the stack is empty.
443 This warning should never happen
445 if len(self
.get_applied()) == 0 \
446 and read_string(self
.__base_file
) != git
.get_head():
447 print 'Warning: stack empty but the HEAD and base are different'
449 def head_top_equal(self
):
450 """Return true if the head and the top are the same
452 crt
= self
.get_current_patch()
454 # we don't care, no patches applied
456 return git
.get_head() == crt
.get_top()
458 def is_initialised(self
):
459 """Checks if series is already initialised
461 return os
.path
.isdir(self
.__patch_dir
)
463 def init(self
, create_at
=False):
464 """Initialises the stgit series
466 bases_dir
= os
.path
.join(self
.__base_dir
, 'refs', 'bases')
468 if os
.path
.exists(self
.__patch_dir
):
469 raise StackException
, self
.__patch_dir
+ ' already exists'
470 if os
.path
.exists(self
.__refs_dir
):
471 raise StackException
, self
.__refs_dir
+ ' already exists'
472 if os
.path
.exists(self
.__base_file
):
473 raise StackException
, self
.__base_file
+ ' already exists'
475 if (create_at
!=False):
476 git
.create_branch(self
.__name
, create_at
)
478 os
.makedirs(self
.__patch_dir
)
480 create_dirs(bases_dir
)
482 self
.create_empty_field('applied')
483 self
.create_empty_field('unapplied')
484 self
.create_empty_field('description')
485 os
.makedirs(os
.path
.join(self
._dir(), 'patches'))
486 os
.makedirs(self
.__refs_dir
)
487 self
.__begin_stack_check()
490 """Either convert to use a separate patch directory, or
491 unconvert to place the patches in the same directory with
494 if self
.__patch_dir
== self
._dir():
495 print 'Converting old-style to new-style...',
498 self
.__patch_dir
= os
.path
.join(self
._dir(), 'patches')
499 os
.makedirs(self
.__patch_dir
)
501 for p
in self
.get_applied() + self
.get_unapplied():
502 src
= os
.path
.join(self
._dir(), p
)
503 dest
= os
.path
.join(self
.__patch_dir
, p
)
509 print 'Converting new-style to old-style...',
512 for p
in self
.get_applied() + self
.get_unapplied():
513 src
= os
.path
.join(self
.__patch_dir
, p
)
514 dest
= os
.path
.join(self
._dir(), p
)
517 if not os
.listdir(self
.__patch_dir
):
518 os
.rmdir(self
.__patch_dir
)
521 print 'Patch directory %s is not empty.' % self
.__name
523 self
.__patch_dir
= self
._dir()
525 def rename(self
, to_name
):
528 to_stack
= Series(to_name
)
530 if to_stack
.is_initialised():
531 raise StackException
, '"%s" already exists' % to_stack
.get_branch()
532 if os
.path
.exists(to_stack
.__base_file
):
533 os
.remove(to_stack
.__base_file
)
535 git
.rename_branch(self
.__name
, to_name
)
537 if os
.path
.isdir(self
._dir()):
538 rename(os
.path
.join(self
.__base_dir
, 'patches'),
539 self
.__name
, to_stack
.__name
)
540 if os
.path
.exists(self
.__base_file
):
541 rename(os
.path
.join(self
.__base_dir
, 'refs', 'bases'),
542 self
.__name
, to_stack
.__name
)
543 if os
.path
.exists(self
.__refs_dir
):
544 rename(os
.path
.join(self
.__base_dir
, 'refs', 'patches'),
545 self
.__name
, to_stack
.__name
)
547 self
.__init__(to_name
)
549 def clone(self
, target_series
):
553 # allow cloning of branches not under StGIT control
554 base
= read_string(self
.get_base_file())
556 base
= git
.get_head()
557 Series(target_series
).init(create_at
= base
)
558 new_series
= Series(target_series
)
560 # generate an artificial description file
561 new_series
.set_description('clone of "%s"' % self
.__name
)
563 # clone self's entire series as unapplied patches
565 # allow cloning of branches not under StGIT control
566 applied
= self
.get_applied()
567 unapplied
= self
.get_unapplied()
568 patches
= applied
+ unapplied
571 patches
= applied
= unapplied
= []
573 patch
= self
.get_patch(p
)
574 new_series
.new_patch(p
, message
= patch
.get_description(),
575 can_edit
= False, unapplied
= True,
576 bottom
= patch
.get_bottom(),
577 top
= patch
.get_top(),
578 author_name
= patch
.get_authname(),
579 author_email
= patch
.get_authemail(),
580 author_date
= patch
.get_authdate())
582 # fast forward the cloned series to self's top
583 new_series
.forward_patches(applied
)
585 def delete(self
, force
= False):
586 """Deletes an stgit series
588 if self
.is_initialised():
589 patches
= self
.get_unapplied() + self
.get_applied()
590 if not force
and patches
:
591 raise StackException
, \
592 'Cannot delete: the series still contains patches'
594 Patch(p
, self
.__patch_dir
, self
.__refs_dir
).delete()
596 # remove the trash directory
597 for fname
in os
.listdir(self
.__trash_dir
):
599 os
.rmdir(self
.__trash_dir
)
601 # FIXME: find a way to get rid of those manual removals
602 # (move functionnality to StgitObject ?)
603 if os
.path
.exists(self
.__applied_file
):
604 os
.remove(self
.__applied_file
)
605 if os
.path
.exists(self
.__unapplied_file
):
606 os
.remove(self
.__unapplied_file
)
607 if os
.path
.exists(self
.__hidden_file
):
608 os
.remove(self
.__hidden_file
)
609 if os
.path
.exists(self
.__current_file
):
610 os
.remove(self
.__current_file
)
611 if os
.path
.exists(self
.__descr_file
):
612 os
.remove(self
.__descr_file
)
613 if not os
.listdir(self
.__patch_dir
):
614 os
.rmdir(self
.__patch_dir
)
616 print 'Patch directory %s is not empty.' % self
.__name
617 if not os
.listdir(self
._dir()):
618 remove_dirs(os
.path
.join(self
.__base_dir
, 'patches'),
621 print 'Series directory %s is not empty.' % self
.__name
622 if not os
.listdir(self
.__refs_dir
):
623 remove_dirs(os
.path
.join(self
.__base_dir
, 'refs', 'patches'),
626 print 'Refs directory %s is not empty.' % self
.__refs_dir
628 if os
.path
.exists(self
.__base_file
):
629 remove_file_and_dirs(
630 os
.path
.join(self
.__base_dir
, 'refs', 'bases'), self
.__name
)
632 def refresh_patch(self
, files
= None, message
= None, edit
= False,
635 author_name
= None, author_email
= None,
637 committer_name
= None, committer_email
= None,
638 backup
= False, sign_str
= None, log
= 'refresh'):
639 """Generates a new commit for the given patch
641 name
= self
.get_current()
643 raise StackException
, 'No patches applied'
645 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
647 descr
= patch
.get_description()
648 if not (message
or descr
):
654 if not message
and edit
:
655 descr
= edit_file(self
, descr
.rstrip(), \
656 'Please edit the description for patch "%s" ' \
657 'above.' % name
, show_patch
)
660 author_name
= patch
.get_authname()
662 author_email
= patch
.get_authemail()
664 author_date
= patch
.get_authdate()
665 if not committer_name
:
666 committer_name
= patch
.get_commname()
667 if not committer_email
:
668 committer_email
= patch
.get_commemail()
671 descr
= '%s\n%s: %s <%s>\n' %
(descr
.rstrip(), sign_str
,
672 committer_name
, committer_email
)
674 bottom
= patch
.get_bottom()
676 commit_id
= git
.commit(files
= files
,
677 message
= descr
, parents
= [bottom
],
678 cache_update
= cache_update
,
680 author_name
= author_name
,
681 author_email
= author_email
,
682 author_date
= author_date
,
683 committer_name
= committer_name
,
684 committer_email
= committer_email
)
686 patch
.set_bottom(bottom
, backup
= backup
)
687 patch
.set_top(commit_id
, backup
= backup
)
688 patch
.set_description(descr
)
689 patch
.set_authname(author_name
)
690 patch
.set_authemail(author_email
)
691 patch
.set_authdate(author_date
)
692 patch
.set_commname(committer_name
)
693 patch
.set_commemail(committer_email
)
696 self
.log_patch(patch
, log
)
700 def undo_refresh(self
):
701 """Undo the patch boundaries changes caused by 'refresh'
703 name
= self
.get_current()
706 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
707 old_bottom
= patch
.get_old_bottom()
708 old_top
= patch
.get_old_top()
710 # the bottom of the patch is not changed by refresh. If the
711 # old_bottom is different, there wasn't any previous 'refresh'
712 # command (probably only a 'push')
713 if old_bottom
!= patch
.get_bottom() or old_top
== patch
.get_top():
714 raise StackException
, 'No undo information available'
716 git
.reset(tree_id
= old_top
, check_out
= False)
717 if patch
.restore_old_boundaries():
718 self
.log_patch(patch
, 'undo')
720 def new_patch(self
, name
, message
= None, can_edit
= True,
721 unapplied
= False, show_patch
= False,
722 top
= None, bottom
= None,
723 author_name
= None, author_email
= None, author_date
= None,
724 committer_name
= None, committer_email
= None,
725 before_existing
= False, refresh
= True):
726 """Creates a new patch
728 if self
.patch_applied(name
) or self
.patch_unapplied(name
):
729 raise StackException
, 'Patch "%s" already exists' % name
731 if not message
and can_edit
:
732 descr
= edit_file(self
, None, \
733 'Please enter the description for patch "%s" ' \
734 'above.' % name
, show_patch
)
738 head
= git
.get_head()
740 self
.__begin_stack_check()
742 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
746 patch
.set_bottom(bottom
)
748 patch
.set_bottom(head
)
754 patch
.set_description(descr
)
755 patch
.set_authname(author_name
)
756 patch
.set_authemail(author_email
)
757 patch
.set_authdate(author_date
)
758 patch
.set_commname(committer_name
)
759 patch
.set_commemail(committer_email
)
762 self
.log_patch(patch
, 'new')
764 patches
= [patch
.get_name()] + self
.get_unapplied()
766 f
= file(self
.__unapplied_file
, 'w+')
767 f
.writelines([line
+ '\n' for line
in patches
])
769 elif before_existing
:
770 self
.log_patch(patch
, 'new')
772 insert_string(self
.__applied_file
, patch
.get_name())
773 if not self
.get_current():
774 self
.__set_current(name
)
776 append_string(self
.__applied_file
, patch
.get_name())
777 self
.__set_current(name
)
779 self
.refresh_patch(cache_update
= False, log
= 'new')
781 def delete_patch(self
, name
):
784 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
786 if self
.__patch_is_current(patch
):
788 elif self
.patch_applied(name
):
789 raise StackException
, 'Cannot remove an applied patch, "%s", ' \
790 'which is not current' % name
791 elif not name
in self
.get_unapplied():
792 raise StackException
, 'Unknown patch "%s"' % name
794 # save the commit id to a trash file
795 write_string(os
.path
.join(self
.__trash_dir
, name
), patch
.get_top())
799 unapplied
= self
.get_unapplied()
800 unapplied
.remove(name
)
801 f
= file(self
.__unapplied_file
, 'w+')
802 f
.writelines([line
+ '\n' for line
in unapplied
])
805 if self
.patch_hidden(name
):
806 self
.unhide_patch(name
)
808 self
.__begin_stack_check()
810 def forward_patches(self
, names
):
811 """Try to fast-forward an array of patches.
813 On return, patches in names[0:returned_value] have been pushed on the
814 stack. Apply the rest with push_patch
816 unapplied
= self
.get_unapplied()
817 self
.__begin_stack_check()
823 assert(name
in unapplied
)
825 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
828 bottom
= patch
.get_bottom()
829 top
= patch
.get_top()
831 # top != bottom always since we have a commit for each patch
833 # reset the backup information. No logging since the
834 # patch hasn't changed
835 patch
.set_bottom(head
, backup
= True)
836 patch
.set_top(top
, backup
= True)
839 head_tree
= git
.get_commit(head
).get_tree()
840 bottom_tree
= git
.get_commit(bottom
).get_tree()
841 if head_tree
== bottom_tree
:
842 # We must just reparent this patch and create a new commit
844 descr
= patch
.get_description()
845 author_name
= patch
.get_authname()
846 author_email
= patch
.get_authemail()
847 author_date
= patch
.get_authdate()
848 committer_name
= patch
.get_commname()
849 committer_email
= patch
.get_commemail()
851 top_tree
= git
.get_commit(top
).get_tree()
853 top
= git
.commit(message
= descr
, parents
= [head
],
854 cache_update
= False,
857 author_name
= author_name
,
858 author_email
= author_email
,
859 author_date
= author_date
,
860 committer_name
= committer_name
,
861 committer_email
= committer_email
)
863 patch
.set_bottom(head
, backup
= True)
864 patch
.set_top(top
, backup
= True)
866 self
.log_patch(patch
, 'push(f)')
869 # stop the fast-forwarding, must do a real merge
873 unapplied
.remove(name
)
880 append_strings(self
.__applied_file
, names
[0:forwarded
])
882 f
= file(self
.__unapplied_file
, 'w+')
883 f
.writelines([line
+ '\n' for line
in unapplied
])
886 self
.__set_current(name
)
890 def merged_patches(self
, names
):
891 """Test which patches were merged upstream by reverse-applying
892 them in reverse order. The function returns the list of
893 patches detected to have been applied. The state of the tree
894 is restored to the original one
896 patches
= [Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
902 if git
.apply_diff(p
.get_top(), p
.get_bottom()):
903 merged
.append(p
.get_name())
910 def push_patch(self
, name
, empty
= False):
911 """Pushes a patch on the stack
913 unapplied
= self
.get_unapplied()
914 assert(name
in unapplied
)
916 self
.__begin_stack_check()
918 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
920 head
= git
.get_head()
921 bottom
= patch
.get_bottom()
922 top
= patch
.get_top()
927 # top != bottom always since we have a commit for each patch
929 # just make an empty patch (top = bottom = HEAD). This
930 # option is useful to allow undoing already merged
931 # patches. The top is updated by refresh_patch since we
932 # need an empty commit
933 patch
.set_bottom(head
, backup
= True)
934 patch
.set_top(head
, backup
= True)
937 # reset the backup information. No need for logging
938 patch
.set_bottom(bottom
, backup
= True)
939 patch
.set_top(top
, backup
= True)
943 # new patch needs to be refreshed.
944 # The current patch is empty after merge.
945 patch
.set_bottom(head
, backup
= True)
946 patch
.set_top(head
, backup
= True)
948 # Try the fast applying first. If this fails, fall back to the
950 if not git
.apply_diff(bottom
, top
):
951 # if git.apply_diff() fails, the patch requires a diff3
952 # merge and can be reported as modified
955 # merge can fail but the patch needs to be pushed
957 git
.merge(bottom
, head
, top
, recursive
= True)
958 except git
.GitException
, ex
:
959 print >> sys
.stderr
, \
960 'The merge failed during "push". ' \
961 'Use "refresh" after fixing the conflicts'
963 append_string(self
.__applied_file
, name
)
965 unapplied
.remove(name
)
966 f
= file(self
.__unapplied_file
, 'w+')
967 f
.writelines([line
+ '\n' for line
in unapplied
])
970 self
.__set_current(name
)
972 # head == bottom case doesn't need to refresh the patch
973 if empty
or head
!= bottom
:
975 # if the merge was OK and no conflicts, just refresh the patch
976 # The GIT cache was already updated by the merge operation
981 self
.refresh_patch(cache_update
= False, log
= log
)
983 # we store the correctly merged files only for
984 # tracking the conflict history. Note that the
985 # git.merge() operations shouls always leave the index
986 # in a valid state (i.e. only stage 0 files)
987 self
.refresh_patch(cache_update
= False, log
= 'push(c)')
988 raise StackException
, str(ex
)
993 name
= self
.get_current()
996 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
997 old_bottom
= patch
.get_old_bottom()
998 old_top
= patch
.get_old_top()
1000 # the top of the patch is changed by a push operation only
1001 # together with the bottom (otherwise the top was probably
1002 # modified by 'refresh'). If they are both unchanged, there
1003 # was a fast forward
1004 if old_bottom
== patch
.get_bottom() and old_top
!= patch
.get_top():
1005 raise StackException
, 'No undo information available'
1008 self
.pop_patch(name
)
1009 ret
= patch
.restore_old_boundaries()
1011 self
.log_patch(patch
, 'undo')
1015 def pop_patch(self
, name
, keep
= False):
1016 """Pops the top patch from the stack
1018 applied
= self
.get_applied()
1020 assert(name
in applied
)
1022 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
1024 # only keep the local changes
1025 if keep
and not git
.apply_diff(git
.get_head(), patch
.get_bottom()):
1026 raise StackException
, \
1027 'Failed to pop patches while preserving the local changes'
1029 git
.switch(patch
.get_bottom(), keep
)
1031 # save the new applied list
1032 idx
= applied
.index(name
) + 1
1034 popped
= applied
[:idx
]
1036 unapplied
= popped
+ self
.get_unapplied()
1038 f
= file(self
.__unapplied_file
, 'w+')
1039 f
.writelines([line
+ '\n' for line
in unapplied
])
1045 f
= file(self
.__applied_file
, 'w+')
1046 f
.writelines([line
+ '\n' for line
in applied
])
1050 self
.__set_current(None)
1052 self
.__set_current(applied
[-1])
1054 self
.__end_stack_check()
1056 def empty_patch(self
, name
):
1057 """Returns True if the patch is empty
1059 patch
= Patch(name
, self
.__patch_dir
, self
.__refs_dir
)
1060 bottom
= patch
.get_bottom()
1061 top
= patch
.get_top()
1065 elif git
.get_commit(top
).get_tree() \
1066 == git
.get_commit(bottom
).get_tree():
1071 def rename_patch(self
, oldname
, newname
):
1072 applied
= self
.get_applied()
1073 unapplied
= self
.get_unapplied()
1075 if oldname
== newname
:
1076 raise StackException
, '"To" name and "from" name are the same'
1078 if newname
in applied
or newname
in unapplied
:
1079 raise StackException
, 'Patch "%s" already exists' % newname
1081 if self
.patch_hidden(oldname
):
1082 self
.unhide_patch(oldname
)
1083 self
.hide_patch(newname
)
1085 if oldname
in unapplied
:
1086 Patch(oldname
, self
.__patch_dir
, self
.__refs_dir
).rename(newname
)
1087 unapplied
[unapplied
.index(oldname
)] = newname
1089 f
= file(self
.__unapplied_file
, 'w+')
1090 f
.writelines([line
+ '\n' for line
in unapplied
])
1092 elif oldname
in applied
:
1093 Patch(oldname
, self
.__patch_dir
, self
.__refs_dir
).rename(newname
)
1094 if oldname
== self
.get_current():
1095 self
.__set_current(newname
)
1097 applied
[applied
.index(oldname
)] = newname
1099 f
= file(self
.__applied_file
, 'w+')
1100 f
.writelines([line
+ '\n' for line
in applied
])
1103 raise StackException
, 'Unknown patch "%s"' % oldname
1105 def log_patch(self
, patch
, message
):
1106 """Generate a log commit for a patch
1108 top
= git
.get_commit(patch
.get_top())
1109 msg
= '%s\t%s' %
(message
, top
.get_id_hash())
1111 old_log
= patch
.get_log()
1117 log
= git
.commit(message
= msg
, parents
= parents
,
1118 cache_update
= False, tree_id
= top
.get_tree(),
1122 def hide_patch(self
, name
):
1123 """Add the patch to the hidden list.
1125 if not self
.patch_exists(name
):
1126 raise StackException
, 'Unknown patch "%s"' % name
1127 elif self
.patch_hidden(name
):
1128 raise StackException
, 'Patch "%s" already hidden' % name
1130 append_string(self
.__hidden_file
, name
)
1132 def unhide_patch(self
, name
):
1133 """Add the patch to the hidden list.
1135 if not self
.patch_exists(name
):
1136 raise StackException
, 'Unknown patch "%s"' % name
1137 hidden
= self
.get_hidden()
1138 if not name
in hidden
:
1139 raise StackException
, 'Patch "%s" not hidden' % name
1143 f
= file(self
.__hidden_file
, 'w+')
1144 f
.writelines([line
+ '\n' for line
in hidden
])