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, re, gitmergeonefile
  22 from shutil import copyfile
  23
  24 from stgit import basedir
  25 from stgit.utils import *
  26 from stgit.config import config
  27 from sets import Set
  28
  29 # git exception class
  30 class GitException(Exception):
  31     pass
  32
  33
  34
  35 #
  36 # Classes
  37 #
  38
  39 class Person:
  40     """An author, committer, etc."""
  41     def __init__(self, name = None, email = None, date = '',
  42                  desc = None):
  43         self.name = self.email = self.date = None
  44         if name or email or date:
  45             assert not desc
  46             self.name = name
  47             self.email = email
  48             self.date = date
  49         elif desc:
  50             assert not (name or email or date)
  51             def parse_desc(s):
  52                 m = re.match(r'^(.+)<(.+)>(.*)$', s)
  53                 assert m
  54                 return [x.strip() or None for x in m.groups()]
  55             self.name, self.email, self.date = parse_desc(desc)
  56     def set_name(self, val):
  57         if val:
  58             self.name = val
  59     def set_email(self, val):
  60         if val:
  61             self.email = val
  62     def set_date(self, val):
  63         if val:
  64             self.date = val
  65     def __str__(self):
  66         if self.name and self.email:
  67             return '%s <%s>' % (self.name, self.email)
  68         else:
  69             raise GitException, 'not enough identity data'
  70
  71 class Commit:
  72     """Handle the commit objects
  73     """
  74     def __init__(self, id_hash):
  75         self.__id_hash = id_hash
  76
  77         lines = _output_lines('git-cat-file commit %s' % id_hash)
  78         for i in range(len(lines)):
  79             line = lines[i]
  80             if line == '\n':
  81                 break
  82             field = line.strip().split(' ', 1)
  83             if field[0] == 'tree':
  84                 self.__tree = field[1]
  85             if field[0] == 'author':
  86                 self.__author = field[1]
  87             if field[0] == 'committer':
  88                 self.__committer = field[1]
  89         self.__log = ''.join(lines[i+1:])
  90
  91     def get_id_hash(self):
  92         return self.__id_hash
  93
  94     def get_tree(self):
  95         return self.__tree
  96
  97     def get_parent(self):
  98         parents = self.get_parents()
  99         if parents:
 100             return parents[0]
 101         else:
 102             return None
 103
 104     def get_parents(self):
 105         return _output_lines('git-rev-list --parents --max-count=1 %s'
 106                              % self.__id_hash)[0].split()[1:]
 107
 108     def get_author(self):
 109         return self.__author
 110
 111     def get_committer(self):
 112         return self.__committer
 113
 114     def get_log(self):
 115         return self.__log
 116
 117     def __str__(self):
 118         return self.get_id_hash()
 119
 120 # dictionary of Commit objects, used to avoid multiple calls to git
 121 __commits = dict()
 122
 123 #
 124 # Functions
 125 #
 126
 127 def get_commit(id_hash):
 128     """Commit objects factory. Save/look-up them in the __commits
 129     dictionary
 130     """
 131     global __commits
 132
 133     if id_hash in __commits:
 134         return __commits[id_hash]
 135     else:
 136         commit = Commit(id_hash)
 137         __commits[id_hash] = commit
 138         return commit
 139
 140 def get_conflicts():
 141     """Return the list of file conflicts
 142     """
 143     conflicts_file = os.path.join(basedir.get(), 'conflicts')
 144     if os.path.isfile(conflicts_file):
 145         f = file(conflicts_file)
 146         names = [line.strip() for line in f.readlines()]
 147         f.close()
 148         return names
 149     else:
 150         return None
 151
 152 def _input(cmd, file_desc):
 153     p = popen2.Popen3(cmd, True)
 154     while True:
 155         line = file_desc.readline()
 156         if not line:
 157             break
 158         p.tochild.write(line)
 159     p.tochild.close()
 160     if p.wait():
 161         raise GitException, '%s failed (%s)' % (str(cmd),
 162                                                 p.childerr.read().strip())
 163
 164 def _input_str(cmd, string):
 165     p = popen2.Popen3(cmd, True)
 166     p.tochild.write(string)
 167     p.tochild.close()
 168     if p.wait():
 169         raise GitException, '%s failed (%s)' % (str(cmd),
 170                                                 p.childerr.read().strip())
 171
 172 def _output(cmd):
 173     p=popen2.Popen3(cmd, True)
 174     output = p.fromchild.read()
 175     if p.wait():
 176         raise GitException, '%s failed (%s)' % (str(cmd),
 177                                                 p.childerr.read().strip())
 178     return output
 179
 180 def _output_one_line(cmd, file_desc = None):
 181     p=popen2.Popen3(cmd, True)
 182     if file_desc != None:
 183         for line in file_desc:
 184             p.tochild.write(line)
 185         p.tochild.close()
 186     output = p.fromchild.readline().strip()
 187     if p.wait():
 188         raise GitException, '%s failed (%s)' % (str(cmd),
 189                                                 p.childerr.read().strip())
 190     return output
 191
 192 def _output_lines(cmd):
 193     p=popen2.Popen3(cmd, True)
 194     lines = p.fromchild.readlines()
 195     if p.wait():
 196         raise GitException, '%s failed (%s)' % (str(cmd),
 197                                                 p.childerr.read().strip())
 198     return lines
 199
 200 def __run(cmd, args=None):
 201     """__run: runs cmd using spawnvp.
 202
 203     Runs cmd using spawnvp.  The shell is avoided so it won't mess up
 204     our arguments.  If args is very large, the command is run multiple
 205     times; args is split xargs style: cmd is passed on each
 206     invocation.  Unlike xargs, returns immediately if any non-zero
 207     return code is received.
 208     """
 209
 210     args_l=cmd.split()
 211     if args is None:
 212         args = []
 213     for i in range(0, len(args)+1, 100):
 214         r=os.spawnvp(os.P_WAIT, args_l[0], args_l + args[i:min(i+100, len(args))])
 215     if r:
 216         return r
 217     return 0
 218
 219 def __tree_status(files = None, tree_id = 'HEAD', unknown = False,
 220                   noexclude = True, verbose = False):
 221     """Returns a list of pairs - [status, filename]
 222     """
 223     if verbose and sys.stdout.isatty():
 224         print 'Checking for changes in the working directory...',
 225         sys.stdout.flush()
 226
 227     refresh_index()
 228
 229     if not files:
 230         files = []
 231     cache_files = []
 232
 233     # unknown files
 234     if unknown:
 235         exclude_file = os.path.join(basedir.get(), 'info', 'exclude')
 236         base_exclude = ['--exclude=%s' % s for s in
 237                         ['*.[ao]', '*.pyc', '.*', '*~', '#*', 'TAGS', 'tags']]
 238         base_exclude.append('--exclude-per-directory=.gitignore')
 239
 240         if os.path.exists(exclude_file):
 241             extra_exclude = ['--exclude-from=%s' % exclude_file]
 242         else:
 243             extra_exclude = []
 244         if noexclude:
 245             extra_exclude = base_exclude = []
 246
 247         lines = _output_lines(['git-ls-files', '--others', '--directory']
 248                         + base_exclude + extra_exclude)
 249         cache_files += [('?', line.strip()) for line in lines]
 250
 251     # conflicted files
 252     conflicts = get_conflicts()
 253     if not conflicts:
 254         conflicts = []
 255     cache_files += [('C', filename) for filename in conflicts]
 256
 257     # the rest
 258     for line in _output_lines(['git-diff-index', tree_id, '--'] + files):
 259         fs = tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
 260         if fs[1] not in conflicts:
 261             cache_files.append(fs)
 262
 263     if verbose and sys.stdout.isatty():
 264         print 'done'
 265
 266     return cache_files
 267
 268 def local_changes(verbose = True):
 269     """Return true if there are local changes in the tree
 270     """
 271     return len(__tree_status(verbose = verbose)) != 0
 272
 273 # HEAD value cached
 274 __head = None
 275
 276 def get_head():
 277     """Verifies the HEAD and returns the SHA1 id that represents it
 278     """
 279     global __head
 280
 281     if not __head:
 282         __head = rev_parse('HEAD')
 283     return __head
 284
 285 def get_head_file():
 286     """Returns the name of the file pointed to by the HEAD link
 287     """
 288     return strip_prefix('refs/heads/',
 289                         _output_one_line('git-symbolic-ref HEAD'))
 290
 291 def set_head_file(ref):
 292     """Resets HEAD to point to a new ref
 293     """
 294     # head cache flushing is needed since we might have a different value
 295     # in the new head
 296     __clear_head_cache()
 297     if __run('git-symbolic-ref HEAD',
 298              [os.path.join('refs', 'heads', ref)]) != 0:
 299         raise GitException, 'Could not set head to "%s"' % ref
 300
 301 def __set_head(val):
 302     """Sets the HEAD value
 303     """
 304     global __head
 305
 306     if not __head or __head != val:
 307         if __run('git-update-ref HEAD', [val]) != 0:
 308             raise GitException, 'Could not update HEAD to "%s".' % val
 309         __head = val
 310
 311     # only allow SHA1 hashes
 312     assert(len(__head) == 40)
 313
 314 def __clear_head_cache():
 315     """Sets the __head to None so that a re-read is forced
 316     """
 317     global __head
 318
 319     __head = None
 320
 321 def refresh_index():
 322     """Refresh index with stat() information from the working directory.
 323     """
 324     __run('git-update-index -q --unmerged --refresh')
 325
 326 def rev_parse(git_id):
 327     """Parse the string and return a verified SHA1 id
 328     """
 329     try:
 330         return _output_one_line(['git-rev-parse', '--verify', git_id])
 331     except GitException:
 332         raise GitException, 'Unknown revision: %s' % git_id
 333
 334 def branch_exists(branch):
 335     """Existence check for the named branch
 336     """
 337     branch = os.path.join('refs', 'heads', branch)
 338     for line in _output_lines('git-rev-parse --symbolic --all 2>&1'):
 339         if line.strip() == branch:
 340             return True
 341         if re.compile('[ |/]'+branch+' ').search(line):
 342             raise GitException, 'Bogus branch: %s' % line
 343     return False
 344
 345 def create_branch(new_branch, tree_id = None):
 346     """Create a new branch in the git repository
 347     """
 348     if branch_exists(new_branch):
 349         raise GitException, 'Branch "%s" already exists' % new_branch
 350
 351     current_head = get_head()
 352     set_head_file(new_branch)
 353     __set_head(current_head)
 354
 355     # a checkout isn't needed if new branch points to the current head
 356     if tree_id:
 357         switch(tree_id)
 358
 359     if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
 360         os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
 361
 362 def switch_branch(new_branch):
 363     """Switch to a git branch
 364     """
 365     global __head
 366
 367     if not branch_exists(new_branch):
 368         raise GitException, 'Branch "%s" does not exist' % new_branch
 369
 370     tree_id = rev_parse(os.path.join('refs', 'heads', new_branch)
 371                         + '^{commit}')
 372     if tree_id != get_head():
 373         refresh_index()
 374         if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
 375             raise GitException, 'git-read-tree failed (local changes maybe?)'
 376         __head = tree_id
 377     set_head_file(new_branch)
 378
 379     if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
 380         os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
 381
 382 def delete_branch(name):
 383     """Delete a git branch
 384     """
 385     if not branch_exists(name):
 386         raise GitException, 'Branch "%s" does not exist' % name
 387     remove_file_and_dirs(os.path.join(basedir.get(), 'refs', 'heads'),
 388                          name)
 389
 390 def rename_branch(from_name, to_name):
 391     """Rename a git branch
 392     """
 393     if not branch_exists(from_name):
 394         raise GitException, 'Branch "%s" does not exist' % from_name
 395     if branch_exists(to_name):
 396         raise GitException, 'Branch "%s" already exists' % to_name
 397
 398     if get_head_file() == from_name:
 399         set_head_file(to_name)
 400     rename(os.path.join(basedir.get(), 'refs', 'heads'),
 401            from_name, to_name)
 402
 403     reflog_dir = os.path.join(basedir.get(), 'logs', 'refs', 'heads')
 404     if os.path.exists(reflog_dir) \
 405            and os.path.exists(os.path.join(reflog_dir, from_name)):
 406         rename(reflog_dir, from_name, to_name)
 407
 408 def add(names):
 409     """Add the files or recursively add the directory contents
 410     """
 411     # generate the file list
 412     files = []
 413     for i in names:
 414         if not os.path.exists(i):
 415             raise GitException, 'Unknown file or directory: %s' % i
 416
 417         if os.path.isdir(i):
 418             # recursive search. We only add files
 419             for root, dirs, local_files in os.walk(i):
 420                 for name in [os.path.join(root, f) for f in local_files]:
 421                     if os.path.isfile(name):
 422                         files.append(os.path.normpath(name))
 423         elif os.path.isfile(i):
 424             files.append(os.path.normpath(i))
 425         else:
 426             raise GitException, '%s is not a file or directory' % i
 427
 428     if files:
 429         if __run('git-update-index --add --', files):
 430             raise GitException, 'Unable to add file'
 431
 432 def __copy_single(source, target, target2=''):
 433     """Copy file or dir named 'source' to name target+target2"""
 434
 435     # "source" (file or dir) must match one or more git-controlled file
 436     realfiles = _output_lines(['git-ls-files', source])
 437     if len(realfiles) == 0:
 438         raise GitException, '"%s" matches no git-controled files' % source
 439
 440     if os.path.isdir(source):
 441         # physically copy the files, and record them to add them in one run
 442         newfiles = []
 443         re_string='^'+source+'/(.*)$'
 444         prefix_regexp = re.compile(re_string)
 445         for f in [f.strip() for f in realfiles]:
 446             m = prefix_regexp.match(f)
 447             if not m:
 448                 print '"%s" does not match "%s"' % (f, re_string)
 449                 assert(m)
 450             newname = target+target2+'/'+m.group(1)
 451             if not os.path.exists(os.path.dirname(newname)):
 452                 os.makedirs(os.path.dirname(newname))
 453             copyfile(f, newname)
 454             newfiles.append(newname)
 455
 456         add(newfiles)
 457     else: # files, symlinks, ...
 458         newname = target+target2
 459         copyfile(source, newname)
 460         add([newname])
 461
 462
 463 def copy(filespecs, target):
 464     if os.path.isdir(target):
 465         # target is a directory: copy each entry on the command line,
 466         # with the same name, into the target
 467         for filespec in filespecs:
 468             filespec = filespec.rstrip('/')
 469             basename = '/' + os.path.basename(filespec)
 470             __copy_single(filespec, target, basename)
 471
 472     elif os.path.exists(target):
 473         raise GitException, 'Target "%s" exists but is not a directory' % target
 474     elif len(filespecs) != 1:
 475         raise GitException, 'Cannot copy more than one file to non-directory'
 476
 477     else:
 478         # at this point: len(filespecs)==1 and target does not exist
 479
 480         # check target directory
 481         targetdir = os.path.dirname(target)
 482         if targetdir != '' and not os.path.isdir(targetdir):
 483             raise GitException, 'Target directory "%s" does not exist' % targetdir
 484
 485         __copy_single(filespecs[0].rstrip('/'), target)
 486
 487
 488 def rm(files, force = False):
 489     """Remove a file from the repository
 490     """
 491     if not force:
 492         for f in files:
 493             if os.path.exists(f):
 494                 raise GitException, '%s exists. Remove it first' %f
 495         if files:
 496             __run('git-update-index --remove --', files)
 497     else:
 498         if files:
 499             __run('git-update-index --force-remove --', files)
 500
 501 # Persons caching
 502 __user = None
 503 __author = None
 504 __committer = None
 505
 506 def user():
 507     """Return the user information.
 508     """
 509     global __user
 510     if not __user:
 511         name=config.get('user.name')
 512         email=config.get('user.email')
 513         __user = Person(name, email)
 514     return __user;
 515
 516 def author():
 517     """Return the author information.
 518     """
 519     global __author
 520     if not __author:
 521         try:
 522             # the environment variables take priority over config
 523             try:
 524                 date = os.environ['GIT_AUTHOR_DATE']
 525             except KeyError:
 526                 date = ''
 527             __author = Person(os.environ['GIT_AUTHOR_NAME'],
 528                               os.environ['GIT_AUTHOR_EMAIL'],
 529                               date)
 530         except KeyError:
 531             __author = user()
 532     return __author
 533
 534 def committer():
 535     """Return the author information.
 536     """
 537     global __committer
 538     if not __committer:
 539         try:
 540             # the environment variables take priority over config
 541             try:
 542                 date = os.environ['GIT_COMMITTER_DATE']
 543             except KeyError:
 544                 date = ''
 545             __committer = Person(os.environ['GIT_COMMITTER_NAME'],
 546                                  os.environ['GIT_COMMITTER_EMAIL'],
 547                                  date)
 548         except KeyError:
 549             __committer = user()
 550     return __committer
 551
 552 def update_cache(files = None, force = False):
 553     """Update the cache information for the given files
 554     """
 555     if not files:
 556         files = []
 557
 558     cache_files = __tree_status(files, verbose = False)
 559
 560     # everything is up-to-date
 561     if len(cache_files) == 0:
 562         return False
 563
 564     # check for unresolved conflicts
 565     if not force and [x for x in cache_files
 566                       if x[0] not in ['M', 'N', 'A', 'D']]:
 567         raise GitException, 'Updating cache failed: unresolved conflicts'
 568
 569     # update the cache
 570     add_files = [x[1] for x in cache_files if x[0] in ['N', 'A']]
 571     rm_files =  [x[1] for x in cache_files if x[0] in ['D']]
 572     m_files =   [x[1] for x in cache_files if x[0] in ['M']]
 573
 574     if add_files and __run('git-update-index --add --', add_files) != 0:
 575         raise GitException, 'Failed git-update-index --add'
 576     if rm_files and __run('git-update-index --force-remove --', rm_files) != 0:
 577         raise GitException, 'Failed git-update-index --rm'
 578     if m_files and __run('git-update-index --', m_files) != 0:
 579         raise GitException, 'Failed git-update-index'
 580
 581     return True
 582
 583 def commit(message, files = None, parents = None, allowempty = False,
 584            cache_update = True, tree_id = None,
 585            author_name = None, author_email = None, author_date = None,
 586            committer_name = None, committer_email = None):
 587     """Commit the current tree to repository
 588     """
 589     if not files:
 590         files = []
 591     if not parents:
 592         parents = []
 593
 594     # Get the tree status
 595     if cache_update and parents != []:
 596         changes = update_cache(files)
 597         if not changes and not allowempty:
 598             raise GitException, 'No changes to commit'
 599
 600     # get the commit message
 601     if not message:
 602         message = '\n'
 603     elif message[-1:] != '\n':
 604         message += '\n'
 605
 606     must_switch = True
 607     # write the index to repository
 608     if tree_id == None:
 609         tree_id = _output_one_line('git-write-tree')
 610     else:
 611         must_switch = False
 612
 613     # the commit
 614     cmd = ''
 615     if author_name:
 616         cmd += 'GIT_AUTHOR_NAME="%s" ' % author_name
 617     if author_email:
 618         cmd += 'GIT_AUTHOR_EMAIL="%s" ' % author_email
 619     if author_date:
 620         cmd += 'GIT_AUTHOR_DATE="%s" ' % author_date
 621     if committer_name:
 622         cmd += 'GIT_COMMITTER_NAME="%s" ' % committer_name
 623     if committer_email:
 624         cmd += 'GIT_COMMITTER_EMAIL="%s" ' % committer_email
 625     cmd += 'git-commit-tree %s' % tree_id
 626
 627     # get the parents
 628     for p in parents:
 629         cmd += ' -p %s' % p
 630
 631     commit_id = _output_one_line(cmd, message)
 632     if must_switch:
 633         __set_head(commit_id)
 634
 635     return commit_id
 636
 637 def apply_diff(rev1, rev2, check_index = True, files = None):
 638     """Apply the diff between rev1 and rev2 onto the current
 639     index. This function doesn't need to raise an exception since it
 640     is only used for fast-pushing a patch. If this operation fails,
 641     the pushing would fall back to the three-way merge.
 642     """
 643     if check_index:
 644         index_opt = '--index'
 645     else:
 646         index_opt = ''
 647
 648     if not files:
 649         files = []
 650
 651     diff_str = diff(files, rev1, rev2)
 652     if diff_str:
 653         try:
 654             _input_str('git-apply %s' % index_opt, diff_str)
 655         except GitException:
 656             return False
 657
 658     return True
 659
 660 def merge(base, head1, head2, recursive = False):
 661     """Perform a 3-way merge between base, head1 and head2 into the
 662     local tree
 663     """
 664     refresh_index()
 665
 666     if recursive:
 667         # this operation tracks renames but it is slower (used in
 668         # general when pushing or picking patches)
 669         try:
 670             # use _output() to mask the verbose prints of the tool
 671             _output('git-merge-recursive %s -- %s %s' % (base, head1, head2))
 672         except GitException:
 673             pass
 674     else:
 675         # the fast case where we don't track renames (used when the
 676         # distance between base and heads is small, i.e. folding or
 677         # synchronising patches)
 678         if __run('git-read-tree -u -m --aggressive',
 679                  [base, head1, head2]) != 0:
 680             raise GitException, 'git-read-tree failed (local changes maybe?)'
 681
 682     # check the index for unmerged entries
 683     files = {}
 684     stages_re = re.compile('^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
 685
 686     for line in _output('git-ls-files --unmerged --stage -z').split('\0'):
 687         if not line:
 688             continue
 689
 690         mode, hash, stage, path = stages_re.findall(line)[0]
 691
 692         if not path in files:
 693             files[path] = {}
 694             files[path]['1'] = ('', '')
 695             files[path]['2'] = ('', '')
 696             files[path]['3'] = ('', '')
 697
 698         files[path][stage] = (mode, hash)
 699
 700     # merge the unmerged files
 701     errors = False
 702     for path in files:
 703         # remove additional files that might be generated for some
 704         # newer versions of GIT
 705         for suffix in [base, head1, head2]:
 706             if not suffix:
 707                 continue
 708             fname = path + '~' + suffix
 709             if os.path.exists(fname):
 710                 os.remove(fname)
 711
 712         stages = files[path]
 713         if gitmergeonefile.merge(stages['1'][1], stages['2'][1],
 714                                  stages['3'][1], path, stages['1'][0],
 715                                  stages['2'][0], stages['3'][0]) != 0:
 716             errors = True
 717
 718     if errors:
 719         raise GitException, 'GIT index merging failed (possible conflicts)'
 720
 721 def status(files = None, modified = False, new = False, deleted = False,
 722            conflict = False, unknown = False, noexclude = False):
 723     """Show the tree status
 724     """
 725     if not files:
 726         files = []
 727
 728     cache_files = __tree_status(files, unknown = True, noexclude = noexclude)
 729     all = not (modified or new or deleted or conflict or unknown)
 730
 731     if not all:
 732         filestat = []
 733         if modified:
 734             filestat.append('M')
 735         if new:
 736             filestat.append('A')
 737             filestat.append('N')
 738         if deleted:
 739             filestat.append('D')
 740         if conflict:
 741             filestat.append('C')
 742         if unknown:
 743             filestat.append('?')
 744         cache_files = [x for x in cache_files if x[0] in filestat]
 745
 746     for fs in cache_files:
 747         if files and not fs[1] in files:
 748             continue
 749         if all:
 750             print '%s %s' % (fs[0], fs[1])
 751         else:
 752             print '%s' % fs[1]
 753
 754 def diff(files = None, rev1 = 'HEAD', rev2 = None, out_fd = None):
 755     """Show the diff between rev1 and rev2
 756     """
 757     if not files:
 758         files = []
 759
 760     if rev1 and rev2:
 761         diff_str = _output(['git-diff-tree', '-p', rev1, rev2, '--'] + files)
 762     elif rev1 or rev2:
 763         refresh_index()
 764         if rev2:
 765             diff_str = _output(['git-diff-index', '-p', '-R', rev2, '--'] + files)
 766         else:
 767             diff_str = _output(['git-diff-index', '-p', rev1, '--'] + files)
 768     else:
 769         diff_str = ''
 770
 771     if out_fd:
 772         out_fd.write(diff_str)
 773     else:
 774         return diff_str
 775
 776 def diffstat(files = None, rev1 = 'HEAD', rev2 = None):
 777     """Return the diffstat between rev1 and rev2
 778     """
 779     if not files:
 780         files = []
 781
 782     p=popen2.Popen3('git-apply --stat')
 783     diff(files, rev1, rev2, p.tochild)
 784     p.tochild.close()
 785     diff_str = p.fromchild.read().rstrip()
 786     if p.wait():
 787         raise GitException, 'git.diffstat failed'
 788     return diff_str
 789
 790 def files(rev1, rev2):
 791     """Return the files modified between rev1 and rev2
 792     """
 793
 794     result = ''
 795     for line in _output_lines('git-diff-tree -r %s %s' % (rev1, rev2)):
 796         result += '%s %s\n' % tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
 797
 798     return result.rstrip()
 799
 800 def barefiles(rev1, rev2):
 801     """Return the files modified between rev1 and rev2, without status info
 802     """
 803
 804     result = ''
 805     for line in _output_lines('git-diff-tree -r %s %s' % (rev1, rev2)):
 806         result += '%s\n' % line.rstrip().split(' ',4)[-1].split('\t',1)[-1]
 807
 808     return result.rstrip()
 809
 810 def pretty_commit(commit_id = 'HEAD'):
 811     """Return a given commit (log + diff)
 812     """
 813     return _output(['git-diff-tree', '--cc', '--always', '--pretty', '-r',
 814                     commit_id])
 815
 816 def checkout(files = None, tree_id = None, force = False):
 817     """Check out the given or all files
 818     """
 819     if not files:
 820         files = []
 821
 822     if tree_id and __run('git-read-tree --reset', [tree_id]) != 0:
 823         raise GitException, 'Failed git-read-tree --reset %s' % tree_id
 824
 825     checkout_cmd = 'git-checkout-index -q -u'
 826     if force:
 827         checkout_cmd += ' -f'
 828     if len(files) == 0:
 829         checkout_cmd += ' -a'
 830     else:
 831         checkout_cmd += ' --'
 832
 833     if __run(checkout_cmd, files) != 0:
 834         raise GitException, 'Failed git-checkout-index'
 835
 836 def switch(tree_id, keep = False):
 837     """Switch the tree to the given id
 838     """
 839     if not keep:
 840         refresh_index()
 841         if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
 842             raise GitException, 'git-read-tree failed (local changes maybe?)'
 843
 844     __set_head(tree_id)
 845
 846 def reset(files = None, tree_id = None, check_out = True):
 847     """Revert the tree changes relative to the given tree_id. It removes
 848     any local changes
 849     """
 850     if not tree_id:
 851         tree_id = get_head()
 852
 853     if check_out:
 854         cache_files = __tree_status(files, tree_id)
 855         # files which were added but need to be removed
 856         rm_files =  [x[1] for x in cache_files if x[0] in ['A']]
 857
 858         checkout(files, tree_id, True)
 859         # checkout doesn't remove files
 860         map(os.remove, rm_files)
 861
 862     # if the reset refers to the whole tree, switch the HEAD as well
 863     if not files:
 864         __set_head(tree_id)
 865
 866 def fetch(repository = 'origin', refspec = None):
 867     """Fetches changes from the remote repository, using 'git-fetch'
 868     by default.
 869     """
 870     # we update the HEAD
 871     __clear_head_cache()
 872
 873     args = [repository]
 874     if refspec:
 875         args.append(refspec)
 876
 877     command = config.get('branch.%s.stgit.fetchcmd' % get_head_file()) or \
 878               config.get('stgit.fetchcmd')
 879     if __run(command, args) != 0:
 880         raise GitException, 'Failed "%s %s"' % (command, repository)
 881
 882 def pull(repository = 'origin', refspec = None):
 883     """Fetches changes from the remote repository, using 'git-pull'
 884     by default.
 885     """
 886     # we update the HEAD
 887     __clear_head_cache()
 888
 889     args = [repository]
 890     if refspec:
 891         args.append(refspec)
 892
 893     command = config.get('branch.%s.stgit.pullcmd' % get_head_file()) or \
 894               config.get('stgit.pullcmd')
 895     if __run(command, args) != 0:
 896         raise GitException, 'Failed "%s %s"' % (command, repository)
 897
 898 def repack():
 899     """Repack all objects into a single pack
 900     """
 901     __run('git-repack -a -d -f')
 902
 903 def apply_patch(filename = None, diff = None, base = None,
 904                 fail_dump = True):
 905     """Apply a patch onto the current or given index. There must not
 906     be any local changes in the tree, otherwise the command fails
 907     """
 908     if diff is None:
 909         if filename:
 910             f = file(filename)
 911         else:
 912             f = sys.stdin
 913         diff = f.read()
 914         if filename:
 915             f.close()
 916
 917     if base:
 918         orig_head = get_head()
 919         switch(base)
 920     else:
 921         refresh_index()
 922
 923     try:
 924         _input_str('git-apply --index', diff)
 925     except GitException:
 926         if base:
 927             switch(orig_head)
 928         if fail_dump:
 929             # write the failed diff to a file
 930             f = file('.stgit-failed.patch', 'w+')
 931             f.write(diff)
 932             f.close()
 933             print >> sys.stderr, 'Diff written to the .stgit-failed.patch file'
 934
 935         raise
 936
 937     if base:
 938         top = commit(message = 'temporary commit used for applying a patch',
 939                      parents = [base])
 940         switch(orig_head)
 941         merge(base, orig_head, top)
 942
 943 def clone(repository, local_dir):
 944     """Clone a remote repository. At the moment, just use the
 945     'git-clone' script
 946     """
 947     if __run('git-clone', [repository, local_dir]) != 0:
 948         raise GitException, 'Failed "git-clone %s %s"' \
 949               % (repository, local_dir)
 950
 951 def modifying_revs(files, base_rev, head_rev):
 952     """Return the revisions from the list modifying the given files
 953     """
 954     cmd = ['git-rev-list', '%s..%s' % (base_rev, head_rev), '--']
 955     revs = [line.strip() for line in _output_lines(cmd + files)]
 956
 957     return revs
 958
 959
 960 def refspec_localpart(refspec):
 961     m = re.match('^[^:]*:([^:]*)$', refspec)
 962     if m:
 963         return m.group(1)
 964     else:
 965         raise GitException, 'Cannot parse refspec "%s"' % line
 966
 967 def refspec_remotepart(refspec):
 968     m = re.match('^([^:]*):[^:]*$', refspec)
 969     if m:
 970         return m.group(1)
 971     else:
 972         raise GitException, 'Cannot parse refspec "%s"' % line
 973
 974
 975 def __remotes_from_config():
 976     return config.sections_matching(r'remote\.(.*)\.url')
 977
 978 def __remotes_from_dir(dir):
 979     d = os.path.join(basedir.get(), dir)
 980     if os.path.exists(d):
 981         return os.listdir(d)
 982     else:
 983         return None
 984
 985 def remotes_list():
 986     """Return the list of remotes in the repository
 987     """
 988
 989     return Set(__remotes_from_config()) | \
 990            Set(__remotes_from_dir('remotes')) | \
 991            Set(__remotes_from_dir('branches'))
 992
 993 def remotes_local_branches(remote):
 994     """Returns the list of local branches fetched from given remote
 995     """
 996
 997     branches = []
 998     if remote in __remotes_from_config():
 999         for line in config.getall('remote.%s.fetch' % remote):
1000             branches.append(refspec_localpart(line))
1001     elif remote in __remotes_from_dir('remotes'):
1002         stream = open(os.path.join(basedir.get(), 'remotes', remote), 'r')
1003         for line in stream:
1004             # Only consider Pull lines
1005             m = re.match('^Pull: (.*)\n$', line)
1006             if m:
1007                 branches.append(refspec_localpart(m.group(1)))
1008         stream.close()
1009     elif remote in __remotes_from_dir('branches'):
1010         # old-style branches only declare one branch
1011         branches.append('refs/heads/'+remote);
1012     else:
1013         raise GitException, 'Unknown remote "%s"' % remote
1014
1015     return branches
1016
1017 def identify_remote(branchname):
1018     """Return the name for the remote to pull the given branchname
1019     from, or None if we believe it is a local branch.
1020     """
1021
1022     for remote in remotes_list():
1023         if branchname in remotes_local_branches(remote):
1024             return remote
1025
1026     # if we get here we've found nothing, the branch is a local one
1027     return None
1028
1029 def fetch_head():
1030     """Return the git id for the tip of the parent branch as left by
1031     'git fetch'.
1032     """
1033
1034     fetch_head=None
1035     stream = open(os.path.join(basedir.get(), 'FETCH_HEAD'), "r")
1036     for line in stream:
1037         # Only consider lines not tagged not-for-merge
1038         m = re.match('^([^\t]*)\t\t', line)
1039         if m:
1040             if fetch_head:
1041                 raise GitException, "StGit does not support multiple FETCH_HEAD"
1042             else:
1043                 fetch_head=m.group(1)
1044     stream.close()
1045
1046     # here we are sure to have a single fetch_head
1047     return fetch_head