chiark - git - mdw - stgit/blob - stgit/main.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
  22 from optparse import OptionParser, make_option
  23
  24 from stgit.utils import *
  25 from stgit import stack, git
  26 from stgit.version import version
  27 from stgit.config import config
  28
  29
  30 # Main exception class
  31 class MainException(Exception):
  32     pass
  33
  34
  35 # Utility functions
  36 def __git_id(string):
  37     """Return the GIT id
  38     """
  39     if not string:
  40         return None
  41
  42     string_list = string.split('/')
  43
  44     if len(string_list) == 1:
  45         patch_name = None
  46         git_id = string_list[0]
  47
  48         if git_id == 'HEAD':
  49             return git.get_head()
  50         if git_id == 'base':
  51             return read_string(crt_series.get_base_file())
  52
  53         for path in [os.path.join(git.base_dir, 'refs', 'heads'),
  54                      os.path.join(git.base_dir, 'refs', 'tags')]:
  55             id_file = os.path.join(path, git_id)
  56             if os.path.isfile(id_file):
  57                 return read_string(id_file)
  58     elif len(string_list) == 2:
  59         patch_name = string_list[0]
  60         if patch_name == '':
  61             patch_name = crt_series.get_current()
  62         git_id = string_list[1]
  63
  64         if not patch_name:
  65             raise MainException, 'No patches applied'
  66         elif not (patch_name in crt_series.get_applied()
  67                 + crt_series.get_unapplied()):
  68             raise MainException, 'Unknown patch "%s"' % patch_name
  69
  70         if git_id == 'bottom':
  71             return crt_series.get_patch(patch_name).get_bottom()
  72         if git_id == 'top':
  73             return crt_series.get_patch(patch_name).get_top()
  74
  75     raise MainException, 'Unknown id: %s' % string
  76
  77 def __check_local_changes():
  78     if git.local_changes():
  79         raise MainException, \
  80               'local changes in the tree. Use "refresh" to commit them'
  81
  82 def __check_head_top_equal():
  83     if not crt_series.head_top_equal():
  84         raise MainException, \
  85               'HEAD and top are not the same. You probably committed\n' \
  86               '  changes to the tree ouside of StGIT. If you know what you\n' \
  87               '  are doing, use the "refresh -f" command'
  88
  89 def __check_conflicts():
  90     if os.path.exists(os.path.join(git.base_dir, 'conflicts')):
  91         raise MainException, 'Unsolved conflicts. Please resolve them first'
  92
  93 def __print_crt_patch():
  94     patch = crt_series.get_current()
  95     if patch:
  96         print 'Now at patch "%s"' % patch
  97     else:
  98         print 'No patches applied'
  99
 100
 101 #
 102 # Command functions
 103 #
 104 class Command:
 105     """This class is used to store the command details
 106     """
 107     def __init__(self, func, help, usage, option_list):
 108         self.func = func
 109         self.help = help
 110         self.usage = usage
 111         self.option_list = option_list
 112
 113
 114 def init(parser, options, args):
 115     """Performs the repository initialisation
 116     """
 117     if len(args) != 0:
 118         parser.error('incorrect number of arguments')
 119
 120     crt_series.init()
 121
 122 init_cmd = \
 123          Command(init,
 124                  'initialise the tree for use with StGIT',
 125                  '%prog',
 126                  [])
 127
 128
 129 def add(parser, options, args):
 130     """Add files or directories to the repository
 131     """
 132     if len(args) < 1:
 133         parser.error('incorrect number of arguments')
 134
 135     git.add(args)
 136
 137 add_cmd = \
 138         Command(add,
 139                 'add files or directories to the repository',
 140                 '%prog <files/dirs...>',
 141                 [])
 142
 143
 144 def rm(parser, options, args):
 145     """Remove files from the repository
 146     """
 147     if len(args) < 1:
 148         parser.error('incorrect number of arguments')
 149
 150     git.rm(args, options.force)
 151
 152 rm_cmd = \
 153        Command(rm,
 154                'remove files from the repository',
 155                '%prog [options] <files...>',
 156                [make_option('-f', '--force',
 157                             help = 'force removing even if the file exists',
 158                             action = 'store_true')])
 159
 160
 161 def status(parser, options, args):
 162     """Show the tree status
 163     """
 164     git.status(args, options.modified, options.new, options.deleted,
 165                options.conflict, options.unknown)
 166
 167 status_cmd = \
 168            Command(status,
 169                    'show the tree status',
 170                    '%prog [options] [<files...>]',
 171                    [make_option('-m', '--modified',
 172                                 help = 'show modified files only',
 173                                 action = 'store_true'),
 174                     make_option('-n', '--new',
 175                                 help = 'show new files only',
 176                                 action = 'store_true'),
 177                     make_option('-d', '--deleted',
 178                                 help = 'show deleted files only',
 179                                 action = 'store_true'),
 180                     make_option('-c', '--conflict',
 181                                 help = 'show conflict files only',
 182                                 action = 'store_true'),
 183                     make_option('-u', '--unknown',
 184                                 help = 'show unknown files only',
 185                                 action = 'store_true')])
 186
 187
 188 def diff(parser, options, args):
 189     """Show the tree diff
 190     """
 191     if options.revs:
 192         rev_list = options.revs.split(':')
 193         rev_list_len = len(rev_list)
 194         if rev_list_len == 1:
 195             if rev_list[0][-1] == '/':
 196                 # the whole patch
 197                 rev1 = rev_list[0] + 'bottom'
 198                 rev2 = rev_list[0] + 'top'
 199             else:
 200                 rev1 = rev_list[0]
 201                 rev2 = None
 202         elif rev_list_len == 2:
 203             rev1 = rev_list[0]
 204             rev2 = rev_list[1]
 205             if rev2 == '':
 206                 rev2 = 'HEAD'
 207         else:
 208             parser.error('incorrect parameters to -r')
 209     else:
 210         rev1 = 'HEAD'
 211         rev2 = None
 212
 213     if options.stat:
 214         print git.diffstat(args, __git_id(rev1), __git_id(rev2))
 215     else:
 216         git.diff(args, __git_id(rev1), __git_id(rev2))
 217
 218 diff_cmd = \
 219            Command(diff,
 220                    'show the tree diff',
 221                    '%prog [options] [<files...>]\n\n'
 222                    'The revision format is "([patch]/[bottom | top]) | <tree-ish>"',
 223                    [make_option('-r', metavar = 'rev1[:[rev2]]', dest = 'revs',
 224                                 help = 'show the diff between revisions'),
 225                     make_option('-s', '--stat',
 226                                 help = 'show the stat instead of the diff',
 227                                 action = 'store_true')])
 228
 229
 230 def files(parser, options, args):
 231     """Show the files modified by a patch (or the current patch)
 232     """
 233     if len(args) == 0:
 234         patch = ''
 235     elif len(args) == 1:
 236         patch = args[0]
 237     else:
 238         parser.error('incorrect number of arguments')
 239
 240     rev1 = __git_id('%s/bottom' % patch)
 241     rev2 = __git_id('%s/top' % patch)
 242
 243     if options.stat:
 244         print git.diffstat(rev1 = rev1, rev2 = rev2)
 245     else:
 246         print git.files(rev1, rev2)
 247
 248 files_cmd = \
 249           Command(files,
 250                   'show the files modified by a patch (or the current patch)',
 251                   '%prog [options] [<patch>]',
 252                   [make_option('-s', '--stat',
 253                                help = 'show the diff stat',
 254                                action = 'store_true')])
 255
 256
 257 def refresh(parser, options, args):
 258     if len(args) != 0:
 259         parser.error('incorrect number of arguments')
 260
 261     if config.has_option('stgit', 'autoresolved'):
 262         autoresolved = config.get('stgit', 'autoresolved')
 263     else:
 264         autoresolved = 'no'
 265
 266     if autoresolved != 'yes':
 267         __check_conflicts()
 268
 269     patch = crt_series.get_current()
 270     if not patch:
 271         raise MainException, 'No patches applied'
 272
 273     if not options.force:
 274         __check_head_top_equal()
 275
 276     if git.local_changes() \
 277            or not crt_series.head_top_equal() \
 278            or options.edit or options.message \
 279            or options.authname or options.authemail or options.authdate \
 280            or options.commname or options.commemail:
 281         print 'Refreshing patch "%s"...' % patch,
 282         sys.stdout.flush()
 283
 284         if autoresolved == 'yes':
 285             __resolved_all()
 286         crt_series.refresh_patch(message = options.message,
 287                                  edit = options.edit,
 288                                  author_name = options.authname,
 289                                  author_email = options.authemail,
 290                                  author_date = options.authdate,
 291                                  committer_name = options.commname,
 292                                  committer_email = options.commemail)
 293
 294         print 'done'
 295     else:
 296         print 'Patch "%s" is already up to date' % patch
 297
 298 refresh_cmd = \
 299             Command(refresh,
 300                     'generate a new commit for the current patch',
 301                     '%prog [options]',
 302                     [make_option('-f', '--force',
 303                                  help = 'force the refresh even if HEAD and '\
 304                                  'top differ',
 305                                  action = 'store_true'),
 306                      make_option('-e', '--edit',
 307                                  help = 'invoke an editor for the patch '\
 308                                  'description',
 309                                  action = 'store_true'),
 310                      make_option('-m', '--message',
 311                                  help = 'use MESSAGE as the patch ' \
 312                                  'description'),
 313                      make_option('--authname',
 314                                  help = 'use AUTHNAME as the author name'),
 315                      make_option('--authemail',
 316                                  help = 'use AUTHEMAIL as the author e-mail'),
 317                      make_option('--authdate',
 318                                  help = 'use AUTHDATE as the author date'),
 319                      make_option('--commname',
 320                                  help = 'use COMMNAME as the committer name'),
 321                      make_option('--commemail',
 322                                  help = 'use COMMEMAIL as the committer ' \
 323                                  'e-mail')])
 324
 325
 326 def new(parser, options, args):
 327     """Creates a new patch
 328     """
 329     if len(args) != 1:
 330         parser.error('incorrect number of arguments')
 331
 332     __check_local_changes()
 333     __check_conflicts()
 334     __check_head_top_equal()
 335
 336     crt_series.new_patch(args[0], message = options.message,
 337                          author_name = options.authname,
 338                          author_email = options.authemail,
 339                          author_date = options.authdate,
 340                          committer_name = options.commname,
 341                          committer_email = options.commemail)
 342
 343 new_cmd = \
 344         Command(new,
 345                 'create a new patch and make it the topmost one',
 346                 '%prog [options] <name>',
 347                 [make_option('-m', '--message',
 348                              help = 'use MESSAGE as the patch description'),
 349                  make_option('--authname',
 350                              help = 'use AUTHNAME as the author name'),
 351                  make_option('--authemail',
 352                              help = 'use AUTHEMAIL as the author e-mail'),
 353                  make_option('--authdate',
 354                              help = 'use AUTHDATE as the author date'),
 355                  make_option('--commname',
 356                              help = 'use COMMNAME as the committer name'),
 357                  make_option('--commemail',
 358                              help = 'use COMMEMAIL as the committer e-mail')])
 359
 360 def delete(parser, options, args):
 361     """Deletes a patch
 362     """
 363     if len(args) != 1:
 364         parser.error('incorrect number of arguments')
 365
 366     if args[0] == crt_series.get_current():
 367         __check_local_changes()
 368         __check_conflicts()
 369         __check_head_top_equal()
 370
 371     crt_series.delete_patch(args[0])
 372     print 'Patch "%s" successfully deleted' % args[0]
 373     __print_crt_patch()
 374
 375 delete_cmd = \
 376            Command(delete,
 377                    'remove the topmost or any unapplied patch',
 378                    '%prog <name>',
 379                    [])
 380
 381
 382 def push(parser, options, args):
 383     """Pushes the given patch or all onto the series
 384     """
 385     # If --undo is passed, do the work and exit
 386     if options.undo:
 387         patch = crt_series.get_current()
 388         if not patch:
 389             raise MainException, 'No patch to undo'
 390
 391         print 'Undoing the "%s" push...' % patch,
 392         sys.stdout.flush()
 393         __resolved_all()
 394         crt_series.undo_push()
 395         print 'done'
 396         __print_crt_patch()
 397
 398         return
 399
 400     __check_local_changes()
 401     __check_conflicts()
 402     __check_head_top_equal()
 403
 404     unapplied = crt_series.get_unapplied()
 405     if not unapplied:
 406         raise MainException, 'No more patches to push'
 407
 408     if options.to:
 409         boundaries = options.to.split(':')
 410         if len(boundaries) == 1:
 411             if boundaries[0] not in unapplied:
 412                 raise MainException, 'Patch "%s" not unapplied' % boundaries[0]
 413             patches = unapplied[:unapplied.index(boundaries[0])+1]
 414         elif len(boundaries) == 2:
 415             if boundaries[0] not in unapplied:
 416                 raise MainException, 'Patch "%s" not unapplied' % boundaries[0]
 417             if boundaries[1] not in unapplied:
 418                 raise MainException, 'Patch "%s" not unapplied' % boundaries[1]
 419             lb = unapplied.index(boundaries[0])
 420             hb = unapplied.index(boundaries[1])
 421             if lb > hb:
 422                 raise MainException, 'Patch "%s" after "%s"' \
 423                       % (boundaries[0], boundaries[1])
 424             patches = unapplied[lb:hb+1]
 425         else:
 426             raise MainException, 'incorrect parameters to "--to"'
 427     elif options.number:
 428         patches = unapplied[:options.number]
 429     elif options.all:
 430         patches = unapplied
 431     elif len(args) == 0:
 432         patches = [unapplied[0]]
 433     elif len(args) == 1:
 434         patches = [args[0]]
 435     else:
 436         parser.error('incorrect number of arguments')
 437
 438     if patches == []:
 439         raise MainException, 'No patches to push'
 440
 441     if options.reverse:
 442         patches.reverse()
 443
 444     for p in patches:
 445         print 'Pushing patch "%s"...' % p,
 446         sys.stdout.flush()
 447
 448         crt_series.push_patch(p)
 449
 450         if crt_series.empty_patch(p):
 451             print 'done (empty patch)'
 452         else:
 453             print 'done'
 454     __print_crt_patch()
 455
 456 push_cmd = \
 457          Command(push,
 458                  'push a patch on top of the series',
 459                  '%prog [options] [<name>]',
 460                  [make_option('-a', '--all',
 461                               help = 'push all the unapplied patches',
 462                               action = 'store_true'),
 463                   make_option('-n', '--number', type = 'int',
 464                               help = 'push the specified number of patches'),
 465                   make_option('-t', '--to', metavar = 'PATCH1[:PATCH2]',
 466                               help = 'push all patches to PATCH1 or between '
 467                               'PATCH1 and PATCH2'),
 468                   make_option('--reverse',
 469                               help = 'push the patches in reverse order',
 470                               action = 'store_true'),
 471                   make_option('--undo',
 472                               help = 'undo the last push operation',
 473                               action = 'store_true')])
 474
 475
 476 def pop(parser, options, args):
 477     if len(args) != 0:
 478         parser.error('incorrect number of arguments')
 479
 480     __check_local_changes()
 481     __check_conflicts()
 482     __check_head_top_equal()
 483
 484     applied = crt_series.get_applied()
 485     if not applied:
 486         raise MainException, 'No patches applied'
 487     applied.reverse()
 488
 489     if options.to:
 490         if options.to not in applied:
 491             raise MainException, 'Patch "%s" not applied' % options.to
 492         patches = applied[:applied.index(options.to)]
 493     elif options.number:
 494         patches = applied[:options.number]
 495     elif options.all:
 496         patches = applied
 497     else:
 498         patches = [applied[0]]
 499
 500     if patches == []:
 501         raise MainException, 'No patches to pop'
 502
 503     # pop everything to the given patch
 504     p = patches[-1]
 505     if len(patches) == 1:
 506         print 'Popping patch "%s"...' % p,
 507     else:
 508         print 'Popping "%s" - "%s" patches...' % (patches[0], p),
 509     sys.stdout.flush()
 510
 511     crt_series.pop_patch(p)
 512
 513     print 'done'
 514     __print_crt_patch()
 515
 516 pop_cmd = \
 517         Command(pop,
 518                 'pop the top of the series',
 519                 '%prog [options]',
 520                 [make_option('-a', '--all',
 521                              help = 'pop all the applied patches',
 522                              action = 'store_true'),
 523                  make_option('-n', '--number', type = 'int',
 524                              help = 'pop the specified number of patches'),
 525                  make_option('-t', '--to', metavar = 'PATCH',
 526                              help = 'pop all patches up to PATCH')])
 527
 528
 529 def __resolved(filename):
 530     git.update_cache([filename])
 531     for ext in ['.local', '.older', '.remote']:
 532         fn = filename + ext
 533         if os.path.isfile(fn):
 534             os.remove(fn)
 535
 536 def __resolved_all():
 537     conflicts = git.get_conflicts()
 538     if conflicts:
 539         for filename in conflicts:
 540             __resolved(filename)
 541         os.remove(os.path.join(git.base_dir, 'conflicts'))
 542
 543 def resolved(parser, options, args):
 544     if options.all:
 545         __resolved_all()
 546         return
 547
 548     if len(args) == 0:
 549         parser.error('incorrect number of arguments')
 550
 551     conflicts = git.get_conflicts()
 552     if not conflicts:
 553         raise MainException, 'No more conflicts'
 554     # check for arguments validity
 555     for filename in args:
 556         if not filename in conflicts:
 557             raise MainException, 'No conflicts for "%s"' % filename
 558     # resolved
 559     for filename in args:
 560         __resolved(filename)
 561         del conflicts[conflicts.index(filename)]
 562
 563     # save or remove the conflicts file
 564     if conflicts == []:
 565         os.remove(os.path.join(git.base_dir, 'conflicts'))
 566     else:
 567         f = file(os.path.join(git.base_dir, 'conflicts'), 'w+')
 568         f.writelines([line + '\n' for line in conflicts])
 569         f.close()
 570
 571 resolved_cmd = \
 572              Command(resolved,
 573                      'mark a file conflict as solved',
 574                      '%prog [options] [<file>[ <file>]]',
 575                      [make_option('-a', '--all',
 576                                   help = 'mark all conflicts as solved',
 577                                   action = 'store_true')])
 578
 579
 580 def series(parser, options, args):
 581     if len(args) != 0:
 582         parser.error('incorrect number of arguments')
 583
 584     applied = crt_series.get_applied()
 585     if len(applied) > 0:
 586         for p in applied [0:-1]:
 587             if crt_series.empty_patch(p):
 588                 print '0', p
 589             else:
 590                 print '+', p
 591         p = applied[-1]
 592
 593         if crt_series.empty_patch(p):
 594             print '0>%s' % p
 595         else:
 596             print '> %s' % p
 597
 598     for p in crt_series.get_unapplied():
 599         if crt_series.empty_patch(p):
 600             print '0', p
 601         else:
 602             print '-', p
 603
 604 series_cmd = \
 605            Command(series,
 606                    'print the patch series',
 607                    '%prog',
 608                    [])
 609
 610
 611 def applied(parser, options, args):
 612     if len(args) != 0:
 613         parser.error('incorrect number of arguments')
 614
 615     for p in crt_series.get_applied():
 616         print p
 617
 618 applied_cmd = \
 619             Command(applied,
 620                     'print the applied patches',
 621                     '%prog',
 622                     [])
 623
 624
 625 def unapplied(parser, options, args):
 626     if len(args) != 0:
 627         parser.error('incorrect number of arguments')
 628
 629     for p in crt_series.get_unapplied():
 630         print p
 631
 632 unapplied_cmd = \
 633               Command(unapplied,
 634                       'print the unapplied patches',
 635                       '%prog',
 636                       [])
 637
 638
 639 def top(parser, options, args):
 640     if len(args) != 0:
 641         parser.error('incorrect number of arguments')
 642
 643     name = crt_series.get_current()
 644     if name:
 645         print name
 646     else:
 647         raise MainException, 'No patches applied'
 648
 649 top_cmd = \
 650         Command(top,
 651                 'print the name of the top patch',
 652                 '%prog',
 653                 [])
 654
 655
 656 def export(parser, options, args):
 657     if len(args) == 0:
 658         dirname = 'patches'
 659     elif len(args) == 1:
 660         dirname = args[0]
 661     else:
 662         parser.error('incorrect number of arguments')
 663
 664     if git.local_changes():
 665         print 'Warning: local changes in the tree. ' \
 666               'You might want to commit them first'
 667
 668     if not os.path.isdir(dirname):
 669         os.makedirs(dirname)
 670     series = file(os.path.join(dirname, 'series'), 'w+')
 671
 672     patches = crt_series.get_applied()
 673     num = len(patches)
 674     zpadding = len(str(num))
 675     if zpadding < 2:
 676         zpadding = 2
 677
 678     patch_no = 1;
 679     for p in patches:
 680         pname = p
 681         if options.diff:
 682             pname = '%s.diff' % pname
 683         if options.numbered:
 684             pname = '%s-%s' % (str(patch_no).zfill(zpadding), pname)
 685         pfile = os.path.join(dirname, pname)
 686         print >> series, pname
 687
 688         # get the template
 689         if options.template:
 690             patch_tmpl = options.template
 691         else:
 692             patch_tmpl = os.path.join(git.base_dir, 'patchexport.tmpl')
 693         if os.path.isfile(patch_tmpl):
 694             tmpl = file(patch_tmpl).read()
 695         else:
 696             tmpl = ''
 697
 698         # get the patch description
 699         patch = crt_series.get_patch(p)
 700
 701         tmpl_dict = {'description': patch.get_description().rstrip(),
 702                      'diffstat': git.diffstat(rev1 = __git_id('%s/bottom' % p),
 703                                               rev2 = __git_id('%s/top' % p)),
 704                      'authname': patch.get_authname(),
 705                      'authemail': patch.get_authemail(),
 706                      'authdate': patch.get_authdate(),
 707                      'commname': patch.get_commname(),
 708                      'commemail': patch.get_commemail()}
 709         for key in tmpl_dict:
 710             if not tmpl_dict[key]:
 711                 tmpl_dict[key] = ''
 712
 713         try:
 714             descr = tmpl % tmpl_dict
 715         except KeyError, err:
 716             raise MainException, 'Unknown patch template variable: %s' \
 717                   % err
 718         except TypeError:
 719             raise MainException, 'Only "%(name)s" variables are ' \
 720                   'supported in the patch template'
 721         f = open(pfile, 'w+')
 722         f.write(descr)
 723         f.close()
 724
 725         # write the diff
 726         git.diff(rev1 = __git_id('%s/bottom' % p),
 727                  rev2 = __git_id('%s/top' % p),
 728                  output = pfile, append = True)
 729         patch_no += 1
 730
 731     series.close()
 732
 733 export_cmd = \
 734            Command(export,
 735                    'exports a series of patches to <dir> (or patches)',
 736                    '%prog [options] [<dir>]',
 737                    [make_option('-n', '--numbered',
 738                                 help = 'number the patch names',
 739                                 action = 'store_true'),
 740                     make_option('-d', '--diff',
 741                                 help = 'append .diff to the patch names',
 742                                 action = 'store_true'),
 743                     make_option('-t', '--template', metavar = 'FILE',
 744                                 help = 'Use FILE as a template')])
 745
 746 #
 747 # The commands map
 748 #
 749 commands = {
 750     'init':     init_cmd,
 751     'add':      add_cmd,
 752     'rm':       rm_cmd,
 753     'status':   status_cmd,
 754     'diff':     diff_cmd,
 755     'files':    files_cmd,
 756     'new':      new_cmd,
 757     'delete':   delete_cmd,
 758     'push':     push_cmd,
 759     'pop':      pop_cmd,
 760     'resolved': resolved_cmd,
 761     'series':   series_cmd,
 762     'applied':  applied_cmd,
 763     'unapplied':unapplied_cmd,
 764     'top':      top_cmd,
 765     'refresh':  refresh_cmd,
 766     'export':   export_cmd,
 767     }
 768
 769 def print_help():
 770     print 'usage: %s <command> [options]' % os.path.basename(sys.argv[0])
 771     print
 772     print 'commands:'
 773     print '  help        print this message'
 774
 775     cmds = commands.keys()
 776     cmds.sort()
 777     for cmd in cmds:
 778         print '  ' + cmd + ' ' * (12 - len(cmd)) + commands[cmd].help
 779
 780 #
 781 # The main function (command dispatcher)
 782 #
 783 def main():
 784     """The main function
 785     """
 786     global crt_series
 787
 788     prog = os.path.basename(sys.argv[0])
 789
 790     if len(sys.argv) < 2:
 791         print >> sys.stderr, 'Unknown command'
 792         print >> sys.stderr, \
 793               '  Try "%s help" for a list of supported commands' % prog
 794         sys.exit(1)
 795
 796     cmd = sys.argv[1]
 797
 798     if cmd in ['-h', '--help', 'help']:
 799         print_help()
 800         sys.exit(0)
 801     if cmd in ['-v', '--version']:
 802         print '%s %s' % (prog, version)
 803         sys.exit(0)
 804     if not cmd in commands:
 805         print >> sys.stderr, 'Unknown command: %s' % cmd
 806         print >> sys.stderr, '  Try "%s help" for a list of supported commands' \
 807               % prog
 808         sys.exit(1)
 809
 810     # re-build the command line arguments
 811     sys.argv[0] += ' %s' % cmd
 812     del(sys.argv[1])
 813
 814     command = commands[cmd]
 815     parser = OptionParser(usage = command.usage,
 816                           option_list = command.option_list)
 817     options, args = parser.parse_args()
 818     try:
 819         crt_series = stack.Series()
 820         command.func(parser, options, args)
 821     except (IOError, MainException, stack.StackException, git.GitException), \
 822                err:
 823         print >> sys.stderr, '%s %s: %s' % (prog, cmd, err)
 824         sys.exit(2)
 825
 826     sys.exit(0)