Move debian specific functions from GitRepository to DebianGitRepository

6 files changed, 112 insertions, 86 deletions

diff --git a/gbp/deb/git.py b/gbp/deb/git.py
new file mode 100644
index 00000000..00970f61
--- /dev/null
+++ b/gbp/deb/git.py
@@ -0,0 +1,94 @@
+# vim: set fileencoding=utf-8 :
+#
+# (C) 2011 Guido Günther <agx@sigxcpu.org>
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+"""A Debian Changelog"""
+
+import re
+from gbp.git import GitRepository, GitRepositoryError
+
+class DebianGitRepository(GitRepository):
+    """A git repository that holds the source of a Debian package"""
+
+    def find_version(self, format, version):
+        """
+        Check if a certain version is stored in this repo. Return it's SHA1 in
+        this case. For legacy tags Don't check only the tag but also the
+        message, since the former wasn't injective until recently.
+        You only need to use this funciton if you also need to check for legacy
+        tags.
+
+        @param format: tag pattern
+        @param version: debian version number
+        @return: sha1 of the version tag
+        """
+        tag = self.version_to_tag(format, version)
+        legacy_tag = self._build_legacy_tag(format, version)
+        if self.has_tag(tag): # new tags are injective
+            return self.rev_parse(tag)
+        elif self.has_tag(legacy_tag):
+            out, ret = self.__git_getoutput('cat-file', args=['-p', legacy_tag])
+            if ret:
+                return None
+            for line in out:
+                if line.endswith(" %s\n" % version):
+                    return self.rev_parse(legacy_tag)
+                elif line.startswith('---'): # GPG signature start
+                    return None
+        return None
+
+    @staticmethod
+    def version_to_tag(format, version):
+        """Generate a tag from a given format and a version
+
+        >>> DebianGitRepository.version_to_tag("debian/%(version)s", "0:0~0")
+        'debian/0%0_0'
+        """
+        return format % dict(version=DebianGitRepository._sanitize_version(version))
+
+    @staticmethod
+    def _sanitize_version(version):
+        """sanitize a version so git accepts it as a tag
+
+        >>> DebianGitRepository._sanitize_version("0.0.0")
+        '0.0.0'
+        >>> DebianGitRepository._sanitize_version("0.0~0")
+        '0.0_0'
+        >>> DebianGitRepository._sanitize_version("0:0.0")
+        '0%0.0'
+        >>> DebianGitRepository._sanitize_version("0%0~0")
+        '0%0_0'
+        """
+        return version.replace('~', '_').replace(':', '%')
+
+    @staticmethod
+    def tag_to_version(tag, format):
+        """Extract the version from a tag
+
+        >>> DebianGitRepository.tag_to_version("upstream/1%2_3-4", "upstream/%(version)s")
+        '1:2~3-4'
+        >>> DebianGitRepository.tag_to_version("foo/2.3.4", "foo/%(version)s")
+        '2.3.4'
+        >>> DebianGitRepository.tag_to_version("foo/2.3.4", "upstream/%(version)s")
+        """
+        version_re = format.replace('%(version)s',
+                                    '(?P<version>[\w_%+-.]+)')
+        r = re.match(version_re, tag)
+        if r:
+            version = r.group('version').replace('_', '~').replace('%', ':')
+            return version
+        return None
+
+# vim:et:ts=4:sw=4:et:sts=4:ai:set list listchars=tab\:»·,trail\:·:
diff --git a/gbp/git/__init__.py b/gbp/git/__init__.py
index 96e79b1f..1a35e2dd 100644
--- a/gbp/git/__init__.py
+++ b/gbp/git/__init__.py
@@ -433,33 +433,6 @@ class GitRepository(object):
         version = version.replace('~', '.')
         return format % dict(version=version)
 
-    def find_version(self, format, version):
-        """
-        Check if a certain version is stored in this repo. Return it's SHA1 in
-        this case. For legacy tags Don't check only the tag but also the
-        message, since the former wasn't injective until recently.
-        You only need to use this funciton if you also need to check for legacy
-        tags.
-
-        @param format: tag pattern
-        @param version: debian version number
-        @return: sha1 of the version tag
-        """
-        tag = build_tag(format, version)
-        legacy_tag = self._build_legacy_tag(format, version)
-        if self.has_tag(tag): # new tags are injective
-            return self.rev_parse(tag)
-        elif self.has_tag(legacy_tag):
-            out, ret = self.__git_getoutput('cat-file', args=['-p', legacy_tag])
-            if ret:
-                return None
-            for line in out:
-                if line.endswith(" %s\n" % version):
-                    return self.rev_parse(legacy_tag)
-                elif line.startswith('---'): # GPG signature start
-                    return None
-        return None
-
     def find_tag(self, commit, pattern=None):
         """
         Find the closest tag to a given commit
@@ -1201,47 +1174,6 @@ class GitRepository(object):
         return None
 #}
 
-def build_tag(format, version):
-    """Generate a tag from a given format and a version
-
-    >>> build_tag("debian/%(version)s", "0:0~0")
-    'debian/0%0_0'
-    """
-    return format % dict(version=__sanitize_version(version))
-
-
-def __sanitize_version(version):
-    """sanitize a version so git accepts it as a tag
-
-    >>> __sanitize_version("0.0.0")
-    '0.0.0'
-    >>> __sanitize_version("0.0~0")
-    '0.0_0'
-    >>> __sanitize_version("0:0.0")
-    '0%0.0'
-    >>> __sanitize_version("0%0~0")
-    '0%0_0'
-    """
-    return version.replace('~', '_').replace(':', '%')
-
-
-def tag_to_version(tag, format):
-    """Extract the version from a tag
-
-    >>> tag_to_version("upstream/1%2_3-4", "upstream/%(version)s")
-    '1:2~3-4'
-    >>> tag_to_version("foo/2.3.4", "foo/%(version)s")
-    '2.3.4'
-    >>> tag_to_version("foo/2.3.4", "upstream/%(version)s")
-    """
-    version_re = format.replace('%(version)s',
-                                '(?P<version>[\w_%+-.]+)')
-    r = re.match(version_re, tag)
-    if r:
-        version = r.group('version').replace('_', '~').replace('%', ':')
-        return version
-    return None
-
 
 def rfc822_date_to_git(rfc822_date):
     """Parse a date in RFC822 format, and convert to a 'seconds tz' C{str}ing.
diff --git a/gbp/scripts/buildpackage.py b/gbp/scripts/buildpackage.py
index cdea328b..922b89eb 100644
--- a/gbp/scripts/buildpackage.py
+++ b/gbp/scripts/buildpackage.py
@@ -26,11 +26,11 @@ import time
 import tempfile
 import shutil
 import gbp.deb as du
-from gbp.git import (GitRepositoryError, GitRepository, build_tag)
 from gbp.command_wrappers import (Command,
                                   RunAtCommand, CommandExecFailed, PristineTar,
                                   RemoveTree, CatenateTarArchive)
 from gbp.config import (GbpOptionParser, GbpOptionGroup)
+from gbp.deb.git import (GitRepositoryError, DebianGitRepository)
 from gbp.deb.changelog import ChangeLog, NoChangeLogError, ParseChangeLogError
 from gbp.errors import GbpError
 from glob import glob
@@ -333,7 +333,7 @@ def pristine_tar_build_orig(repo, cp, output_dir, options):
 def git_archive_build_orig(repo, cp, output_dir, options):
     """build orig using git-archive"""
     if options.upstream_tree == 'tag':
-        upstream_tree = build_tag(options.upstream_tag, cp['Upstream-Version'])
+        upstream_tree = repo.version_to_tag(options.upstream_tag, cp['Upstream-Version'])
     elif options.upstream_tree == 'branch':
         upstream_tree = options.upstream_branch
     else:
@@ -512,7 +512,7 @@ def main(argv):
         return 1
 
     try:
-        repo = GitRepository(os.path.curdir)
+        repo = DebianGitRepository(os.path.curdir)
     except GitRepositoryError:
         gbp.log.err("%s is not a git repository" % (os.path.abspath('.')))
         return 1
@@ -601,7 +601,7 @@ def main(argv):
                                    'GBP_BUILD_DIR': build_dir})()
         if options.tag or options.tag_only:
             gbp.log.info("Tagging %s" % cp.version)
-            tag = build_tag(options.debian_tag, cp.version)
+            tag = repo.version_to_tag(options.debian_tag, cp.version)
             if options.retag and repo.has_tag(tag):
                 repo.delete_tag(tag)
             repo.create_tag(name=tag, msg="Debian release %s" % cp.version,
diff --git a/gbp/scripts/dch.py b/gbp/scripts/dch.py
index b502e216..1a4a6c08 100644
--- a/gbp/scripts/dch.py
+++ b/gbp/scripts/dch.py
@@ -26,10 +26,10 @@ import subprocess
 import gbp.command_wrappers as gbpc
 import gbp.dch as dch
 import gbp.log
-from gbp.git import (GitRepositoryError, GitRepository, build_tag, tag_to_version)
 from gbp.config import GbpOptionParser, GbpOptionGroup
 from gbp.errors import GbpError
 from gbp.deb import compare_versions
+from gbp.deb.git import GitRepositoryError, DebianGitRepository
 from gbp.deb.changelog import ChangeLog, NoChangeLogError
 
 user_customizations = {}
@@ -110,7 +110,7 @@ def add_changelog_section(msg, distribution, repo, options, cp,
         pattern = options.upstream_tag.replace('%(version)s', '*')
         try:
             tag = repo.find_tag('HEAD', pattern=pattern)
-            upstream = tag_to_version(tag, options.upstream_tag)
+            upstream = repo.tag_to_version(tag, options.upstream_tag)
             if upstream:
                 gbp.log.debug("Found %s." % upstream)
                 new_version = "%s-1" % upstream
@@ -379,7 +379,7 @@ def main(argv):
 
     try:
         try:
-            repo = GitRepository('.')
+            repo = DebianGitRepository('.')
         except GitRepositoryError:
             raise GbpError, "%s is not a git repository" % (os.path.abspath('.'))
 
diff --git a/gbp/scripts/import_dsc.py b/gbp/scripts/import_dsc.py
index 10721c12..4d512e3f 100644
--- a/gbp/scripts/import_dsc.py
+++ b/gbp/scripts/import_dsc.py
@@ -28,9 +28,9 @@ from email.Utils import parseaddr
 import gbp.command_wrappers as gbpc
 from gbp.deb import (debian_version_chars,
                      parse_dsc, DscFile, UpstreamSource)
+from gbp.deb.git import (DebianGitRepository, GitRepositoryError)
 from gbp.deb.changelog import ChangeLog
-from gbp.git import (build_tag, GitRepository,
-                     GitRepositoryError, rfc822_date_to_git)
+from gbp.git import rfc822_date_to_git
 from gbp.config import GbpOptionParser, GbpOptionGroup, no_upstream_branch_msg
 from gbp.errors import GbpError
 import gbp.log
@@ -109,7 +109,7 @@ def apply_debian_patch(repo, unpack_dir, src, options, parents):
                                  committer=dict(name=[None, author][options.author_committer],
                                                 email=[None, email][options.author_committer],
                                                 date=[None, date][options.author_committer_date]))
-        repo.create_tag(build_tag(options.debian_tag, src.version),
+        repo.create_tag(repo.version_to_tag(options.debian_tag, src.version),
                         msg="Debian release %s" % src.version,
                         commit=commit,
                         sign=options.sign_tags,
@@ -140,9 +140,9 @@ def print_dsc(dsc):
 
 def move_tag_stamp(repo, format, version):
     "Move tag out of the way appending the current timestamp"
-    old = build_tag(format, version)
+    old = repo.version_to_tag(format, version)
     timestamped = "%s~%s" % (version, int(time.time()))
-    new = build_tag(format, timestamped)
+    new = repo.version_to_tag(format, timestamped)
     repo.move_tag(old, new)
 
 
@@ -237,7 +237,7 @@ def main(argv):
                 print_dsc(src)
 
             try:
-                repo = GitRepository('.')
+                repo = DebianGitRepository('.')
                 is_empty = repo.is_empty()
 
                 (clean, out) = repo.is_clean()
@@ -252,7 +252,7 @@ def main(argv):
 
             if needs_repo:
                 gbp.log.info("No git repository found, creating one.")
-                repo = GitRepository.create(src.pkg)
+                repo = DebianGitRepository.create(src.pkg)
                 os.chdir(repo.path)
 
             if repo.bare:
@@ -263,7 +263,7 @@ def main(argv):
             upstream.unpack(dirs['tmp'], options.filters)
 
             format = [(options.upstream_tag, "Upstream"), (options.debian_tag, "Debian")][src.native]
-            tag = build_tag(format[0], src.upstream_version)
+            tag = repo.version_to_tag(format[0], src.upstream_version)
             msg = "%s version %s" % (format[1], src.upstream_version)
 
             if repo.find_version(options.debian_tag, src.version):
diff --git a/gbp/scripts/import_orig.py b/gbp/scripts/import_orig.py
index f6c8aa5e..55b2c2e6 100644
--- a/gbp/scripts/import_orig.py
+++ b/gbp/scripts/import_orig.py
@@ -31,7 +31,7 @@ from gbp.deb import (UpstreamSource,
                      packagename_msg, is_valid_upstreamversion,
                      upstreamversion_msg)
 from gbp.deb.changelog import ChangeLog, NoChangeLogError
-from gbp.git import (GitRepositoryError, GitRepository, build_tag)
+from gbp.deb.git import (GitRepositoryError, DebianGitRepository)
 from gbp.config import GbpOptionParser, GbpOptionGroup, no_upstream_branch_msg
 from gbp.errors import (GbpError, GbpNothingImported)
 import gbp.log
@@ -338,7 +338,7 @@ def main(argv):
             return ret
 
         try:
-            repo = GitRepository('.')
+            repo = DebianGitRepository('.')
         except GitRepositoryError:
             raise GbpError, "%s is not a git repository" % (os.path.abspath('.'))
 
@@ -400,7 +400,7 @@ def main(argv):
                 else:
                     gbp.log.warn("'%s' not an archive, skipping pristine-tar" % source.path)
 
-            tag = build_tag(options.upstream_tag, version)
+            tag = repo.version_to_tag(options.upstream_tag, version)
             repo.create_tag(name=tag,
                             msg="Upstream version %s" % version,
                             commit=commit,