Fix "stg resolved" to work with new conflict representation

[stgit] / stgit / git.py

diff --git a/stgit/git.py b/stgit/git.py
index 6c96a1682a5a975583f8aaa8edea776894f6e908..6629e395ab5de48e26e5b50c06b870de2cc255f1 100644 (file)
--- a/stgit/git.py
+++ b/stgit/git.py
@@ -18,19 +18,39 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 """
 

-import sys, os, popen2, re, gitmergeonefile
+import sys, os, re, gitmergeonefile

 from shutil import copyfile
 
 from shutil import copyfile
 

+from stgit.exception import *

 from stgit import basedir
 from stgit.utils import *
 from stgit import basedir
 from stgit.utils import *

+from stgit.out import *
+from stgit.run import *

 from stgit.config import config
 from stgit.config import config

-from sets import Set

 
 # git exception class
 
 # git exception class

-class GitException(Exception):
+class GitException(StgException):

     pass
 
     pass
 

-
+# When a subprocess has a problem, we want the exception to be a
+# subclass of GitException.
+class GitRunException(GitException):
+    pass
+class GRun(Run):
+    exc = GitRunException
+    def __init__(self, *cmd):
+        """Initialise the Run object and insert the 'git' command name.
+        """
+        Run.__init__(self, 'git', *cmd)
+
+class GitConflictException(GitException):
+    def __init__(self, conflicts):
+        GitException.__init__(self)
+        self.conflicts = conflicts
+    def __str__(self):
+        return "%d conflicts" % len(self.conflicts)
+    def list(self):
+        out.info(*self.conflicts)

 
 #
 # Classes
 
 #
 # Classes


@@ -74,19 +94,21 @@ class Commit:
     def __init__(self, id_hash):
         self.__id_hash = id_hash
 
     def __init__(self, id_hash):
         self.__id_hash = id_hash
 

-        lines = _output_lines(['git-cat-file', 'commit', id_hash])
+        lines = GRun('cat-file', 'commit', id_hash).output_lines()

         for i in range(len(lines)):
             line = lines[i]
         for i in range(len(lines)):
             line = lines[i]

-            if line == '\n':
-                break
-            field = line.strip().split(' ', 1)
-            if field[0] == 'tree':
-                self.__tree = field[1]
-            if field[0] == 'author':
-                self.__author = field[1]
-            if field[0] == 'committer':
-                self.__committer = field[1]
-        self.__log = ''.join(lines[i+1:])
+            if not line:
+                break # we've seen all the header fields
+            key, val = line.split(' ', 1)
+            if key == 'tree':
+                self.__tree = val
+            elif key == 'author':
+                self.__author = val
+            elif key == 'committer':
+                self.__committer = val
+            else:
+                pass # ignore other headers
+        self.__log = '\n'.join(lines[i+1:])

 
     def get_id_hash(self):
         return self.__id_hash
 
     def get_id_hash(self):
         return self.__id_hash


@@ -102,8 +124,8 @@ class Commit:
             return None
 
     def get_parents(self):
             return None
 
     def get_parents(self):

-        return _output_lines(['git-rev-list', '--parents', '--max-count=1',
-                              self.__id_hash])[0].split()[1:]
+        return GRun('rev-list', '--parents', '--max-count=1', self.__id_hash
+                    ).output_one_line().split()[1:]

 
     def get_author(self):
         return self.__author
 
     def get_author(self):
         return self.__author


@@ -140,125 +162,101 @@ def get_commit(id_hash):
 def get_conflicts():
     """Return the list of file conflicts
     """
 def get_conflicts():
     """Return the list of file conflicts
     """

-    conflicts_file = os.path.join(basedir.get(), 'conflicts')
-    if os.path.isfile(conflicts_file):
-        f = file(conflicts_file)
-        names = [line.strip() for line in f.readlines()]
-        f.close()
-        return names
-    else:
-        return None
-
-def _input(cmd, file_desc):
-    p = popen2.Popen3(cmd, True)
-    while True:
-        line = file_desc.readline()
-        if not line:
-            break
-        p.tochild.write(line)
-    p.tochild.close()
-    if p.wait():
-        raise GitException, '%s failed (%s)' % (' '.join(cmd),
-                                                p.childerr.read().strip())
-
-def _input_str(cmd, string):
-    p = popen2.Popen3(cmd, True)
-    p.tochild.write(string)
-    p.tochild.close()
-    if p.wait():
-        raise GitException, '%s failed (%s)' % (' '.join(cmd),
-                                                p.childerr.read().strip())
-
-def _output(cmd):
-    p=popen2.Popen3(cmd, True)
-    output = p.fromchild.read()
-    if p.wait():
-        raise GitException, '%s failed (%s)' % (' '.join(cmd),
-                                                p.childerr.read().strip())
-    return output
-
-def _output_one_line(cmd, file_desc = None):
-    p=popen2.Popen3(cmd, True)
-    if file_desc != None:
-        for line in file_desc:
-            p.tochild.write(line)
-        p.tochild.close()
-    output = p.fromchild.readline().strip()
-    if p.wait():
-        raise GitException, '%s failed (%s)' % (' '.join(cmd),
-                                                p.childerr.read().strip())
-    return output
-
-def _output_lines(cmd):
-    p=popen2.Popen3(cmd, True)
-    lines = p.fromchild.readlines()
-    if p.wait():
-        raise GitException, '%s failed (%s)' % (' '.join(cmd),
-                                                p.childerr.read().strip())
-    return lines
-
-def __run(cmd, args=None):
-    """__run: runs cmd using spawnvp.
-
-    Runs cmd using spawnvp.  The shell is avoided so it won't mess up
-    our arguments.  If args is very large, the command is run multiple
-    times; args is split xargs style: cmd is passed on each
-    invocation.  Unlike xargs, returns immediately if any non-zero
-    return code is received.  
+    names = []
+    for line in GRun('ls-files', '-z', '--unmerged'
+                     ).raw_output().split('\0')[:-1]:
+        stat, path = line.split('\t', 1)
+        # Look for entries in stage 2 (could equally well use 3)
+        if stat.endswith(' 2'):
+            names.append(path)
+    return names
+
+def exclude_files():
+    files = [os.path.join(basedir.get(), 'info', 'exclude')]
+    user_exclude = config.get('core.excludesfile')
+    if user_exclude:
+        files.append(user_exclude)
+    return files
+
+def ls_files(files, tree = None, full_name = True):
+    """Return the files known to GIT or raise an error otherwise. It also
+    converts the file to the full path relative the the .git directory.

     """
     """

-    
-    args_l=cmd.split()
-    if args is None:
-        args = []
-    for i in range(0, len(args)+1, 100):
-        r=os.spawnvp(os.P_WAIT, args_l[0], args_l + args[i:min(i+100, len(args))])
-    if r:
-        return r
-    return 0
+    if not files:
+        return []
+
+    args = []
+    if tree:
+        args.append('--with-tree=%s' % tree)
+    if full_name:
+        args.append('--full-name')
+    args.append('--')
+    args.extend(files)
+    try:
+        return GRun('ls-files', '--error-unmatch', *args).output_lines()
+    except GitRunException:
+        # just hide the details of the 'git ls-files' command we use
+        raise GitException, \
+            'Some of the given paths are either missing or not known to GIT'

 
 

-def __tree_status(files = None, tree_id = 'HEAD', unknown = False,
+def tree_status(files = None, tree_id = 'HEAD', unknown = False,

                   noexclude = True, verbose = False, diff_flags = []):
                   noexclude = True, verbose = False, diff_flags = []):

-    """Returns a list of pairs - [status, filename]
+    """Get the status of all changed files, or of a selected set of
+    files. Returns a list of pairs - (status, filename).
+
+    If 'not files', it will check all files, and optionally all
+    unknown files.  If 'files' is a list, it will only check the files
+    in the list.

     """
     """

+    assert not files or not unknown
+

     if verbose:
         out.start('Checking for changes in the working directory')
 
     refresh_index()
 
     if verbose:
         out.start('Checking for changes in the working directory')
 
     refresh_index()
 

-    if not files:
-        files = []

     cache_files = []
 
     # unknown files
     if unknown:
     cache_files = []
 
     # unknown files
     if unknown:

-        exclude_file = os.path.join(basedir.get(), 'info', 'exclude')
-        base_exclude = ['--exclude=%s' % s for s in
-                        ['*.[ao]', '*.pyc', '.*', '*~', '#*', 'TAGS', 'tags']]
-        base_exclude.append('--exclude-per-directory=.gitignore')
-
-        if os.path.exists(exclude_file):
-            extra_exclude = ['--exclude-from=%s' % exclude_file]
-        else:
-            extra_exclude = []
-        if noexclude:
-            extra_exclude = base_exclude = []
-
-        lines = _output_lines(['git-ls-files', '--others', '--directory']
-                        + base_exclude + extra_exclude)
-        cache_files += [('?', line.strip()) for line in lines]
+        cmd = ['ls-files', '-z', '--others', '--directory',
+               '--no-empty-directory']
+        if not noexclude:
+            cmd += ['--exclude=%s' % s for s in
+                    ['*.[ao]', '*.pyc', '.*', '*~', '#*', 'TAGS', 'tags']]
+            cmd += ['--exclude-per-directory=.gitignore']
+            cmd += ['--exclude-from=%s' % fn
+                    for fn in exclude_files()
+                    if os.path.exists(fn)]
+
+        lines = GRun(*cmd).raw_output().split('\0')
+        cache_files += [('?', line) for line in lines if line]

 
     # conflicted files
     conflicts = get_conflicts()
 
     # conflicted files
     conflicts = get_conflicts()

-    if not conflicts:
-        conflicts = []
-    cache_files += [('C', filename) for filename in conflicts]
+    cache_files += [('C', filename) for filename in conflicts
+                    if not files or filename in files]
+    reported_files = set(conflicts)

 
 

-    # the rest
-    for line in _output_lines(['git-diff-index'] + diff_flags +
-                              [ tree_id, '--'] + files):
+    # files in the index
+    args = diff_flags + [tree_id]
+    if files:
+        args += ['--'] + files
+    for line in GRun('diff-index', *args).output_lines():

         fs = tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
         fs = tuple(line.rstrip().split(' ',4)[-1].split('\t',1))

-        if fs[1] not in conflicts:
+        if fs[1] not in reported_files:

             cache_files.append(fs)
             cache_files.append(fs)

+            reported_files.add(fs[1])
+
+    # files in the index but changed on (or removed from) disk
+    args = list(diff_flags)
+    if files:
+        args += ['--'] + files
+    for line in GRun('diff-files', *args).output_lines():
+        fs = tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
+        if fs[1] not in reported_files:
+            cache_files.append(fs)
+            reported_files.add(fs[1])

 
     if verbose:
         out.done()
 
     if verbose:
         out.done()


@@ -268,7 +266,15 @@ def __tree_status(files = None, tree_id = 'HEAD', unknown = False,
 def local_changes(verbose = True):
     """Return true if there are local changes in the tree
     """
 def local_changes(verbose = True):
     """Return true if there are local changes in the tree
     """

-    return len(__tree_status(verbose = verbose)) != 0
+    return len(tree_status(verbose = verbose)) != 0
+
+def get_heads():
+    heads = []
+    hr = re.compile(r'^[0-9a-f]{40} refs/heads/(.+)$')
+    for line in GRun('show-ref', '--heads').output_lines():
+        m = hr.match(line)
+        heads.append(m.group(1))
+    return heads

 
 # HEAD value cached
 __head = None
 
 # HEAD value cached
 __head = None


@@ -282,11 +288,19 @@ def get_head():
         __head = rev_parse('HEAD')
     return __head
 
         __head = rev_parse('HEAD')
     return __head
 

+class DetachedHeadException(GitException):
+    def __init__(self):
+        GitException.__init__(self, 'Not on any branch')
+

 def get_head_file():
 def get_head_file():

-    """Returns the name of the file pointed to by the HEAD link
-    """
-    return strip_prefix('refs/heads/',
-                        _output_one_line(['git-symbolic-ref', 'HEAD']))
+    """Return the name of the file pointed to by the HEAD symref.
+    Throw an exception if HEAD is detached."""
+    try:
+        return strip_prefix(
+            'refs/heads/', GRun('symbolic-ref', '-q', 'HEAD'
+                                ).output_one_line())
+    except GitRunException:
+        raise DetachedHeadException()

 
 def set_head_file(ref):
     """Resets HEAD to point to a new ref
 
 def set_head_file(ref):
     """Resets HEAD to point to a new ref


@@ -294,14 +308,20 @@ def set_head_file(ref):
     # head cache flushing is needed since we might have a different value
     # in the new head
     __clear_head_cache()
     # head cache flushing is needed since we might have a different value
     # in the new head
     __clear_head_cache()

-    if __run('git-symbolic-ref HEAD',
-             [os.path.join('refs', 'heads', ref)]) != 0:
+    try:
+        GRun('symbolic-ref', 'HEAD', 'refs/heads/%s' % ref).run()
+    except GitRunException:

         raise GitException, 'Could not set head to "%s"' % ref
 
         raise GitException, 'Could not set head to "%s"' % ref
 

+def set_ref(ref, val):
+    """Point ref at a new commit object."""
+    try:
+        GRun('update-ref', ref, val).run()
+    except GitRunException:
+        raise GitException, 'Could not update %s to "%s".' % (ref, val)
+

 def set_branch(branch, val):
 def set_branch(branch, val):

-    """Point branch at a new commit object."""
-    if __run('git-update-ref', [branch, val]) != 0:
-        raise GitException, 'Could not update %s to "%s".' % (branch, val)
+    set_ref('refs/heads/%s' % branch, val)

 
 def __set_head(val):
     """Sets the HEAD value
 
 def __set_head(val):
     """Sets the HEAD value


@@ -309,7 +329,7 @@ def __set_head(val):
     global __head
 
     if not __head or __head != val:
     global __head
 
     if not __head or __head != val:

-        set_branch('HEAD', val)
+        set_ref('HEAD', val)

         __head = val
 
     # only allow SHA1 hashes
         __head = val
 
     # only allow SHA1 hashes


@@ -325,26 +345,26 @@ def __clear_head_cache():
 def refresh_index():
     """Refresh index with stat() information from the working directory.
     """
 def refresh_index():
     """Refresh index with stat() information from the working directory.
     """

-    __run('git-update-index -q --unmerged --refresh')
+    GRun('update-index', '-q', '--unmerged', '--refresh').run()

 
 def rev_parse(git_id):
     """Parse the string and return a verified SHA1 id
     """
     try:
 
 def rev_parse(git_id):
     """Parse the string and return a verified SHA1 id
     """
     try:

-        return _output_one_line(['git-rev-parse', '--verify', git_id])
-    except GitException:
+        return GRun('rev-parse', '--verify', git_id
+                    ).discard_stderr().output_one_line()
+    except GitRunException:

         raise GitException, 'Unknown revision: %s' % git_id
 
         raise GitException, 'Unknown revision: %s' % git_id
 

+def ref_exists(ref):
+    try:
+        rev_parse(ref)
+        return True
+    except GitException:
+        return False
+

 def branch_exists(branch):
 def branch_exists(branch):

-    """Existence check for the named branch
-    """
-    branch = os.path.join('refs', 'heads', branch)
-    for line in _output_lines('git-rev-parse --symbolic --all 2>&1'):
-        if line.strip() == branch:
-            return True
-        if re.compile('[ |/]'+branch+' ').search(line):
-            raise GitException, 'Bogus branch: %s' % line
-    return False
+    return ref_exists('refs/heads/%s' % branch)

 
 def create_branch(new_branch, tree_id = None):
     """Create a new branch in the git repository
 
 def create_branch(new_branch, tree_id = None):
     """Create a new branch in the git repository


@@ -352,13 +372,20 @@ def create_branch(new_branch, tree_id = None):
     if branch_exists(new_branch):
         raise GitException, 'Branch "%s" already exists' % new_branch
 
     if branch_exists(new_branch):
         raise GitException, 'Branch "%s" already exists' % new_branch
 

+    current_head_file = get_head_file()

     current_head = get_head()
     set_head_file(new_branch)
     __set_head(current_head)
 
     # a checkout isn't needed if new branch points to the current head
     if tree_id:
     current_head = get_head()
     set_head_file(new_branch)
     __set_head(current_head)
 
     # a checkout isn't needed if new branch points to the current head
     if tree_id:

-        switch(tree_id)
+        try:
+            switch(tree_id)
+        except GitException:
+            # Tree switching failed. Revert the head file
+            set_head_file(current_head_file)
+            delete_branch(new_branch)
+            raise

 
     if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
         os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
 
     if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
         os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))


@@ -371,39 +398,55 @@ def switch_branch(new_branch):
     if not branch_exists(new_branch):
         raise GitException, 'Branch "%s" does not exist' % new_branch
 
     if not branch_exists(new_branch):
         raise GitException, 'Branch "%s" does not exist' % new_branch
 

-    tree_id = rev_parse(os.path.join('refs', 'heads', new_branch)
-                        + '^{commit}')
+    tree_id = rev_parse('refs/heads/%s^{commit}' % new_branch)

     if tree_id != get_head():
         refresh_index()
     if tree_id != get_head():
         refresh_index()

-        if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
-            raise GitException, 'git-read-tree failed (local changes maybe?)'
+        try:
+            GRun('read-tree', '-u', '-m', get_head(), tree_id).run()
+        except GitRunException:
+            raise GitException, 'read-tree failed (local changes maybe?)'

         __head = tree_id
     set_head_file(new_branch)
 
     if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
         os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
 
         __head = tree_id
     set_head_file(new_branch)
 
     if os.path.isfile(os.path.join(basedir.get(), 'MERGE_HEAD')):
         os.remove(os.path.join(basedir.get(), 'MERGE_HEAD'))
 

+def delete_ref(ref):
+    if not ref_exists(ref):
+        raise GitException, '%s does not exist' % ref
+    sha1 = GRun('show-ref', '-s', ref).output_one_line()
+    try:
+        GRun('update-ref', '-d', ref, sha1).run()
+    except GitRunException:
+        raise GitException, 'Failed to delete ref %s' % ref
+

 def delete_branch(name):
 def delete_branch(name):

-    """Delete a git branch
-    """
-    if not branch_exists(name):
-        raise GitException, 'Branch "%s" does not exist' % name
-    remove_file_and_dirs(os.path.join(basedir.get(), 'refs', 'heads'),
-                         name)
+    delete_ref('refs/heads/%s' % name)

 
 

-def rename_branch(from_name, to_name):
-    """Rename a git branch
-    """
-    if not branch_exists(from_name):
-        raise GitException, 'Branch "%s" does not exist' % from_name
-    if branch_exists(to_name):
-        raise GitException, 'Branch "%s" already exists' % to_name
+def rename_ref(from_ref, to_ref):
+    if not ref_exists(from_ref):
+        raise GitException, '"%s" does not exist' % from_ref
+    if ref_exists(to_ref):
+        raise GitException, '"%s" already exists' % to_ref

 
 

-    if get_head_file() == from_name:
-        set_head_file(to_name)
-    rename(os.path.join(basedir.get(), 'refs', 'heads'),
-           from_name, to_name)
+    sha1 = GRun('show-ref', '-s', from_ref).output_one_line()
+    try:
+        GRun('update-ref', to_ref, sha1, '0'*40).run()
+    except GitRunException:
+        raise GitException, 'Failed to create new ref %s' % to_ref
+    try:
+        GRun('update-ref', '-d', from_ref, sha1).run()
+    except GitRunException:
+        raise GitException, 'Failed to delete ref %s' % from_ref

 
 

+def rename_branch(from_name, to_name):
+    """Rename a git branch."""
+    rename_ref('refs/heads/%s' % from_name, 'refs/heads/%s' % to_name)
+    try:
+        if get_head_file() == from_name:
+            set_head_file(to_name)
+    except DetachedHeadException:
+        pass # detached HEAD, so the renamee can't be the current branch

     reflog_dir = os.path.join(basedir.get(), 'logs', 'refs', 'heads')
     if os.path.exists(reflog_dir) \
            and os.path.exists(os.path.join(reflog_dir, from_name)):
     reflog_dir = os.path.join(basedir.get(), 'logs', 'refs', 'heads')
     if os.path.exists(reflog_dir) \
            and os.path.exists(os.path.join(reflog_dir, from_name)):


@@ -430,14 +473,16 @@ def add(names):
             raise GitException, '%s is not a file or directory' % i
 
     if files:
             raise GitException, '%s is not a file or directory' % i
 
     if files:

-        if __run('git-update-index --add --', files):
+        try:
+            GRun('update-index', '--add', '--').xargs(files)
+        except GitRunException:

             raise GitException, 'Unable to add file'
 
 def __copy_single(source, target, target2=''):
     """Copy file or dir named 'source' to name target+target2"""
 
     # "source" (file or dir) must match one or more git-controlled file
             raise GitException, 'Unable to add file'
 
 def __copy_single(source, target, target2=''):
     """Copy file or dir named 'source' to name target+target2"""
 
     # "source" (file or dir) must match one or more git-controlled file

-    realfiles = _output_lines(['git-ls-files', source])
+    realfiles = GRun('ls-files', source).output_lines()

     if len(realfiles) == 0:
         raise GitException, '"%s" matches no git-controled files' % source
 
     if len(realfiles) == 0:
         raise GitException, '"%s" matches no git-controled files' % source
 


@@ -505,10 +550,10 @@ def rm(files, force = False):
             if os.path.exists(f):
                 raise GitException, '%s exists. Remove it first' %f
         if files:
             if os.path.exists(f):
                 raise GitException, '%s exists. Remove it first' %f
         if files:

-            __run('git-update-index --remove --', files)
+            GRun('update-index', '--remove', '--').xargs(files)

     else:
         if files:
     else:
         if files:

-            __run('git-update-index --force-remove --', files)
+            GRun('update-index', '--force-remove', '--').xargs(files)

 
 # Persons caching
 __user = None
 
 # Persons caching
 __user = None


@@ -564,10 +609,7 @@ def committer():
 def update_cache(files = None, force = False):
     """Update the cache information for the given files
     """
 def update_cache(files = None, force = False):
     """Update the cache information for the given files
     """

-    if not files:
-        files = []
-
-    cache_files = __tree_status(files, verbose = False)
+    cache_files = tree_status(files, verbose = False)

 
     # everything is up-to-date
     if len(cache_files) == 0:
 
     # everything is up-to-date
     if len(cache_files) == 0:


@@ -583,23 +625,18 @@ def update_cache(files = None, force = False):
     rm_files =  [x[1] for x in cache_files if x[0] in ['D']]
     m_files =   [x[1] for x in cache_files if x[0] in ['M']]
 
     rm_files =  [x[1] for x in cache_files if x[0] in ['D']]
     m_files =   [x[1] for x in cache_files if x[0] in ['M']]
 

-    if add_files and __run('git-update-index --add --', add_files) != 0:
-        raise GitException, 'Failed git-update-index --add'
-    if rm_files and __run('git-update-index --force-remove --', rm_files) != 0:
-        raise GitException, 'Failed git-update-index --rm'
-    if m_files and __run('git-update-index --', m_files) != 0:
-        raise GitException, 'Failed git-update-index'
+    GRun('update-index', '--add', '--').xargs(add_files)
+    GRun('update-index', '--force-remove', '--').xargs(rm_files)
+    GRun('update-index', '--').xargs(m_files)

 
     return True
 
 def commit(message, files = None, parents = None, allowempty = False,
 
     return True
 
 def commit(message, files = None, parents = None, allowempty = False,

-           cache_update = True, tree_id = None,
+           cache_update = True, tree_id = None, set_head = False,

            author_name = None, author_email = None, author_date = None,
            committer_name = None, committer_email = None):
     """Commit the current tree to repository
     """
            author_name = None, author_email = None, author_date = None,
            committer_name = None, committer_email = None):
     """Commit the current tree to repository
     """

-    if not files:
-        files = []

     if not parents:
         parents = []
 
     if not parents:
         parents = []
 


@@ -615,33 +652,27 @@ def commit(message, files = None, parents = None, allowempty = False,
     elif message[-1:] != '\n':
         message += '\n'
 
     elif message[-1:] != '\n':
         message += '\n'
 

-    must_switch = True

     # write the index to repository
     if tree_id == None:
     # write the index to repository
     if tree_id == None:

-        tree_id = _output_one_line(['git-write-tree'])
-    else:
-        must_switch = False
+        tree_id = GRun('write-tree').output_one_line()
+        set_head = True

 
     # the commit
 
     # the commit

-    cmd = ['env']
+    env = {}

     if author_name:
     if author_name:

-        cmd += ['GIT_AUTHOR_NAME=%s' % author_name]
+        env['GIT_AUTHOR_NAME'] = author_name

     if author_email:
     if author_email:

-        cmd += ['GIT_AUTHOR_EMAIL=%s' % author_email]
+        env['GIT_AUTHOR_EMAIL'] = author_email

     if author_date:
     if author_date:

-        cmd += ['GIT_AUTHOR_DATE=%s' % author_date]
+        env['GIT_AUTHOR_DATE'] = author_date

     if committer_name:
     if committer_name:

-        cmd += ['GIT_COMMITTER_NAME=%s' % committer_name]
+        env['GIT_COMMITTER_NAME'] = committer_name

     if committer_email:
     if committer_email:

-        cmd += ['GIT_COMMITTER_EMAIL=%s' % committer_email]
-    cmd += ['git-commit-tree', tree_id]
-
-    # get the parents
-    for p in parents:
-        cmd += ['-p', p]
-
-    commit_id = _output_one_line(cmd, message)
-    if must_switch:
+        env['GIT_COMMITTER_EMAIL'] = committer_email
+    commit_id = GRun('commit-tree', tree_id,
+                     *sum([['-p', p] for p in parents], [])
+                     ).env(env).raw_input(message).output_one_line()
+    if set_head:

         __set_head(commit_id)
 
     return commit_id
         __set_head(commit_id)
 
     return commit_id


@@ -663,41 +694,55 @@ def apply_diff(rev1, rev2, check_index = True, files = None):
     diff_str = diff(files, rev1, rev2)
     if diff_str:
         try:
     diff_str = diff(files, rev1, rev2)
     if diff_str:
         try:

-            _input_str(['git-apply'] + index_opt, diff_str)
-        except GitException:
+            GRun('apply', *index_opt).raw_input(
+                diff_str).discard_stderr().no_output()
+        except GitRunException:

             return False
 
     return True
 
             return False
 
     return True
 

-def merge(base, head1, head2, recursive = False):
+stages_re = re.compile('^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
+
+def merge_recursive(base, head1, head2):
+    """Perform a 3-way merge between base, head1 and head2 into the
+    local tree
+    """
+    refresh_index()
+    p = GRun('merge-recursive', base, '--', head1, head2).env(
+        { 'GITHEAD_%s' % base: 'ancestor',
+          'GITHEAD_%s' % head1: 'current',
+          'GITHEAD_%s' % head2: 'patched'}).returns([0, 1])
+    output = p.output_lines()
+    if p.exitcode == 0:
+        # No problems
+        return
+    else: # exitcode == 1
+        # There were conflicts
+        conflicts = [l.strip() for l in output if l.startswith('CONFLICT')]
+        raise GitConflictException(conflicts)
+
+def merge(base, head1, head2):

     """Perform a 3-way merge between base, head1 and head2 into the
     local tree
     """
     refresh_index()
 
     err_output = None
     """Perform a 3-way merge between base, head1 and head2 into the
     local tree
     """
     refresh_index()
 
     err_output = None

-    if recursive:
-        # this operation tracks renames but it is slower (used in
-        # general when pushing or picking patches)
-        try:
-            # use _output() to mask the verbose prints of the tool
-            _output(['git-merge-recursive', base, '--', head1, head2])
-        except GitException, ex:
-            err_output = str(ex)
-            pass
-    else:
-        # the fast case where we don't track renames (used when the
-        # distance between base and heads is small, i.e. folding or
-        # synchronising patches)
-        if __run('git-read-tree -u -m --aggressive',
-                 [base, head1, head2]) != 0:
-            raise GitException, 'git-read-tree failed (local changes maybe?)'
+    # the fast case where we don't track renames (used when the
+    # distance between base and heads is small, i.e. folding or
+    # synchronising patches)
+    try:
+        GRun('read-tree', '-u', '-m', '--aggressive', base, head1, head2
+             ).run()
+    except GitRunException:
+        raise GitException, 'read-tree failed (local changes maybe?)'

 
     # check the index for unmerged entries
     files = {}
     stages_re = re.compile('^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
 
 
     # check the index for unmerged entries
     files = {}
     stages_re = re.compile('^([0-7]+) ([0-9a-f]{40}) ([1-3])\t(.*)$', re.S)
 

-    for line in _output(['git-ls-files', '--unmerged', '--stage', '-z']).split('\0'):
+    for line in GRun('ls-files', '--unmerged', '--stage', '-z'
+                     ).raw_output().split('\0'):

         if not line:
             continue
 
         if not line:
             continue
 


@@ -737,134 +782,91 @@ def merge(base, head1, head2, recursive = False):
     if errors:
         raise GitException, 'GIT index merging failed (possible conflicts)'
 
     if errors:
         raise GitException, 'GIT index merging failed (possible conflicts)'
 

-def status(files = None, modified = False, new = False, deleted = False,
-           conflict = False, unknown = False, noexclude = False,
-           diff_flags = []):
-    """Show the tree status
-    """
-    if not files:
-        files = []
-
-    cache_files = __tree_status(files, unknown = True, noexclude = noexclude,
-                                diff_flags = diff_flags)
-    all = not (modified or new or deleted or conflict or unknown)
-
-    if not all:
-        filestat = []
-        if modified:
-            filestat.append('M')
-        if new:
-            filestat.append('A')
-            filestat.append('N')
-        if deleted:
-            filestat.append('D')
-        if conflict:
-            filestat.append('C')
-        if unknown:
-            filestat.append('?')
-        cache_files = [x for x in cache_files if x[0] in filestat]
-
-    for fs in cache_files:
-        if files and not fs[1] in files:
-            continue
-        if all:
-            out.stdout('%s %s' % (fs[0], fs[1]))
-        else:
-            out.stdout('%s' % fs[1])
-
-def diff(files = None, rev1 = 'HEAD', rev2 = None, out_fd = None,
-         diff_flags = []):
+def diff(files = None, rev1 = 'HEAD', rev2 = None, diff_flags = [],
+         binary = True):

     """Show the diff between rev1 and rev2
     """
     if not files:
         files = []
     """Show the diff between rev1 and rev2
     """
     if not files:
         files = []

+    if binary and '--binary' not in diff_flags:
+        diff_flags = diff_flags + ['--binary']

 
     if rev1 and rev2:
 
     if rev1 and rev2:

-        diff_str = _output(['git-diff-tree', '-p'] + diff_flags
-                           + [rev1, rev2, '--'] + files)
+        return GRun('diff-tree', '-p',
+                    *(diff_flags + [rev1, rev2, '--'] + files)).raw_output()

     elif rev1 or rev2:
         refresh_index()
         if rev2:
     elif rev1 or rev2:
         refresh_index()
         if rev2:

-            diff_str = _output(['git-diff-index', '-p', '-R']
-                               + diff_flags + [rev2, '--'] + files)
+            return GRun('diff-index', '-p', '-R',
+                        *(diff_flags + [rev2, '--'] + files)).raw_output()

         else:
         else:

-            diff_str = _output(['git-diff-index', '-p']
-                               + diff_flags + [rev1, '--'] + files)
-    else:
-        diff_str = ''
-
-    if out_fd:
-        out_fd.write(diff_str)
+            return GRun('diff-index', '-p',
+                        *(diff_flags + [rev1, '--'] + files)).raw_output()

     else:
     else:

-        return diff_str
+        return ''

 
 

+# TODO: take another parameter representing a diff string as we
+# usually invoke git.diff() form the calling functions

 def diffstat(files = None, rev1 = 'HEAD', rev2 = None):
 def diffstat(files = None, rev1 = 'HEAD', rev2 = None):

-    """Return the diffstat between rev1 and rev2
-    """
-    if not files:
-        files = []
-
-    p=popen2.Popen3('git-apply --stat')
-    diff(files, rev1, rev2, p.tochild)
-    p.tochild.close()
-    diff_str = p.fromchild.read().rstrip()
-    if p.wait():
-        raise GitException, 'git.diffstat failed'
-    return diff_str
+    """Return the diffstat between rev1 and rev2."""
+    return GRun('apply', '--stat', '--summary'
+                ).raw_input(diff(files, rev1, rev2)).raw_output()

 
 def files(rev1, rev2, diff_flags = []):
     """Return the files modified between rev1 and rev2
     """
 
 
 def files(rev1, rev2, diff_flags = []):
     """Return the files modified between rev1 and rev2
     """
 

-    result = ''
-    for line in _output_lines(['git-diff-tree'] + diff_flags + ['-r', rev1, rev2]):
-        result += '%s %s\n' % tuple(line.rstrip().split(' ',4)[-1].split('\t',1))
+    result = []
+    for line in GRun('diff-tree', *(diff_flags + ['-r', rev1, rev2])
+                     ).output_lines():
+        result.append('%s %s' % tuple(line.split(' ', 4)[-1].split('\t', 1)))

 
 

-    return result.rstrip()
+    return '\n'.join(result)

 
 def barefiles(rev1, rev2):
     """Return the files modified between rev1 and rev2, without status info
     """
 
 
 def barefiles(rev1, rev2):
     """Return the files modified between rev1 and rev2, without status info
     """
 

-    result = ''
-    for line in _output_lines(['git-diff-tree', '-r', rev1, rev2]):
-        result += '%s\n' % line.rstrip().split(' ',4)[-1].split('\t',1)[-1]
+    result = []
+    for line in GRun('diff-tree', '-r', rev1, rev2).output_lines():
+        result.append(line.split(' ', 4)[-1].split('\t', 1)[-1])

 
 

-    return result.rstrip()
+    return '\n'.join(result)

 
 

-def pretty_commit(commit_id = 'HEAD', diff_flags = []):
+def pretty_commit(commit_id = 'HEAD', flags = []):

     """Return a given commit (log + diff)
     """
     """Return a given commit (log + diff)
     """

-    return _output(['git-diff-tree'] + diff_flags +
-                   ['--cc', '--always', '--pretty', '-r', commit_id])
+    return GRun('show', *(flags + [commit_id])).raw_output()

 
 def checkout(files = None, tree_id = None, force = False):
     """Check out the given or all files
     """
 
 def checkout(files = None, tree_id = None, force = False):
     """Check out the given or all files
     """

-    if not files:
-        files = []
-
-    if tree_id and __run('git-read-tree --reset', [tree_id]) != 0:
-        raise GitException, 'Failed git-read-tree --reset %s' % tree_id
+    if tree_id:
+        try:
+            GRun('read-tree', '--reset', tree_id).run()
+        except GitRunException:
+            raise GitException, 'Failed "git read-tree" --reset %s' % tree_id

 
 

-    checkout_cmd = 'git-checkout-index -q -u'
+    cmd = ['checkout-index', '-q', '-u']

     if force:
     if force:

-        checkout_cmd += ' -f'
-    if len(files) == 0:
-        checkout_cmd += ' -a'
+        cmd.append('-f')
+    if files:
+        GRun(*(cmd + ['--'])).xargs(files)

     else:
     else:

-        checkout_cmd += ' --'
-
-    if __run(checkout_cmd, files) != 0:
-        raise GitException, 'Failed git-checkout-index'
+        GRun(*(cmd + ['-a'])).run()

 
 def switch(tree_id, keep = False):
     """Switch the tree to the given id
     """
 
 def switch(tree_id, keep = False):
     """Switch the tree to the given id
     """

-    if not keep:
+    if keep:
+        # only update the index while keeping the local changes
+        GRun('read-tree', tree_id).run()
+    else:

         refresh_index()
         refresh_index()

-        if __run('git-read-tree -u -m', [get_head(), tree_id]) != 0:
-            raise GitException, 'git-read-tree failed (local changes maybe?)'
+        try:
+            GRun('read-tree', '-u', '-m', get_head(), tree_id).run()
+        except GitRunException:
+            raise GitException, 'read-tree failed (local changes maybe?)'

 
     __set_head(tree_id)
 
 
     __set_head(tree_id)
 


@@ -876,7 +878,7 @@ def reset(files = None, tree_id = None, check_out = True):
         tree_id = get_head()
 
     if check_out:
         tree_id = get_head()
 
     if check_out:

-        cache_files = __tree_status(files, tree_id)
+        cache_files = tree_status(files, tree_id)

         # files which were added but need to be removed
         rm_files =  [x[1] for x in cache_files if x[0] in ['A']]
 
         # files which were added but need to be removed
         rm_files =  [x[1] for x in cache_files if x[0] in ['A']]
 


@@ -889,7 +891,7 @@ def reset(files = None, tree_id = None, check_out = True):
         __set_head(tree_id)
 
 def fetch(repository = 'origin', refspec = None):
         __set_head(tree_id)
 
 def fetch(repository = 'origin', refspec = None):

-    """Fetches changes from the remote repository, using 'git-fetch'
+    """Fetches changes from the remote repository, using 'git fetch'

     by default.
     """
     # we update the HEAD
     by default.
     """
     # we update the HEAD


@@ -901,11 +903,10 @@ def fetch(repository = 'origin', refspec = None):
 
     command = config.get('branch.%s.stgit.fetchcmd' % get_head_file()) or \
               config.get('stgit.fetchcmd')
 
     command = config.get('branch.%s.stgit.fetchcmd' % get_head_file()) or \
               config.get('stgit.fetchcmd')

-    if __run(command, args) != 0:
-        raise GitException, 'Failed "%s %s"' % (command, repository)
+    Run(*(command.split() + args)).run()

 
 def pull(repository = 'origin', refspec = None):
 
 def pull(repository = 'origin', refspec = None):

-    """Fetches changes from the remote repository, using 'git-pull'
+    """Fetches changes from the remote repository, using 'git pull'

     by default.
     """
     # we update the HEAD
     by default.
     """
     # we update the HEAD


@@ -917,13 +918,33 @@ def pull(repository = 'origin', refspec = None):
 
     command = config.get('branch.%s.stgit.pullcmd' % get_head_file()) or \
               config.get('stgit.pullcmd')
 
     command = config.get('branch.%s.stgit.pullcmd' % get_head_file()) or \
               config.get('stgit.pullcmd')

-    if __run(command, args) != 0:
-        raise GitException, 'Failed "%s %s"' % (command, repository)
+    Run(*(command.split() + args)).run()
+
+def rebase(tree_id = None):
+    """Rebase the current tree to the give tree_id. The tree_id
+    argument may be something other than a GIT id if an external
+    command is invoked.
+    """
+    command = config.get('branch.%s.stgit.rebasecmd' % get_head_file()) \
+                or config.get('stgit.rebasecmd')
+    if tree_id:
+        args = [tree_id]
+    elif command:
+        args = []
+    else:
+        raise GitException, 'Default rebasing requires a commit id'
+    if command:
+        # clear the HEAD cache as the custom rebase command will update it
+        __clear_head_cache()
+        Run(*(command.split() + args)).run()
+    else:
+        # default rebasing
+        reset(tree_id = tree_id)

 
 def repack():
     """Repack all objects into a single pack
     """
 
 def repack():
     """Repack all objects into a single pack
     """

-    __run('git-repack -a -d -f')
+    GRun('repack', '-a', '-d', '-f').run()

 
 def apply_patch(filename = None, diff = None, base = None,
                 fail_dump = True):
 
 def apply_patch(filename = None, diff = None, base = None,
                 fail_dump = True):


@@ -946,8 +967,8 @@ def apply_patch(filename = None, diff = None, base = None,
         refresh_index()
 
     try:
         refresh_index()
 
     try:

-        _input_str(['git-apply', '--index'], diff)
-    except GitException:
+        GRun('apply', '--index').raw_input(diff).no_output()
+    except GitRunException:

         if base:
             switch(orig_head)
         if fail_dump:
         if base:
             switch(orig_head)
         if fail_dump:


@@ -967,20 +988,14 @@ def apply_patch(filename = None, diff = None, base = None,
 
 def clone(repository, local_dir):
     """Clone a remote repository. At the moment, just use the
 
 def clone(repository, local_dir):
     """Clone a remote repository. At the moment, just use the

-    'git-clone' script
+    'git clone' script

     """
     """

-    if __run('git-clone', [repository, local_dir]) != 0:
-        raise GitException, 'Failed "git-clone %s %s"' \
-              % (repository, local_dir)
+    GRun('clone', repository, local_dir).run()

 
 def modifying_revs(files, base_rev, head_rev):
 
 def modifying_revs(files, base_rev, head_rev):

-    """Return the revisions from the list modifying the given files
-    """
-    cmd = ['git-rev-list', '%s..%s' % (base_rev, head_rev), '--']
-    revs = [line.strip() for line in _output_lines(cmd + files)]
-
-    return revs
-
+    """Return the revisions from the list modifying the given files."""
+    return GRun('rev-list', '%s..%s' % (base_rev, head_rev), '--', *files
+                ).output_lines()

 
 def refspec_localpart(refspec):
     m = re.match('^[^:]*:([^:]*)$', refspec)
 
 def refspec_localpart(refspec):
     m = re.match('^[^:]*:([^:]*)$', refspec)


@@ -1005,15 +1020,14 @@ def __remotes_from_dir(dir):
     if os.path.exists(d):
         return os.listdir(d)
     else:
     if os.path.exists(d):
         return os.listdir(d)
     else:

-        return None
+        return []

 
 def remotes_list():
     """Return the list of remotes in the repository
     """
 
 def remotes_list():
     """Return the list of remotes in the repository
     """

-
-    return Set(__remotes_from_config()) | \
-           Set(__remotes_from_dir('remotes')) | \
-           Set(__remotes_from_dir('branches'))
+    return (set(__remotes_from_config())
+            | set(__remotes_from_dir('remotes'))
+            | set(__remotes_from_dir('branches')))

 
 def remotes_local_branches(remote):
     """Returns the list of local branches fetched from given remote
 
 def remotes_local_branches(remote):
     """Returns the list of local branches fetched from given remote


@@ -1063,10 +1077,19 @@ def fetch_head():
         m = re.match('^([^\t]*)\t\t', line)
         if m:
             if fetch_head:
         m = re.match('^([^\t]*)\t\t', line)
         if m:
             if fetch_head:

-                raise GitException, "StGit does not support multiple FETCH_HEAD"
+                raise GitException, 'StGit does not support multiple FETCH_HEAD'

             else:
                 fetch_head=m.group(1)
     stream.close()
 
             else:
                 fetch_head=m.group(1)
     stream.close()
 

+    if not fetch_head:
+        out.warn('No for-merge remote head found in FETCH_HEAD')
+

     # here we are sure to have a single fetch_head
     return fetch_head
     # here we are sure to have a single fetch_head
     return fetch_head

+
+def all_refs():
+    """Return a list of all refs in the current repository.
+    """
+
+    return [line.split()[1] for line in GRun('show-ref').output_lines()]