diff options
Diffstat (limited to 'lib/git')
| -rw-r--r-- | lib/git/base.py | 161 | ||||
| -rw-r--r-- | lib/git/head.py | 89 | ||||
| -rw-r--r-- | lib/git/tag.py | 166 |
3 files changed, 273 insertions, 143 deletions
diff --git a/lib/git/base.py b/lib/git/base.py index 687fb50a..84dd0754 100644 --- a/lib/git/base.py +++ b/lib/git/base.py @@ -3,10 +3,13 @@ # # This module is part of GitPython and is released under # the BSD License: http://www.opensource.org/licenses/bsd-license.php +import os class LazyMixin(object): lazy_properties = [] - + + __slots__ = "__baked__" + def __init__(self): self.__baked__ = False @@ -38,7 +41,7 @@ class Object(LazyMixin): """ TYPES = ("blob", "tree", "commit", "tag") __slots__ = ("repo", "id", "size") - type = None # to be set by subclass + type = None # to be set by subclass def __init__(self, repo, id, size=None): """ @@ -46,9 +49,11 @@ class Object(LazyMixin): will be set on demand if None. ``repo`` - repository this object is located in + repository this object is located in + ``id`` SHA1 or ref suitable for git-rev-parse + ``size`` Size of the object's data in bytes """ @@ -97,3 +102,153 @@ class Object(LazyMixin): string with pythonic representation of our object """ return '<git.%s "%s">' % (self.__class__.__name__, self.id) + + @classmethod + def get_type_by_name(cls, object_type_name): + """ + Returns + type suitable to handle the given object type name. + Use the type to create new instances. + + ``object_type_name`` + Member of TYPES + + Raises + ValueError: In case object_type_name is unknown + """ + if object_type_name == "commit": + import commit + return commit.Commit + elif object_type_name == "tag": + import tag + return tag.TagObject + elif object_type_name == "blob": + import blob + return blob.Blob + elif object_type_name == "tree": + import tree + return tree.Tree + else: + raise ValueError("Cannot handle unknown object type: %s" % object_type_name) + + +class Ref(object): + """ + Represents a named reference to any object + """ + __slots__ = ("path", "object") + + def __init__(self, path, object = None): + """ + Initialize this instance + + ``path`` + Path relative to the .git/ directory pointing to the ref in question, i.e. + refs/heads/master + + ``object`` + Object instance, will be retrieved on demand if None + """ + self.path = path + self.object = object + + def __str__(self): + return self.name() + + def __repr__(self): + return '<git.%s "%s">' % (self.__class__.__name__, self.path) + + def __eq__(self, other): + return self.path == other.path and self.object == other.object + + def __ne__(self, other): + return not ( self == other ) + + def __hash__(self): + return hash(self.path) + + @property + def name(self): + """ + Returns + Name of this reference + """ + return os.path.basename(self.path) + + @classmethod + def find_all(cls, repo, common_path = "refs", **kwargs): + """ + Find all refs in the repository + + ``repo`` + is the Repo + + ``common_path`` + Optional keyword argument to the path which is to be shared by all + returned Ref objects + + ``kwargs`` + Additional options given as keyword arguments, will be passed + to git-for-each-ref + + Returns + git.Ref[] + + List is sorted by committerdate + The returned objects are compatible to the Ref base, but represent the + actual type, such as Head or Tag + """ + + options = {'sort': "committerdate", + 'format': "%(refname)%00%(objectname)%00%(objecttype)%00%(objectsize)"} + + options.update(kwargs) + + output = repo.git.for_each_ref(common_path, **options) + return cls.list_from_string(repo, output) + + @classmethod + def list_from_string(cls, repo, text): + """ + Parse out ref information into a list of Ref compatible objects + + ``repo`` + is the Repo + ``text`` + is the text output from the git-for-each-ref command + + Returns + git.Ref[] + + list of Ref objects + """ + heads = [] + + for line in text.splitlines(): + heads.append(cls.from_string(repo, line)) + + return heads + + @classmethod + def from_string(cls, repo, line): + """ + Create a new Ref instance from the given string. + + ``repo`` + is the Repo + + ``line`` + is the formatted ref information + + Format:: + + name: [a-zA-Z_/]+ + <null byte> + id: [0-9A-Fa-f]{40} + + Returns + git.Head + """ + full_path, hexsha, type_name, object_size = line.split("\x00") + obj = Object.get_type_by_name(type_name)(repo, hexsha, object_size) + return cls(full_path, obj) diff --git a/lib/git/head.py b/lib/git/head.py index 639cee40..3c3f13ac 100644 --- a/lib/git/head.py +++ b/lib/git/head.py @@ -5,8 +5,9 @@ # the BSD License: http://www.opensource.org/licenses/bsd-license.php import commit +import base -class Head(object): +class Head(base.Ref): """ A Head is a named reference to a Commit. Every Head instance contains a name and a Commit object. @@ -26,93 +27,37 @@ class Head(object): '1c09f116cbc2cb4100fb6935bb162daa4723f455' """ - def __init__(self, name, commit): + def __init__(self, path, commit): """ Initialize a newly instanced Head - `name` - is the name of the head + ``path`` + is the path to the head ref, relative to the .git directory, i.e. + refs/heads/master `commit` is the Commit object that the head points to """ - self.name = name - self.commit = commit + super(Head, self).__init__(name, commit) - @classmethod - def find_all(cls, repo, **kwargs): - """ - Find all Heads in the repository - - `repo` - is the Repo - - `kwargs` - Additional options given as keyword arguments, will be passed - to git-for-each-ref - - Returns - git.Head[] - - List is sorted by committerdate - """ - - options = {'sort': "committerdate", - 'format': "%(refname)%00%(objectname)"} - options.update(kwargs) - - output = repo.git.for_each_ref("refs/heads", **options) - return cls.list_from_string(repo, output) - @classmethod - def list_from_string(cls, repo, text): + @property + def commit(self): """ - Parse out head information into a list of head objects - - ``repo`` - is the Repo - ``text`` - is the text output from the git-for-each-ref command - Returns - git.Head[] + Commit object the head points to """ - heads = [] - - for line in text.splitlines(): - heads.append(cls.from_string(repo, line)) - - return heads - + return self.object + @classmethod - def from_string(cls, repo, line): + def find_all(cls, repo, common_path = "refs/heads", **kwargs): """ - Create a new Head instance from the given string. - - ``repo`` - is the Repo - - ``line`` - is the formatted head information - - Format:: - - name: [a-zA-Z_/]+ - <null byte> - id: [0-9A-Fa-f]{40} - Returns - git.Head + git.Head[] + + For more documentation, please refer to git.base.Ref.find_all """ - full_name, ids = line.split("\x00") - - if full_name.startswith('refs/heads/'): - name = full_name[len('refs/heads/'):] - else: - name = full_name - - c = commit.Commit(repo, id=ids) - return Head(name, c) + return super(Head,cls).find_all(repo, common_path, **kwargs) def __repr__(self): return '<git.Head "%s">' % self.name 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:]) + + |