yap/yap.py

   1 import sys
   2 import os
   3 import glob
   4 import getopt
   5 import pickle
   6 import tempfile
   7
   8 from util import *
   9
  10 class ShellError(Exception):
  11     def __init__(self, cmd, rc):
  12         self.cmd = cmd
  13         self.rc = rc
  14
  15     def __str__(self):
  16         return "%s returned %d" % (self.cmd, self.rc)
  17
  18 class YapError(Exception):
  19     def __init__(self, msg):
  20         self.msg = msg
  21
  22     def __str__(self):
  23         return self.msg
  24
  25 class YapCore(object):
  26     def _add_new_file(self, file):
  27         repo = get_output('git rev-parse --git-dir')[0]
  28         dir = os.path.join(repo, 'yap')
  29         try:
  30             os.mkdir(dir)
  31         except OSError:
  32             pass
  33         files = self._get_new_files()
  34         files.append(file)
  35         path = os.path.join(dir, 'new-files')
  36         pickle.dump(files, open(path, 'w'))
  37
  38     def _get_new_files(self):
  39         repo = get_output('git rev-parse --git-dir')[0]
  40         path = os.path.join(repo, 'yap', 'new-files')
  41         try:
  42             files = pickle.load(file(path))
  43         except IOError:
  44             files = []
  45
  46         x = []
  47         for f in files:
  48             # if f in the index
  49             if get_output("git ls-files --cached '%s'" % f) != []:
  50                 continue
  51             x.append(f)
  52         return x
  53
  54     def _remove_new_file(self, file):
  55         files = self._get_new_files()
  56         files = filter(lambda x: x != file, files)
  57
  58         repo = get_output('git rev-parse --git-dir')[0]
  59         path = os.path.join(repo, 'yap', 'new-files')
  60         try:
  61             pickle.dump(files, open(path, 'w'))
  62         except IOError:
  63             pass
  64
  65     def _assert_file_exists(self, file):
  66         if not os.access(file, os.R_OK):
  67             raise YapError("No such file: %s" % file)
  68
  69     def _repo_path_to_rel(self, path):
  70         prefix = get_output("git rev-parse --show-prefix")
  71         if not prefix:
  72             return path
  73
  74         prefix = [ prefix[0] ]
  75         while True:
  76             head, tail = os.path.split(prefix[0])
  77             if not head:
  78                 break
  79             prefix[0] = head
  80             if tail:
  81                 prefix.insert(1, tail)
  82
  83         path = [ path ]
  84         while True:
  85             head, tail = os.path.split(path[0])
  86             if not head:
  87                 break
  88             path[0] = head
  89             if tail:
  90                 path.insert(1, tail)
  91
  92         common = 0
  93         for a, b in zip(prefix, path):
  94             if a != b:
  95                 break
  96             common += 1
  97
  98         path = path[common:]
  99         cdup = [".."] * (len(prefix) - common)
 100         path = cdup + list(path)
 101         path = os.path.join(*path)
 102         return path
 103
 104     def _get_staged_files(self):
 105         if run_command("git rev-parse HEAD"):
 106             files = get_output("git ls-files --cached")
 107         else:
 108             files = get_output("git diff-index --cached --name-only HEAD")
 109         unmerged = self._get_unmerged_files()
 110         if unmerged:
 111             unmerged = set(unmerged)
 112             files = set(files).difference(unmerged)
 113             files = list(files)
 114         return files
 115
 116     def _get_unstaged_files(self):
 117         cwd = os.getcwd()
 118         cdup = self._get_cdup()
 119         os.chdir(cdup)
 120         files = get_output("git ls-files -m")
 121         os.chdir(cwd)
 122
 123         new_files = self._get_new_files()
 124         if new_files:
 125             staged = self._get_staged_files()
 126             if staged:
 127                 staged = set(staged)
 128                 new_files = set(new_files).difference(staged)
 129                 new_files = list(new_files)
 130             files += new_files
 131         unmerged = self._get_unmerged_files()
 132         if unmerged:
 133             unmerged = set(unmerged)
 134             files = set(files).difference(unmerged)
 135             files = list(files)
 136         return files
 137
 138     def _get_unmerged_files(self):
 139         cwd = os.getcwd()
 140         cdup = self._get_cdup()
 141         os.chdir(cdup)
 142         files = get_output("git ls-files -u")
 143         os.chdir(cwd)
 144         files = [ x.replace('\t', ' ').split(' ')[3] for x in files ]
 145         return list(set(files))
 146
 147     def _resolve_rev(self, rev):
 148         ref = get_output("git rev-parse --verify %s 2>/dev/null" % rev)
 149         if not ref:
 150             raise YapError("No such revision: %s" % rev)
 151         return ref[0]
 152
 153     def _delete_branch(self, branch, force):
 154         current = get_output("git symbolic-ref HEAD")
 155         if current:
 156             current = current[0].replace('refs/heads/', '')
 157             if branch == current:
 158                 raise YapError("Can't delete current branch")
 159
 160         ref = self._resolve_rev('refs/heads/'+branch)
 161         run_safely("git update-ref -d 'refs/heads/%s' '%s'" % (branch, ref))
 162
 163         if not force:
 164             name = get_output("git name-rev --name-only '%s'" % ref)[0]
 165             if name == 'undefined':
 166                 run_command("git update-ref 'refs/heads/%s' '%s'" % (branch, ref))
 167                 raise YapError("Refusing to delete leaf branch (use -f to force)")
 168     def _get_pager_cmd(self):
 169         if 'YAP_PAGER' in os.environ:
 170             return os.environ['YAP_PAGER']
 171         elif 'GIT_PAGER' in os.environ:
 172             return os.environ['GIT_PAGER']
 173         elif 'PAGER' in os.environ:
 174             return os.environ['PAGER']
 175         else:
 176             return "less"
 177
 178     def _add_one(self, file):
 179         self._assert_file_exists(file)
 180         x = get_output("git ls-files '%s'" % file)
 181         if x != [] or file in self._get_new_files():
 182             raise YapError("File '%s' already in repository" % file)
 183         self._add_new_file(file)
 184
 185     def _rm_one(self, file):
 186         self._assert_file_exists(file)
 187         if get_output("git ls-files '%s'" % file) != []:
 188             run_safely("git rm --cached '%s'" % file)
 189         self._remove_new_file(file)
 190
 191     def _stage_one(self, file, allow_unmerged=False):
 192         self._assert_file_exists(file)
 193         prefix = get_output("git rev-parse --show-prefix")
 194         if prefix:
 195             tmp = os.path.normpath(os.path.join(prefix[0], file))
 196         else:
 197             tmp = file
 198         if not allow_unmerged and tmp in self._get_unmerged_files():
 199             raise YapError("Refusing to stage conflicted file: %s" % file)
 200         run_safely("git update-index --add '%s'" % file)
 201
 202     def _get_cdup(self):
 203         cdup = get_output("git rev-parse --show-cdup")
 204         assert cdup
 205         if cdup[0]:
 206             cdup = cdup[0]
 207         else:
 208             cdup = '.'
 209         return cdup
 210
 211     def _unstage_one(self, file):
 212         self._assert_file_exists(file)
 213         if run_command("git rev-parse HEAD"):
 214             rc = run_command("git update-index --force-remove '%s'" % file)
 215         else:
 216             cdup = self._get_cdup()
 217             rc = run_command("git diff-index --cached -p HEAD '%s' | (cd %s; git apply -R --cached)" % (file, cdup))
 218         if rc:
 219             raise YapError("Failed to unstage")
 220
 221     def _revert_one(self, file):
 222         self._assert_file_exists(file)
 223         try:
 224             self._unstage_one(file)
 225         except YapError:
 226             pass
 227         run_safely("git checkout-index -u -f '%s'" % file)
 228
 229     def _parse_commit(self, commit):
 230         lines = get_output("git cat-file commit '%s'" % commit)
 231         commit = {}
 232
 233         mode = None
 234         for l in lines:
 235             if mode != 'commit' and l.strip() == "":
 236                 mode = 'commit'
 237                 commit['log'] = []
 238                 continue
 239             if mode == 'commit':
 240                 commit['log'].append(l)
 241                 continue
 242
 243             x = l.split(' ')
 244             k = x[0]
 245             v = ' '.join(x[1:])
 246             commit[k] = v
 247         commit['log'] = '\n'.join(commit['log'])
 248         return commit
 249
 250     def _check_commit(self, **flags):
 251         if '-a' in flags and '-d' in flags:
 252             raise YapError("Conflicting flags: -a and -d")
 253
 254         if '-d' not in flags and self._get_unstaged_files():
 255             if '-a' not in flags and self._get_staged_files():
 256                 raise YapError("Staged and unstaged changes present.  Specify what to commit")
 257             cdup = self._get_cdup()
 258             os.system("git diff-files -p | (cd %s; git apply --cached)" % cdup)
 259             for f in self._get_new_files():
 260                 self._stage_one(f)
 261
 262     def _do_uncommit(self):
 263         commit = self._parse_commit("HEAD")
 264         repo = get_output('git rev-parse --git-dir')[0]
 265         dir = os.path.join(repo, 'yap')
 266         try:
 267             os.mkdir(dir)
 268         except OSError:
 269             pass
 270         msg_file = os.path.join(dir, 'msg')
 271         fd = file(msg_file, 'w')
 272         print >>fd, commit['log']
 273         fd.close()
 274
 275         tree = get_output("git rev-parse --verify HEAD^")
 276         run_safely("git update-ref -m uncommit HEAD '%s'" % tree[0])
 277
 278     def _do_commit(self, msg=None):
 279         tree = get_output("git write-tree")[0]
 280
 281         repo = get_output('git rev-parse --git-dir')[0]
 282         head_file = os.path.join(repo, 'yap', 'merge')
 283         try:
 284             parent = pickle.load(file(head_file))
 285         except IOError:
 286             parent = get_output("git rev-parse --verify HEAD 2> /dev/null")
 287
 288         if os.environ.has_key('YAP_EDITOR'):
 289             editor = os.environ['YAP_EDITOR']
 290         elif os.environ.has_key('GIT_EDITOR'):
 291             editor = os.environ['GIT_EDITOR']
 292         elif os.environ.has_key('EDITOR'):
 293             editor = os.environ['EDITOR']
 294         else:
 295             editor = "vi"
 296
 297         fd, tmpfile = tempfile.mkstemp("yap")
 298         os.close(fd)
 299
 300         if msg is None:
 301             msg_file = os.path.join(repo, 'yap', 'msg')
 302             if os.access(msg_file, os.R_OK):
 303                 fd1 = file(msg_file)
 304                 fd2 = file(tmpfile, 'w')
 305                 for l in fd1.xreadlines():
 306                     print >>fd2, l.strip()
 307                 fd2.close()
 308                 os.unlink(msg_file)
 309             if os.system("%s '%s'" % (editor, tmpfile)) != 0:
 310                 raise YapError("Editing commit message failed")
 311             fd = file(tmpfile)
 312             msg = fd.readlines()
 313             msg = ''.join(msg)
 314
 315         msg = msg.strip()
 316         if not msg:
 317             raise YapError("Refusing to use empty commit message")
 318
 319         fd = os.popen("git stripspace > %s" % tmpfile, 'w')
 320         print >>fd, msg,
 321         fd.close()
 322
 323         if parent:
 324             parent = ' -p '.join(parent)
 325             commit = get_output("git commit-tree '%s' -p %s < '%s'" % (tree, parent, tmpfile))
 326         else:
 327             commit = get_output("git commit-tree '%s' < '%s'" % (tree, tmpfile))
 328
 329         os.unlink(tmpfile)
 330         run_safely("git update-ref HEAD '%s'" % commit[0])
 331         self._clear_state()
 332
 333     def _check_rebasing(self):
 334         repo = get_output('git rev-parse --git-dir')[0]
 335         dotest = os.path.join(repo, '.dotest')
 336         if os.access(dotest, os.R_OK):
 337             raise YapError("A git operation is in progress.  Complete it first")
 338         dotest = os.path.join(repo, '..', '.dotest')
 339         if os.access(dotest, os.R_OK):
 340             raise YapError("A git operation is in progress.  Complete it first")
 341
 342     def _check_git(self):
 343         if run_command("git rev-parse --git-dir"):
 344             raise YapError("That command must be run from inside a git repository")
 345
 346     def _list_remotes(self):
 347         remotes = get_output("git config --get-regexp '^remote.*.url'")
 348         for x in remotes:
 349             remote, url = x.split(' ')
 350             remote = remote.replace('remote.', '')
 351             remote = remote.replace('.url', '')
 352             yield remote, url
 353
 354     def _unstage_all(self):
 355         try:
 356             run_safely("git read-tree -m HEAD")
 357         except ShellError:
 358             run_safely("git read-tree HEAD")
 359             run_safely("git update-index -q --refresh")
 360
 361     def _get_tracking(self, current):
 362         remote = get_output("git config branch.%s.remote" % current)
 363         if not remote:
 364             raise YapError("No tracking branch configured for '%s'" % current)
 365
 366         merge = get_output("git config branch.%s.merge" % current)
 367         if not merge:
 368             raise YapError("No tracking branch configured for '%s'" % current)
 369         return remote[0], merge[0]
 370
 371     def _confirm_push(self, current, rhs, repo):
 372         print "About to push local branch '%s' to '%s' on '%s'" % (current, rhs, repo)
 373         print "Continue (y/n)? ",
 374         sys.stdout.flush()
 375         ans = sys.stdin.readline().strip()
 376
 377         if ans.lower() != 'y' and ans.lower() != 'yes':
 378             raise YapError("Aborted.")
 379
 380     def _clear_state(self):
 381         repo = get_output('git rev-parse --git-dir')[0]
 382         dir = os.path.join(repo, 'yap')
 383         for f in "new-files", "merge", "msg":
 384             try:
 385                 os.unlink(os.path.join(dir, f))
 386             except OSError:
 387                 pass
 388
 389     def _get_attr(self, name, attr):
 390         val = None
 391         for c in self.__class__.__bases__:
 392             try:
 393                 m2 = c.__dict__[name]
 394             except KeyError:
 395                 continue
 396             try:
 397                 val = m2.__getattribute__(attr)
 398             except AttributeError:
 399                 continue
 400         return val
 401
 402     def _filter_log(self, commit):
 403         return commit
 404
 405     def _check_rename(self, rev, path):
 406         renames = get_output("git diff-tree -C -M --diff-filter=R %s %s^"
 407                 % (rev, rev))
 408         for r in renames:
 409             r = r.replace('\t', ' ')
 410             fields = r.split(' ')
 411             mode1, mode2, hash1, hash2, rename, dst, src = fields
 412             if dst == path:
 413                 return src
 414         return None
 415
 416     @short_help("make a local copy of an existing repository")
 417     @long_help("""
 418 The first argument is a URL to the existing repository.  This can be an
 419 absolute path if the repository is local, or a URL with the git://,
 420 ssh://, or http:// schemes.  By default, the directory used is the last
 421 component of the URL, sans '.git'.  This can be overridden by providing
 422 a second argument.
 423 """)
 424     def cmd_clone(self, url, directory=None):
 425         "<url> [directory]"
 426
 427         if '://' not in url and url[0] != '/':
 428             url = os.path.join(os.getcwd(), url)
 429
 430         url = url.rstrip('/')
 431         if directory is None:
 432             directory = url.rsplit('/')[-1]
 433             directory = directory.replace('.git', '')
 434
 435         try:
 436             os.mkdir(directory)
 437         except OSError:
 438             raise YapError("Directory exists: %s" % directory)
 439         os.chdir(directory)
 440         self.cmd_init()
 441         self.cmd_repo("origin", url)
 442         self.cmd_fetch("origin")
 443
 444         branch = None
 445         if not run_command("git rev-parse --verify refs/remotes/origin/HEAD"):
 446             hash = get_output("git rev-parse refs/remotes/origin/HEAD")[0]
 447             for b in get_output("git for-each-ref --format='%(refname)' 'refs/remotes/origin'"):
 448                 if get_output("git rev-parse %s" % b)[0] == hash:
 449                     branch = b
 450                     break
 451         if branch is None:
 452             if not run_command("git rev-parse --verify refs/remotes/origin/master"):
 453                 branch = "refs/remotes/origin/master"
 454         if branch is None:
 455             branch = get_output("git for-each-ref --format='%(refname)' 'refs/remotes/origin'")
 456             branch = branch[0]
 457
 458         hash = get_output("git rev-parse %s" % branch)
 459         assert hash
 460         branch = branch.replace('refs/remotes/origin/', '')
 461         run_safely("git update-ref refs/heads/%s %s" % (branch, hash[0]))
 462         run_safely("git symbolic-ref HEAD refs/heads/%s" % branch)
 463         self.cmd_revert(**{'-a': 1})
 464
 465     @short_help("turn a directory into a repository")
 466     @long_help("""
 467 Converts the current working directory into a repository.  The primary
 468 side-effect of this command is the creation of a '.git' subdirectory.
 469 No files are added nor commits made.
 470 """)
 471     def cmd_init(self):
 472         os.system("git init")
 473
 474     @short_help("add a new file to the repository")
 475     @long_help("""
 476 The arguments are the files to be added to the repository.  Once added,
 477 the files will show as "unstaged changes" in the output of 'status'.  To
 478 reverse the effects of this command, see 'rm'.
 479 """)
 480     def cmd_add(self, *files):
 481         "<file>..."
 482         self._check_git()
 483
 484         if not files:
 485             raise TypeError
 486
 487         for f in files:
 488             self._add_one(f)
 489         self.cmd_status()
 490
 491     @short_help("delete a file from the repository")
 492     @long_help("""
 493 The arguments are the files to be removed from the current revision of
 494 the repository.  The files will still exist in any past commits that the
 495 files may have been a part of.  The file is not actually deleted, it is
 496 just no longer tracked as part of the repository.
 497 """)
 498     def cmd_rm(self, *files):
 499         "<file>..."
 500         self._check_git()
 501         if not files:
 502             raise TypeError
 503
 504         for f in files:
 505             self._rm_one(f)
 506         self.cmd_status()
 507
 508     @short_help("stage changes in a file for commit")
 509     @long_help("""
 510 The arguments are the files to be staged.  Staging changes is a way to
 511 build up a commit when you do not want to commit all changes at once.
 512 To commit only staged changes, use the '-d' flag to 'commit.'  To
 513 reverse the effects of this command, see 'unstage'.  Once staged, the
 514 files will show as "staged changes" in the output of 'status'.
 515 """)
 516     def cmd_stage(self, *files):
 517         "<file>..."
 518         self._check_git()
 519         if not files:
 520             raise TypeError
 521
 522         for f in files:
 523             self._stage_one(f)
 524         self.cmd_status()
 525
 526     @short_help("unstage changes in a file")
 527     @long_help("""
 528 The arguments are the files to be unstaged.  Once unstaged, the files
 529 will show as "unstaged changes" in the output of 'status'.  The '-a'
 530 flag can be used to unstage all staged changes at once.
 531 """)
 532     @takes_options("a")
 533     def cmd_unstage(self, *files, **flags):
 534         "[-a] | <file>..."
 535         self._check_git()
 536         if '-a' in flags:
 537             files = self._get_staged_files()
 538
 539         if not files:
 540             raise YapError("Nothing to do")
 541
 542         files = [ self._repo_path_to_rel(x) for x in files ]
 543         for f in files:
 544             self._unstage_one(f)
 545         self.cmd_status()
 546
 547     @short_help("show files with staged and unstaged changes")
 548     @long_help("""
 549 Show the files in the repository with changes since the last commit,
 550 categorized based on whether the changes are staged or not.  A file may
 551 appear under each heading if the same file has both staged and unstaged
 552 changes.
 553 """)
 554     def cmd_status(self):
 555         ""
 556         self._check_git()
 557         branch = get_output("git symbolic-ref HEAD")
 558         if branch:
 559             branch = branch[0].replace('refs/heads/', '')
 560         else:
 561             branch = "DETACHED"
 562         print "Current branch: %s" % branch
 563
 564         print "Files with staged changes:"
 565         files = self._get_staged_files()
 566         for f in files:
 567             print "\t%s" % self._repo_path_to_rel(f)
 568         if not files:
 569             print "\t(none)"
 570
 571         print "Files with unstaged changes:"
 572         files = self._get_unstaged_files()
 573         for f in files:
 574             print "\t%s" % self._repo_path_to_rel(f)
 575         if not files:
 576             print "\t(none)"
 577
 578         files = self._get_unmerged_files()
 579         if files:
 580             print "Files with conflicts:"
 581             for f in files:
 582                 print "\t%s" % self._repo_path_to_rel(f)
 583
 584     @short_help("remove uncommitted changes from a file (*)")
 585     @long_help("""
 586 The arguments are the files whose changes will be reverted.  If the '-a'
 587 flag is given, then all files will have uncommitted changes removed.
 588 Note that there is no way to reverse this command short of manually
 589 editing each file again.
 590 """)
 591     @takes_options("a")
 592     def cmd_revert(self, *files, **flags):
 593         "(-a | <file>)"
 594         self._check_git()
 595         if '-a' in flags:
 596             self._unstage_all()
 597             run_safely("git checkout-index -u -f -a")
 598             self._clear_state()
 599             self.cmd_status()
 600             return
 601
 602         if not files:
 603             raise TypeError
 604
 605         for f in files:
 606             self._revert_one(f)
 607         self.cmd_status()
 608
 609     @short_help("record changes to files as a new commit")
 610     @long_help("""
 611 Create a new commit recording changes since the last commit.  If there
 612 are only unstaged changes, those will be recorded.  If there are only
 613 staged changes, those will be recorded.  Otherwise, you will have to
 614 specify either the '-a' flag or the '-d' flag to commit all changes or
 615 only staged changes, respectively.  To reverse the effects of this
 616 command, see 'uncommit'.
 617 """)
 618     @takes_options("adm:")
 619     def cmd_commit(self, **flags):
 620         "[-a | -d] [-m <msg>]"
 621         self._check_git()
 622         self._check_rebasing()
 623         self._check_commit(**flags)
 624         if not self._get_staged_files():
 625             raise YapError("No changes to commit")
 626         msg = flags.get('-m', None)
 627         self._do_commit(msg)
 628         self.cmd_status()
 629
 630     @short_help("reverse the actions of the last commit")
 631     @long_help("""
 632 Reverse the effects of the last 'commit' operation.  The changes that
 633 were part of the previous commit will show as "staged changes" in the
 634 output of 'status'.  This means that if no files were changed since the
 635 last commit was created, 'uncommit' followed by 'commit' is a lossless
 636 operation.
 637 """)
 638     def cmd_uncommit(self):
 639         ""
 640         self._check_git()
 641         self._do_uncommit()
 642         self.cmd_status()
 643
 644     @short_help("report the current version of yap")
 645     def cmd_version(self):
 646         print "Yap version %s" % self.version
 647
 648     @short_help("show the changelog for particular versions or files")
 649     @long_help("""
 650 The arguments are the files with which to filter history.  If none are
 651 given, all changes are listed.  Otherwise only commits that affected one
 652 or more of the given files are listed.  The -r option changes the
 653 starting revision for traversing history.  By default, history is listed
 654 starting at HEAD.
 655 """)
 656     @takes_options("pr:")
 657     def cmd_log(self, *paths, **flags):
 658         "[-p] [-r <rev>] <path>..."
 659         self._check_git()
 660         rev = flags.get('-r', 'HEAD')
 661         rev = self._resolve_rev(rev)
 662         paths = list(paths)
 663
 664         if '-p' in flags:
 665             flags['-p'] = '-p'
 666
 667         try:
 668             pager = os.popen(self._get_pager_cmd(), 'w')
 669             rename = False
 670             while True:
 671                 for hash in yield_output("git rev-list '%s' -- %s"
 672                         % (rev, ' '.join(paths))):
 673                     commit = get_output("git show -M -C %s %s"
 674                             % (flags.get('-p', '--name-status'), hash),
 675                             strip=False)
 676                     commit = self._filter_log(commit)
 677                     print >>pager, ''.join(commit)
 678
 679                     # Check for renames
 680                     if len(paths) == 1:
 681                         src = self._check_rename(hash, paths[0])
 682                         if src is not None:
 683                             paths[0] = src
 684                             rename = True
 685                             rev = hash+"^"
 686                             break
 687                 if not rename:
 688                     break
 689                 rename = False
 690         except (IOError, KeyboardInterrupt):
 691             pass
 692
 693     @short_help("show staged, unstaged, or all uncommitted changes")
 694     @long_help("""
 695 Show staged, unstaged, or all uncommitted changes.  By default, all
 696 changes are shown.  The '-u' flag causes only unstaged changes to be
 697 shown.  The '-d' flag causes only staged changes to be shown.
 698 """)
 699     @takes_options("ud")
 700     def cmd_diff(self, **flags):
 701         "[ -u | -d ]"
 702         self._check_git()
 703         if '-u' in flags and '-d' in flags:
 704             raise YapError("Conflicting flags: -u and -d")
 705
 706         pager = self._get_pager_cmd()
 707
 708         if '-u' in flags:
 709             os.system("git diff-files -p | %s" % pager)
 710         elif '-d' in flags:
 711             os.system("git diff-index --cached -p HEAD | %s" % pager)
 712         else:
 713             os.system("git diff-index -p HEAD | %s" % pager)
 714
 715     @short_help("list, create, or delete branches")
 716     @long_help("""
 717 If no arguments are specified, a list of local branches is given.  The
 718 current branch is indicated by a "*" next to the name.  If an argument
 719 is given, it is taken as the name of a new branch to create.  The branch
 720 will start pointing at the current HEAD.  See 'point' for details on
 721 changing the revision of the new branch.  Note that this command does
 722 not switch the current working branch.  See 'switch' for details on
 723 changing the current working branch.
 724
 725 The '-d' flag can be used to delete local branches.  If the delete
 726 operation would remove the last branch reference to a given line of
 727 history (colloquially referred to as "dangling commits"), yap will
 728 report an error and abort.  The '-f' flag can be used to force the delete
 729 in spite of this.
 730 """)
 731     @takes_options("fd:")
 732     def cmd_branch(self, branch=None, **flags):
 733         "[ [-f] -d <branch> | <branch> ]"
 734         self._check_git()
 735         force = '-f' in flags
 736         if '-d' in flags:
 737             self._delete_branch(flags['-d'], force)
 738             self.cmd_branch()
 739             return
 740
 741         if branch is not None:
 742             ref = get_output("git rev-parse --verify HEAD")
 743             if not ref:
 744                 raise YapError("No branch point yet.  Make a commit")
 745             run_safely("git update-ref 'refs/heads/%s' '%s'" % (branch, ref[0]))
 746
 747         current = get_output("git symbolic-ref HEAD")
 748         branches = get_output("git for-each-ref --format='%(refname)' 'refs/heads'")
 749         for b in branches:
 750             if current and b == current[0]:
 751                 print "* ",
 752             else:
 753                 print "  ",
 754             b = b.replace('refs/heads/', '')
 755             print b
 756
 757     @short_help("change the current working branch")
 758     @long_help("""
 759 The argument is the name of the branch to make the current working
 760 branch.  This command will fail if there are uncommitted changes to any
 761 files.  Otherwise, the contents of the files in the working directory
 762 are updated to reflect their state in the new branch.  Additionally, any
 763 future commits are added to the new branch instead of the previous line
 764 of history.
 765 """)
 766     @takes_options("f")
 767     def cmd_switch(self, branch, **flags):
 768         "[-f] <branch>"
 769         self._check_git()
 770         self._check_rebasing()
 771         ref = self._resolve_rev('refs/heads/'+branch)
 772
 773         if '-f' not in flags:
 774             if (self._get_staged_files()
 775                     or (self._get_unstaged_files()
 776                         and run_command("git update-index --refresh"))):
 777                 raise YapError("You have uncommitted changes.  Use -f to continue anyway")
 778
 779         if self._get_unstaged_files() and self._get_staged_files():
 780             raise YapError("You have staged and unstaged changes.  Perhaps unstage -a?")
 781
 782         staged = bool(self._get_staged_files())
 783
 784         cdup = self._get_cdup()
 785         run_command("git diff-files -p | (cd %s; git apply --cached)" % cdup)
 786         for f in self._get_new_files():
 787             self._stage_one(f)
 788
 789         idx = get_output("git write-tree")
 790         new = self._resolve_rev('refs/heads/'+branch)
 791
 792         run_command("git update-index --refresh")
 793         readtree = "git read-tree -v --aggressive -u -m HEAD %s %s" % (idx[0], new)
 794         if os.system(readtree):
 795             raise YapError("Failed to switch")
 796         run_safely("git symbolic-ref HEAD refs/heads/%s" % branch)
 797
 798         if '-f' not in flags:
 799             self._clear_state()
 800
 801         if not staged:
 802             self._unstage_all()
 803         self.cmd_status()
 804
 805     @short_help("move the current branch to a different revision")
 806     @long_help("""
 807 The argument is the hash of the commit to which the current branch
 808 should point, or alternately a branch or tag (a.k.a, "committish").  If
 809 moving the branch would create "dangling commits" (see 'branch'), yap
 810 will report an error and abort.  The '-f' flag can be used to force the
 811 operation in spite of this.
 812 """)
 813     @takes_options("f")
 814     def cmd_point(self, where, **flags):
 815         "[-f] <where>"
 816         self._check_git()
 817         self._check_rebasing()
 818
 819         head = get_output("git rev-parse --verify HEAD")
 820         if not head:
 821             raise YapError("No commit yet; nowhere to point")
 822
 823         ref = self._resolve_rev(where)
 824         ref = get_output("git rev-parse --verify '%s^{commit}'" % ref)
 825         if not ref:
 826             raise YapError("Not a commit: %s" % where)
 827
 828         if self._get_unstaged_files() or self._get_staged_files():
 829             raise YapError("You have uncommitted changes.  Commit them first")
 830
 831         run_safely("git update-ref HEAD '%s'" % ref[0])
 832
 833         if '-f' not in flags:
 834             name = get_output("git name-rev --name-only '%s'" % head[0])[0]
 835             if name == "undefined":
 836                 os.system("git update-ref HEAD '%s'" % head[0])
 837                 raise YapError("Pointing there will lose commits.  Use -f to force")
 838
 839         run_command("git update-index --refresh")
 840         rc = os.system("git read-tree -v --reset -u HEAD")
 841         if rc:
 842             raise YapError("checkout-index failed")
 843         self._clear_state()
 844
 845     @short_help("alter history by dropping or amending commits")
 846     @long_help("""
 847 This command operates in two distinct modes, "amend" and "drop" mode.
 848 In drop mode, the given commit is removed from the history of the
 849 current branch, as though that commit never happened.  By default the
 850 commit used is HEAD.
 851
 852 In amend mode, the uncommitted changes present are merged into a
 853 previous commit.  This is useful for correcting typos or adding missed
 854 files into past commits.  By default the commit used is HEAD.
 855
 856 While rewriting history it is possible that conflicts will arise.  If
 857 this happens, the rewrite will pause and you will be prompted to resolve
 858 the conflicts and stage them.  Once that is done, you will run "yap
 859 history continue."  If instead you want the conflicting commit removed
 860 from history (perhaps your changes supercede that commit) you can run
 861 "yap history skip".  Once the rewrite completes, your branch will be on
 862 the same commit as when the rewrite started.
 863 """)
 864     def cmd_history(self, subcmd, *args):
 865         "amend | drop <commit>"
 866         self._check_git()
 867
 868         if subcmd not in ("amend", "drop", "continue", "skip"):
 869             raise TypeError
 870
 871         resolvemsg = """
 872 When you have resolved the conflicts run \"yap history continue\".
 873 To skip the problematic patch, run \"yap history skip\"."""
 874
 875         if subcmd == "continue":
 876             os.system("git am -3 -r --resolvemsg='%s'" % resolvemsg)
 877             return
 878         if subcmd == "skip":
 879             os.system("git reset --hard")
 880             os.system("git am -3 --skip --resolvemsg='%s'" % resolvemsg)
 881             return
 882
 883         if subcmd == "amend":
 884             flags, args = getopt.getopt(args, "ad")
 885             flags = dict(flags)
 886
 887         if len(args) > 1:
 888             raise TypeError
 889         if args:
 890             commit = args[0]
 891         else:
 892             commit = "HEAD"
 893
 894         self._resolve_rev(commit)
 895         self._check_rebasing()
 896
 897         if subcmd == "amend":
 898             self._check_commit(**flags)
 899             if self._get_unstaged_files():
 900                 # XXX: handle unstaged changes better
 901                 raise YapError("Commit away changes that you aren't amending")
 902
 903         self._unstage_all()
 904
 905         start = get_output("git rev-parse HEAD")
 906         stash = get_output("git stash create")
 907         run_command("git reset --hard")
 908         try:
 909             fd, tmpfile = tempfile.mkstemp("yap")
 910             try:
 911                 try:
 912                     os.close(fd)
 913                     os.system("git format-patch -k --stdout '%s' > %s" % (commit, tmpfile))
 914                     if subcmd == "amend":
 915                         self.cmd_point(commit, **{'-f': True})
 916                 finally:
 917                     if subcmd == "amend":
 918                         if stash:
 919                             rc = os.system("git stash apply %s" % stash[0])
 920                             if rc:
 921                                 self.cmd_point(start[0], **{'-f': True})
 922                                 os.system("git stash apply %s" % stash[0])
 923                                 raise YapError("Failed to apply stash")
 924                         stash = None
 925
 926                 if subcmd == "amend":
 927                     self._do_uncommit()
 928                     self._check_commit(**{'-a': True})
 929                     self._do_commit()
 930                 else:
 931                     self.cmd_point("%s^" % commit, **{'-f': True})
 932
 933                 stat = os.stat(tmpfile)
 934                 size = stat[6]
 935                 if size > 0:
 936                     run_safely("git update-index --refresh")
 937                     rc = os.system("git am -3 --resolvemsg=\'%s\' %s" % (resolvemsg, tmpfile))
 938                     if (rc):
 939                         raise YapError("Failed to apply changes")
 940             finally:
 941                 os.unlink(tmpfile)
 942         finally:
 943             if stash:
 944                 run_command("git stash apply %s" % stash[0])
 945         self.cmd_status()
 946
 947     @short_help("show the changes introduced by a given commit")
 948     @long_help("""
 949 By default, the changes in the last commit are shown.  To override this,
 950 specify a hash, branch, or tag (committish).  The hash of the commit,
 951 the commit's author, log message, and a diff of the changes are shown.
 952 """)
 953     def cmd_show(self, commit="HEAD"):
 954         "[commit]"
 955         self._check_git()
 956         commit = self._resolve_rev(commit)
 957         os.system("git show '%s'" % commit)
 958
 959     @short_help("apply the changes in a given commit to the current branch")
 960     @long_help("""
 961 The argument is the hash, branch, or tag (committish) of the commit to
 962 be applied.  In general, it only makes sense to apply commits that
 963 happened on another branch.  The '-r' flag can be used to have the
 964 changes in the given commit reversed from the current branch.  In
 965 general, this only makes sense for commits that happened on the current
 966 branch.
 967 """)
 968     @takes_options("r")
 969     def cmd_cherry_pick(self, commit, **flags):
 970         "[-r] <commit>"
 971         self._check_git()
 972         commit = self._resolve_rev(commit)
 973         if '-r' in flags:
 974             os.system("git revert '%s'" % commit)
 975         else:
 976             os.system("git cherry-pick '%s'" % commit)
 977
 978     @short_help("list, add, or delete configured remote repositories")
 979     @long_help("""
 980 When invoked with no arguments, this command will show the list of
 981 currently configured remote repositories, giving both the name and URL
 982 of each.  To add a new repository, give the desired name as the first
 983 argument and the URL as the second.  The '-d' flag can be used to remove
 984 a previously added repository.
 985 """)
 986     @takes_options("d:")
 987     def cmd_repo(self, name=None, url=None, **flags):
 988         "[<name> <url> | -d <name>]"
 989         self._check_git()
 990         if name is not None and url is None:
 991             raise TypeError
 992
 993         if '-d' in flags:
 994             if flags['-d'] not in [ x[0] for x in self._list_remotes() ]:
 995                 raise YapError("No such repository: %s" % flags['-d'])
 996             os.system("git config --unset remote.%s.url" % flags['-d'])
 997             os.system("git config --unset remote.%s.fetch" % flags['-d'])
 998             for b in get_output("git for-each-ref --format='%(refname)' 'refs/remotes/origin'"):
 999                 hash = get_output("git rev-parse %s" % b)
1000                 assert hash
1001                 run_safely("git update-ref -d %s %s" % (b, hash[0]))
1002
1003         if name:
1004             if name in [ x[0] for x in self._list_remotes() ]:
1005                 raise YapError("Repository '%s' already exists" % name)
1006             os.system("git config remote.%s.url %s" % (name, url))
1007             os.system("git config remote.%s.fetch +refs/heads/*:refs/remotes/%s/*" % (name, name))
1008
1009         for remote, url in self._list_remotes():
1010             print "%s" % remote
1011             print "    URL:      %s" % url
1012             first = True
1013             for b in get_output("git for-each-ref --format='%%(refname)' 'refs/remotes/%s'" % remote):
1014                 b = b.replace('refs/remotes/', '')
1015                 if first:
1016                     branches = "Branches: "
1017                 else:
1018                     branches = "          "
1019                 print "    %s%s" % (branches, b)
1020                 first = False
1021
1022     @short_help("send local commits to a remote repository (*)")
1023     @long_help("""
1024 When invoked with no arguments, the current branch is synchronized to
1025 the tracking branch of the tracking remote.  If no tracking remote is
1026 specified, the repository will have to be specified on the command line.
1027 In that case, the default is to push to a branch with the same name as
1028 the current branch.  This behavior can be overridden by giving a second
1029 argument to specify the remote branch.
1030
1031 If the remote branch does not currently exist, the command will abort
1032 unless the -c flag is provided.  If the remote branch is not a direct
1033 descendent of the local branch, the command will abort unless the -f
1034 flag is provided.  Forcing a push in this way can be problematic to
1035 other users of the repository if they are not expecting it.
1036
1037 To delete a branch on the remote repository, use the -d flag.
1038 """)
1039     @takes_options("cdf")
1040     def cmd_push(self, repo=None, rhs=None, **flags):
1041         "[-c | -d] <repo>"
1042         self._check_git()
1043         if '-c' in flags and '-d' in flags:
1044             raise TypeError
1045
1046         if repo and repo not in [ x[0] for x in self._list_remotes() ]:
1047             raise YapError("No such repository: %s" % repo)
1048
1049         current = get_output("git symbolic-ref HEAD")
1050         if not current:
1051             raise YapError("Not on a branch!")
1052
1053         self._check_rebasing()
1054
1055         current = current[0].replace('refs/heads/', '')
1056         remote = get_output("git config branch.%s.remote" % current)
1057         if repo is None and remote:
1058             repo = remote[0]
1059
1060         if repo is None:
1061             raise YapError("No tracking branch configured; specify destination repository")
1062
1063         if rhs is None and remote and remote[0] == repo:
1064             merge = get_output("git config branch.%s.merge" % current)
1065             if merge:
1066                 rhs = merge[0]
1067
1068         if rhs is None:
1069             rhs = "refs/heads/%s" % current
1070
1071         if '-c' not in flags and '-d' not in flags:
1072             if run_command("git rev-parse --verify refs/remotes/%s/%s"
1073                     % (repo, rhs.replace('refs/heads/', ''))):
1074                 raise YapError("No matching branch on that repo.  Use -c to create a new branch there.")
1075             if '-f' not in flags:
1076                 hash = get_output("git rev-parse refs/remotes/%s/%s" % (repo, rhs.replace('refs/heads/', '')))
1077                 base = get_output("git merge-base HEAD %s" % hash[0])
1078                 assert base
1079                 if base[0] != hash[0]:
1080                     raise YapError("Branch not up-to-date with remote.  Update or use -f")
1081
1082         self._confirm_push(current, rhs, repo)
1083         if '-f' in flags:
1084             flags['-f'] = '-f'
1085
1086         if '-d' in flags:
1087             lhs = ""
1088         else:
1089             lhs = "refs/heads/%s" % current
1090         rc = os.system("git push %s %s %s:%s" % (flags.get('-f', ''), repo, lhs, rhs))
1091         if rc:
1092             raise YapError("Push failed.")
1093
1094     @short_help("retrieve commits from a remote repository")
1095     @long_help("""
1096 When run with no arguments, the command will retrieve new commits from
1097 the remote tracking repository.  Note that this does not in any way
1098 alter the current branch.  For that, see "update".  If a remote other
1099 than the tracking remote is desired, it can be specified as the first
1100 argument.
1101 """)
1102     def cmd_fetch(self, repo=None):
1103         "<repo>"
1104         self._check_git()
1105         current = get_output("git symbolic-ref HEAD")
1106         if not current:
1107             raise YapError("Not on a branch!")
1108
1109         if repo and repo not in [ x[0] for x in self._list_remotes() ]:
1110             raise YapError("No such repository: %s" % repo)
1111         if repo is None:
1112             current = current[0].replace('refs/heads/', '')
1113             remote = get_output("git config branch.%s.remote" % current)
1114             if remote:
1115                 repo = remote[0]
1116         if repo is None:
1117             raise YapError("No tracking branch configured; specify a repository")
1118         os.system("git fetch %s" % repo)
1119
1120     @short_help("update the current branch relative to its tracking branch")
1121     @long_help("""
1122 Updates the current branch relative to its remote tracking branch.  This
1123 command requires that the current branch have a remote tracking branch
1124 configured.  If any conflicts occur while applying your changes to the
1125 updated remote, the command will pause to allow you to fix them.  Once
1126 that is done, run "update" with the "continue" subcommand.  Alternately,
1127 the "skip" subcommand can be used to discard the conflicting changes.
1128 """)
1129     def cmd_update(self, subcmd=None):
1130         "[continue | skip]"
1131         self._check_git()
1132         if subcmd and subcmd not in ["continue", "skip"]:
1133             raise TypeError
1134
1135         resolvemsg = """
1136 When you have resolved the conflicts run \"yap update continue\".
1137 To skip the problematic patch, run \"yap update skip\"."""
1138
1139         if subcmd == "continue":
1140             os.system("git am -3 -r --resolvemsg='%s'" % resolvemsg)
1141             return
1142         if subcmd == "skip":
1143             os.system("git reset --hard")
1144             os.system("git am -3 --skip --resolvemsg='%s'" % resolvemsg)
1145             return
1146
1147         self._check_rebasing()
1148         if self._get_unstaged_files() or self._get_staged_files():
1149             raise YapError("You have uncommitted changes.  Commit them first")
1150
1151         current = get_output("git symbolic-ref HEAD")
1152         if not current:
1153             raise YapError("Not on a branch!")
1154
1155         current = current[0].replace('refs/heads/', '')
1156         remote, merge = self._get_tracking(current)
1157         merge = merge.replace('refs/heads/', '')
1158
1159         self.cmd_fetch(remote)
1160         base = get_output("git merge-base HEAD refs/remotes/%s/%s" % (remote, merge))
1161
1162         try:
1163             fd, tmpfile = tempfile.mkstemp("yap")
1164             os.close(fd)
1165             os.system("git format-patch -k --stdout '%s' > %s" % (base[0], tmpfile))
1166             self.cmd_point("refs/remotes/%s/%s" % (remote, merge), **{'-f': True})
1167
1168             stat = os.stat(tmpfile)
1169             size = stat[6]
1170             if size > 0:
1171                 rc = os.system("git am -3 --resolvemsg=\'%s\' %s" % (resolvemsg, tmpfile))
1172                 if (rc):
1173                     raise YapError("Failed to apply changes")
1174         finally:
1175             os.unlink(tmpfile)
1176
1177     @short_help("query and configure remote branch tracking")
1178     @long_help("""
1179 When invoked with no arguments, the command displays the tracking
1180 information for the current branch.  To configure the tracking
1181 information, two arguments for the remote repository and remote branch
1182 are given.  The tracking information is used to provide defaults for
1183 where to push local changes and from where to get updates to the branch.
1184 """)
1185     def cmd_track(self, repo=None, branch=None):
1186         "[<repo> <branch>]"
1187         self._check_git()
1188
1189         current = get_output("git symbolic-ref HEAD")
1190         if not current:
1191             raise YapError("Not on a branch!")
1192         current = current[0].replace('refs/heads/', '')
1193
1194         if repo is None and branch is None:
1195             repo, merge = self._get_tracking(current)
1196             merge = merge.replace('refs/heads/', '')
1197             print "Branch '%s' tracking refs/remotes/%s/%s" % (current, repo, merge)
1198             return
1199
1200         if repo is None or branch is None:
1201             raise TypeError
1202
1203         if repo not in [ x[0] for x in self._list_remotes() ]:
1204             raise YapError("No such repository: %s" % repo)
1205
1206         if run_command("git rev-parse --verify refs/remotes/%s/%s" % (repo, branch)):
1207             raise YapError("No such branch '%s' on repository '%s'" % (branch, repo))
1208
1209         os.system("git config branch.%s.remote '%s'" % (current, repo))
1210         os.system("git config branch.%s.merge 'refs/heads/%s'" % (current, branch))
1211         print "Branch '%s' now tracking refs/remotes/%s/%s" % (current, repo, branch)
1212
1213     @short_help("mark files with conflicts as resolved")
1214     @long_help("""
1215 The arguments are the files to be marked resolved.  When a conflict
1216 occurs while merging changes to a file, that file is marked as
1217 "unmerged."  Until the file(s) with conflicts are marked resolved,
1218 commits cannot be made.
1219 """)
1220     def cmd_resolved(self, *files):
1221         "<file>..."
1222         self._check_git()
1223         if not files:
1224             raise TypeError
1225
1226         for f in files:
1227             self._stage_one(f, True)
1228         self.cmd_status()
1229
1230     @short_help("merge a branch into the current branch")
1231     def cmd_merge(self, branch):
1232         "<branch>"
1233         self._check_git()
1234
1235         branch_name = branch
1236         branch = self._resolve_rev(branch)
1237         base = get_output("git merge-base HEAD %s" % branch)
1238         if not base:
1239             raise YapError("Branch '%s' is not a fork of the current branch"
1240                     % branch)
1241
1242         readtree = ("git read-tree --aggressive -u -m %s HEAD %s"
1243                 % (base[0], branch))
1244         if run_command(readtree):
1245             run_command("git update-index --refresh")
1246             if os.system(readtree):
1247                 raise YapError("Failed to merge")
1248
1249         repo = get_output('git rev-parse --git-dir')[0]
1250         dir = os.path.join(repo, 'yap')
1251         try:
1252             os.mkdir(dir)
1253         except OSError:
1254             pass
1255         msg_file = os.path.join(dir, 'msg')
1256         msg = file(msg_file, 'w')
1257         print >>msg, "Merge branch '%s'" % branch_name
1258         msg.close()
1259
1260         head = get_output("git rev-parse --verify HEAD")
1261         assert head
1262         heads = [head[0], branch]
1263         head_file = os.path.join(dir, 'merge')
1264         pickle.dump(heads, file(head_file, 'w'))
1265
1266         self._merge_index(branch, base[0])
1267         if self._get_unmerged_files():
1268             self.cmd_status()
1269             raise YapError("Fix conflicts then commit")
1270
1271         self._do_commit()
1272
1273     def _merge_index(self, branch, base):
1274         for f in self._get_unmerged_files():
1275             fd, bfile = tempfile.mkstemp("yap")
1276             os.close(fd)
1277             rc = os.system("git show %s:%s > %s" % (base, f, bfile))
1278             assert rc == 0
1279
1280             fd, ofile = tempfile.mkstemp("yap")
1281             os.close(fd)
1282             rc = os.system("git show %s:%s > %s" % (branch, f, ofile))
1283             assert rc == 0
1284
1285             command = "git merge-file -L %(file)s -L %(file)s.base -L %(file)s.%(branch)s %(file)s %(base)s %(other)s " % dict(file=f, branch=branch, base=bfile, other=ofile)
1286             rc = os.system(command)
1287             os.unlink(ofile)
1288             os.unlink(bfile)
1289
1290             assert rc >= 0
1291             if rc == 0:
1292                 self._stage_one(f, True)
1293
1294     def cmd_help(self, cmd=None):
1295         if cmd is not None:
1296             oldcmd = cmd
1297             cmd = "cmd_" + cmd.replace('-', '_')
1298             try:
1299                 attr = self.__getattribute__(cmd)
1300             except AttributeError:
1301                 raise YapError("No such command: %s" % cmd)
1302
1303             help = self._get_attr(cmd, "long_help")
1304             if help is None:
1305                 raise YapError("Sorry, no help for '%s'.  Ask Steven." % oldcmd)
1306
1307             print >>sys.stderr, "The '%s' command" % oldcmd
1308             doc = self._get_attr(cmd, "__doc__")
1309             if doc is None:
1310                 doc = ""
1311             print >>sys.stderr, "\tyap %s %s" % (oldcmd, doc)
1312             print >>sys.stderr, "%s" % help
1313             return
1314
1315         print >> sys.stderr, "Yet Another (Git) Porcelein"
1316         print >> sys.stderr
1317
1318         for name in dir(self):
1319             if not name.startswith('cmd_'):
1320                 continue
1321             attr = self.__getattribute__(name)
1322             if not callable(attr):
1323                 continue
1324
1325             short_msg = self._get_attr(name, "short_help")
1326             if short_msg is None:
1327                 continue
1328
1329             name = name.replace('cmd_', '')
1330             name = name.replace('_', '-')
1331             print >> sys.stderr, "%-16s%s" % (name, short_msg)
1332
1333         print >> sys.stderr
1334         print >> sys.stderr, "(*) Indicates that the command is not readily reversible"
1335
1336     @short_help("show information about loaded plugins")
1337     def cmd_plugins(self):
1338         ""
1339         print >> sys.stderr, "Loaded plugins:"
1340         plugins = load_plugins()
1341         for name, cls in plugins.items():
1342             print "\t%-16s: %s" % (name, cls.__doc__)
1343         if not plugins:
1344             print "\t%-16s" % "None"
1345
1346     def cmd_usage(self):
1347         print >> sys.stderr, "usage: %s <command>" % os.path.basename(sys.argv[0])
1348         print >> sys.stderr, "  valid commands: help init clone add rm stage unstage status revert commit uncommit log show diff branch switch point cherry-pick repo track push fetch update history resolved version"
1349
1350 def load_plugins():
1351     plugindir = os.path.join("~", ".yap", "plugins")
1352     plugindir = os.path.expanduser(plugindir)
1353     plugindir = os.path.join(plugindir, "*.py")
1354
1355     plugins = dict()
1356     for p in glob.glob(os.path.expanduser(plugindir)):
1357         plugin = os.path.basename(p).replace('.py', '')
1358         m = __import__(plugin)
1359         for k in dir(m):
1360             cls = m.__dict__[k]
1361             if not type(cls) == type:
1362                 continue
1363             if not issubclass(cls, YapCore):
1364                 continue
1365             if cls is YapCore:
1366                 continue
1367             plugins[k] = cls
1368     return plugins
1369
1370 def yap_metaclass(name, bases, dct):
1371     plugindir = os.path.join("~", ".yap", "plugins")
1372     plugindir = os.path.expanduser(plugindir)
1373     sys.path.insert(0, plugindir)
1374
1375     plugins = set(load_plugins().values())
1376     p2 = plugins.copy()
1377     for cls in plugins:
1378         p2 -= set(cls.__bases__)
1379     plugins = p2
1380     bases = list(plugins) + list(bases)
1381     return type(name, tuple(bases), dct)
1382
1383 class Yap(YapCore):
1384     __metaclass__ = yap_metaclass
1385
1386     def main(self, args):
1387         if len(args) < 1:
1388             self.cmd_usage()
1389             sys.exit(2)
1390
1391         command = args[0]
1392         args = args[1:]
1393
1394         if run_command("git --version"):
1395             print >>sys.stderr, "Failed to run git; is it installed?"
1396             sys.exit(1)
1397
1398         debug = os.getenv('YAP_DEBUG')
1399
1400         try:
1401             command = command.replace('-', '_')
1402             meth = self.__getattribute__("cmd_"+command)
1403             doc = self._get_attr("cmd_"+command, "__doc__")
1404
1405             try:
1406                 options = ""
1407                 for c in self.__class__.__bases__:
1408                     try:
1409                         t = c.__dict__["cmd_"+command]
1410                     except KeyError:
1411                         continue
1412                     if "options" in t.__dict__:
1413                         options += t.options
1414
1415                 if options:
1416                     try:
1417                         flags, args = getopt.getopt(args, options)
1418                         flags = dict(flags)
1419                     except getopt.GetoptError, e:
1420                         if debug:
1421                             raise
1422                         print "Usage: %s %s %s" % (os.path.basename(sys.argv[0]), command, doc)
1423                         print e
1424                         sys.exit(2)
1425                 else:
1426                     flags = dict()
1427
1428                 meth(*args, **flags)
1429             except (TypeError, getopt.GetoptError):
1430                 if debug:
1431                     raise
1432                 print "Usage: %s %s %s" % (os.path.basename(sys.argv[0]), command, doc)
1433             except YapError, e:
1434                 if debug:
1435                     raise
1436                 print >> sys.stderr, e
1437                 sys.exit(1)
1438         except AttributeError:
1439             if debug:
1440                 raise
1441             self.cmd_usage()
1442             sys.exit(2)