5ae3c0b304a5131183c1ed3b0c300e4418267244
[stgit] / stgit / stack.py
1 """Basic quilt-like functionality
2 """
3
4 __copyright__ = """
5 Copyright (C) 2005, Catalin Marinas <catalin.marinas@gmail.com>
6
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.
10
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.
15
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
19 """
20
21 import sys, os, re
22
23 from stgit.utils import *
24 from stgit import git, basedir, templates
25 from stgit.config import config
26 from shutil import copyfile
27
28
29 # stack exception class
30 class StackException(Exception):
31 pass
32
33 class FilterUntil:
34 def __init__(self):
35 self.should_print = True
36 def __call__(self, x, until_test, prefix):
37 if until_test(x):
38 self.should_print = False
39 if self.should_print:
40 return x[0:len(prefix)] != prefix
41 return False
42
43 #
44 # Functions
45 #
46 __comment_prefix = 'STG:'
47 __patch_prefix = 'STG_PATCH:'
48
49 def __clean_comments(f):
50 """Removes lines marked for status in a commit file
51 """
52 f.seek(0)
53
54 # remove status-prefixed lines
55 lines = f.readlines()
56
57 patch_filter = FilterUntil()
58 until_test = lambda t: t == (__patch_prefix + '\n')
59 lines = [l for l in lines if patch_filter(l, until_test, __comment_prefix)]
60
61 # remove empty lines at the end
62 while len(lines) != 0 and lines[-1] == '\n':
63 del lines[-1]
64
65 f.seek(0); f.truncate()
66 f.writelines(lines)
67
68 def edit_file(series, line, comment, show_patch = True):
69 fname = '.stgitmsg.txt'
70 tmpl = templates.get_template('patchdescr.tmpl')
71
72 f = file(fname, 'w+')
73 if line:
74 print >> f, line
75 elif tmpl:
76 print >> f, tmpl,
77 else:
78 print >> f
79 print >> f, __comment_prefix, comment
80 print >> f, __comment_prefix, \
81 'Lines prefixed with "%s" will be automatically removed.' \
82 % __comment_prefix
83 print >> f, __comment_prefix, \
84 'Trailing empty lines will be automatically removed.'
85
86 if show_patch:
87 print >> f, __patch_prefix
88 # series.get_patch(series.get_current()).get_top()
89 git.diff([], series.get_patch(series.get_current()).get_bottom(), None, f)
90
91 #Vim modeline must be near the end.
92 print >> f, __comment_prefix, 'vi: set textwidth=75 filetype=diff nobackup:'
93 f.close()
94
95 call_editor(fname)
96
97 f = file(fname, 'r+')
98
99 __clean_comments(f)
100 f.seek(0)
101 result = f.read()
102
103 f.close()
104 os.remove(fname)
105
106 return result
107
108 #
109 # Classes
110 #
111
112 class StgitObject:
113 """An object with stgit-like properties stored as files in a directory
114 """
115 def _set_dir(self, dir):
116 self.__dir = dir
117 def _dir(self):
118 return self.__dir
119
120 def create_empty_field(self, name):
121 create_empty_file(os.path.join(self.__dir, name))
122
123 def _get_field(self, name, multiline = False):
124 id_file = os.path.join(self.__dir, name)
125 if os.path.isfile(id_file):
126 line = read_string(id_file, multiline)
127 if line == '':
128 return None
129 else:
130 return line
131 else:
132 return None
133
134 def _set_field(self, name, value, multiline = False):
135 fname = os.path.join(self.__dir, name)
136 if value and value != '':
137 write_string(fname, value, multiline)
138 elif os.path.isfile(fname):
139 os.remove(fname)
140
141
142 class Patch(StgitObject):
143 """Basic patch implementation
144 """
145 def __init__(self, name, series_dir, refs_dir):
146 self.__series_dir = series_dir
147 self.__name = name
148 self._set_dir(os.path.join(self.__series_dir, self.__name))
149 self.__refs_dir = refs_dir
150 self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
151 self.__log_ref_file = os.path.join(self.__refs_dir,
152 self.__name + '.log')
153
154 def create(self):
155 os.mkdir(self._dir())
156 self.create_empty_field('bottom')
157 self.create_empty_field('top')
158
159 def delete(self):
160 for f in os.listdir(self._dir()):
161 os.remove(os.path.join(self._dir(), f))
162 os.rmdir(self._dir())
163 os.remove(self.__top_ref_file)
164 if os.path.exists(self.__log_ref_file):
165 os.remove(self.__log_ref_file)
166
167 def get_name(self):
168 return self.__name
169
170 def rename(self, newname):
171 olddir = self._dir()
172 old_top_ref_file = self.__top_ref_file
173 old_log_ref_file = self.__log_ref_file
174 self.__name = newname
175 self._set_dir(os.path.join(self.__series_dir, self.__name))
176 self.__top_ref_file = os.path.join(self.__refs_dir, self.__name)
177 self.__log_ref_file = os.path.join(self.__refs_dir,
178 self.__name + '.log')
179
180 os.rename(olddir, self._dir())
181 os.rename(old_top_ref_file, self.__top_ref_file)
182 if os.path.exists(old_log_ref_file):
183 os.rename(old_log_ref_file, self.__log_ref_file)
184
185 def __update_top_ref(self, ref):
186 write_string(self.__top_ref_file, ref)
187
188 def __update_log_ref(self, ref):
189 write_string(self.__log_ref_file, ref)
190
191 def update_top_ref(self):
192 top = self.get_top()
193 if top:
194 self.__update_top_ref(top)
195
196 def get_old_bottom(self):
197 return self._get_field('bottom.old')
198
199 def get_bottom(self):
200 return self._get_field('bottom')
201
202 def set_bottom(self, value, backup = False):
203 if backup:
204 curr = self._get_field('bottom')
205 self._set_field('bottom.old', curr)
206 self._set_field('bottom', value)
207
208 def get_old_top(self):
209 return self._get_field('top.old')
210
211 def get_top(self):
212 return self._get_field('top')
213
214 def set_top(self, value, backup = False):
215 if backup:
216 curr = self._get_field('top')
217 self._set_field('top.old', curr)
218 self._set_field('top', value)
219 self.__update_top_ref(value)
220
221 def restore_old_boundaries(self):
222 bottom = self._get_field('bottom.old')
223 top = self._get_field('top.old')
224
225 if top and bottom:
226 self._set_field('bottom', bottom)
227 self._set_field('top', top)
228 self.__update_top_ref(top)
229 return True
230 else:
231 return False
232
233 def get_description(self):
234 return self._get_field('description', True)
235
236 def set_description(self, line):
237 self._set_field('description', line, True)
238
239 def get_authname(self):
240 return self._get_field('authname')
241
242 def set_authname(self, name):
243 self._set_field('authname', name or git.author().name)
244
245 def get_authemail(self):
246 return self._get_field('authemail')
247
248 def set_authemail(self, email):
249 self._set_field('authemail', email or git.author().email)
250
251 def get_authdate(self):
252 return self._get_field('authdate')
253
254 def set_authdate(self, date):
255 self._set_field('authdate', date or git.author().date)
256
257 def get_commname(self):
258 return self._get_field('commname')
259
260 def set_commname(self, name):
261 self._set_field('commname', name or git.committer().name)
262
263 def get_commemail(self):
264 return self._get_field('commemail')
265
266 def set_commemail(self, email):
267 self._set_field('commemail', email or git.committer().email)
268
269 def get_log(self):
270 return self._get_field('log')
271
272 def set_log(self, value, backup = False):
273 self._set_field('log', value)
274 self.__update_log_ref(value)
275
276 # The current StGIT metadata format version.
277 FORMAT_VERSION = 2
278
279 def format_version_key(branch):
280 return 'branch.%s.stgitformatversion' % branch
281
282 def update_to_current_format_version(branch, git_dir):
283 """Update a potentially older StGIT directory structure to the
284 latest version. Note: This function should depend as little as
285 possible on external functions that may change during a format
286 version bump, since it must remain able to process older formats."""
287
288 branch_dir = os.path.join(git_dir, 'patches', branch)
289 def get_format_version():
290 """Return the integer format version number, or None if the
291 branch doesn't have any StGIT metadata at all, of any version."""
292 fv = config.get(format_version_key(branch))
293 if fv:
294 # Great, there's an explicitly recorded format version
295 # number, which means that the branch is initialized and
296 # of that exact version.
297 return int(fv)
298 elif os.path.isdir(os.path.join(branch_dir, 'patches')):
299 # There's a .git/patches/<branch>/patches dirctory, which
300 # means this is an initialized version 1 branch.
301 return 1
302 elif os.path.isdir(branch_dir):
303 # There's a .git/patches/<branch> directory, which means
304 # this is an initialized version 0 branch.
305 return 0
306 else:
307 # The branch doesn't seem to be initialized at all.
308 return None
309 def set_format_version(v):
310 out.info('Upgraded branch %s to format version %d' % (branch, v))
311 config.set(format_version_key(branch), '%d' % v)
312 def mkdir(d):
313 if not os.path.isdir(d):
314 os.makedirs(d)
315 def rm(f):
316 if os.path.exists(f):
317 os.remove(f)
318
319 # Update 0 -> 1.
320 if get_format_version() == 0:
321 mkdir(os.path.join(branch_dir, 'trash'))
322 patch_dir = os.path.join(branch_dir, 'patches')
323 mkdir(patch_dir)
324 refs_dir = os.path.join(git_dir, 'refs', 'patches', branch)
325 mkdir(refs_dir)
326 for patch in (file(os.path.join(branch_dir, 'unapplied')).readlines()
327 + file(os.path.join(branch_dir, 'applied')).readlines()):
328 patch = patch.strip()
329 os.rename(os.path.join(branch_dir, patch),
330 os.path.join(patch_dir, patch))
331 Patch(patch, patch_dir, refs_dir).update_top_ref()
332 set_format_version(1)
333
334 # Update 1 -> 2.
335 if get_format_version() == 1:
336 desc_file = os.path.join(branch_dir, 'description')
337 if os.path.isfile(desc_file):
338 desc = read_string(desc_file)
339 if desc:
340 config.set('branch.%s.description' % branch, desc)
341 rm(desc_file)
342 rm(os.path.join(branch_dir, 'current'))
343 rm(os.path.join(git_dir, 'refs', 'bases', branch))
344 set_format_version(2)
345
346 # Make sure we're at the latest version.
347 if not get_format_version() in [None, FORMAT_VERSION]:
348 raise StackException('Branch %s is at format version %d, expected %d'
349 % (branch, get_format_version(), FORMAT_VERSION))
350
351 class Series(StgitObject):
352 """Class including the operations on series
353 """
354 def __init__(self, name = None):
355 """Takes a series name as the parameter.
356 """
357 try:
358 if name:
359 self.set_name (name)
360 else:
361 self.set_name (git.get_head_file())
362 self.__base_dir = basedir.get()
363 except git.GitException, ex:
364 raise StackException, 'GIT tree not initialised: %s' % ex
365
366 self._set_dir(os.path.join(self.__base_dir, 'patches', self.get_name()))
367
368 # Update the branch to the latest format version if it is
369 # initialized, but don't touch it if it isn't.
370 update_to_current_format_version(self.get_name(), self.__base_dir)
371
372 self.__refs_dir = os.path.join(self.__base_dir, 'refs', 'patches',
373 self.get_name())
374
375 self.__applied_file = os.path.join(self._dir(), 'applied')
376 self.__unapplied_file = os.path.join(self._dir(), 'unapplied')
377 self.__hidden_file = os.path.join(self._dir(), 'hidden')
378
379 # where this series keeps its patches
380 self.__patch_dir = os.path.join(self._dir(), 'patches')
381
382 # trash directory
383 self.__trash_dir = os.path.join(self._dir(), 'trash')
384
385 def __patch_name_valid(self, name):
386 """Raise an exception if the patch name is not valid.
387 """
388 if not name or re.search('[^\w.-]', name):
389 raise StackException, 'Invalid patch name: "%s"' % name
390
391 def get_name(self):
392 return self.__name
393 def set_name(self, name):
394 self.__name = name
395
396 def get_patch(self, name):
397 """Return a Patch object for the given name
398 """
399 return Patch(name, self.__patch_dir, self.__refs_dir)
400
401 def get_current_patch(self):
402 """Return a Patch object representing the topmost patch, or
403 None if there is no such patch."""
404 crt = self.get_current()
405 if not crt:
406 return None
407 return Patch(crt, self.__patch_dir, self.__refs_dir)
408
409 def get_current(self):
410 """Return the name of the topmost patch, or None if there is
411 no such patch."""
412 try:
413 applied = self.get_applied()
414 except StackException:
415 # No "applied" file: branch is not initialized.
416 return None
417 try:
418 return applied[-1]
419 except IndexError:
420 # No patches applied.
421 return None
422
423 def get_applied(self):
424 if not os.path.isfile(self.__applied_file):
425 raise StackException, 'Branch "%s" not initialised' % self.get_name()
426 return read_strings(self.__applied_file)
427
428 def get_unapplied(self):
429 if not os.path.isfile(self.__unapplied_file):
430 raise StackException, 'Branch "%s" not initialised' % self.get_name()
431 return read_strings(self.__unapplied_file)
432
433 def get_hidden(self):
434 if not os.path.isfile(self.__hidden_file):
435 return []
436 return read_strings(self.__hidden_file)
437
438 def get_base(self):
439 # Return the parent of the bottommost patch, if there is one.
440 if os.path.isfile(self.__applied_file):
441 bottommost = file(self.__applied_file).readline().strip()
442 if bottommost:
443 return self.get_patch(bottommost).get_bottom()
444 # No bottommost patch, so just return HEAD
445 return git.get_head()
446
447 def get_head(self):
448 """Return the head of the branch
449 """
450 crt = self.get_current_patch()
451 if crt:
452 return crt.get_top()
453 else:
454 return self.get_base()
455
456 def get_protected(self):
457 return os.path.isfile(os.path.join(self._dir(), 'protected'))
458
459 def protect(self):
460 protect_file = os.path.join(self._dir(), 'protected')
461 if not os.path.isfile(protect_file):
462 create_empty_file(protect_file)
463
464 def unprotect(self):
465 protect_file = os.path.join(self._dir(), 'protected')
466 if os.path.isfile(protect_file):
467 os.remove(protect_file)
468
469 def __branch_descr(self):
470 return 'branch.%s.description' % self.get_name()
471
472 def get_description(self):
473 return config.get(self.__branch_descr()) or ''
474
475 def set_description(self, line):
476 if line:
477 config.set(self.__branch_descr(), line)
478 else:
479 config.unset(self.__branch_descr())
480
481 def get_parent_remote(self):
482 value = config.get('branch.%s.remote' % self.get_name())
483 if value:
484 return value
485 elif 'origin' in git.remotes_list():
486 out.note(('No parent remote declared for stack "%s",'
487 ' defaulting to "origin".' % self.get_name()),
488 ('Consider setting "branch.%s.remote" and'
489 ' "branch.%s.merge" with "git repo-config".'
490 % (self.get_name(), self.get_name())))
491 return 'origin'
492 else:
493 raise StackException, 'Cannot find a parent remote for "%s"' % self.get_name()
494
495 def __set_parent_remote(self, remote):
496 value = config.set('branch.%s.remote' % self.get_name(), remote)
497
498 def get_parent_branch(self):
499 value = config.get('branch.%s.stgit.parentbranch' % self.get_name())
500 if value:
501 return value
502 elif git.rev_parse('heads/origin'):
503 out.note(('No parent branch declared for stack "%s",'
504 ' defaulting to "heads/origin".' % self.get_name()),
505 ('Consider setting "branch.%s.stgit.parentbranch"'
506 ' with "git repo-config".' % self.get_name()))
507 return 'heads/origin'
508 else:
509 raise StackException, 'Cannot find a parent branch for "%s"' % self.get_name()
510
511 def __set_parent_branch(self, name):
512 if config.get('branch.%s.remote' % self.get_name()):
513 # Never set merge if remote is not set to avoid
514 # possibly-erroneous lookups into 'origin'
515 config.set('branch.%s.merge' % self.get_name(), name)
516 config.set('branch.%s.stgit.parentbranch' % self.get_name(), name)
517
518 def set_parent(self, remote, localbranch):
519 if localbranch:
520 self.__set_parent_remote(remote)
521 self.__set_parent_branch(localbranch)
522 # We'll enforce this later
523 # else:
524 # raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.get_name()
525
526 def __patch_is_current(self, patch):
527 return patch.get_name() == self.get_current()
528
529 def patch_applied(self, name):
530 """Return true if the patch exists in the applied list
531 """
532 return name in self.get_applied()
533
534 def patch_unapplied(self, name):
535 """Return true if the patch exists in the unapplied list
536 """
537 return name in self.get_unapplied()
538
539 def patch_hidden(self, name):
540 """Return true if the patch is hidden.
541 """
542 return name in self.get_hidden()
543
544 def patch_exists(self, name):
545 """Return true if there is a patch with the given name, false
546 otherwise."""
547 return self.patch_applied(name) or self.patch_unapplied(name) \
548 or self.patch_hidden(name)
549
550 def head_top_equal(self):
551 """Return true if the head and the top are the same
552 """
553 crt = self.get_current_patch()
554 if not crt:
555 # we don't care, no patches applied
556 return True
557 return git.get_head() == crt.get_top()
558
559 def is_initialised(self):
560 """Checks if series is already initialised
561 """
562 return bool(config.get(format_version_key(self.get_name())))
563
564 def init(self, create_at=False, parent_remote=None, parent_branch=None):
565 """Initialises the stgit series
566 """
567 if self.is_initialised():
568 raise StackException, '%s already initialized' % self.get_name()
569 for d in [self._dir(), self.__refs_dir]:
570 if os.path.exists(d):
571 raise StackException, '%s already exists' % d
572
573 if (create_at!=False):
574 git.create_branch(self.get_name(), create_at)
575
576 os.makedirs(self.__patch_dir)
577
578 self.set_parent(parent_remote, parent_branch)
579
580 self.create_empty_field('applied')
581 self.create_empty_field('unapplied')
582 os.makedirs(self.__refs_dir)
583
584 config.set(format_version_key(self.get_name()), str(FORMAT_VERSION))
585
586 def rename(self, to_name):
587 """Renames a series
588 """
589 to_stack = Series(to_name)
590
591 if to_stack.is_initialised():
592 raise StackException, '"%s" already exists' % to_stack.get_name()
593
594 git.rename_branch(self.get_name(), to_name)
595
596 if os.path.isdir(self._dir()):
597 rename(os.path.join(self.__base_dir, 'patches'),
598 self.get_name(), to_stack.get_name())
599 if os.path.exists(self.__refs_dir):
600 rename(os.path.join(self.__base_dir, 'refs', 'patches'),
601 self.get_name(), to_stack.get_name())
602
603 # Rename the config section
604 config.rename_section("branch.%s" % self.get_name(),
605 "branch.%s" % to_name)
606
607 self.__init__(to_name)
608
609 def clone(self, target_series):
610 """Clones a series
611 """
612 try:
613 # allow cloning of branches not under StGIT control
614 base = self.get_base()
615 except:
616 base = git.get_head()
617 Series(target_series).init(create_at = base)
618 new_series = Series(target_series)
619
620 # generate an artificial description file
621 new_series.set_description('clone of "%s"' % self.get_name())
622
623 # clone self's entire series as unapplied patches
624 try:
625 # allow cloning of branches not under StGIT control
626 applied = self.get_applied()
627 unapplied = self.get_unapplied()
628 patches = applied + unapplied
629 patches.reverse()
630 except:
631 patches = applied = unapplied = []
632 for p in patches:
633 patch = self.get_patch(p)
634 newpatch = new_series.new_patch(p, message = patch.get_description(),
635 can_edit = False, unapplied = True,
636 bottom = patch.get_bottom(),
637 top = patch.get_top(),
638 author_name = patch.get_authname(),
639 author_email = patch.get_authemail(),
640 author_date = patch.get_authdate())
641 if patch.get_log():
642 out.info('Setting log to %s' % patch.get_log())
643 newpatch.set_log(patch.get_log())
644 else:
645 out.info('No log for %s' % p)
646
647 # fast forward the cloned series to self's top
648 new_series.forward_patches(applied)
649
650 # Clone parent informations
651 value = config.get('branch.%s.remote' % self.get_name())
652 if value:
653 config.set('branch.%s.remote' % target_series, value)
654
655 value = config.get('branch.%s.merge' % self.get_name())
656 if value:
657 config.set('branch.%s.merge' % target_series, value)
658
659 value = config.get('branch.%s.stgit.parentbranch' % self.get_name())
660 if value:
661 config.set('branch.%s.stgit.parentbranch' % target_series, value)
662
663 def delete(self, force = False):
664 """Deletes an stgit series
665 """
666 if self.is_initialised():
667 patches = self.get_unapplied() + self.get_applied()
668 if not force and patches:
669 raise StackException, \
670 'Cannot delete: the series still contains patches'
671 for p in patches:
672 Patch(p, self.__patch_dir, self.__refs_dir).delete()
673
674 # remove the trash directory if any
675 if os.path.exists(self.__trash_dir):
676 for fname in os.listdir(self.__trash_dir):
677 os.remove(os.path.join(self.__trash_dir, fname))
678 os.rmdir(self.__trash_dir)
679
680 # FIXME: find a way to get rid of those manual removals
681 # (move functionality to StgitObject ?)
682 if os.path.exists(self.__applied_file):
683 os.remove(self.__applied_file)
684 if os.path.exists(self.__unapplied_file):
685 os.remove(self.__unapplied_file)
686 if os.path.exists(self.__hidden_file):
687 os.remove(self.__hidden_file)
688 if os.path.exists(self._dir()+'/orig-base'):
689 os.remove(self._dir()+'/orig-base')
690
691 if not os.listdir(self.__patch_dir):
692 os.rmdir(self.__patch_dir)
693 else:
694 out.warn('Patch directory %s is not empty' % self.__patch_dir)
695
696 try:
697 os.removedirs(self._dir())
698 except OSError:
699 raise StackException('Series directory %s is not empty'
700 % self._dir())
701
702 try:
703 os.removedirs(self.__refs_dir)
704 except OSError:
705 out.warn('Refs directory %s is not empty' % self.__refs_dir)
706
707 # Cleanup parent informations
708 # FIXME: should one day make use of git-config --section-remove,
709 # scheduled for 1.5.1
710 config.unset('branch.%s.remote' % self.get_name())
711 config.unset('branch.%s.merge' % self.get_name())
712 config.unset('branch.%s.stgit.parentbranch' % self.get_name())
713 config.unset('branch.%s.stgitformatversion' % self.get_name())
714
715 def refresh_patch(self, files = None, message = None, edit = False,
716 show_patch = False,
717 cache_update = True,
718 author_name = None, author_email = None,
719 author_date = None,
720 committer_name = None, committer_email = None,
721 backup = False, sign_str = None, log = 'refresh'):
722 """Generates a new commit for the given patch
723 """
724 name = self.get_current()
725 if not name:
726 raise StackException, 'No patches applied'
727
728 patch = Patch(name, self.__patch_dir, self.__refs_dir)
729
730 descr = patch.get_description()
731 if not (message or descr):
732 edit = True
733 descr = ''
734 elif message:
735 descr = message
736
737 if not message and edit:
738 descr = edit_file(self, descr.rstrip(), \
739 'Please edit the description for patch "%s" ' \
740 'above.' % name, show_patch)
741
742 if not author_name:
743 author_name = patch.get_authname()
744 if not author_email:
745 author_email = patch.get_authemail()
746 if not author_date:
747 author_date = patch.get_authdate()
748 if not committer_name:
749 committer_name = patch.get_commname()
750 if not committer_email:
751 committer_email = patch.get_commemail()
752
753 if sign_str:
754 descr = descr.rstrip()
755 if descr.find("\nSigned-off-by:") < 0 \
756 and descr.find("\nAcked-by:") < 0:
757 descr = descr + "\n"
758
759 descr = '%s\n%s: %s <%s>\n' % (descr, sign_str,
760 committer_name, committer_email)
761
762 bottom = patch.get_bottom()
763
764 commit_id = git.commit(files = files,
765 message = descr, parents = [bottom],
766 cache_update = cache_update,
767 allowempty = True,
768 author_name = author_name,
769 author_email = author_email,
770 author_date = author_date,
771 committer_name = committer_name,
772 committer_email = committer_email)
773
774 patch.set_bottom(bottom, backup = backup)
775 patch.set_top(commit_id, backup = backup)
776 patch.set_description(descr)
777 patch.set_authname(author_name)
778 patch.set_authemail(author_email)
779 patch.set_authdate(author_date)
780 patch.set_commname(committer_name)
781 patch.set_commemail(committer_email)
782
783 if log:
784 self.log_patch(patch, log)
785
786 return commit_id
787
788 def undo_refresh(self):
789 """Undo the patch boundaries changes caused by 'refresh'
790 """
791 name = self.get_current()
792 assert(name)
793
794 patch = Patch(name, self.__patch_dir, self.__refs_dir)
795 old_bottom = patch.get_old_bottom()
796 old_top = patch.get_old_top()
797
798 # the bottom of the patch is not changed by refresh. If the
799 # old_bottom is different, there wasn't any previous 'refresh'
800 # command (probably only a 'push')
801 if old_bottom != patch.get_bottom() or old_top == patch.get_top():
802 raise StackException, 'No undo information available'
803
804 git.reset(tree_id = old_top, check_out = False)
805 if patch.restore_old_boundaries():
806 self.log_patch(patch, 'undo')
807
808 def new_patch(self, name, message = None, can_edit = True,
809 unapplied = False, show_patch = False,
810 top = None, bottom = None,
811 author_name = None, author_email = None, author_date = None,
812 committer_name = None, committer_email = None,
813 before_existing = False, refresh = True):
814 """Creates a new patch
815 """
816
817 if name != None:
818 self.__patch_name_valid(name)
819 if self.patch_exists(name):
820 raise StackException, 'Patch "%s" already exists' % name
821
822 if not message and can_edit:
823 descr = edit_file(
824 self, None,
825 'Please enter the description for the patch above.',
826 show_patch)
827 else:
828 descr = message
829
830 head = git.get_head()
831
832 if name == None:
833 name = make_patch_name(descr, self.patch_exists)
834
835 patch = Patch(name, self.__patch_dir, self.__refs_dir)
836 patch.create()
837
838 if bottom:
839 patch.set_bottom(bottom)
840 else:
841 patch.set_bottom(head)
842 if top:
843 patch.set_top(top)
844 else:
845 patch.set_top(head)
846
847 patch.set_description(descr)
848 patch.set_authname(author_name)
849 patch.set_authemail(author_email)
850 patch.set_authdate(author_date)
851 patch.set_commname(committer_name)
852 patch.set_commemail(committer_email)
853
854 if unapplied:
855 self.log_patch(patch, 'new')
856
857 patches = [patch.get_name()] + self.get_unapplied()
858 write_strings(self.__unapplied_file, patches)
859 elif before_existing:
860 self.log_patch(patch, 'new')
861
862 insert_string(self.__applied_file, patch.get_name())
863 else:
864 append_string(self.__applied_file, patch.get_name())
865 if refresh:
866 self.refresh_patch(cache_update = False, log = 'new')
867
868 return patch
869
870 def delete_patch(self, name):
871 """Deletes a patch
872 """
873 self.__patch_name_valid(name)
874 patch = Patch(name, self.__patch_dir, self.__refs_dir)
875
876 if self.__patch_is_current(patch):
877 self.pop_patch(name)
878 elif self.patch_applied(name):
879 raise StackException, 'Cannot remove an applied patch, "%s", ' \
880 'which is not current' % name
881 elif not name in self.get_unapplied():
882 raise StackException, 'Unknown patch "%s"' % name
883
884 # save the commit id to a trash file
885 write_string(os.path.join(self.__trash_dir, name), patch.get_top())
886
887 patch.delete()
888
889 unapplied = self.get_unapplied()
890 unapplied.remove(name)
891 write_strings(self.__unapplied_file, unapplied)
892
893 def forward_patches(self, names):
894 """Try to fast-forward an array of patches.
895
896 On return, patches in names[0:returned_value] have been pushed on the
897 stack. Apply the rest with push_patch
898 """
899 unapplied = self.get_unapplied()
900
901 forwarded = 0
902 top = git.get_head()
903
904 for name in names:
905 assert(name in unapplied)
906
907 patch = Patch(name, self.__patch_dir, self.__refs_dir)
908
909 head = top
910 bottom = patch.get_bottom()
911 top = patch.get_top()
912
913 # top != bottom always since we have a commit for each patch
914 if head == bottom:
915 # reset the backup information. No logging since the
916 # patch hasn't changed
917 patch.set_bottom(head, backup = True)
918 patch.set_top(top, backup = True)
919
920 else:
921 head_tree = git.get_commit(head).get_tree()
922 bottom_tree = git.get_commit(bottom).get_tree()
923 if head_tree == bottom_tree:
924 # We must just reparent this patch and create a new commit
925 # for it
926 descr = patch.get_description()
927 author_name = patch.get_authname()
928 author_email = patch.get_authemail()
929 author_date = patch.get_authdate()
930 committer_name = patch.get_commname()
931 committer_email = patch.get_commemail()
932
933 top_tree = git.get_commit(top).get_tree()
934
935 top = git.commit(message = descr, parents = [head],
936 cache_update = False,
937 tree_id = top_tree,
938 allowempty = True,
939 author_name = author_name,
940 author_email = author_email,
941 author_date = author_date,
942 committer_name = committer_name,
943 committer_email = committer_email)
944
945 patch.set_bottom(head, backup = True)
946 patch.set_top(top, backup = True)
947
948 self.log_patch(patch, 'push(f)')
949 else:
950 top = head
951 # stop the fast-forwarding, must do a real merge
952 break
953
954 forwarded+=1
955 unapplied.remove(name)
956
957 if forwarded == 0:
958 return 0
959
960 git.switch(top)
961
962 append_strings(self.__applied_file, names[0:forwarded])
963 write_strings(self.__unapplied_file, unapplied)
964
965 return forwarded
966
967 def merged_patches(self, names):
968 """Test which patches were merged upstream by reverse-applying
969 them in reverse order. The function returns the list of
970 patches detected to have been applied. The state of the tree
971 is restored to the original one
972 """
973 patches = [Patch(name, self.__patch_dir, self.__refs_dir)
974 for name in names]
975 patches.reverse()
976
977 merged = []
978 for p in patches:
979 if git.apply_diff(p.get_top(), p.get_bottom()):
980 merged.append(p.get_name())
981 merged.reverse()
982
983 git.reset()
984
985 return merged
986
987 def push_patch(self, name, empty = False):
988 """Pushes a patch on the stack
989 """
990 unapplied = self.get_unapplied()
991 assert(name in unapplied)
992
993 patch = Patch(name, self.__patch_dir, self.__refs_dir)
994
995 head = git.get_head()
996 bottom = patch.get_bottom()
997 top = patch.get_top()
998
999 ex = None
1000 modified = False
1001
1002 # top != bottom always since we have a commit for each patch
1003 if empty:
1004 # just make an empty patch (top = bottom = HEAD). This
1005 # option is useful to allow undoing already merged
1006 # patches. The top is updated by refresh_patch since we
1007 # need an empty commit
1008 patch.set_bottom(head, backup = True)
1009 patch.set_top(head, backup = True)
1010 modified = True
1011 elif head == bottom:
1012 # reset the backup information. No need for logging
1013 patch.set_bottom(bottom, backup = True)
1014 patch.set_top(top, backup = True)
1015
1016 git.switch(top)
1017 else:
1018 # new patch needs to be refreshed.
1019 # The current patch is empty after merge.
1020 patch.set_bottom(head, backup = True)
1021 patch.set_top(head, backup = True)
1022
1023 # Try the fast applying first. If this fails, fall back to the
1024 # three-way merge
1025 if not git.apply_diff(bottom, top):
1026 # if git.apply_diff() fails, the patch requires a diff3
1027 # merge and can be reported as modified
1028 modified = True
1029
1030 # merge can fail but the patch needs to be pushed
1031 try:
1032 git.merge(bottom, head, top, recursive = True)
1033 except git.GitException, ex:
1034 out.error('The merge failed during "push".',
1035 'Use "refresh" after fixing the conflicts or'
1036 ' revert the operation with "push --undo".')
1037
1038 append_string(self.__applied_file, name)
1039
1040 unapplied.remove(name)
1041 write_strings(self.__unapplied_file, unapplied)
1042
1043 # head == bottom case doesn't need to refresh the patch
1044 if empty or head != bottom:
1045 if not ex:
1046 # if the merge was OK and no conflicts, just refresh the patch
1047 # The GIT cache was already updated by the merge operation
1048 if modified:
1049 log = 'push(m)'
1050 else:
1051 log = 'push'
1052 self.refresh_patch(cache_update = False, log = log)
1053 else:
1054 # we store the correctly merged files only for
1055 # tracking the conflict history. Note that the
1056 # git.merge() operations should always leave the index
1057 # in a valid state (i.e. only stage 0 files)
1058 self.refresh_patch(cache_update = False, log = 'push(c)')
1059 raise StackException, str(ex)
1060
1061 return modified
1062
1063 def undo_push(self):
1064 name = self.get_current()
1065 assert(name)
1066
1067 patch = Patch(name, self.__patch_dir, self.__refs_dir)
1068 old_bottom = patch.get_old_bottom()
1069 old_top = patch.get_old_top()
1070
1071 # the top of the patch is changed by a push operation only
1072 # together with the bottom (otherwise the top was probably
1073 # modified by 'refresh'). If they are both unchanged, there
1074 # was a fast forward
1075 if old_bottom == patch.get_bottom() and old_top != patch.get_top():
1076 raise StackException, 'No undo information available'
1077
1078 git.reset()
1079 self.pop_patch(name)
1080 ret = patch.restore_old_boundaries()
1081 if ret:
1082 self.log_patch(patch, 'undo')
1083
1084 return ret
1085
1086 def pop_patch(self, name, keep = False):
1087 """Pops the top patch from the stack
1088 """
1089 applied = self.get_applied()
1090 applied.reverse()
1091 assert(name in applied)
1092
1093 patch = Patch(name, self.__patch_dir, self.__refs_dir)
1094
1095 if git.get_head_file() == self.get_name():
1096 if keep and not git.apply_diff(git.get_head(), patch.get_bottom()):
1097 raise StackException(
1098 'Failed to pop patches while preserving the local changes')
1099 git.switch(patch.get_bottom(), keep)
1100 else:
1101 git.set_branch(self.get_name(), patch.get_bottom())
1102
1103 # save the new applied list
1104 idx = applied.index(name) + 1
1105
1106 popped = applied[:idx]
1107 popped.reverse()
1108 unapplied = popped + self.get_unapplied()
1109 write_strings(self.__unapplied_file, unapplied)
1110
1111 del applied[:idx]
1112 applied.reverse()
1113 write_strings(self.__applied_file, applied)
1114
1115 def empty_patch(self, name):
1116 """Returns True if the patch is empty
1117 """
1118 self.__patch_name_valid(name)
1119 patch = Patch(name, self.__patch_dir, self.__refs_dir)
1120 bottom = patch.get_bottom()
1121 top = patch.get_top()
1122
1123 if bottom == top:
1124 return True
1125 elif git.get_commit(top).get_tree() \
1126 == git.get_commit(bottom).get_tree():
1127 return True
1128
1129 return False
1130
1131 def rename_patch(self, oldname, newname):
1132 self.__patch_name_valid(newname)
1133
1134 applied = self.get_applied()
1135 unapplied = self.get_unapplied()
1136
1137 if oldname == newname:
1138 raise StackException, '"To" name and "from" name are the same'
1139
1140 if newname in applied or newname in unapplied:
1141 raise StackException, 'Patch "%s" already exists' % newname
1142
1143 if oldname in unapplied:
1144 Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1145 unapplied[unapplied.index(oldname)] = newname
1146 write_strings(self.__unapplied_file, unapplied)
1147 elif oldname in applied:
1148 Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1149
1150 applied[applied.index(oldname)] = newname
1151 write_strings(self.__applied_file, applied)
1152 else:
1153 raise StackException, 'Unknown patch "%s"' % oldname
1154
1155 def log_patch(self, patch, message):
1156 """Generate a log commit for a patch
1157 """
1158 top = git.get_commit(patch.get_top())
1159 msg = '%s\t%s' % (message, top.get_id_hash())
1160
1161 old_log = patch.get_log()
1162 if old_log:
1163 parents = [old_log]
1164 else:
1165 parents = []
1166
1167 log = git.commit(message = msg, parents = parents,
1168 cache_update = False, tree_id = top.get_tree(),
1169 allowempty = True)
1170 patch.set_log(log)
1171
1172 def hide_patch(self, name):
1173 """Add the patch to the hidden list.
1174 """
1175 unapplied = self.get_unapplied()
1176 if name not in unapplied:
1177 # keep the checking order for backward compatibility with
1178 # the old hidden patches functionality
1179 if self.patch_applied(name):
1180 raise StackException, 'Cannot hide applied patch "%s"' % name
1181 elif self.patch_hidden(name):
1182 raise StackException, 'Patch "%s" already hidden' % name
1183 else:
1184 raise StackException, 'Unknown patch "%s"' % name
1185
1186 if not self.patch_hidden(name):
1187 # check needed for backward compatibility with the old
1188 # hidden patches functionality
1189 append_string(self.__hidden_file, name)
1190
1191 unapplied.remove(name)
1192 write_strings(self.__unapplied_file, unapplied)
1193
1194 def unhide_patch(self, name):
1195 """Remove the patch from the hidden list.
1196 """
1197 hidden = self.get_hidden()
1198 if not name in hidden:
1199 if self.patch_applied(name) or self.patch_unapplied(name):
1200 raise StackException, 'Patch "%s" not hidden' % name
1201 else:
1202 raise StackException, 'Unknown patch "%s"' % name
1203
1204 hidden.remove(name)
1205 write_strings(self.__hidden_file, hidden)
1206
1207 if not self.patch_applied(name) and not self.patch_unapplied(name):
1208 # check needed for backward compatibility with the old
1209 # hidden patches functionality
1210 append_string(self.__unapplied_file, name)