Re-designed the tag testing - it does not use fixtures anymore but dyamically checks the existance of tags within the repository - it basically tests the interface and checks that expected return types are actually returned

1 files changed, 98 insertions, 68 deletions

diff --git a/lib/git/tag.py b/lib/git/tag.py
index df3158a6..0c4122ab 100644
--- a/lib/git/tag.py
+++ b/lib/git/tag.py
@@ -4,95 +4,125 @@
 # This module is part of GitPython and is released under
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
-from commit import Commit
+import commit
+import base
 
-class Tag(object):
+class TagRef(base.Ref):
     """
-    Class representing a tag reference which either points to a commit 
+    Class representing a lightweight tag reference which either points to a commit 
     or to a tag object. In the latter case additional information, like the signature
     or the tag-creator, is available.
+    
+    This tag object will always point to a commit object, but may carray additional
+    information in a tag object::
+    
+     tagref = TagRef.find_all(repo)[0]
+     print tagref.commit.message
+     if tagref.tag is not None:
+        print tagref.tag.message
     """
     
-    def __init__(self, name, commit):
+    __slots__ = "tag"
+    
+    def __init__(self, path, commit_or_tag):
         """
         Initialize a newly instantiated Tag
 
-        ``name``
-            is the name of the head
+        ``path``
+            is the full path to the tag
 
-        ``commit``
-            is the Commit that the head points to
+        ``commit_or_tag``
+            is the Commit or TagObject that this tag ref points to
         """
-        self.name = name
-        self.commit = commit
-
-    @classmethod
-    def find_all(cls, repo, **kwargs):
+        super(TagRef, self).__init__(path, commit_or_tag)
+        self.tag = None
+        
+        if commit_or_tag.type == "tag":
+            self.tag = commit_or_tag
+        # END tag object handling 
+    
+    @property
+    def commit(self):
         """
-        Find all Tags in the repository
-
-        ``repo``
-            is the Repo
-
-        ``kwargs``
-            Additional options given as keyword arguments, will be passed 
-            to git-for-each-ref
-
         Returns
-            ``git.Tag[]``
-            
-            List is sorted by committerdate
+            Commit object the tag ref points to
         """
-        options = {'sort': "committerdate",
-                  'format': "%(refname)%00%(objectname)"}
-        options.update(**kwargs)
-
-        output = repo.git.for_each_ref("refs/tags", **options)
-        return cls.list_from_string(repo, output)
+        if self.object.type == "commit":
+            return self.object
+        # it is a tag object
+        return self.object.object
 
     @classmethod
-    def list_from_string(cls, repo, text):
+    def find_all(cls, repo, common_path = "refs/tags", **kwargs):
         """
-        Parse out tag information into an array of Tag objects
-
-        ``repo``
-            is the Repo
-
-        ``text``
-            is the text output from the git-for-each command
-
         Returns
             git.Tag[]
+            
+        For more documentation, please refer to git.base.Ref.find_all
         """
-        tags = []
-        for line in text.splitlines():
-            tags.append(cls.from_string(repo, line))
-        return tags
-
-    @classmethod
-    def from_string(cls, repo, line):
+        return super(TagRef,cls).find_all(repo, common_path, **kwargs)
+        
+        
+# provide an alias
+Tag = TagRef
+        
+class TagObject(base.Object):
+    """
+    Non-Lightweight tag carrying additional information about an object we are pointing 
+    to.
+    """
+    type = "tag"
+    __slots__ = ( "object", "tag", "tagger", "tagged_date", "message" )
+        
+    def __init__(self, repo, id, size=None, object=None, tag=None, 
+                tagger=None, tagged_date=None, message=None):
         """
-        Create a new Tag instance from the given string.
-
+        Initialize a tag object with additional data
+        
         ``repo``
-            is the Repo
-
-        ``line``
-            is the formatted tag information
-
-        Format::
+            repository this object is located in
             
-            name: [a-zA-Z_/]+
-            <null byte>
-            id: [0-9A-Fa-f]{40}
-        
-        Returns
-            git.Tag
+        ``id``
+            SHA1 or ref suitable for git-rev-parse
+            
+        ``size``
+            Size of the object's data in bytes
+            
+         ``object``
+            Object instance of object we are pointing to
+         
+         ``tag``
+            name of this tag
+            
+         ``tagger``
+            Actor identifying the tagger
+            
+          ``tagged_date`` : (tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst)
+            is the DateTime of the tag creation
         """
-        full_name, ids = line.split("\x00")
-        name = full_name.split("/")[-1]
-        commit = Commit(repo, id=ids)
-        return Tag(name, commit)
-
-    def __repr__(self):
-        return '<git.Tag "%s">' % self.name
+        super(TagObject, self).__init__(repo, id , size)
+        self.object = object
+        self.tag = tag
+        self.tagger = tagger
+        self.tagged_date = tagged_date
+        self.message = message
+        
+    def __bake__(self):
+        super(TagObject, self).__bake__()
+        
+        output = self.repo.git.cat_file(self.type,self.id)
+        lines = output.split("\n")
+        
+        obj, hexsha = lines[0].split(" ")       # object <hexsha>
+        type_token, type_name = lines[1].split(" ") # type <type_name>
+        self.object = base.Object.get_type_by_name(type_name)(self.repo, hexsha)
+        
+        self.tag = lines[2][4:]  # tag <tag name>
+        
+        tagger_info = lines[3][7:]# tagger <actor> <date>
+        self.tagger, self.tagged_date = commit.Commit._actor(tagger_info)
+        
+        # line 4 empty - check git source to figure out purpose
+        self.message = "\n".join(lines[5:])
+        
+