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.__name = name
 360             else:
 361                 self.__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.__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.__name, self.__base_dir)
 371
 372         self.__refs_dir = os.path.join(self.__base_dir, 'refs', 'patches',
 373                                        self.__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_branch(self):
 392         """Return the branch name for the Series object
 393         """
 394         return self.__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.__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.__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_branch()
 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.__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.__name),
 488                      ('Consider setting "branch.%s.remote" and'
 489                       ' "branch.%s.merge" with "git repo-config".'
 490                       % (self.__name, self.__name)))
 491             return 'origin'
 492         else:
 493             raise StackException, 'Cannot find a parent remote for "%s"' % self.__name
 494
 495     def __set_parent_remote(self, remote):
 496         value = config.set('branch.%s.remote' % self.__name, remote)
 497
 498     def get_parent_branch(self):
 499         value = config.get('branch.%s.stgit.parentbranch' % self.__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.__name),
 505                      ('Consider setting "branch.%s.stgit.parentbranch"'
 506                       ' with "git repo-config".' % self.__name))
 507             return 'heads/origin'
 508         else:
 509             raise StackException, 'Cannot find a parent branch for "%s"' % self.__name
 510
 511     def __set_parent_branch(self, name):
 512         if config.get('branch.%s.remote' % self.__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.__name, name)
 516         config.set('branch.%s.stgit.parentbranch' % self.__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.__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_branch())))
 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_branch()
 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.__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         self._set_field('orig-base', git.get_head())
 584
 585         config.set(format_version_key(self.get_branch()), str(FORMAT_VERSION))
 586
 587     def rename(self, to_name):
 588         """Renames a series
 589         """
 590         to_stack = Series(to_name)
 591
 592         if to_stack.is_initialised():
 593             raise StackException, '"%s" already exists' % to_stack.get_branch()
 594
 595         git.rename_branch(self.__name, to_name)
 596
 597         if os.path.isdir(self._dir()):
 598             rename(os.path.join(self.__base_dir, 'patches'),
 599                    self.__name, to_stack.__name)
 600         if os.path.exists(self.__refs_dir):
 601             rename(os.path.join(self.__base_dir, 'refs', 'patches'),
 602                    self.__name, to_stack.__name)
 603
 604         # Rename the config section
 605         config.rename_section("branch.%s" % self.__name,
 606                               "branch.%s" % to_name)
 607
 608         self.__init__(to_name)
 609
 610     def clone(self, target_series):
 611         """Clones a series
 612         """
 613         try:
 614             # allow cloning of branches not under StGIT control
 615             base = self.get_base()
 616         except:
 617             base = git.get_head()
 618         Series(target_series).init(create_at = base)
 619         new_series = Series(target_series)
 620
 621         # generate an artificial description file
 622         new_series.set_description('clone of "%s"' % self.__name)
 623
 624         # clone self's entire series as unapplied patches
 625         try:
 626             # allow cloning of branches not under StGIT control
 627             applied = self.get_applied()
 628             unapplied = self.get_unapplied()
 629             patches = applied + unapplied
 630             patches.reverse()
 631         except:
 632             patches = applied = unapplied = []
 633         for p in patches:
 634             patch = self.get_patch(p)
 635             newpatch = new_series.new_patch(p, message = patch.get_description(),
 636                                             can_edit = False, unapplied = True,
 637                                             bottom = patch.get_bottom(),
 638                                             top = patch.get_top(),
 639                                             author_name = patch.get_authname(),
 640                                             author_email = patch.get_authemail(),
 641                                             author_date = patch.get_authdate())
 642             if patch.get_log():
 643                 out.info('Setting log to %s' %  patch.get_log())
 644                 newpatch.set_log(patch.get_log())
 645             else:
 646                 out.info('No log for %s' % p)
 647
 648         # fast forward the cloned series to self's top
 649         new_series.forward_patches(applied)
 650
 651         # Clone parent informations
 652         value = config.get('branch.%s.remote' % self.__name)
 653         if value:
 654             config.set('branch.%s.remote' % target_series, value)
 655
 656         value = config.get('branch.%s.merge' % self.__name)
 657         if value:
 658             config.set('branch.%s.merge' % target_series, value)
 659
 660         value = config.get('branch.%s.stgit.parentbranch' % self.__name)
 661         if value:
 662             config.set('branch.%s.stgit.parentbranch' % target_series, value)
 663
 664     def delete(self, force = False):
 665         """Deletes an stgit series
 666         """
 667         if self.is_initialised():
 668             patches = self.get_unapplied() + self.get_applied()
 669             if not force and patches:
 670                 raise StackException, \
 671                       'Cannot delete: the series still contains patches'
 672             for p in patches:
 673                 Patch(p, self.__patch_dir, self.__refs_dir).delete()
 674
 675             # remove the trash directory if any
 676             if os.path.exists(self.__trash_dir):
 677                 for fname in os.listdir(self.__trash_dir):
 678                     os.remove(os.path.join(self.__trash_dir, fname))
 679                 os.rmdir(self.__trash_dir)
 680
 681             # FIXME: find a way to get rid of those manual removals
 682             # (move functionality to StgitObject ?)
 683             if os.path.exists(self.__applied_file):
 684                 os.remove(self.__applied_file)
 685             if os.path.exists(self.__unapplied_file):
 686                 os.remove(self.__unapplied_file)
 687             if os.path.exists(self.__hidden_file):
 688                 os.remove(self.__hidden_file)
 689             if os.path.exists(self._dir()+'/orig-base'):
 690                 os.remove(self._dir()+'/orig-base')
 691
 692             if not os.listdir(self.__patch_dir):
 693                 os.rmdir(self.__patch_dir)
 694             else:
 695                 out.warn('Patch directory %s is not empty' % self.__patch_dir)
 696
 697             try:
 698                 os.removedirs(self._dir())
 699             except OSError:
 700                 raise StackException('Series directory %s is not empty'
 701                                      % self._dir())
 702
 703             try:
 704                 os.removedirs(self.__refs_dir)
 705             except OSError:
 706                 out.warn('Refs directory %s is not empty' % self.__refs_dir)
 707
 708         # Cleanup parent informations
 709         # FIXME: should one day make use of git-config --section-remove,
 710         # scheduled for 1.5.1
 711         config.unset('branch.%s.remote' % self.__name)
 712         config.unset('branch.%s.merge' % self.__name)
 713         config.unset('branch.%s.stgit.parentbranch' % self.__name)
 714         config.unset('branch.%s.stgitformatversion' % self.__name)
 715
 716     def refresh_patch(self, files = None, message = None, edit = False,
 717                       show_patch = False,
 718                       cache_update = True,
 719                       author_name = None, author_email = None,
 720                       author_date = None,
 721                       committer_name = None, committer_email = None,
 722                       backup = False, sign_str = None, log = 'refresh'):
 723         """Generates a new commit for the given patch
 724         """
 725         name = self.get_current()
 726         if not name:
 727             raise StackException, 'No patches applied'
 728
 729         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 730
 731         descr = patch.get_description()
 732         if not (message or descr):
 733             edit = True
 734             descr = ''
 735         elif message:
 736             descr = message
 737
 738         if not message and edit:
 739             descr = edit_file(self, descr.rstrip(), \
 740                               'Please edit the description for patch "%s" ' \
 741                               'above.' % name, show_patch)
 742
 743         if not author_name:
 744             author_name = patch.get_authname()
 745         if not author_email:
 746             author_email = patch.get_authemail()
 747         if not author_date:
 748             author_date = patch.get_authdate()
 749         if not committer_name:
 750             committer_name = patch.get_commname()
 751         if not committer_email:
 752             committer_email = patch.get_commemail()
 753
 754         if sign_str:
 755             descr = descr.rstrip()
 756             if descr.find("\nSigned-off-by:") < 0 \
 757                and descr.find("\nAcked-by:") < 0:
 758                 descr = descr + "\n"
 759
 760             descr = '%s\n%s: %s <%s>\n' % (descr, sign_str,
 761                                            committer_name, committer_email)
 762
 763         bottom = patch.get_bottom()
 764
 765         commit_id = git.commit(files = files,
 766                                message = descr, parents = [bottom],
 767                                cache_update = cache_update,
 768                                allowempty = True,
 769                                author_name = author_name,
 770                                author_email = author_email,
 771                                author_date = author_date,
 772                                committer_name = committer_name,
 773                                committer_email = committer_email)
 774
 775         patch.set_bottom(bottom, backup = backup)
 776         patch.set_top(commit_id, backup = backup)
 777         patch.set_description(descr)
 778         patch.set_authname(author_name)
 779         patch.set_authemail(author_email)
 780         patch.set_authdate(author_date)
 781         patch.set_commname(committer_name)
 782         patch.set_commemail(committer_email)
 783
 784         if log:
 785             self.log_patch(patch, log)
 786
 787         return commit_id
 788
 789     def undo_refresh(self):
 790         """Undo the patch boundaries changes caused by 'refresh'
 791         """
 792         name = self.get_current()
 793         assert(name)
 794
 795         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 796         old_bottom = patch.get_old_bottom()
 797         old_top = patch.get_old_top()
 798
 799         # the bottom of the patch is not changed by refresh. If the
 800         # old_bottom is different, there wasn't any previous 'refresh'
 801         # command (probably only a 'push')
 802         if old_bottom != patch.get_bottom() or old_top == patch.get_top():
 803             raise StackException, 'No undo information available'
 804
 805         git.reset(tree_id = old_top, check_out = False)
 806         if patch.restore_old_boundaries():
 807             self.log_patch(patch, 'undo')
 808
 809     def new_patch(self, name, message = None, can_edit = True,
 810                   unapplied = False, show_patch = False,
 811                   top = None, bottom = None,
 812                   author_name = None, author_email = None, author_date = None,
 813                   committer_name = None, committer_email = None,
 814                   before_existing = False, refresh = True):
 815         """Creates a new patch
 816         """
 817
 818         if name != None:
 819             self.__patch_name_valid(name)
 820             if self.patch_exists(name):
 821                 raise StackException, 'Patch "%s" already exists' % name
 822
 823         if not message and can_edit:
 824             descr = edit_file(
 825                 self, None,
 826                 'Please enter the description for the patch above.',
 827                 show_patch)
 828         else:
 829             descr = message
 830
 831         head = git.get_head()
 832
 833         if name == None:
 834             name = make_patch_name(descr, self.patch_exists)
 835
 836         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 837         patch.create()
 838
 839         if bottom:
 840             patch.set_bottom(bottom)
 841         else:
 842             patch.set_bottom(head)
 843         if top:
 844             patch.set_top(top)
 845         else:
 846             patch.set_top(head)
 847
 848         patch.set_description(descr)
 849         patch.set_authname(author_name)
 850         patch.set_authemail(author_email)
 851         patch.set_authdate(author_date)
 852         patch.set_commname(committer_name)
 853         patch.set_commemail(committer_email)
 854
 855         if unapplied:
 856             self.log_patch(patch, 'new')
 857
 858             patches = [patch.get_name()] + self.get_unapplied()
 859             write_strings(self.__unapplied_file, patches)
 860         elif before_existing:
 861             self.log_patch(patch, 'new')
 862
 863             insert_string(self.__applied_file, patch.get_name())
 864         else:
 865             append_string(self.__applied_file, patch.get_name())
 866             if refresh:
 867                 self.refresh_patch(cache_update = False, log = 'new')
 868
 869         return patch
 870
 871     def delete_patch(self, name):
 872         """Deletes a patch
 873         """
 874         self.__patch_name_valid(name)
 875         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 876
 877         if self.__patch_is_current(patch):
 878             self.pop_patch(name)
 879         elif self.patch_applied(name):
 880             raise StackException, 'Cannot remove an applied patch, "%s", ' \
 881                   'which is not current' % name
 882         elif not name in self.get_unapplied():
 883             raise StackException, 'Unknown patch "%s"' % name
 884
 885         # save the commit id to a trash file
 886         write_string(os.path.join(self.__trash_dir, name), patch.get_top())
 887
 888         patch.delete()
 889
 890         unapplied = self.get_unapplied()
 891         unapplied.remove(name)
 892         write_strings(self.__unapplied_file, unapplied)
 893
 894     def forward_patches(self, names):
 895         """Try to fast-forward an array of patches.
 896
 897         On return, patches in names[0:returned_value] have been pushed on the
 898         stack. Apply the rest with push_patch
 899         """
 900         unapplied = self.get_unapplied()
 901
 902         forwarded = 0
 903         top = git.get_head()
 904
 905         for name in names:
 906             assert(name in unapplied)
 907
 908             patch = Patch(name, self.__patch_dir, self.__refs_dir)
 909
 910             head = top
 911             bottom = patch.get_bottom()
 912             top = patch.get_top()
 913
 914             # top != bottom always since we have a commit for each patch
 915             if head == bottom:
 916                 # reset the backup information. No logging since the
 917                 # patch hasn't changed
 918                 patch.set_bottom(head, backup = True)
 919                 patch.set_top(top, backup = True)
 920
 921             else:
 922                 head_tree = git.get_commit(head).get_tree()
 923                 bottom_tree = git.get_commit(bottom).get_tree()
 924                 if head_tree == bottom_tree:
 925                     # We must just reparent this patch and create a new commit
 926                     # for it
 927                     descr = patch.get_description()
 928                     author_name = patch.get_authname()
 929                     author_email = patch.get_authemail()
 930                     author_date = patch.get_authdate()
 931                     committer_name = patch.get_commname()
 932                     committer_email = patch.get_commemail()
 933
 934                     top_tree = git.get_commit(top).get_tree()
 935
 936                     top = git.commit(message = descr, parents = [head],
 937                                      cache_update = False,
 938                                      tree_id = top_tree,
 939                                      allowempty = True,
 940                                      author_name = author_name,
 941                                      author_email = author_email,
 942                                      author_date = author_date,
 943                                      committer_name = committer_name,
 944                                      committer_email = committer_email)
 945
 946                     patch.set_bottom(head, backup = True)
 947                     patch.set_top(top, backup = True)
 948
 949                     self.log_patch(patch, 'push(f)')
 950                 else:
 951                     top = head
 952                     # stop the fast-forwarding, must do a real merge
 953                     break
 954
 955             forwarded+=1
 956             unapplied.remove(name)
 957
 958         if forwarded == 0:
 959             return 0
 960
 961         git.switch(top)
 962
 963         append_strings(self.__applied_file, names[0:forwarded])
 964         write_strings(self.__unapplied_file, unapplied)
 965
 966         return forwarded
 967
 968     def merged_patches(self, names):
 969         """Test which patches were merged upstream by reverse-applying
 970         them in reverse order. The function returns the list of
 971         patches detected to have been applied. The state of the tree
 972         is restored to the original one
 973         """
 974         patches = [Patch(name, self.__patch_dir, self.__refs_dir)
 975                    for name in names]
 976         patches.reverse()
 977
 978         merged = []
 979         for p in patches:
 980             if git.apply_diff(p.get_top(), p.get_bottom()):
 981                 merged.append(p.get_name())
 982         merged.reverse()
 983
 984         git.reset()
 985
 986         return merged
 987
 988     def push_patch(self, name, empty = False):
 989         """Pushes a patch on the stack
 990         """
 991         unapplied = self.get_unapplied()
 992         assert(name in unapplied)
 993
 994         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 995
 996         head = git.get_head()
 997         bottom = patch.get_bottom()
 998         top = patch.get_top()
 999
1000         ex = None
1001         modified = False
1002
1003         # top != bottom always since we have a commit for each patch
1004         if empty:
1005             # just make an empty patch (top = bottom = HEAD). This
1006             # option is useful to allow undoing already merged
1007             # patches. The top is updated by refresh_patch since we
1008             # need an empty commit
1009             patch.set_bottom(head, backup = True)
1010             patch.set_top(head, backup = True)
1011             modified = True
1012         elif head == bottom:
1013             # reset the backup information. No need for logging
1014             patch.set_bottom(bottom, backup = True)
1015             patch.set_top(top, backup = True)
1016
1017             git.switch(top)
1018         else:
1019             # new patch needs to be refreshed.
1020             # The current patch is empty after merge.
1021             patch.set_bottom(head, backup = True)
1022             patch.set_top(head, backup = True)
1023
1024             # Try the fast applying first. If this fails, fall back to the
1025             # three-way merge
1026             if not git.apply_diff(bottom, top):
1027                 # if git.apply_diff() fails, the patch requires a diff3
1028                 # merge and can be reported as modified
1029                 modified = True
1030
1031                 # merge can fail but the patch needs to be pushed
1032                 try:
1033                     git.merge(bottom, head, top, recursive = True)
1034                 except git.GitException, ex:
1035                     out.error('The merge failed during "push".',
1036                               'Use "refresh" after fixing the conflicts or'
1037                               ' revert the operation with "push --undo".')
1038
1039         append_string(self.__applied_file, name)
1040
1041         unapplied.remove(name)
1042         write_strings(self.__unapplied_file, unapplied)
1043
1044         # head == bottom case doesn't need to refresh the patch
1045         if empty or head != bottom:
1046             if not ex:
1047                 # if the merge was OK and no conflicts, just refresh the patch
1048                 # The GIT cache was already updated by the merge operation
1049                 if modified:
1050                     log = 'push(m)'
1051                 else:
1052                     log = 'push'
1053                 self.refresh_patch(cache_update = False, log = log)
1054             else:
1055                 # we store the correctly merged files only for
1056                 # tracking the conflict history. Note that the
1057                 # git.merge() operations should always leave the index
1058                 # in a valid state (i.e. only stage 0 files)
1059                 self.refresh_patch(cache_update = False, log = 'push(c)')
1060                 raise StackException, str(ex)
1061
1062         return modified
1063
1064     def undo_push(self):
1065         name = self.get_current()
1066         assert(name)
1067
1068         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1069         old_bottom = patch.get_old_bottom()
1070         old_top = patch.get_old_top()
1071
1072         # the top of the patch is changed by a push operation only
1073         # together with the bottom (otherwise the top was probably
1074         # modified by 'refresh'). If they are both unchanged, there
1075         # was a fast forward
1076         if old_bottom == patch.get_bottom() and old_top != patch.get_top():
1077             raise StackException, 'No undo information available'
1078
1079         git.reset()
1080         self.pop_patch(name)
1081         ret = patch.restore_old_boundaries()
1082         if ret:
1083             self.log_patch(patch, 'undo')
1084
1085         return ret
1086
1087     def pop_patch(self, name, keep = False):
1088         """Pops the top patch from the stack
1089         """
1090         applied = self.get_applied()
1091         applied.reverse()
1092         assert(name in applied)
1093
1094         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1095
1096         if git.get_head_file() == self.get_branch():
1097             if keep and not git.apply_diff(git.get_head(), patch.get_bottom()):
1098                 raise StackException(
1099                     'Failed to pop patches while preserving the local changes')
1100             git.switch(patch.get_bottom(), keep)
1101         else:
1102             git.set_branch(self.get_branch(), patch.get_bottom())
1103
1104         # save the new applied list
1105         idx = applied.index(name) + 1
1106
1107         popped = applied[:idx]
1108         popped.reverse()
1109         unapplied = popped + self.get_unapplied()
1110         write_strings(self.__unapplied_file, unapplied)
1111
1112         del applied[:idx]
1113         applied.reverse()
1114         write_strings(self.__applied_file, applied)
1115
1116     def empty_patch(self, name):
1117         """Returns True if the patch is empty
1118         """
1119         self.__patch_name_valid(name)
1120         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1121         bottom = patch.get_bottom()
1122         top = patch.get_top()
1123
1124         if bottom == top:
1125             return True
1126         elif git.get_commit(top).get_tree() \
1127                  == git.get_commit(bottom).get_tree():
1128             return True
1129
1130         return False
1131
1132     def rename_patch(self, oldname, newname):
1133         self.__patch_name_valid(newname)
1134
1135         applied = self.get_applied()
1136         unapplied = self.get_unapplied()
1137
1138         if oldname == newname:
1139             raise StackException, '"To" name and "from" name are the same'
1140
1141         if newname in applied or newname in unapplied:
1142             raise StackException, 'Patch "%s" already exists' % newname
1143
1144         if oldname in unapplied:
1145             Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1146             unapplied[unapplied.index(oldname)] = newname
1147             write_strings(self.__unapplied_file, unapplied)
1148         elif oldname in applied:
1149             Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1150
1151             applied[applied.index(oldname)] = newname
1152             write_strings(self.__applied_file, applied)
1153         else:
1154             raise StackException, 'Unknown patch "%s"' % oldname
1155
1156     def log_patch(self, patch, message):
1157         """Generate a log commit for a patch
1158         """
1159         top = git.get_commit(patch.get_top())
1160         msg = '%s\t%s' % (message, top.get_id_hash())
1161
1162         old_log = patch.get_log()
1163         if old_log:
1164             parents = [old_log]
1165         else:
1166             parents = []
1167
1168         log = git.commit(message = msg, parents = parents,
1169                          cache_update = False, tree_id = top.get_tree(),
1170                          allowempty = True)
1171         patch.set_log(log)
1172
1173     def hide_patch(self, name):
1174         """Add the patch to the hidden list.
1175         """
1176         unapplied = self.get_unapplied()
1177         if name not in unapplied:
1178             # keep the checking order for backward compatibility with
1179             # the old hidden patches functionality
1180             if self.patch_applied(name):
1181                 raise StackException, 'Cannot hide applied patch "%s"' % name
1182             elif self.patch_hidden(name):
1183                 raise StackException, 'Patch "%s" already hidden' % name
1184             else:
1185                 raise StackException, 'Unknown patch "%s"' % name
1186
1187         if not self.patch_hidden(name):
1188             # check needed for backward compatibility with the old
1189             # hidden patches functionality
1190             append_string(self.__hidden_file, name)
1191
1192         unapplied.remove(name)
1193         write_strings(self.__unapplied_file, unapplied)
1194
1195     def unhide_patch(self, name):
1196         """Remove the patch from the hidden list.
1197         """
1198         hidden = self.get_hidden()
1199         if not name in hidden:
1200             if self.patch_applied(name) or self.patch_unapplied(name):
1201                 raise StackException, 'Patch "%s" not hidden' % name
1202             else:
1203                 raise StackException, 'Unknown patch "%s"' % name
1204
1205         hidden.remove(name)
1206         write_strings(self.__hidden_file, hidden)
1207
1208         if not self.patch_applied(name) and not self.patch_unapplied(name):
1209             # check needed for backward compatibility with the old
1210             # hidden patches functionality
1211             append_string(self.__unapplied_file, name)