yap/yap.py

   1 import sys
   2 import os
   3 import glob
   4 import getopt
   5 import pickle
   6 import tempfile
   7
   8 from plugin import YapPlugin
   9 from util import *
  10
  11 class ShellError(Exception):
  12     def __init__(self, cmd, rc):
  13         self.cmd = cmd
  14         self.rc = rc
  15
  16     def __str__(self):
  17         return "%s returned %d" % (self.cmd, self.rc)
  18
  19 class YapError(Exception):
  20     def __init__(self, msg):
  21         self.msg = msg
  22
  23     def __str__(self):
  24         return self.msg
  25
  26 class Yap(object):
  27     def __init__(self):
  28         self.plugins = set()
  29         self.overrides = []
  30         plugindir = os.path.expanduser("~/.yap/plugins")
  31         for p in glob.glob(os.path.join(plugindir, "*.py")):
  32             glbls = {}
  33             execfile(p, glbls)
  34             for cls in glbls.values():
  35                 if not type(cls) == type:
  36                     continue
  37                 if not issubclass(cls, YapPlugin):
  38                     continue
  39                 if cls is YapPlugin:
  40                     continue
  41                 x = cls(self)
  42                 self.plugins.add(x)
  43
  44                 for func in dir(x):
  45                     if not func.startswith('cmd_'):
  46                         continue
  47                     if func in self.overrides:
  48                         print >>sys.stderr, "Plugin %s overrides already overridden function %s.  Disabling" % (p, func)
  49                         self.plugins.remove(x)
  50                         break
  51
  52     def _add_new_file(self, file):
  53         repo = get_output('git rev-parse --git-dir')[0]
  54         dir = os.path.join(repo, 'yap')
  55         try:
  56             os.mkdir(dir)
  57         except OSError:
  58             pass
  59         files = self._get_new_files()
  60         files.append(file)
  61         path = os.path.join(dir, 'new-files')
  62         pickle.dump(files, open(path, 'w'))
  63
  64     def _get_new_files(self):
  65         repo = get_output('git rev-parse --git-dir')[0]
  66         path = os.path.join(repo, 'yap', 'new-files')
  67         try:
  68             files = pickle.load(file(path))
  69         except IOError:
  70             files = []
  71
  72         x = []
  73         for f in files:
  74             # if f in the index
  75             if get_output("git ls-files --cached '%s'" % f) != []:
  76                 continue
  77             x.append(f)
  78         return x
  79
  80     def _remove_new_file(self, file):
  81         files = self._get_new_files()
  82         files = filter(lambda x: x != file, files)
  83
  84         repo = get_output('git rev-parse --git-dir')[0]
  85         path = os.path.join(repo, 'yap', 'new-files')
  86         pickle.dump(files, open(path, 'w'))
  87
  88     def _clear_new_files(self):
  89         repo = get_output('git rev-parse --git-dir')[0]
  90         path = os.path.join(repo, 'yap', 'new-files')
  91         os.unlink(path)
  92
  93     def _assert_file_exists(self, file):
  94         if not os.access(file, os.R_OK):
  95             raise YapError("No such file: %s" % file)
  96
  97     def _get_staged_files(self):
  98         if run_command("git rev-parse HEAD"):
  99             files = get_output("git ls-files --cached")
 100         else:
 101             files = get_output("git diff-index --cached --name-only HEAD")
 102         unmerged = self._get_unmerged_files()
 103         if unmerged:
 104             unmerged = set(unmerged)
 105             files = set(files).difference(unmerged)
 106             files = list(files)
 107         return files
 108
 109     def _get_unstaged_files(self):
 110         files = get_output("git ls-files -m")
 111         prefix = get_output("git rev-parse --show-prefix")
 112         if prefix:
 113             files = [ os.path.join(prefix[0], x) for x in files ]
 114         files += self._get_new_files()
 115         unmerged = self._get_unmerged_files()
 116         if unmerged:
 117             unmerged = set(unmerged)
 118             files = set(files).difference(unmerged)
 119             files = list(files)
 120         return files
 121
 122     def _get_unmerged_files(self):
 123         files = get_output("git ls-files -u")
 124         files = [ x.replace('\t', ' ').split(' ')[3] for x in files ]
 125         prefix = get_output("git rev-parse --show-prefix")
 126         if prefix:
 127             files = [ os.path.join(prefix[0], x) for x in files ]
 128         return list(set(files))
 129
 130     def _delete_branch(self, branch, force):
 131         current = get_output("git symbolic-ref HEAD")[0]
 132         current = current.replace('refs/heads/', '')
 133         if branch == current:
 134             raise YapError("Can't delete current branch")
 135
 136         ref = get_output("git rev-parse --verify 'refs/heads/%s'" % branch)
 137         if not ref:
 138             raise YapError("No such branch: %s" % branch)
 139         run_safely("git update-ref -d 'refs/heads/%s' '%s'" % (branch, ref[0]))
 140
 141         if not force:
 142             name = get_output("git name-rev --name-only '%s'" % ref[0])[0]
 143             if name == 'undefined':
 144                 run_command("git update-ref 'refs/heads/%s' '%s'" % (branch, ref[0]))
 145                 raise YapError("Refusing to delete leaf branch (use -f to force)")
 146     def _get_pager_cmd(self):
 147         if 'YAP_PAGER' in os.environ:
 148             return os.environ['YAP_PAGER']
 149         elif 'GIT_PAGER' in os.environ:
 150             return os.environ['GIT_PAGER']
 151         elif 'PAGER' in os.environ:
 152             return os.environ['PAGER']
 153         else:
 154             return "more"
 155
 156     def _add_one(self, file):
 157         self._assert_file_exists(file)
 158         x = get_output("git ls-files '%s'" % file)
 159         if x != []:
 160             raise YapError("File '%s' already in repository" % file)
 161         self._add_new_file(file)
 162
 163     def _rm_one(self, file):
 164         self._assert_file_exists(file)
 165         if get_output("git ls-files '%s'" % file) != []:
 166             run_safely("git rm --cached '%s'" % file)
 167         self._remove_new_file(file)
 168
 169     def _stage_one(self, file, allow_unmerged=False):
 170         self._assert_file_exists(file)
 171         prefix = get_output("git rev-parse --show-prefix")
 172         if prefix:
 173             tmp = os.path.normpath(os.path.join(prefix[0], file))
 174         else:
 175             tmp = file
 176         if not allow_unmerged and tmp in self._get_unmerged_files():
 177             raise YapError("Refusing to stage conflicted file: %s" % file)
 178         run_safely("git update-index --add '%s'" % file)
 179
 180     def _unstage_one(self, file):
 181         self._assert_file_exists(file)
 182         if run_command("git rev-parse HEAD"):
 183             run_safely("git update-index --force-remove '%s'" % file)
 184         else:
 185             run_safely("git diff-index -p HEAD '%s' | git apply -R --cached" % file)
 186
 187     def _revert_one(self, file):
 188         self._assert_file_exists(file)
 189         self._unstage_one(file)
 190         run_safely("git checkout-index -u -f '%s'" % file)
 191
 192     def _parse_commit(self, commit):
 193         lines = get_output("git cat-file commit '%s'" % commit)
 194         commit = {}
 195
 196         mode = None
 197         for l in lines:
 198             if mode != 'commit' and l.strip() == "":
 199                 mode = 'commit'
 200                 commit['log'] = []
 201                 continue
 202             if mode == 'commit':
 203                 commit['log'].append(l)
 204                 continue
 205
 206             x = l.split(' ')
 207             k = x[0]
 208             v = ' '.join(x[1:])
 209             commit[k] = v
 210         commit['log'] = '\n'.join(commit['log'])
 211         return commit
 212
 213     def _check_commit(self, **flags):
 214         if '-a' in flags and '-d' in flags:
 215             raise YapError("Conflicting flags: -a and -d")
 216
 217         if '-d' not in flags and self._get_unstaged_files():
 218             if '-a' not in flags and self._get_staged_files():
 219                 raise YapError("Staged and unstaged changes present.  Specify what to commit")
 220             os.system("git diff-files -p | git apply --cached")
 221             for f in self._get_new_files():
 222                 self._stage_one(f)
 223
 224     def _do_uncommit(self):
 225         commit = self._parse_commit("HEAD")
 226         repo = get_output('git rev-parse --git-dir')[0]
 227         dir = os.path.join(repo, 'yap')
 228         try:
 229             os.mkdir(dir)
 230         except OSError:
 231             pass
 232         msg_file = os.path.join(dir, 'msg')
 233         fd = file(msg_file, 'w')
 234         print >>fd, commit['log']
 235         fd.close()
 236
 237         tree = get_output("git rev-parse --verify HEAD^")
 238         run_safely("git update-ref -m uncommit HEAD '%s'" % tree[0])
 239
 240     def _do_commit(self, msg=None):
 241         tree = get_output("git write-tree")[0]
 242         parent = get_output("git rev-parse --verify HEAD 2> /dev/null")[0]
 243
 244         if os.environ.has_key('YAP_EDITOR'):
 245             editor = os.environ['YAP_EDITOR']
 246         elif os.environ.has_key('GIT_EDITOR'):
 247             editor = os.environ['GIT_EDITOR']
 248         elif os.environ.has_key('EDITOR'):
 249             editor = os.environ['EDITOR']
 250         else:
 251             editor = "vi"
 252
 253         fd, tmpfile = tempfile.mkstemp("yap")
 254         os.close(fd)
 255
 256
 257         if msg is None:
 258             repo = get_output('git rev-parse --git-dir')[0]
 259             msg_file = os.path.join(repo, 'yap', 'msg')
 260             if os.access(msg_file, os.R_OK):
 261                 fd1 = file(msg_file)
 262                 fd2 = file(tmpfile, 'w')
 263                 for l in fd1.xreadlines():
 264                     print >>fd2, l.strip()
 265                 fd2.close()
 266                 os.unlink(msg_file)
 267             if os.system("%s '%s'" % (editor, tmpfile)) != 0:
 268                 raise YapError("Editing commit message failed")
 269             fd = file(tmpfile)
 270             msg = fd.readlines()
 271             msg = ''.join(msg)
 272
 273         msg = msg.strip()
 274         if not msg:
 275             raise YapError("Refusing to use empty commit message")
 276
 277         (fd_w, fd_r) = os.popen2("git stripspace > %s" % tmpfile)
 278         print >>fd_w, msg,
 279         fd_w.close()
 280         fd_r.close()
 281
 282         if parent != 'HEAD':
 283             commit = get_output("git commit-tree '%s' -p '%s' < '%s'" % (tree, parent, tmpfile))
 284         else:
 285             commit = get_output("git commit-tree '%s' < '%s'" % (tree, tmpfile))
 286
 287         os.unlink(tmpfile)
 288         run_safely("git update-ref HEAD '%s'" % commit[0])
 289
 290     def _check_rebasing(self):
 291         repo = get_output('git rev-parse --git-dir')[0]
 292         dotest = os.path.join(repo, '.dotest')
 293         if os.access(dotest, os.R_OK):
 294             raise YapError("A git operation is in progress.  Complete it first")
 295         dotest = os.path.join(repo, '..', '.dotest')
 296         if os.access(dotest, os.R_OK):
 297             raise YapError("A git operation is in progress.  Complete it first")
 298
 299     def _list_remotes(self):
 300         remotes = get_output("git config --get-regexp '^remote.*.url'")
 301         for x in remotes:
 302             remote, url = x.split(' ')
 303             remote = remote.replace('remote.', '')
 304             remote = remote.replace('.url', '')
 305             yield remote, url
 306
 307     def _unstage_all(self):
 308         try:
 309             run_safely("git read-tree -m HEAD")
 310         except ShellError:
 311             run_safely("git read-tree HEAD")
 312             run_safely("git update-index -q --refresh")
 313
 314     def _get_tracking(self, current):
 315         remote = get_output("git config branch.%s.remote" % current)
 316         if not remote:
 317             raise YapError("No tracking branch configured for '%s'" % current)
 318
 319         merge = get_output("git config branch.%s.merge" % current)
 320         if not merge:
 321             raise YapError("No tracking branch configured for '%s'" % current)
 322         return remote[0], merge
 323
 324     @short_help("make a local copy of an existing repository")
 325     @long_help("""
 326 The first argument is a URL to the existing repository.  This can be an
 327 absolute path if the repository is local, or a URL with the git://,
 328 ssh://, or http:// schemes.  By default, the directory used is the last
 329 component of the URL, sans '.git'.  This can be overridden by providing
 330 a second argument.
 331 """)
 332     def cmd_clone(self, url, directory=None):
 333         "<url> [directory]"
 334
 335         if '://' not in url and url[0] != '/':
 336             url = os.path.join(os.getcwd(), url)
 337
 338         url = url.rstrip('/')
 339         if directory is None:
 340             directory = url.rsplit('/')[-1]
 341             directory = directory.replace('.git', '')
 342
 343         try:
 344             os.mkdir(directory)
 345         except OSError:
 346             raise YapError("Directory exists: %s" % directory)
 347         os.chdir(directory)
 348         self.cmd_init()
 349         self.cmd_repo("origin", url)
 350         self.cmd_fetch("origin")
 351
 352         branch = None
 353         if not run_command("git rev-parse --verify refs/remotes/origin/HEAD"):
 354             hash = get_output("git rev-parse refs/remotes/origin/HEAD")[0]
 355             for b in get_output("git for-each-ref --format='%(refname)' 'refs/remotes/origin/*'"):
 356                 if get_output("git rev-parse %s" % b)[0] == hash:
 357                     branch = b
 358                     break
 359         if branch is None:
 360             if not run_command("git rev-parse --verify refs/remotes/origin/master"):
 361                 branch = "refs/remotes/origin/master"
 362         if branch is None:
 363             branch = get_output("git for-each-ref --format='%(refname)' 'refs/remotes/origin/*'")
 364             branch = branch[0]
 365
 366         hash = get_output("git rev-parse %s" % branch)
 367         assert hash
 368         branch = branch.replace('refs/remotes/origin/', '')
 369         run_safely("git update-ref refs/heads/%s %s" % (branch, hash[0]))
 370         run_safely("git symbolic-ref HEAD refs/heads/%s" % branch)
 371         self.cmd_revert(**{'-a': 1})
 372
 373     @short_help("turn a directory into a repository")
 374     @long_help("""
 375 Converts the current working directory into a repository.  The primary
 376 side-effect of this command is the creation of a '.git' subdirectory.
 377 No files are added nor commits made.
 378 """)
 379     def cmd_init(self):
 380         os.system("git init")
 381
 382     @short_help("add a new file to the repository")
 383     @long_help("""
 384 The arguments are the files to be added to the repository.  Once added,
 385 the files will show as "unstaged changes" in the output of 'status'.  To
 386 reverse the effects of this command, see 'rm'.
 387 """)
 388     def cmd_add(self, *files):
 389         "<file>..."
 390         if not files:
 391             raise TypeError
 392
 393         for f in files:
 394             self._add_one(f)
 395         self.cmd_status()
 396
 397     @short_help("delete a file from the repository")
 398     @long_help("""
 399 The arguments are the files to be removed from the current revision of
 400 the repository.  The files will still exist in any past commits that the
 401 files may have been a part of.  The file is not actually deleted, it is
 402 just no longer tracked as part of the repository.
 403 """)
 404     def cmd_rm(self, *files):
 405         "<file>..."
 406         if not files:
 407             raise TypeError
 408
 409         for f in files:
 410             self._rm_one(f)
 411         self.cmd_status()
 412
 413     @short_help("stage changes in a file for commit")
 414     @long_help("""
 415 The arguments are the files to be staged.  Staging changes is a way to
 416 build up a commit when you do not want to commit all changes at once.
 417 To commit only staged changes, use the '-d' flag to 'commit.'  To
 418 reverse the effects of this command, see 'unstage'.  Once staged, the
 419 files will show as "staged changes" in the output of 'status'.
 420 """)
 421     def cmd_stage(self, *files):
 422         "<file>..."
 423         if not files:
 424             raise TypeError
 425
 426         for f in files:
 427             self._stage_one(f)
 428         self.cmd_status()
 429
 430     @short_help("unstage changes in a file")
 431     @long_help("""
 432 The arguments are the files to be unstaged.  Once unstaged, the files
 433 will show as "unstaged changes" in the output of 'status'.  The '-a'
 434 flag can be used to unstage all staged changes at once.
 435 """)
 436     @takes_options("a")
 437     def cmd_unstage(self, *files, **flags):
 438         "[-a] | <file>..."
 439         if '-a' in flags:
 440             self._unstage_all()
 441             self.cmd_status()
 442             return
 443
 444         if not files:
 445             raise TypeError
 446
 447         for f in files:
 448             self._unstage_one(f)
 449         self.cmd_status()
 450
 451     @short_help("show files with staged and unstaged changes")
 452     @long_help("""
 453 Show the files in the repository with changes since the last commit,
 454 categorized based on whether the changes are staged or not.  A file may
 455 appear under each heading if the same file has both staged and unstaged
 456 changes.
 457 """)
 458     def cmd_status(self):
 459         ""
 460         branch = get_output("git symbolic-ref HEAD")[0]
 461         branch = branch.replace('refs/heads/', '')
 462         print "Current branch: %s" % branch
 463
 464         print "Files with staged changes:"
 465         files = self._get_staged_files()
 466         for f in files:
 467             print "\t%s" % f
 468         if not files:
 469             print "\t(none)"
 470
 471         print "Files with unstaged changes:"
 472         files = self._get_unstaged_files()
 473         for f in files:
 474             print "\t%s" % f
 475         if not files:
 476             print "\t(none)"
 477
 478         files = self._get_unmerged_files()
 479         if files:
 480             print "Files with conflicts:"
 481             for f in files:
 482                 print "\t%s" % f
 483
 484     @short_help("remove uncommitted changes from a file (*)")
 485     @long_help("""
 486 The arguments are the files whose changes will be reverted.  If the '-a'
 487 flag is given, then all files will have uncommitted changes removed.
 488 Note that there is no way to reverse this command short of manually
 489 editing each file again.
 490 """)
 491     @takes_options("a")
 492     def cmd_revert(self, *files, **flags):
 493         "(-a | <file>)"
 494         if '-a' in flags:
 495             self._unstage_all()
 496             run_safely("git checkout-index -u -f -a")
 497             self.cmd_status()
 498             return
 499
 500         if not files:
 501             raise TypeError
 502
 503         for f in files:
 504             self._revert_one(f)
 505         self.cmd_status()
 506
 507     @short_help("record changes to files as a new commit")
 508     @long_help("""
 509 Create a new commit recording changes since the last commit.  If there
 510 are only unstaged changes, those will be recorded.  If there are only
 511 staged changes, those will be recorded.  Otherwise, you will have to
 512 specify either the '-a' flag or the '-d' flag to commit all changes or
 513 only staged changes, respectively.  To reverse the effects of this
 514 command, see 'uncommit'.
 515 """)
 516     @takes_options("adm:")
 517     def cmd_commit(self, **flags):
 518         "[-a | -d]"
 519         self._check_rebasing()
 520         self._check_commit(**flags)
 521         if not self._get_staged_files():
 522             raise YapError("No changes to commit")
 523         msg = flags.get('-m', None)
 524         self._do_commit(msg)
 525         self.cmd_status()
 526
 527     @short_help("reverse the actions of the last commit")
 528     @long_help("""
 529 Reverse the effects of the last 'commit' operation.  The changes that
 530 were part of the previous commit will show as "staged changes" in the
 531 output of 'status'.  This means that if no files were changed since the
 532 last commit was created, 'uncommit' followed by 'commit' is a lossless
 533 operation.
 534 """)
 535     def cmd_uncommit(self):
 536         ""
 537         self._do_uncommit()
 538         self.cmd_status()
 539
 540     @short_help("report the current version of yap")
 541     def cmd_version(self):
 542         print "Yap version 0.1"
 543
 544     @short_help("show the changelog for particular versions or files")
 545     @long_help("""
 546 The arguments are the files with which to filter history.  If none are
 547 given, all changes are listed.  Otherwise only commits that affected one
 548 or more of the given files are listed.  The -r option changes the
 549 starting revision for traversing history.  By default, history is listed
 550 starting at HEAD.
 551 """)
 552     @takes_options("r:")
 553     def cmd_log(self, *paths, **flags):
 554         "[-r <rev>] <path>..."
 555         rev = flags.get('-r', 'HEAD')
 556         paths = ' '.join(paths)
 557         os.system("git log --name-status '%s' -- %s" % (rev, paths))
 558
 559     @short_help("show staged, unstaged, or all uncommitted changes")
 560     @long_help("""
 561 Show staged, unstaged, or all uncommitted changes.  By default, all
 562 changes are shown.  The '-u' flag causes only unstaged changes to be
 563 shown.  The '-d' flag causes only staged changes to be shown.
 564 """)
 565     @takes_options("ud")
 566     def cmd_diff(self, **flags):
 567         "[ -u | -d ]"
 568         if '-u' in flags and '-d' in flags:
 569             raise YapError("Conflicting flags: -u and -d")
 570
 571         pager = self._get_pager_cmd()
 572
 573         if '-u' in flags:
 574             os.system("git diff-files -p | %s" % pager)
 575         elif '-d' in flags:
 576             os.system("git diff-index --cached -p HEAD | %s" % pager)
 577         else:
 578             os.system("git diff-index -p HEAD | %s" % pager)
 579
 580     @short_help("list, create, or delete branches")
 581     @long_help("""
 582 If no arguments are specified, a list of local branches is given.  The
 583 current branch is indicated by a "*" next to the name.  If an argument
 584 is given, it is taken as the name of a new branch to create.  The branch
 585 will start pointing at the current HEAD.  See 'point' for details on
 586 changing the revision of the new branch.  Note that this command does
 587 not switch the current working branch.  See 'switch' for details on
 588 changing the current working branch.
 589
 590 The '-d' flag can be used to delete local branches.  If the delete
 591 operation would remove the last branch reference to a given line of
 592 history (colloquially referred to as "dangling commits"), yap will
 593 report an error and abort.  The '-f' flag can be used to force the delete
 594 in spite of this.
 595 """)
 596     @takes_options("fd:")
 597     def cmd_branch(self, branch=None, **flags):
 598         "[ [-f] -d <branch> | <branch> ]"
 599         force = '-f' in flags
 600         if '-d' in flags:
 601             self._delete_branch(flags['-d'], force)
 602             self.cmd_branch()
 603             return
 604
 605         if branch is not None:
 606             ref = get_output("git rev-parse --verify HEAD")
 607             if not ref:
 608                 raise YapError("No branch point yet.  Make a commit")
 609             run_safely("git update-ref 'refs/heads/%s' '%s'" % (branch, ref[0]))
 610
 611         current = get_output("git symbolic-ref HEAD")[0]
 612         branches = get_output("git for-each-ref --format='%(refname)' 'refs/heads/*'")
 613         for b in branches:
 614             if b == current:
 615                 print "* ",
 616             else:
 617                 print "  ",
 618             b = b.replace('refs/heads/', '')
 619             print b
 620
 621     @short_help("change the current working branch")
 622     @long_help("""
 623 The argument is the name of the branch to make the current working
 624 branch.  This command will fail if there are uncommitted changes to any
 625 files.  Otherwise, the contents of the files in the working directory
 626 are updated to reflect their state in the new branch.  Additionally, any
 627 future commits are added to the new branch instead of the previous line
 628 of history.
 629 """)
 630     @takes_options("f")
 631     def cmd_switch(self, branch, **flags):
 632         "[-f] <branch>"
 633         ref = get_output("git rev-parse --verify 'refs/heads/%s'" % branch)
 634         if not ref:
 635             raise YapError("No such branch: %s" % branch)
 636
 637         if '-f' not in flags and (self._get_unstaged_files() or self._get_staged_files()):
 638             raise YapError("You have uncommitted changes.  Use -f to continue anyway")
 639
 640         if self._get_unstaged_files() and self._get_staged_files():
 641             raise YapError("You have staged and unstaged changes.  Perhaps unstage -a?")
 642
 643         staged = bool(self._get_staged_files())
 644
 645         run_command("git diff-files -p | git apply --cached")
 646         for f in self._get_new_files():
 647             self._stage_one(f)
 648
 649         idx = get_output("git write-tree")
 650         new = get_output("git rev-parse refs/heads/%s" % branch)
 651         run_safely("git read-tree --aggressive -u -m HEAD %s %s" % (idx[0], new[0]))
 652         run_safely("git symbolic-ref HEAD refs/heads/%s" % branch)
 653
 654         if not staged:
 655             self._unstage_all()
 656         self.cmd_status()
 657
 658     @short_help("move the current branch to a different revision")
 659     @long_help("""
 660 The argument is the hash of the commit to which the current branch
 661 should point, or alternately a branch or tag (a.k.a, "committish").  If
 662 moving the branch would create "dangling commits" (see 'branch'), yap
 663 will report an error and abort.  The '-f' flag can be used to force the
 664 operation in spite of this.
 665 """)
 666     @takes_options("f")
 667     def cmd_point(self, where, **flags):
 668         "<where>"
 669         head = get_output("git rev-parse --verify HEAD")
 670         if not head:
 671             raise YapError("No commit yet; nowhere to point")
 672
 673         ref = get_output("git rev-parse --verify '%s'" % where)
 674         if not ref:
 675             raise YapError("Not a valid ref: %s" % where)
 676
 677         if self._get_unstaged_files() or self._get_staged_files():
 678             raise YapError("You have uncommitted changes.  Commit them first")
 679
 680         type = get_output("git cat-file -t '%s'" % ref[0])
 681         if type and type[0] == "tag":
 682             tag = get_output("git cat-file tag '%s'" % ref[0])
 683             ref[0] = tag[0].split(' ')[1]
 684
 685         run_safely("git update-ref HEAD '%s'" % ref[0])
 686
 687         if '-f' not in flags:
 688             name = get_output("git name-rev --name-only '%s'" % head[0])[0]
 689             if name == "undefined":
 690                 os.system("git update-ref HEAD '%s'" % head[0])
 691                 raise YapError("Pointing there will lose commits.  Use -f to force")
 692
 693         run_safely("git read-tree -u -m HEAD")
 694         run_safely("git checkout-index -u -f -a")
 695
 696     @short_help("alter history by dropping or amending commits")
 697     @long_help("""
 698 This command operates in two distinct modes, "amend" and "drop" mode.
 699 In drop mode, the given commit is removed from the history of the
 700 current branch, as though that commit never happened.  By default the
 701 commit used is HEAD.
 702
 703 In amend mode, the uncommitted changes present are merged into a
 704 previous commit.  This is useful for correcting typos or adding missed
 705 files into past commits.  By default the commit used is HEAD.
 706
 707 While rewriting history it is possible that conflicts will arise.  If
 708 this happens, the rewrite will pause and you will be prompted to resolve
 709 the conflicts and stage them.  Once that is done, you will run "yap
 710 history continue."  If instead you want the conflicting commit removed
 711 from history (perhaps your changes supercede that commit) you can run
 712 "yap history skip".  Once the rewrite completes, your branch will be on
 713 the same commit as when the rewrite started.
 714 """)
 715     def cmd_history(self, subcmd, *args):
 716         "amend | drop <commit>"
 717
 718         if subcmd not in ("amend", "drop", "continue", "skip"):
 719             raise TypeError
 720
 721         resolvemsg = """
 722 When you have resolved the conflicts run \"yap history continue\".
 723 To skip the problematic patch, run \"yap history skip\"."""
 724
 725         if subcmd == "continue":
 726             os.system("git am -3 -r --resolvemsg='%s'" % resolvemsg)
 727             return
 728         if subcmd == "skip":
 729             os.system("git reset --hard")
 730             os.system("git am -3 --skip --resolvemsg='%s'" % resolvemsg)
 731             return
 732
 733         if subcmd == "amend":
 734             flags, args = getopt.getopt(args, "ad")
 735             flags = dict(flags)
 736
 737         if len(args) > 1:
 738             raise TypeError
 739         if args:
 740             commit = args[0]
 741         else:
 742             commit = "HEAD"
 743
 744         if run_command("git rev-parse --verify '%s'" % commit):
 745             raise YapError("Not a valid commit: %s" % commit)
 746
 747         self._check_rebasing()
 748
 749         if subcmd == "amend":
 750             self._check_commit(**flags)
 751             if self._get_unstaged_files():
 752                 # XXX: handle unstaged changes better
 753                 raise YapError("Commit away changes that you aren't amending")
 754
 755         stash = get_output("git stash create")
 756         try:
 757             run_command("git reset --hard")
 758             fd, tmpfile = tempfile.mkstemp("yap")
 759             try:
 760                 try:
 761                     os.close(fd)
 762                     os.system("git format-patch -k --stdout '%s' > %s" % (commit, tmpfile))
 763                     if subcmd == "amend":
 764                         self.cmd_point(commit, **{'-f': True})
 765                 finally:
 766                     if subcmd == "amend":
 767                         rc = os.system("git stash apply --index %s" % stash[0])
 768                         if rc:
 769                             raise YapError("Failed to apply stash")
 770                         stash = None
 771
 772                 if subcmd == "amend":
 773                     self._do_uncommit()
 774                     self._do_commit()
 775                 else:
 776                     self.cmd_point("%s^" % commit, **{'-f': True})
 777
 778                 stat = os.stat(tmpfile)
 779                 size = stat[6]
 780                 if size > 0:
 781                     rc = os.system("git am -3 --resolvemsg=\'%s\' %s" % (resolvemsg, tmpfile))
 782                     if (rc):
 783                         raise YapError("Failed to apply changes")
 784             finally:
 785                 os.unlink(tmpfile)
 786         finally:
 787             if stash:
 788                 run_command("git stash apply --index %s" % stash[0])
 789         self.cmd_status()
 790
 791     @short_help("show the changes introduced by a given commit")
 792     @long_help("""
 793 By default, the changes in the last commit are shown.  To override this,
 794 specify a hash, branch, or tag (committish).  The hash of the commit,
 795 the commit's author, log message, and a diff of the changes are shown.
 796 """)
 797     def cmd_show(self, commit="HEAD"):
 798         "[commit]"
 799         os.system("git show '%s'" % commit)
 800
 801     @short_help("apply the changes in a given commit to the current branch")
 802     @long_help("""
 803 The argument is the hash, branch, or tag (committish) of the commit to
 804 be applied.  In general, it only makes sense to apply commits that
 805 happened on another branch.  The '-r' flag can be used to have the
 806 changes in the given commit reversed from the current branch.  In
 807 general, this only makes sense for commits that happened on the current
 808 branch.
 809 """)
 810     @takes_options("r")
 811     def cmd_cherry_pick(self, commit, **flags):
 812         "[-r] <commit>"
 813         if '-r' in flags:
 814             os.system("git revert '%s'" % commit)
 815         else:
 816             os.system("git cherry-pick '%s'" % commit)
 817
 818     @short_help("list, add, or delete configured remote repositories")
 819     @long_help("""
 820 When invoked with no arguments, this command will show the list of
 821 currently configured remote repositories, giving both the name and URL
 822 of each.  To add a new repository, give the desired name as the first
 823 argument and the URL as the second.  The '-d' flag can be used to remove
 824 a previously added repository.
 825 """)
 826     @takes_options("d:")
 827     def cmd_repo(self, name=None, url=None, **flags):
 828         "[<name> <url> | -d <name>]"
 829         if name is not None and url is None:
 830             raise TypeError
 831
 832         if '-d' in flags:
 833             if flags['-d'] not in [ x[0] for x in self._list_remotes() ]:
 834                 raise YapError("No such repository: %s" % flags['-d'])
 835             os.system("git config --unset remote.%s.url" % flags['-d'])
 836             os.system("git config --unset remote.%s.fetch" % flags['-d'])
 837
 838         if name:
 839             if name in [ x[0] for x in self._list_remotes() ]:
 840                 raise YapError("Repository '%s' already exists" % flags['-d'])
 841             os.system("git config remote.%s.url %s" % (name, url))
 842             os.system("git config remote.%s.fetch +refs/heads/*:refs/remotes/%s/*" % (name, name))
 843
 844         for remote, url in self._list_remotes():
 845             print "%-20s %s" % (remote, url)
 846
 847     @takes_options("cd")
 848     @short_help("send local commits to a remote repository")
 849     def cmd_push(self, repo, **flags):
 850         "[-c | -d] <repo>"
 851
 852         if repo not in [ x[0] for x in self._list_remotes() ]:
 853             raise YapError("No such repository: %s" % repo)
 854
 855         current = get_output("git symbolic-ref HEAD")
 856         if not current:
 857             raise YapError("Not on a branch!")
 858         ref = current[0]
 859         current = current[0].replace('refs/heads/', '')
 860         remote = get_output("git config branch.%s.remote" % current)
 861         if remote and remote[0] == repo:
 862             merge = get_output("git config branch.%s.merge" % current)
 863             if merge:
 864                 ref = merge[0]
 865
 866         if '-c' not in flags and '-d' not in flags:
 867             if run_command("git rev-parse --verify refs/remotes/%s/%s"
 868                     % (repo, ref.replace('refs/heads/', ''))):
 869                 raise YapError("No matching branch on that repo.  Use -c to create a new branch there.")
 870
 871         if '-d' in flags:
 872             lhs = ""
 873         else:
 874             lhs = "refs/heads/%s" % current
 875         rc = os.system("git push %s %s:%s" % (repo, lhs, ref))
 876         if rc:
 877             raise YapError("Push failed.")
 878
 879     @short_help("retrieve commits from a remote repository")
 880     def cmd_fetch(self, repo):
 881         "<repo>"
 882         # XXX allow defaulting of repo? yap.default
 883         if repo not in [ x[0] for x in self._list_remotes() ]:
 884             raise YapError("No such repository: %s" % repo)
 885         os.system("git fetch %s" % repo)
 886
 887     @short_help("update the current branch relative to its tracking branch")
 888     def cmd_update(self, subcmd=None):
 889         "[continue | skip]"
 890         if subcmd and subcmd not in ["continue", "skip"]:
 891             raise TypeError
 892
 893         resolvemsg = """
 894 When you have resolved the conflicts run \"yap update continue\".
 895 To skip the problematic patch, run \"yap update skip\"."""
 896
 897         if subcmd == "continue":
 898             os.system("git am -3 -r --resolvemsg='%s'" % resolvemsg)
 899             return
 900         if subcmd == "skip":
 901             os.system("git reset --hard")
 902             os.system("git am -3 --skip --resolvemsg='%s'" % resolvemsg)
 903             return
 904
 905         self._check_rebasing()
 906         if self._get_unstaged_files() or self._get_staged_files():
 907             raise YapError("You have uncommitted changes.  Commit them first")
 908
 909         current = get_output("git symbolic-ref HEAD")
 910         if not current:
 911             raise YapError("Not on a branch!")
 912
 913         current = current[0].replace('refs/heads/', '')
 914         remote, merge = self._get_tracking(current)
 915         merge = merge[0].replace('refs/heads/', '')
 916
 917         self.cmd_fetch(remote)
 918         base = get_output("git merge-base HEAD refs/remotes/%s/%s" % (remote, merge))
 919
 920         try:
 921             fd, tmpfile = tempfile.mkstemp("yap")
 922             os.close(fd)
 923             os.system("git format-patch -k --stdout '%s' > %s" % (base[0], tmpfile))
 924             self.cmd_point("refs/remotes/%s/%s" % (remote, merge), **{'-f': True})
 925
 926             stat = os.stat(tmpfile)
 927             size = stat[6]
 928             if size > 0:
 929                 rc = os.system("git am -3 --resolvemsg=\'%s\' %s" % (resolvemsg, tmpfile))
 930                 if (rc):
 931                     raise YapError("Failed to apply changes")
 932         finally:
 933             os.unlink(tmpfile)
 934
 935     @short_help("query and configure remote branch tracking")
 936     def cmd_track(self, repo=None, branch=None):
 937         "[<repo> <branch>]"
 938
 939         current = get_output("git symbolic-ref HEAD")
 940         if not current:
 941             raise YapError("Not on a branch!")
 942         current = current[0].replace('refs/heads/', '')
 943
 944         if repo is None and branch is None:
 945             repo, merge = self._get_tracking(current)
 946             merge = merge[0].replace('refs/heads/', '')
 947             print "Branch '%s' tracking refs/remotes/%s/%s" % (current, repo, merge)
 948             return
 949
 950         if repo is None or branch is None:
 951             raise TypeError
 952
 953         if repo not in [ x[0] for x in self._list_remotes() ]:
 954             raise YapError("No such repository: %s" % repo)
 955
 956         if run_command("git rev-parse --verify refs/remotes/%s/%s" % (repo, branch)):
 957             raise YapError("No such branch '%s' on repository '%s'" % (repo, branch))
 958
 959         os.system("git config branch.%s.remote '%s'" % (current, repo))
 960         os.system("git config branch.%s.merge 'refs/heads/%s'" % (current, branch))
 961         print "Branch '%s' now tracking refs/remotes/%s/%s" % (current, repo, branch)
 962
 963     @short_help("mark files with conflicts as resolved")
 964     def cmd_resolved(self, *args):
 965         "<file>..."
 966         if not files:
 967             raise TypeError
 968
 969         for f in files:
 970             self._stage_one(f, True)
 971         self.cmd_status()
 972
 973     def cmd_help(self, cmd=None):
 974         if cmd is not None:
 975             try:
 976                 attr = self.__getattribute__("cmd_"+cmd.replace('-', '_'))
 977             except AttributeError:
 978                 raise YapError("No such command: %s" % cmd)
 979             try:
 980                 help = attr.long_help
 981             except AttributeError:
 982                 raise YapError("Sorry, no help for '%s'.  Ask Steven." % cmd)
 983
 984             print >>sys.stderr, "The '%s' command" % cmd
 985             print >>sys.stderr, "\tyap %s %s" % (cmd, attr.__doc__)
 986             print >>sys.stderr, "%s" % help
 987             return
 988
 989         print >> sys.stderr, "Yet Another (Git) Porcelein"
 990         print >> sys.stderr
 991
 992         for name in dir(self):
 993             if not name.startswith('cmd_'):
 994                 continue
 995             attr = self.__getattribute__(name)
 996             if not callable(attr):
 997                 continue
 998             try:
 999                 short_msg = attr.short_help
1000             except AttributeError:
1001                 continue
1002
1003             name = name.replace('cmd_', '')
1004             name = name.replace('_', '-')
1005             print >> sys.stderr, "%-16s%s" % (name, short_msg)
1006         print >> sys.stderr
1007         print >> sys.stderr, "(*) Indicates that the command is not readily reversible"
1008
1009     def cmd_usage(self):
1010         print >> sys.stderr, "usage: %s <command>" % os.path.basename(sys.argv[0])
1011         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"
1012
1013     def main(self, args):
1014         if len(args) < 1:
1015             self.cmd_usage()
1016             sys.exit(2)
1017
1018         command = args[0]
1019         args = args[1:]
1020
1021         debug = os.getenv('YAP_DEBUG')
1022
1023         try:
1024             command = command.replace('-', '_')
1025
1026             meth = None
1027             for p in self.plugins:
1028                 try:
1029                     meth = p.__getattribute__("cmd_"+command)
1030                 except AttributeError:
1031                     continue
1032
1033             try:
1034                 default_meth = self.__getattribute__("cmd_"+command)
1035             except AttributeError:
1036                 default_meth = None
1037
1038             if meth is None:
1039                 meth = default_meth
1040             if meth is None:
1041                 raise AttributeError
1042
1043             try:
1044                 if "options" in meth.__dict__:
1045                     options = meth.options
1046                     if default_meth and "options" in default_meth.__dict__:
1047                         options += default_meth.options
1048                     flags, args = getopt.getopt(args, options)
1049                     flags = dict(flags)
1050                 else:
1051                     flags = dict()
1052
1053                 # invoke pre-hooks
1054                 for p in self.plugins:
1055                     try:
1056                         meth = p.__getattribute__("pre_"+command)
1057                     except AttributeError:
1058                         continue
1059                     meth(*args, **flags)
1060
1061                 meth(*args, **flags)
1062
1063                 # invoke post-hooks
1064                 for p in self.plugins:
1065                     try:
1066                         meth = p.__getattribute__("post_"+command)
1067                     except AttributeError:
1068                         continue
1069                     meth()
1070
1071             except (TypeError, getopt.GetoptError):
1072                 if debug:
1073                     raise
1074                 print "%s %s %s" % (sys.argv[0], command, meth.__doc__)
1075             except YapError, e:
1076                 print >> sys.stderr, e
1077                 sys.exit(1)
1078         except AttributeError:
1079             if debug:
1080                 raise
1081             self.cmd_usage()
1082             sys.exit(2)