mdw@git.distorted.org.uk Git - 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, check_index = True):
 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     if check_index:
 475         index_opt = '--index'
 476     else:
 477         index_opt = ''
 478     cmd = 'git-diff-tree -p %s %s | git-apply %s 2> /dev/null' \
 479           % (rev1, rev2, index_opt)
 480
 481     return os.system(cmd) == 0
 482
 483 def merge(base, head1, head2):
 484     """Perform a 3-way merge between base, head1 and head2 into the
 485     local tree
 486     """
 487     refresh_index()
 488     if __run('git-read-tree -u -m', [base, head1, head2]) != 0:
 489         raise GitException, 'git-read-tree failed (local changes maybe?)'
 490
 491     # this can fail if there are conflicts
 492     if __run('git-merge-index -o -q gitmergeonefile.py -a') != 0:
 493         raise GitException, 'git-merge-index failed (possible conflicts)'
 494
 495 def status(files = None, modified = False, new = False, deleted = False,
 496            conflict = False, unknown = False, noexclude = False):
 497     """Show the tree status
 498     """
 499     if not files:
 500         files = []
 501
 502     cache_files = __tree_status(files, unknown = True, noexclude = noexclude)
 503     all = not (modified or new or deleted or conflict or unknown)
 504
 505     if not all:
 506         filestat = []
 507         if modified:
 508             filestat.append('M')
 509         if new:
 510             filestat.append('A')
 511             filestat.append('N')
 512         if deleted:
 513             filestat.append('D')
 514         if conflict:
 515             filestat.append('C')
 516         if unknown:
 517             filestat.append('?')
 518         cache_files = [x for x in cache_files if x[0] in filestat]
 519
 520     for fs in cache_files:
 521         if all:
 522             print '%s %s' % (fs[0], fs[1])
 523         else:
 524             print '%s' % fs[1]
 525
 526 def diff(files = None, rev1 = 'HEAD', rev2 = None, out_fd = None):
 527     """Show the diff between rev1 and rev2
 528     """
 529     if not files:
 530         files = []
 531
 532     if rev1 and rev2:
 533         diff_str = _output(['git-diff-tree', '-p', rev1, rev2] + files)
 534     elif rev1 or rev2:
 535         refresh_index()
 536         if rev2:
 537             diff_str = _output(['git-diff-index', '-p', '-R', rev2] + files)
 538         else:
 539             diff_str = _output(['git-diff-index', '-p', rev1] + files)
 540     else:
 541         diff_str = ''
 542
 543     if out_fd:
 544         out_fd.write(diff_str)
 545     else:
 546         return diff_str
 547
 548 def diffstat(files = None, rev1 = 'HEAD', rev2 = None):
 549     """Return the diffstat between rev1 and rev2
 550     """
 551     if not files:
 552         files = []
 553
 554     p=popen2.Popen3('git-apply --stat')
 555     diff(files, rev1, rev2, p.tochild)
 556     p.tochild.close()
 557     diff_str = p.fromchild.read().rstrip()
 558     if p.wait():
 559         raise GitException, 'git.diffstat failed'
 560     return diff_str
 561
 562 def files(rev1, rev2):
 563     """Return the files modified between rev1 and rev2
 564     """
 565
 566     result = ''
 567     for line in _output_lines('git-diff-tree -r %s %s' % (rev1, rev2)):
 568         result += '%s %s\n' % tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
 569
 570     return result.rstrip()
 571
 572 def barefiles(rev1, rev2):
 573     """Return the files modified between rev1 and rev2, without status info
 574     """
 575
 576     result = ''
 577     for line in _output_lines('git-diff-tree -r %s %s' % (rev1, rev2)):
 578         result += '%s\n' % line.rstrip().split(' ',4)[-1].split('\t',1)[-1]
 579
 580     return result.rstrip()
 581
 582 def checkout(files = None, tree_id = None, force = False):
 583     """Check out the given or all files
 584     """
 585     if not files:
 586         files = []
 587
 588     if tree_id and __run('git-read-tree -m', [tree_id]) != 0:
 589         raise GitException, 'Failed git-read-tree -m %s' % tree_id
 590
 591     checkout_cmd = 'git-checkout-index -q -u'
 592     if force:
 593         checkout_cmd += ' -f'
 594     if len(files) == 0:
 595         checkout_cmd += ' -a'
 596     else:
 597         checkout_cmd += ' --'
 598
 599     if __run(checkout_cmd, files) != 0:
 600         raise GitException, 'Failed git-checkout-index'
 601
 602 def switch(tree_id):
 603     """Switch the tree to the given id
 604     """
 605     refresh_index()
 606     if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
 607         raise GitException, 'git-read-tree failed (local changes maybe?)'
 608
 609     __set_head(tree_id)
 610
 611 def reset(files = None, tree_id = None):
 612     """Revert the tree changes relative to the given tree_id. It removes
 613     any local changes
 614     """
 615     if not tree_id:
 616         tree_id = get_head()
 617
 618     checkout(files, tree_id, True)
 619
 620     # if the reset refers to the whole tree, switch the HEAD as well
 621     if not files:
 622         __set_head(tree_id)
 623
 624 def pull(repository = 'origin', refspec = None):
 625     """Pull changes from the remote repository. At the moment, just
 626     use the 'git pull' command
 627     """
 628     # 'git pull' updates the HEAD
 629     __clear_head_cache()
 630
 631     args = [repository]
 632     if refspec:
 633         args.append(refspec)
 634
 635     if __run('git pull', args) != 0:
 636         raise GitException, 'Failed "git pull %s"' % repository
 637
 638 def apply_patch(filename = None, base = None):
 639     """Apply a patch onto the current or given index. There must not
 640     be any local changes in the tree, otherwise the command fails
 641     """
 642     def __apply_patch():
 643         if filename:
 644             return __run('git-apply --index', [filename]) == 0
 645         else:
 646             try:
 647                 _input('git-apply --index', sys.stdin)
 648             except GitException:
 649                 return False
 650             return True
 651
 652     if base:
 653         orig_head = get_head()
 654         switch(base)
 655     else:
 656         refresh_index()         # needed since __apply_patch() doesn't do it
 657
 658     if not __apply_patch():
 659         if base:
 660             switch(orig_head)
 661         raise GitException, 'Patch does not apply cleanly'
 662     elif base:
 663         top = commit(message = 'temporary commit used for applying a patch',
 664                      parents = [base])
 665         switch(orig_head)
 666         merge(base, orig_head, top)
 667
 668 def clone(repository, local_dir):
 669     """Clone a remote repository. At the moment, just use the
 670     'git clone' script
 671     """
 672     if __run('git clone', [repository, local_dir]) != 0:
 673         raise GitException, 'Failed "git clone %s %s"' \
 674               % (repository, local_dir)
 675
 676 def modifying_revs(files, base_rev):
 677     """Return the revisions from the list modifying the given files
 678     """
 679     cmd = ['git-rev-list', '%s..' % base_rev, '--']
 680     revs = [line.strip() for line in _output_lines(cmd + files)]
 681
 682     return revs