chiark - git - mdw - stgit/blob - stgit/git.py

   1 """Python GIT interface
   2 """
   3
   4 __copyright__ = """
   5 Copyright (C) 2005, Catalin Marinas <catalin.marinas@gmail.com>
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License version 2 as
   9 published by the Free Software Foundation.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19 """
  20
  21 import sys, os, popen2
  22
  23 from stgit.utils import *
  24
  25 # git exception class
  26 class GitException(Exception):
  27     pass
  28
  29
  30
  31 #
  32 # Classes
  33 #
  34 class Commit:
  35     """Handle the commit objects
  36     """
  37     def __init__(self, id_hash):
  38         self.__id_hash = id_hash
  39
  40         lines = _output_lines('git-cat-file commit %s' % id_hash)
  41         self.__parents = []
  42         for i in range(len(lines)):
  43             line = lines[i]
  44             if line == '\n':
  45                 break
  46             field = line.strip().split(' ', 1)
  47             if field[0] == 'tree':
  48                 self.__tree = field[1]
  49             elif field[0] == 'parent':
  50                 self.__parents.append(field[1])
  51             if field[0] == 'author':
  52                 self.__author = field[1]
  53             if field[0] == 'committer':
  54                 self.__committer = field[1]
  55         self.__log = ''.join(lines[i+1:])
  56
  57     def get_id_hash(self):
  58         return self.__id_hash
  59
  60     def get_tree(self):
  61         return self.__tree
  62
  63     def get_parent(self):
  64         return self.__parents[0]
  65
  66     def get_parents(self):
  67         return self.__parents
  68
  69     def get_author(self):
  70         return self.__author
  71
  72     def get_committer(self):
  73         return self.__committer
  74
  75     def get_log(self):
  76         return self.__log
  77
  78 # dictionary of Commit objects, used to avoid multiple calls to git
  79 __commits = dict()
  80
  81 #
  82 # Functions
  83 #
  84
  85 def get_base_dir():
  86     """Different start-up variables read from the environment
  87     """
  88     if 'GIT_DIR' in os.environ:
  89         return os.environ['GIT_DIR']
  90     else:
  91         return _output_one_line('git-rev-parse --git-dir')
  92
  93 def get_commit(id_hash):
  94     """Commit objects factory. Save/look-up them in the __commits
  95     dictionary
  96     """
  97     global __commits
  98
  99     if id_hash in __commits:
 100         return __commits[id_hash]
 101     else:
 102         commit = Commit(id_hash)
 103         __commits[id_hash] = commit
 104         return commit
 105
 106 def get_conflicts():
 107     """Return the list of file conflicts
 108     """
 109     conflicts_file = os.path.join(get_base_dir(), 'conflicts')
 110     if os.path.isfile(conflicts_file):
 111         f = file(conflicts_file)
 112         names = [line.strip() for line in f.readlines()]
 113         f.close()
 114         return names
 115     else:
 116         return None
 117
 118 def _input(cmd, file_desc):
 119     p = popen2.Popen3(cmd, True)
 120     while True:
 121         line = file_desc.readline()
 122         if not line:
 123             break
 124         p.tochild.write(line)
 125     p.tochild.close()
 126     if p.wait():
 127         raise GitException, '%s failed' % str(cmd)
 128
 129 def _output(cmd):
 130     p=popen2.Popen3(cmd, True)
 131     output = p.fromchild.read()
 132     if p.wait():
 133         raise GitException, '%s failed' % str(cmd)
 134     return output
 135
 136 def _output_one_line(cmd, file_desc = None):
 137     p=popen2.Popen3(cmd, True)
 138     if file_desc != None:
 139         for line in file_desc:
 140             p.tochild.write(line)
 141         p.tochild.close()
 142     output = p.fromchild.readline().strip()
 143     if p.wait():
 144         raise GitException, '%s failed' % str(cmd)
 145     return output
 146
 147 def _output_lines(cmd):
 148     p=popen2.Popen3(cmd, True)
 149     lines = p.fromchild.readlines()
 150     if p.wait():
 151         raise GitException, '%s failed' % str(cmd)
 152     return lines
 153
 154 def __run(cmd, args=None):
 155     """__run: runs cmd using spawnvp.
 156
 157     Runs cmd using spawnvp.  The shell is avoided so it won't mess up
 158     our arguments.  If args is very large, the command is run multiple
 159     times; args is split xargs style: cmd is passed on each
 160     invocation.  Unlike xargs, returns immediately if any non-zero
 161     return code is received.
 162     """
 163
 164     args_l=cmd.split()
 165     if args is None:
 166         args = []
 167     for i in range(0, len(args)+1, 100):
 168         r=os.spawnvp(os.P_WAIT, args_l[0], args_l + args[i:min(i+100, len(args))])
 169     if r:
 170         return r
 171     return 0
 172
 173 def __tree_status(files = None, tree_id = 'HEAD', unknown = False,
 174                   noexclude = True):
 175     """Returns a list of pairs - [status, filename]
 176     """
 177     refresh_index()
 178
 179     if not files:
 180         files = []
 181     cache_files = []
 182
 183     # unknown files
 184     if unknown:
 185         exclude_file = os.path.join(get_base_dir(), 'info', 'exclude')
 186         base_exclude = ['--exclude=%s' % s for s in
 187                         ['*.[ao]', '*.pyc', '.*', '*~', '#*', 'TAGS', 'tags']]
 188         base_exclude.append('--exclude-per-directory=.gitignore')
 189
 190         if os.path.exists(exclude_file):
 191             extra_exclude = ['--exclude-from=%s' % exclude_file]
 192         else:
 193             extra_exclude = []
 194         if noexclude:
 195             extra_exclude = base_exclude = []
 196
 197         lines = _output_lines(['git-ls-files', '--others'] + base_exclude
 198                         + extra_exclude)
 199         cache_files += [('?', line.strip()) for line in lines]
 200
 201     # conflicted files
 202     conflicts = get_conflicts()
 203     if not conflicts:
 204         conflicts = []
 205     cache_files += [('C', filename) for filename in conflicts]
 206
 207     # the rest
 208     for line in _output_lines(['git-diff-index', tree_id] + files):
 209         fs = tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
 210         if fs[1] not in conflicts:
 211             cache_files.append(fs)
 212
 213     return cache_files
 214
 215 def local_changes():
 216     """Return true if there are local changes in the tree
 217     """
 218     return len(__tree_status()) != 0
 219
 220 # HEAD value cached
 221 __head = None
 222
 223 def get_head():
 224     """Verifies the HEAD and returns the SHA1 id that represents it
 225     """
 226     global __head
 227
 228     if not __head:
 229         __head = rev_parse('HEAD')
 230     return __head
 231
 232 def get_head_file():
 233     """Returns the name of the file pointed to by the HEAD link
 234     """
 235     return os.path.basename(_output_one_line('git-symbolic-ref HEAD'))
 236
 237 def set_head_file(ref):
 238     """Resets HEAD to point to a new ref
 239     """
 240     # head cache flushing is needed since we might have a different value
 241     # in the new head
 242     __clear_head_cache()
 243     if __run('git-symbolic-ref HEAD', [ref]) != 0:
 244         raise GitException, 'Could not set head to "%s"' % ref
 245
 246 def __set_head(val):
 247     """Sets the HEAD value
 248     """
 249     global __head
 250
 251     if not __head or __head != val:
 252         if __run('git-update-ref HEAD', [val]) != 0:
 253             raise GitException, 'Could not update HEAD to "%s".' % val
 254         __head = val
 255
 256     # only allow SHA1 hashes
 257     assert(len(__head) == 40)
 258
 259 def __clear_head_cache():
 260     """Sets the __head to None so that a re-read is forced
 261     """
 262     global __head
 263
 264     __head = None
 265
 266 def refresh_index():
 267     """Refresh index with stat() information from the working directory.
 268     """
 269     __run('git-update-index -q --unmerged --refresh')
 270
 271 def rev_parse(git_id):
 272     """Parse the string and return a verified SHA1 id
 273     """
 274     try:
 275         return _output_one_line(['git-rev-parse', '--verify', git_id])
 276     except GitException:
 277         raise GitException, 'Unknown revision: %s' % git_id
 278
 279 def branch_exists(branch):
 280     """Existence check for the named branch
 281     """
 282     for line in _output_lines(['git-rev-parse', '--symbolic', '--all']):
 283         if line.strip() == branch:
 284             return True
 285     return False
 286
 287 def create_branch(new_branch, tree_id = None):
 288     """Create a new branch in the git repository
 289     """
 290     new_head = os.path.join('refs', 'heads', new_branch)
 291     if branch_exists(new_head):
 292         raise GitException, 'Branch "%s" already exists' % new_branch
 293
 294     current_head = get_head()
 295     set_head_file(new_head)
 296     __set_head(current_head)
 297
 298     # a checkout isn't needed if new branch points to the current head
 299     if tree_id:
 300         switch(tree_id)
 301
 302     if os.path.isfile(os.path.join(get_base_dir(), 'MERGE_HEAD')):
 303         os.remove(os.path.join(get_base_dir(), 'MERGE_HEAD'))
 304
 305 def switch_branch(name):
 306     """Switch to a git branch
 307     """
 308     global __head
 309
 310     new_head = os.path.join('refs', 'heads', name)
 311     if not branch_exists(new_head):
 312         raise GitException, 'Branch "%s" does not exist' % name
 313
 314     tree_id = rev_parse(new_head + '^{commit}')
 315     if tree_id != get_head():
 316         refresh_index()
 317         if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
 318             raise GitException, 'git-read-tree failed (local changes maybe?)'
 319         __head = tree_id
 320     set_head_file(new_head)
 321
 322     if os.path.isfile(os.path.join(get_base_dir(), 'MERGE_HEAD')):
 323         os.remove(os.path.join(get_base_dir(), 'MERGE_HEAD'))
 324
 325 def delete_branch(name):
 326     """Delete a git branch
 327     """
 328     branch_head = os.path.join('refs', 'heads', name)
 329     if not branch_exists(branch_head):
 330         raise GitException, 'Branch "%s" does not exist' % name
 331     os.remove(os.path.join(get_base_dir(), branch_head))
 332
 333 def rename_branch(from_name, to_name):
 334     """Rename a git branch
 335     """
 336     from_head = os.path.join('refs', 'heads', from_name)
 337     if not branch_exists(from_head):
 338         raise GitException, 'Branch "%s" does not exist' % from_name
 339     to_head = os.path.join('refs', 'heads', to_name)
 340     if branch_exists(to_head):
 341         raise GitException, 'Branch "%s" already exists' % to_name
 342
 343     if get_head_file() == from_name:
 344         set_head_file(to_head)
 345     os.rename(os.path.join(get_base_dir(), from_head), \
 346               os.path.join(get_base_dir(), to_head))
 347
 348 def add(names):
 349     """Add the files or recursively add the directory contents
 350     """
 351     # generate the file list
 352     files = []
 353     for i in names:
 354         if not os.path.exists(i):
 355             raise GitException, 'Unknown file or directory: %s' % i
 356
 357         if os.path.isdir(i):
 358             # recursive search. We only add files
 359             for root, dirs, local_files in os.walk(i):
 360                 for name in [os.path.join(root, f) for f in local_files]:
 361                     if os.path.isfile(name):
 362                         files.append(os.path.normpath(name))
 363         elif os.path.isfile(i):
 364             files.append(os.path.normpath(i))
 365         else:
 366             raise GitException, '%s is not a file or directory' % i
 367
 368     if files:
 369         if __run('git-update-index --add --', files):
 370             raise GitException, 'Unable to add file'
 371
 372 def rm(files, force = False):
 373     """Remove a file from the repository
 374     """
 375     if not force:
 376         for f in files:
 377             if os.path.exists(f):
 378                 raise GitException, '%s exists. Remove it first' %f
 379         if files:
 380             __run('git-update-index --remove --', files)
 381     else:
 382         if files:
 383             __run('git-update-index --force-remove --', files)
 384
 385 def update_cache(files = None, force = False):
 386     """Update the cache information for the given files
 387     """
 388     if not files:
 389         files = []
 390
 391     cache_files = __tree_status(files)
 392
 393     # everything is up-to-date
 394     if len(cache_files) == 0:
 395         return False
 396
 397     # check for unresolved conflicts
 398     if not force and [x for x in cache_files
 399                       if x[0] not in ['M', 'N', 'A', 'D']]:
 400         raise GitException, 'Updating cache failed: unresolved conflicts'
 401
 402     # update the cache
 403     add_files = [x[1] for x in cache_files if x[0] in ['N', 'A']]
 404     rm_files =  [x[1] for x in cache_files if x[0] in ['D']]
 405     m_files =   [x[1] for x in cache_files if x[0] in ['M']]
 406
 407     if add_files and __run('git-update-index --add --', add_files) != 0:
 408         raise GitException, 'Failed git-update-index --add'
 409     if rm_files and __run('git-update-index --force-remove --', rm_files) != 0:
 410         raise GitException, 'Failed git-update-index --rm'
 411     if m_files and __run('git-update-index --', m_files) != 0:
 412         raise GitException, 'Failed git-update-index'
 413
 414     return True
 415
 416 def commit(message, files = None, parents = None, allowempty = False,
 417            cache_update = True, tree_id = None,
 418            author_name = None, author_email = None, author_date = None,
 419            committer_name = None, committer_email = None):
 420     """Commit the current tree to repository
 421     """
 422     if not files:
 423         files = []
 424     if not parents:
 425         parents = []
 426
 427     # Get the tree status
 428     if cache_update and parents != []:
 429         changes = update_cache(files)
 430         if not changes and not allowempty:
 431             raise GitException, 'No changes to commit'
 432
 433     # get the commit message
 434     if message[-1:] != '\n':
 435         message += '\n'
 436
 437     must_switch = True
 438     # write the index to repository
 439     if tree_id == None:
 440         tree_id = _output_one_line('git-write-tree')
 441     else:
 442         must_switch = False
 443
 444     # the commit
 445     cmd = ''
 446     if author_name:
 447         cmd += 'GIT_AUTHOR_NAME="%s" ' % author_name
 448     if author_email:
 449         cmd += 'GIT_AUTHOR_EMAIL="%s" ' % author_email
 450     if author_date:
 451         cmd += 'GIT_AUTHOR_DATE="%s" ' % author_date
 452     if committer_name:
 453         cmd += 'GIT_COMMITTER_NAME="%s" ' % committer_name
 454     if committer_email:
 455         cmd += 'GIT_COMMITTER_EMAIL="%s" ' % committer_email
 456     cmd += 'git-commit-tree %s' % tree_id
 457
 458     # get the parents
 459     for p in parents:
 460         cmd += ' -p %s' % p
 461
 462     commit_id = _output_one_line(cmd, message)
 463     if must_switch:
 464         __set_head(commit_id)
 465
 466     return commit_id
 467
 468 def apply_diff(rev1, rev2):
 469     """Apply the diff between rev1 and rev2 onto the current
 470     index. This function doesn't need to raise an exception since it
 471     is only used for fast-pushing a patch. If this operation fails,
 472     the pushing would fall back to the three-way merge.
 473     """
 474     return os.system('git-diff-tree -p %s %s | git-apply --index 2> /dev/null'
 475                      % (rev1, rev2)) == 0
 476
 477 def merge(base, head1, head2):
 478     """Perform a 3-way merge between base, head1 and head2 into the
 479     local tree
 480     """
 481     refresh_index()
 482     if __run('git-read-tree -u -m', [base, head1, head2]) != 0:
 483         raise GitException, 'git-read-tree failed (local changes maybe?)'
 484
 485     # this can fail if there are conflicts
 486     if __run('git-merge-index -o -q gitmergeonefile.py -a') != 0:
 487         raise GitException, 'git-merge-index failed (possible conflicts)'
 488
 489 def status(files = None, modified = False, new = False, deleted = False,
 490            conflict = False, unknown = False, noexclude = False):
 491     """Show the tree status
 492     """
 493     if not files:
 494         files = []
 495
 496     cache_files = __tree_status(files, unknown = True, noexclude = noexclude)
 497     all = not (modified or new or deleted or conflict or unknown)
 498
 499     if not all:
 500         filestat = []
 501         if modified:
 502             filestat.append('M')
 503         if new:
 504             filestat.append('A')
 505             filestat.append('N')
 506         if deleted:
 507             filestat.append('D')
 508         if conflict:
 509             filestat.append('C')
 510         if unknown:
 511             filestat.append('?')
 512         cache_files = [x for x in cache_files if x[0] in filestat]
 513
 514     for fs in cache_files:
 515         if all:
 516             print '%s %s' % (fs[0], fs[1])
 517         else:
 518             print '%s' % fs[1]
 519
 520 def diff(files = None, rev1 = 'HEAD', rev2 = None, out_fd = None):
 521     """Show the diff between rev1 and rev2
 522     """
 523     if not files:
 524         files = []
 525
 526     if rev1 and rev2:
 527         diff_str = _output(['git-diff-tree', '-p', rev1, rev2] + files)
 528     elif rev1 or rev2:
 529         refresh_index()
 530         if rev2:
 531             diff_str = _output(['git-diff-index', '-p', '-R', rev2] + files)
 532         else:
 533             diff_str = _output(['git-diff-index', '-p', rev1] + files)
 534     else:
 535         diff_str = ''
 536
 537     if out_fd:
 538         out_fd.write(diff_str)
 539     else:
 540         return diff_str
 541
 542 def diffstat(files = None, rev1 = 'HEAD', rev2 = None):
 543     """Return the diffstat between rev1 and rev2
 544     """
 545     if not files:
 546         files = []
 547
 548     p=popen2.Popen3('git-apply --stat')
 549     diff(files, rev1, rev2, p.tochild)
 550     p.tochild.close()
 551     diff_str = p.fromchild.read().rstrip()
 552     if p.wait():
 553         raise GitException, 'git.diffstat failed'
 554     return diff_str
 555
 556 def files(rev1, rev2):
 557     """Return the files modified between rev1 and rev2
 558     """
 559
 560     result = ''
 561     for line in _output_lines('git-diff-tree -r %s %s' % (rev1, rev2)):
 562         result += '%s %s\n' % tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
 563
 564     return result.rstrip()
 565
 566 def barefiles(rev1, rev2):
 567     """Return the files modified between rev1 and rev2, without status info
 568     """
 569
 570     result = ''
 571     for line in _output_lines('git-diff-tree -r %s %s' % (rev1, rev2)):
 572         result += '%s\n' % line.rstrip().split(' ',4)[-1].split('\t',1)[-1]
 573
 574     return result.rstrip()
 575
 576 def checkout(files = None, tree_id = None, force = False):
 577     """Check out the given or all files
 578     """
 579     if not files:
 580         files = []
 581
 582     if tree_id and __run('git-read-tree -m', [tree_id]) != 0:
 583         raise GitException, 'Failed git-read-tree -m %s' % tree_id
 584
 585     checkout_cmd = 'git-checkout-index -q -u'
 586     if force:
 587         checkout_cmd += ' -f'
 588     if len(files) == 0:
 589         checkout_cmd += ' -a'
 590     else:
 591         checkout_cmd += ' --'
 592
 593     if __run(checkout_cmd, files) != 0:
 594         raise GitException, 'Failed git-checkout-index'
 595
 596 def switch(tree_id):
 597     """Switch the tree to the given id
 598     """
 599     refresh_index()
 600     if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
 601         raise GitException, 'git-read-tree failed (local changes maybe?)'
 602
 603     __set_head(tree_id)
 604
 605 def reset(files = None, tree_id = None):
 606     """Revert the tree changes relative to the given tree_id. It removes
 607     any local changes
 608     """
 609     if not tree_id:
 610         tree_id = get_head()
 611
 612     checkout(files, tree_id, True)
 613
 614     # if the reset refers to the whole tree, switch the HEAD as well
 615     if not files:
 616         __set_head(tree_id)
 617
 618 def pull(repository = 'origin', refspec = None):
 619     """Pull changes from the remote repository. At the moment, just
 620     use the 'git pull' command
 621     """
 622     # 'git pull' updates the HEAD
 623     __clear_head_cache()
 624
 625     args = [repository]
 626     if refspec:
 627         args.append(refspec)
 628
 629     if __run('git pull', args) != 0:
 630         raise GitException, 'Failed "git pull %s"' % repository
 631
 632 def apply_patch(filename = None, base = None):
 633     """Apply a patch onto the current or given index. There must not
 634     be any local changes in the tree, otherwise the command fails
 635     """
 636     def __apply_patch():
 637         if filename:
 638             return __run('git-apply --index', [filename]) == 0
 639         else:
 640             try:
 641                 _input('git-apply --index', sys.stdin)
 642             except GitException:
 643                 return False
 644             return True
 645
 646     if base:
 647         orig_head = get_head()
 648         switch(base)
 649     else:
 650         refresh_index()         # needed since __apply_patch() doesn't do it
 651
 652     if not __apply_patch():
 653         if base:
 654             switch(orig_head)
 655         raise GitException, 'Patch does not apply cleanly'
 656     elif base:
 657         top = commit(message = 'temporary commit used for applying a patch',
 658                      parents = [base])
 659         switch(orig_head)
 660         merge(base, orig_head, top)
 661
 662 def clone(repository, local_dir):
 663     """Clone a remote repository. At the moment, just use the
 664     'git clone' script
 665     """
 666     if __run('git clone', [repository, local_dir]) != 0:
 667         raise GitException, 'Failed "git clone %s %s"' \
 668               % (repository, local_dir)
 669
 670 def modifying_revs(files, base_rev):
 671     """Return the revisions from the list modifying the given files
 672     """
 673     cmd = ['git-rev-list', '%s..' % base_rev, '--']
 674     revs = [line.strip() for line in _output_lines(cmd + files)]
 675
 676     return revs