mdw@git.distorted.org.uk Git - stgit/blob - 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 class PatchSet(StgitObject):
 280     def get_name(self):
 281         return self.__name
 282     def set_name(self, name):
 283         self.__name = name
 284
 285     def get_head(self):
 286         """Return the head of the branch
 287         """
 288         crt = self.get_current_patch()
 289         if crt:
 290             return crt.get_top()
 291         else:
 292             return self.get_base()
 293
 294     def get_protected(self):
 295         return os.path.isfile(os.path.join(self._dir(), 'protected'))
 296
 297     def protect(self):
 298         protect_file = os.path.join(self._dir(), 'protected')
 299         if not os.path.isfile(protect_file):
 300             create_empty_file(protect_file)
 301
 302     def unprotect(self):
 303         protect_file = os.path.join(self._dir(), 'protected')
 304         if os.path.isfile(protect_file):
 305             os.remove(protect_file)
 306
 307     def __branch_descr(self):
 308         return 'branch.%s.description' % self.get_name()
 309
 310     def get_description(self):
 311         return config.get(self.__branch_descr()) or ''
 312
 313     def set_description(self, line):
 314         if line:
 315             config.set(self.__branch_descr(), line)
 316         else:
 317             config.unset(self.__branch_descr())
 318
 319     def head_top_equal(self):
 320         """Return true if the head and the top are the same
 321         """
 322         crt = self.get_current_patch()
 323         if not crt:
 324             # we don't care, no patches applied
 325             return True
 326         return git.get_head() == crt.get_top()
 327
 328     def is_initialised(self):
 329         """Checks if series is already initialised
 330         """
 331         return bool(config.get(self.format_version_key()))
 332
 333
 334 class Series(PatchSet):
 335     """Class including the operations on series
 336     """
 337     def __init__(self, name = None):
 338         """Takes a series name as the parameter.
 339         """
 340         try:
 341             if name:
 342                 self.set_name (name)
 343             else:
 344                 self.set_name (git.get_head_file())
 345             self.__base_dir = basedir.get()
 346         except git.GitException, ex:
 347             raise StackException, 'GIT tree not initialised: %s' % ex
 348
 349         self._set_dir(os.path.join(self.__base_dir, 'patches', self.get_name()))
 350
 351         # Update the branch to the latest format version if it is
 352         # initialized, but don't touch it if it isn't.
 353         self.update_to_current_format_version()
 354
 355         self.__refs_dir = os.path.join(self.__base_dir, 'refs', 'patches',
 356                                        self.get_name())
 357
 358         self.__applied_file = os.path.join(self._dir(), 'applied')
 359         self.__unapplied_file = os.path.join(self._dir(), 'unapplied')
 360         self.__hidden_file = os.path.join(self._dir(), 'hidden')
 361
 362         # where this series keeps its patches
 363         self.__patch_dir = os.path.join(self._dir(), 'patches')
 364
 365         # trash directory
 366         self.__trash_dir = os.path.join(self._dir(), 'trash')
 367
 368     def format_version_key(self):
 369         return 'branch.%s.stgit.stackformatversion' % self.get_name()
 370
 371     def update_to_current_format_version(self):
 372         """Update a potentially older StGIT directory structure to the
 373         latest version. Note: This function should depend as little as
 374         possible on external functions that may change during a format
 375         version bump, since it must remain able to process older formats."""
 376
 377         branch_dir = os.path.join(self.__base_dir, 'patches', self.get_name())
 378         def get_format_version():
 379             """Return the integer format version number, or None if the
 380             branch doesn't have any StGIT metadata at all, of any version."""
 381             fv = config.get(self.format_version_key())
 382             ofv = config.get('branch.%s.stgitformatversion' % self.get_name())
 383             if fv:
 384                 # Great, there's an explicitly recorded format version
 385                 # number, which means that the branch is initialized and
 386                 # of that exact version.
 387                 return int(fv)
 388             elif ofv:
 389                 # Old name for the version info, upgrade it
 390                 config.set(self.format_version_key(), ofv)
 391                 config.unset('branch.%s.stgitformatversion' % self.get_name())
 392                 return int(ofv)
 393             elif os.path.isdir(os.path.join(branch_dir, 'patches')):
 394                 # There's a .git/patches/<branch>/patches dirctory, which
 395                 # means this is an initialized version 1 branch.
 396                 return 1
 397             elif os.path.isdir(branch_dir):
 398                 # There's a .git/patches/<branch> directory, which means
 399                 # this is an initialized version 0 branch.
 400                 return 0
 401             else:
 402                 # The branch doesn't seem to be initialized at all.
 403                 return None
 404         def set_format_version(v):
 405             out.info('Upgraded branch %s to format version %d' % (self.get_name(), v))
 406             config.set(self.format_version_key(), '%d' % v)
 407         def mkdir(d):
 408             if not os.path.isdir(d):
 409                 os.makedirs(d)
 410         def rm(f):
 411             if os.path.exists(f):
 412                 os.remove(f)
 413
 414         # Update 0 -> 1.
 415         if get_format_version() == 0:
 416             mkdir(os.path.join(branch_dir, 'trash'))
 417             patch_dir = os.path.join(branch_dir, 'patches')
 418             mkdir(patch_dir)
 419             refs_dir = os.path.join(self.__base_dir, 'refs', 'patches', self.get_name())
 420             mkdir(refs_dir)
 421             for patch in (file(os.path.join(branch_dir, 'unapplied')).readlines()
 422                           + file(os.path.join(branch_dir, 'applied')).readlines()):
 423                 patch = patch.strip()
 424                 os.rename(os.path.join(branch_dir, patch),
 425                           os.path.join(patch_dir, patch))
 426                 Patch(patch, patch_dir, refs_dir).update_top_ref()
 427             set_format_version(1)
 428
 429         # Update 1 -> 2.
 430         if get_format_version() == 1:
 431             desc_file = os.path.join(branch_dir, 'description')
 432             if os.path.isfile(desc_file):
 433                 desc = read_string(desc_file)
 434                 if desc:
 435                     config.set('branch.%s.description' % self.get_name(), desc)
 436                 rm(desc_file)
 437             rm(os.path.join(branch_dir, 'current'))
 438             rm(os.path.join(self.__base_dir, 'refs', 'bases', self.get_name()))
 439             set_format_version(2)
 440
 441         # Make sure we're at the latest version.
 442         if not get_format_version() in [None, FORMAT_VERSION]:
 443             raise StackException('Branch %s is at format version %d, expected %d'
 444                                  % (self.get_name(), get_format_version(), FORMAT_VERSION))
 445
 446     def __patch_name_valid(self, name):
 447         """Raise an exception if the patch name is not valid.
 448         """
 449         if not name or re.search('[^\w.-]', name):
 450             raise StackException, 'Invalid patch name: "%s"' % name
 451
 452     def get_patch(self, name):
 453         """Return a Patch object for the given name
 454         """
 455         return Patch(name, self.__patch_dir, self.__refs_dir)
 456
 457     def get_current_patch(self):
 458         """Return a Patch object representing the topmost patch, or
 459         None if there is no such patch."""
 460         crt = self.get_current()
 461         if not crt:
 462             return None
 463         return Patch(crt, self.__patch_dir, self.__refs_dir)
 464
 465     def get_current(self):
 466         """Return the name of the topmost patch, or None if there is
 467         no such patch."""
 468         try:
 469             applied = self.get_applied()
 470         except StackException:
 471             # No "applied" file: branch is not initialized.
 472             return None
 473         try:
 474             return applied[-1]
 475         except IndexError:
 476             # No patches applied.
 477             return None
 478
 479     def get_applied(self):
 480         if not os.path.isfile(self.__applied_file):
 481             raise StackException, 'Branch "%s" not initialised' % self.get_name()
 482         return read_strings(self.__applied_file)
 483
 484     def get_unapplied(self):
 485         if not os.path.isfile(self.__unapplied_file):
 486             raise StackException, 'Branch "%s" not initialised' % self.get_name()
 487         return read_strings(self.__unapplied_file)
 488
 489     def get_hidden(self):
 490         if not os.path.isfile(self.__hidden_file):
 491             return []
 492         return read_strings(self.__hidden_file)
 493
 494     def get_base(self):
 495         # Return the parent of the bottommost patch, if there is one.
 496         if os.path.isfile(self.__applied_file):
 497             bottommost = file(self.__applied_file).readline().strip()
 498             if bottommost:
 499                 return self.get_patch(bottommost).get_bottom()
 500         # No bottommost patch, so just return HEAD
 501         return git.get_head()
 502
 503     def get_parent_remote(self):
 504         value = config.get('branch.%s.remote' % self.get_name())
 505         if value:
 506             return value
 507         elif 'origin' in git.remotes_list():
 508             out.note(('No parent remote declared for stack "%s",'
 509                       ' defaulting to "origin".' % self.get_name()),
 510                      ('Consider setting "branch.%s.remote" and'
 511                       ' "branch.%s.merge" with "git repo-config".'
 512                       % (self.get_name(), self.get_name())))
 513             return 'origin'
 514         else:
 515             raise StackException, 'Cannot find a parent remote for "%s"' % self.get_name()
 516
 517     def __set_parent_remote(self, remote):
 518         value = config.set('branch.%s.remote' % self.get_name(), remote)
 519
 520     def get_parent_branch(self):
 521         value = config.get('branch.%s.stgit.parentbranch' % self.get_name())
 522         if value:
 523             return value
 524         elif git.rev_parse('heads/origin'):
 525             out.note(('No parent branch declared for stack "%s",'
 526                       ' defaulting to "heads/origin".' % self.get_name()),
 527                      ('Consider setting "branch.%s.stgit.parentbranch"'
 528                       ' with "git repo-config".' % self.get_name()))
 529             return 'heads/origin'
 530         else:
 531             raise StackException, 'Cannot find a parent branch for "%s"' % self.get_name()
 532
 533     def __set_parent_branch(self, name):
 534         if config.get('branch.%s.remote' % self.get_name()):
 535             # Never set merge if remote is not set to avoid
 536             # possibly-erroneous lookups into 'origin'
 537             config.set('branch.%s.merge' % self.get_name(), name)
 538         config.set('branch.%s.stgit.parentbranch' % self.get_name(), name)
 539
 540     def set_parent(self, remote, localbranch):
 541         if localbranch:
 542             self.__set_parent_remote(remote)
 543             self.__set_parent_branch(localbranch)
 544         # We'll enforce this later
 545 #         else:
 546 #             raise StackException, 'Parent branch (%s) should be specified for %s' % localbranch, self.get_name()
 547
 548     def __patch_is_current(self, patch):
 549         return patch.get_name() == self.get_current()
 550
 551     def patch_applied(self, name):
 552         """Return true if the patch exists in the applied list
 553         """
 554         return name in self.get_applied()
 555
 556     def patch_unapplied(self, name):
 557         """Return true if the patch exists in the unapplied list
 558         """
 559         return name in self.get_unapplied()
 560
 561     def patch_hidden(self, name):
 562         """Return true if the patch is hidden.
 563         """
 564         return name in self.get_hidden()
 565
 566     def patch_exists(self, name):
 567         """Return true if there is a patch with the given name, false
 568         otherwise."""
 569         return self.patch_applied(name) or self.patch_unapplied(name) \
 570                or self.patch_hidden(name)
 571
 572     def init(self, create_at=False, parent_remote=None, parent_branch=None):
 573         """Initialises the stgit series
 574         """
 575         if self.is_initialised():
 576             raise StackException, '%s already initialized' % self.get_name()
 577         for d in [self._dir(), self.__refs_dir]:
 578             if os.path.exists(d):
 579                 raise StackException, '%s already exists' % d
 580
 581         if (create_at!=False):
 582             git.create_branch(self.get_name(), create_at)
 583
 584         os.makedirs(self.__patch_dir)
 585
 586         self.set_parent(parent_remote, parent_branch)
 587
 588         self.create_empty_field('applied')
 589         self.create_empty_field('unapplied')
 590         os.makedirs(self.__refs_dir)
 591         self._set_field('orig-base', git.get_head())
 592
 593         config.set(self.format_version_key(), str(FORMAT_VERSION))
 594
 595     def rename(self, to_name):
 596         """Renames a series
 597         """
 598         to_stack = Series(to_name)
 599
 600         if to_stack.is_initialised():
 601             raise StackException, '"%s" already exists' % to_stack.get_name()
 602
 603         git.rename_branch(self.get_name(), to_name)
 604
 605         if os.path.isdir(self._dir()):
 606             rename(os.path.join(self.__base_dir, 'patches'),
 607                    self.get_name(), to_stack.get_name())
 608         if os.path.exists(self.__refs_dir):
 609             rename(os.path.join(self.__base_dir, 'refs', 'patches'),
 610                    self.get_name(), to_stack.get_name())
 611
 612         # Rename the config section
 613         config.rename_section("branch.%s" % self.get_name(),
 614                               "branch.%s" % to_name)
 615
 616         self.__init__(to_name)
 617
 618     def clone(self, target_series):
 619         """Clones a series
 620         """
 621         try:
 622             # allow cloning of branches not under StGIT control
 623             base = self.get_base()
 624         except:
 625             base = git.get_head()
 626         Series(target_series).init(create_at = base)
 627         new_series = Series(target_series)
 628
 629         # generate an artificial description file
 630         new_series.set_description('clone of "%s"' % self.get_name())
 631
 632         # clone self's entire series as unapplied patches
 633         try:
 634             # allow cloning of branches not under StGIT control
 635             applied = self.get_applied()
 636             unapplied = self.get_unapplied()
 637             patches = applied + unapplied
 638             patches.reverse()
 639         except:
 640             patches = applied = unapplied = []
 641         for p in patches:
 642             patch = self.get_patch(p)
 643             newpatch = new_series.new_patch(p, message = patch.get_description(),
 644                                             can_edit = False, unapplied = True,
 645                                             bottom = patch.get_bottom(),
 646                                             top = patch.get_top(),
 647                                             author_name = patch.get_authname(),
 648                                             author_email = patch.get_authemail(),
 649                                             author_date = patch.get_authdate())
 650             if patch.get_log():
 651                 out.info('Setting log to %s' %  patch.get_log())
 652                 newpatch.set_log(patch.get_log())
 653             else:
 654                 out.info('No log for %s' % p)
 655
 656         # fast forward the cloned series to self's top
 657         new_series.forward_patches(applied)
 658
 659         # Clone parent informations
 660         value = config.get('branch.%s.remote' % self.get_name())
 661         if value:
 662             config.set('branch.%s.remote' % target_series, value)
 663
 664         value = config.get('branch.%s.merge' % self.get_name())
 665         if value:
 666             config.set('branch.%s.merge' % target_series, value)
 667
 668         value = config.get('branch.%s.stgit.parentbranch' % self.get_name())
 669         if value:
 670             config.set('branch.%s.stgit.parentbranch' % target_series, value)
 671
 672     def delete(self, force = False):
 673         """Deletes an stgit series
 674         """
 675         if self.is_initialised():
 676             patches = self.get_unapplied() + self.get_applied()
 677             if not force and patches:
 678                 raise StackException, \
 679                       'Cannot delete: the series still contains patches'
 680             for p in patches:
 681                 Patch(p, self.__patch_dir, self.__refs_dir).delete()
 682
 683             # remove the trash directory if any
 684             if os.path.exists(self.__trash_dir):
 685                 for fname in os.listdir(self.__trash_dir):
 686                     os.remove(os.path.join(self.__trash_dir, fname))
 687                 os.rmdir(self.__trash_dir)
 688
 689             # FIXME: find a way to get rid of those manual removals
 690             # (move functionality to StgitObject ?)
 691             if os.path.exists(self.__applied_file):
 692                 os.remove(self.__applied_file)
 693             if os.path.exists(self.__unapplied_file):
 694                 os.remove(self.__unapplied_file)
 695             if os.path.exists(self.__hidden_file):
 696                 os.remove(self.__hidden_file)
 697             if os.path.exists(self._dir()+'/orig-base'):
 698                 os.remove(self._dir()+'/orig-base')
 699
 700             if not os.listdir(self.__patch_dir):
 701                 os.rmdir(self.__patch_dir)
 702             else:
 703                 out.warn('Patch directory %s is not empty' % self.__patch_dir)
 704
 705             try:
 706                 os.removedirs(self._dir())
 707             except OSError:
 708                 raise StackException('Series directory %s is not empty'
 709                                      % self._dir())
 710
 711             try:
 712                 os.removedirs(self.__refs_dir)
 713             except OSError:
 714                 out.warn('Refs directory %s is not empty' % self.__refs_dir)
 715
 716         # Cleanup parent informations
 717         # FIXME: should one day make use of git-config --section-remove,
 718         # scheduled for 1.5.1
 719         config.unset('branch.%s.remote' % self.get_name())
 720         config.unset('branch.%s.merge' % self.get_name())
 721         config.unset('branch.%s.stgit.parentbranch' % self.get_name())
 722         config.unset(self.format_version_key())
 723
 724     def refresh_patch(self, files = None, message = None, edit = False,
 725                       show_patch = False,
 726                       cache_update = True,
 727                       author_name = None, author_email = None,
 728                       author_date = None,
 729                       committer_name = None, committer_email = None,
 730                       backup = False, sign_str = None, log = 'refresh'):
 731         """Generates a new commit for the given patch
 732         """
 733         name = self.get_current()
 734         if not name:
 735             raise StackException, 'No patches applied'
 736
 737         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 738
 739         descr = patch.get_description()
 740         if not (message or descr):
 741             edit = True
 742             descr = ''
 743         elif message:
 744             descr = message
 745
 746         if not message and edit:
 747             descr = edit_file(self, descr.rstrip(), \
 748                               'Please edit the description for patch "%s" ' \
 749                               'above.' % name, show_patch)
 750
 751         if not author_name:
 752             author_name = patch.get_authname()
 753         if not author_email:
 754             author_email = patch.get_authemail()
 755         if not author_date:
 756             author_date = patch.get_authdate()
 757         if not committer_name:
 758             committer_name = patch.get_commname()
 759         if not committer_email:
 760             committer_email = patch.get_commemail()
 761
 762         if sign_str:
 763             descr = descr.rstrip()
 764             if descr.find("\nSigned-off-by:") < 0 \
 765                and descr.find("\nAcked-by:") < 0:
 766                 descr = descr + "\n"
 767
 768             descr = '%s\n%s: %s <%s>\n' % (descr, sign_str,
 769                                            committer_name, committer_email)
 770
 771         bottom = patch.get_bottom()
 772
 773         commit_id = git.commit(files = files,
 774                                message = descr, parents = [bottom],
 775                                cache_update = cache_update,
 776                                allowempty = True,
 777                                author_name = author_name,
 778                                author_email = author_email,
 779                                author_date = author_date,
 780                                committer_name = committer_name,
 781                                committer_email = committer_email)
 782
 783         patch.set_bottom(bottom, backup = backup)
 784         patch.set_top(commit_id, backup = backup)
 785         patch.set_description(descr)
 786         patch.set_authname(author_name)
 787         patch.set_authemail(author_email)
 788         patch.set_authdate(author_date)
 789         patch.set_commname(committer_name)
 790         patch.set_commemail(committer_email)
 791
 792         if log:
 793             self.log_patch(patch, log)
 794
 795         return commit_id
 796
 797     def undo_refresh(self):
 798         """Undo the patch boundaries changes caused by 'refresh'
 799         """
 800         name = self.get_current()
 801         assert(name)
 802
 803         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 804         old_bottom = patch.get_old_bottom()
 805         old_top = patch.get_old_top()
 806
 807         # the bottom of the patch is not changed by refresh. If the
 808         # old_bottom is different, there wasn't any previous 'refresh'
 809         # command (probably only a 'push')
 810         if old_bottom != patch.get_bottom() or old_top == patch.get_top():
 811             raise StackException, 'No undo information available'
 812
 813         git.reset(tree_id = old_top, check_out = False)
 814         if patch.restore_old_boundaries():
 815             self.log_patch(patch, 'undo')
 816
 817     def new_patch(self, name, message = None, can_edit = True,
 818                   unapplied = False, show_patch = False,
 819                   top = None, bottom = None,
 820                   author_name = None, author_email = None, author_date = None,
 821                   committer_name = None, committer_email = None,
 822                   before_existing = False, refresh = True):
 823         """Creates a new patch
 824         """
 825
 826         if name != None:
 827             self.__patch_name_valid(name)
 828             if self.patch_exists(name):
 829                 raise StackException, 'Patch "%s" already exists' % name
 830
 831         if not message and can_edit:
 832             descr = edit_file(
 833                 self, None,
 834                 'Please enter the description for the patch above.',
 835                 show_patch)
 836         else:
 837             descr = message
 838
 839         head = git.get_head()
 840
 841         if name == None:
 842             name = make_patch_name(descr, self.patch_exists)
 843
 844         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 845         patch.create()
 846
 847         if bottom:
 848             patch.set_bottom(bottom)
 849         else:
 850             patch.set_bottom(head)
 851         if top:
 852             patch.set_top(top)
 853         else:
 854             patch.set_top(head)
 855
 856         patch.set_description(descr)
 857         patch.set_authname(author_name)
 858         patch.set_authemail(author_email)
 859         patch.set_authdate(author_date)
 860         patch.set_commname(committer_name)
 861         patch.set_commemail(committer_email)
 862
 863         if unapplied:
 864             self.log_patch(patch, 'new')
 865
 866             patches = [patch.get_name()] + self.get_unapplied()
 867             write_strings(self.__unapplied_file, patches)
 868         elif before_existing:
 869             self.log_patch(patch, 'new')
 870
 871             insert_string(self.__applied_file, patch.get_name())
 872         else:
 873             append_string(self.__applied_file, patch.get_name())
 874             if refresh:
 875                 self.refresh_patch(cache_update = False, log = 'new')
 876
 877         return patch
 878
 879     def delete_patch(self, name):
 880         """Deletes a patch
 881         """
 882         self.__patch_name_valid(name)
 883         patch = Patch(name, self.__patch_dir, self.__refs_dir)
 884
 885         if self.__patch_is_current(patch):
 886             self.pop_patch(name)
 887         elif self.patch_applied(name):
 888             raise StackException, 'Cannot remove an applied patch, "%s", ' \
 889                   'which is not current' % name
 890         elif not name in self.get_unapplied():
 891             raise StackException, 'Unknown patch "%s"' % name
 892
 893         # save the commit id to a trash file
 894         write_string(os.path.join(self.__trash_dir, name), patch.get_top())
 895
 896         patch.delete()
 897
 898         unapplied = self.get_unapplied()
 899         unapplied.remove(name)
 900         write_strings(self.__unapplied_file, unapplied)
 901
 902     def forward_patches(self, names):
 903         """Try to fast-forward an array of patches.
 904
 905         On return, patches in names[0:returned_value] have been pushed on the
 906         stack. Apply the rest with push_patch
 907         """
 908         unapplied = self.get_unapplied()
 909
 910         forwarded = 0
 911         top = git.get_head()
 912
 913         for name in names:
 914             assert(name in unapplied)
 915
 916             patch = Patch(name, self.__patch_dir, self.__refs_dir)
 917
 918             head = top
 919             bottom = patch.get_bottom()
 920             top = patch.get_top()
 921
 922             # top != bottom always since we have a commit for each patch
 923             if head == bottom:
 924                 # reset the backup information. No logging since the
 925                 # patch hasn't changed
 926                 patch.set_bottom(head, backup = True)
 927                 patch.set_top(top, backup = True)
 928
 929             else:
 930                 head_tree = git.get_commit(head).get_tree()
 931                 bottom_tree = git.get_commit(bottom).get_tree()
 932                 if head_tree == bottom_tree:
 933                     # We must just reparent this patch and create a new commit
 934                     # for it
 935                     descr = patch.get_description()
 936                     author_name = patch.get_authname()
 937                     author_email = patch.get_authemail()
 938                     author_date = patch.get_authdate()
 939                     committer_name = patch.get_commname()
 940                     committer_email = patch.get_commemail()
 941
 942                     top_tree = git.get_commit(top).get_tree()
 943
 944                     top = git.commit(message = descr, parents = [head],
 945                                      cache_update = False,
 946                                      tree_id = top_tree,
 947                                      allowempty = True,
 948                                      author_name = author_name,
 949                                      author_email = author_email,
 950                                      author_date = author_date,
 951                                      committer_name = committer_name,
 952                                      committer_email = committer_email)
 953
 954                     patch.set_bottom(head, backup = True)
 955                     patch.set_top(top, backup = True)
 956
 957                     self.log_patch(patch, 'push(f)')
 958                 else:
 959                     top = head
 960                     # stop the fast-forwarding, must do a real merge
 961                     break
 962
 963             forwarded+=1
 964             unapplied.remove(name)
 965
 966         if forwarded == 0:
 967             return 0
 968
 969         git.switch(top)
 970
 971         append_strings(self.__applied_file, names[0:forwarded])
 972         write_strings(self.__unapplied_file, unapplied)
 973
 974         return forwarded
 975
 976     def merged_patches(self, names):
 977         """Test which patches were merged upstream by reverse-applying
 978         them in reverse order. The function returns the list of
 979         patches detected to have been applied. The state of the tree
 980         is restored to the original one
 981         """
 982         patches = [Patch(name, self.__patch_dir, self.__refs_dir)
 983                    for name in names]
 984         patches.reverse()
 985
 986         merged = []
 987         for p in patches:
 988             if git.apply_diff(p.get_top(), p.get_bottom()):
 989                 merged.append(p.get_name())
 990         merged.reverse()
 991
 992         git.reset()
 993
 994         return merged
 995
 996     def push_patch(self, name, empty = False):
 997         """Pushes a patch on the stack
 998         """
 999         unapplied = self.get_unapplied()
1000         assert(name in unapplied)
1001
1002         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1003
1004         head = git.get_head()
1005         bottom = patch.get_bottom()
1006         top = patch.get_top()
1007
1008         ex = None
1009         modified = False
1010
1011         # top != bottom always since we have a commit for each patch
1012         if empty:
1013             # just make an empty patch (top = bottom = HEAD). This
1014             # option is useful to allow undoing already merged
1015             # patches. The top is updated by refresh_patch since we
1016             # need an empty commit
1017             patch.set_bottom(head, backup = True)
1018             patch.set_top(head, backup = True)
1019             modified = True
1020         elif head == bottom:
1021             # reset the backup information. No need for logging
1022             patch.set_bottom(bottom, backup = True)
1023             patch.set_top(top, backup = True)
1024
1025             git.switch(top)
1026         else:
1027             # new patch needs to be refreshed.
1028             # The current patch is empty after merge.
1029             patch.set_bottom(head, backup = True)
1030             patch.set_top(head, backup = True)
1031
1032             # Try the fast applying first. If this fails, fall back to the
1033             # three-way merge
1034             if not git.apply_diff(bottom, top):
1035                 # if git.apply_diff() fails, the patch requires a diff3
1036                 # merge and can be reported as modified
1037                 modified = True
1038
1039                 # merge can fail but the patch needs to be pushed
1040                 try:
1041                     git.merge(bottom, head, top, recursive = True)
1042                 except git.GitException, ex:
1043                     out.error('The merge failed during "push".',
1044                               'Use "refresh" after fixing the conflicts or'
1045                               ' revert the operation with "push --undo".')
1046
1047         append_string(self.__applied_file, name)
1048
1049         unapplied.remove(name)
1050         write_strings(self.__unapplied_file, unapplied)
1051
1052         # head == bottom case doesn't need to refresh the patch
1053         if empty or head != bottom:
1054             if not ex:
1055                 # if the merge was OK and no conflicts, just refresh the patch
1056                 # The GIT cache was already updated by the merge operation
1057                 if modified:
1058                     log = 'push(m)'
1059                 else:
1060                     log = 'push'
1061                 self.refresh_patch(cache_update = False, log = log)
1062             else:
1063                 # we store the correctly merged files only for
1064                 # tracking the conflict history. Note that the
1065                 # git.merge() operations should always leave the index
1066                 # in a valid state (i.e. only stage 0 files)
1067                 self.refresh_patch(cache_update = False, log = 'push(c)')
1068                 raise StackException, str(ex)
1069
1070         return modified
1071
1072     def undo_push(self):
1073         name = self.get_current()
1074         assert(name)
1075
1076         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1077         old_bottom = patch.get_old_bottom()
1078         old_top = patch.get_old_top()
1079
1080         # the top of the patch is changed by a push operation only
1081         # together with the bottom (otherwise the top was probably
1082         # modified by 'refresh'). If they are both unchanged, there
1083         # was a fast forward
1084         if old_bottom == patch.get_bottom() and old_top != patch.get_top():
1085             raise StackException, 'No undo information available'
1086
1087         git.reset()
1088         self.pop_patch(name)
1089         ret = patch.restore_old_boundaries()
1090         if ret:
1091             self.log_patch(patch, 'undo')
1092
1093         return ret
1094
1095     def pop_patch(self, name, keep = False):
1096         """Pops the top patch from the stack
1097         """
1098         applied = self.get_applied()
1099         applied.reverse()
1100         assert(name in applied)
1101
1102         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1103
1104         if git.get_head_file() == self.get_name():
1105             if keep and not git.apply_diff(git.get_head(), patch.get_bottom()):
1106                 raise StackException(
1107                     'Failed to pop patches while preserving the local changes')
1108             git.switch(patch.get_bottom(), keep)
1109         else:
1110             git.set_branch(self.get_name(), patch.get_bottom())
1111
1112         # save the new applied list
1113         idx = applied.index(name) + 1
1114
1115         popped = applied[:idx]
1116         popped.reverse()
1117         unapplied = popped + self.get_unapplied()
1118         write_strings(self.__unapplied_file, unapplied)
1119
1120         del applied[:idx]
1121         applied.reverse()
1122         write_strings(self.__applied_file, applied)
1123
1124     def empty_patch(self, name):
1125         """Returns True if the patch is empty
1126         """
1127         self.__patch_name_valid(name)
1128         patch = Patch(name, self.__patch_dir, self.__refs_dir)
1129         bottom = patch.get_bottom()
1130         top = patch.get_top()
1131
1132         if bottom == top:
1133             return True
1134         elif git.get_commit(top).get_tree() \
1135                  == git.get_commit(bottom).get_tree():
1136             return True
1137
1138         return False
1139
1140     def rename_patch(self, oldname, newname):
1141         self.__patch_name_valid(newname)
1142
1143         applied = self.get_applied()
1144         unapplied = self.get_unapplied()
1145
1146         if oldname == newname:
1147             raise StackException, '"To" name and "from" name are the same'
1148
1149         if newname in applied or newname in unapplied:
1150             raise StackException, 'Patch "%s" already exists' % newname
1151
1152         if oldname in unapplied:
1153             Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1154             unapplied[unapplied.index(oldname)] = newname
1155             write_strings(self.__unapplied_file, unapplied)
1156         elif oldname in applied:
1157             Patch(oldname, self.__patch_dir, self.__refs_dir).rename(newname)
1158
1159             applied[applied.index(oldname)] = newname
1160             write_strings(self.__applied_file, applied)
1161         else:
1162             raise StackException, 'Unknown patch "%s"' % oldname
1163
1164     def log_patch(self, patch, message):
1165         """Generate a log commit for a patch
1166         """
1167         top = git.get_commit(patch.get_top())
1168         msg = '%s\t%s' % (message, top.get_id_hash())
1169
1170         old_log = patch.get_log()
1171         if old_log:
1172             parents = [old_log]
1173         else:
1174             parents = []
1175
1176         log = git.commit(message = msg, parents = parents,
1177                          cache_update = False, tree_id = top.get_tree(),
1178                          allowempty = True)
1179         patch.set_log(log)
1180
1181     def hide_patch(self, name):
1182         """Add the patch to the hidden list.
1183         """
1184         unapplied = self.get_unapplied()
1185         if name not in unapplied:
1186             # keep the checking order for backward compatibility with
1187             # the old hidden patches functionality
1188             if self.patch_applied(name):
1189                 raise StackException, 'Cannot hide applied patch "%s"' % name
1190             elif self.patch_hidden(name):
1191                 raise StackException, 'Patch "%s" already hidden' % name
1192             else:
1193                 raise StackException, 'Unknown patch "%s"' % name
1194
1195         if not self.patch_hidden(name):
1196             # check needed for backward compatibility with the old
1197             # hidden patches functionality
1198             append_string(self.__hidden_file, name)
1199
1200         unapplied.remove(name)
1201         write_strings(self.__unapplied_file, unapplied)
1202
1203     def unhide_patch(self, name):
1204         """Remove the patch from the hidden list.
1205         """
1206         hidden = self.get_hidden()
1207         if not name in hidden:
1208             if self.patch_applied(name) or self.patch_unapplied(name):
1209                 raise StackException, 'Patch "%s" not hidden' % name
1210             else:
1211                 raise StackException, 'Unknown patch "%s"' % name
1212
1213         hidden.remove(name)
1214         write_strings(self.__hidden_file, hidden)
1215
1216         if not self.patch_applied(name) and not self.patch_unapplied(name):
1217             # check needed for backward compatibility with the old
1218             # hidden patches functionality
1219             append_string(self.__unapplied_file, name)