Fix the caching of the HEAD value

[stgit] / stgit / git.py

diff --git a/stgit/git.py b/stgit/git.py
index cc0ae79..5dcb90d 100644 (file)
--- a/stgit/git.py
+++ b/stgit/git.py
@@ -59,7 +59,7 @@ class Commit:
                 self.__author = field[1]
             if field[0] == 'committer':
                 self.__committer = field[1]
-        self.__log = ''.join(lines[i:])
+        self.__log = ''.join(lines[i+1:])
 
     def get_id_hash(self):
         return self.__id_hash
@@ -92,6 +92,8 @@ def get_commit(id_hash):
     """Commit objects factory. Save/look-up them in the __commits
     dictionary
     """
+    global __commits
+
     if id_hash in __commits:
         return __commits[id_hash]
     else:
@@ -214,29 +216,47 @@ def local_changes():
     """
     return len(__tree_status()) != 0
 
+# HEAD value cached
+__head = None
+
 def get_head():
-    """Returns a string representing the HEAD
+    """Verifies the HEAD and returns the SHA1 id that represents it
     """
-    return read_string(head_link)
+    global __head
+
+    if not __head:
+        __head = rev_parse('HEAD')
+    return __head
 
 def get_head_file():
     """Returns the name of the file pointed to by the HEAD link
     """
-    # valid link
-    if os.path.islink(head_link) and os.path.isfile(head_link):
-        return os.path.basename(os.readlink(head_link))
-    else:
-        raise GitException, 'Invalid .git/HEAD link. Git tree not initialised?'
+    return os.path.basename(_output_one_line('git-symbolic-ref HEAD'))
 
 def __set_head(val):
     """Sets the HEAD value
     """
-    write_string(head_link, val)
+    global __head
+
+    if not __head or __head != val:
+        if __run('git-update-ref HEAD', [val]) != 0:
+            raise GitException, 'Could not update HEAD to "%s".' % val
+        __head = val
+
+def __clear_head_cache():
+    """Sets the __head to None so that a re-read is forced
+    """
+    global __head
+
+    __head = None
 
 def rev_parse(git_id):
-    """Parse the string and return an SHA1 id
+    """Parse the string and return a verified SHA1 id
     """
-    _output(['git-rev-parse', git_id])
+    try:
+        return _output_one_line(['git-rev-parse', '--verify', git_id])
+    except GitException:
+        raise GitException, 'Unknown revision: %s' % git_id
 
 def add(names):
     """Add the files or recursively add the directory contents
@@ -355,6 +375,15 @@ def commit(message, files = [], parents = [], allowempty = False,
 
     return commit_id
 
+def apply_diff(rev1, rev2):
+    """Apply the diff between rev1 and rev2 onto the current
+    index. This function doesn't need to raise an exception since it
+    is only used for fast-pushing a patch. If this operation fails,
+    the pushing would fall back to the three-way merge.
+    """
+    return os.system('git-diff-tree -p %s %s | git-apply --index 2> /dev/null'
+                     % (rev1, rev2)) == 0
+
 def merge(base, head1, head2):
     """Perform a 3-way merge between base, head1 and head2 into the
     local tree
@@ -486,6 +515,9 @@ def pull(repository = 'origin', refspec = None):
     """Pull changes from the remote repository. At the moment, just
     use the 'git pull' command
     """
+    # 'git pull' updates the HEAD
+    __clear_head_cache()
+
     args = [repository]
     if refspec:
         args.append(refspec)
@@ -493,17 +525,35 @@ def pull(repository = 'origin', refspec = None):
     if __run('git pull', args) != 0:
         raise GitException, 'Failed "git pull %s"' % repository
 
-def apply_patch(filename = None):
-    """Apply a patch onto the current index. There must not be any
-    local changes in the tree, otherwise the command fails
+def apply_patch(filename = None, base = None):
+    """Apply a patch onto the current or given index. There must not
+    be any local changes in the tree, otherwise the command fails
     """
+    def __apply_patch():
+        if filename:
+            return __run('git-apply --index', [filename]) == 0
+        else:
+            try:
+                _input('git-apply --index', sys.stdin)
+            except GitException:
+                return False
+            return True
+
     os.system('git-update-index --refresh > /dev/null')
 
-    if filename:
-        if __run('git-apply --index', [filename]) != 0:
-            raise GitException, 'Patch does not apply cleanly'
-    else:
-        _input('git-apply --index', sys.stdin)
+    if base:
+        orig_head = get_head()
+        switch(base)
+
+    if not __apply_patch():
+        if base:
+            switch(orig_head)
+        raise GitException, 'Patch does not apply cleanly'
+    elif base:
+        top = commit(message = 'temporary commit used for applying a patch',
+                     parents = [base])
+        switch(orig_head)
+        merge(base, orig_head, top)
 
 def clone(repository, local_dir):
     """Clone a remote repository. At the moment, just use the