--- /dev/null
+# 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\:·:
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
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.
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
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:
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
'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,
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 = {}
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
try:
try:
- repo = GitRepository('.')
+ repo = DebianGitRepository('.')
except GitRepositoryError:
raise GbpError, "%s is not a git repository" % (os.path.abspath('.'))
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
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,
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)
print_dsc(src)
try:
- repo = GitRepository('.')
+ repo = DebianGitRepository('.')
is_empty = repo.is_empty()
(clean, out) = repo.is_clean()
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:
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):
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
return ret
try:
- repo = GitRepository('.')
+ repo = DebianGitRepository('.')
except GitRepositoryError:
raise GbpError, "%s is not a git repository" % (os.path.abspath('.'))
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,
projects / tools / git-buildpackage.git / commitdiff