def find_changelog(t, merge, max_blocks=1):
"""Find the changelog in the given tree.
First looks for 'debian/changelog'. If "merge" is true will also
look for 'changelog'.
The returned changelog is created with 'allow_empty_author=True'
as some people do this but still want to build.
'max_blocks' defaults to 1 to try and prevent old broken
changelog entries from causing the command to fail,
"top_level" is a subset of "merge" mode. It indicates that the
'.bzr' dir is at the same level as 'changelog' etc., rather
than being at the same level as 'debian/'.
:param t: the Tree to look in.
:param merge: whether this is a "merge" package.
:param max_blocks: Number of max_blocks to parse (defaults to 1). Use None
to parse the entire changelog.
:return: (changelog, top_level) where changelog is the Changelog,
and top_level is a boolean indicating whether the file is
located at 'changelog' (rather than 'debian/changelog') if
merge was given, False otherwise.
"""
top_level = False
with t.lock_read():
changelog_file = 'debian/changelog'
if not t.has_filename(changelog_file):
checked_files = ['debian/changelog']
if merge:
# Assume LarstiQ's layout (.bzr in debian/)
changelog_file = 'changelog'
top_level = True
if not t.has_filename(changelog_file):
checked_files.append(changelog_file)
changelog_file = None
else:
changelog_file = None
if changelog_file is None:
if getattr(t, "abspath", None):
checked_files = [t.abspath(f) for f in checked_files]
raise MissingChangelogError(" or ".join(checked_files))
elif merge and t.has_filename('changelog'):
# If it is a "top_level" package and debian is a symlink to
# "." then it will have found debian/changelog. Try and detect
# this.
if (t.is_versioned('debian') and
t.kind('debian') == 'symlink' and
t.get_symlink_target('debian') == '.'):
changelog_file = 'changelog'
top_level = True
mutter("Using '%s' to get package information", changelog_file)
if not t.is_versioned(changelog_file):
raise AddChangelogError(changelog_file)
contents = t.get_file_text(changelog_file)
changelog = Changelog()
try:
changelog.parse_changelog(contents, max_blocks=max_blocks, allow_empty_author=True)
except ChangelogParseError, e:
raise UnparseableChangelog(str(e))
def _parse_deb_project(changelog='debian/changelog'):
clog = Changelog()
try:
clog.parse_changelog(open(changelog), max_blocks=1)
return clog.package
except ChangelogParseError:
raise LGPException("Malformed Debian changelog '%s'" % changelog)
def reload(self):
changelog = open(self.debian_changelog_path).read()
self.debian_changelog = Changelog(changelog)
self.debian = self.debian_changelog.full_version
self.setup_py_text = open(self.setup_py_path).read()
setup_py_results = re.findall(r'version\s*=\s*["\']([0-9]*\.[0-9]*\.[0-9]*)',
self.setup_py_text)
assert len(setup_py_results) == 1
self.setup_py = setup_py_results[0]
self.package_json_json = json.load(open(self.package_json_path),
object_pairs_hook=collections.OrderedDict)
self.package_json = self.package_json_json['version']
build = minidom.parse(self.build_ant_path)
self.build_ant_et = build
build_ant_versions = [x.attributes['value'].value for x in
build.getElementsByTagName('property')
if x.attributes['name'].value == 'pkg_version']
assert len(build_ant_versions) == 1
self.build_ant = build_ant_versions[0]
self.bower_json_json = json.load(open(self.bower_json_path),
object_pairs_hook=collections.OrderedDict)
self.bower_json = self.bower_json_json['version']
self.version = self.debian
def __init__(self,
name,
version,
native=False,
version3=False,
multiple_upstream_tarballs=None):
"""
:param name: Package name
:param version: Package version
:param native: Whether to build a native source package
:param version3: Whether to build a version 3.0 source package
:param multiple_upstream_tarballs: A list of each top-level directory
within the upstream tree which is to be packed as a source format
3.0 (quilt) additional upstream tarball
"""
self.upstream_files = {}
self.upstream_symlinks = {}
self.debian_files = {}
self.name = name
self.native = native
self.version3 = version3
self.multiple_upstream_tarballs = multiple_upstream_tarballs
if multiple_upstream_tarballs and not (version3 and not native):
raise AssertionError("Multiple upstream tarballs are only "
"possible with 3.0 (quilt) format")
self._cl = Changelog()
self.new_version(version)
def create_changelog(self, *distributions):
changelog = Changelog()
changes = [" [ A. Hacker ]", " * Something"]
author = "J. Maintainer <*****@*****.**"
for distro in distributions:
changelog.new_block(changes=changes, author=author,
distributions=distro)
return changelog
def make_changelog(self, versions_and_distributions):
cl = Changelog()
changes = [" [ A. Hacker ]", " * Something"]
author = "J. Maintainer <*****@*****.**>"
for version, distro in versions_and_distributions:
cl.new_block(changes=changes, author=author,
distributions=distro, version=version)
return cl
def parse_changelog(path):
changelog = Changelog()
with open(path, 'r') as file_changelog:
changelog.parse_changelog(file_changelog.read())
set_ids = set()
for block in changelog:
for change in block.changes():
set_ids = set_ids.union(WorkfrontNoteInfo.getIds(change))
return (set_ids, changelog)
def _parse_deb_version(changelog='debian/changelog'):
try:
clog = Changelog()
clog.parse_changelog(open(changelog), max_blocks=1)
return clog.full_version
except IOError:
raise LGPException("Debian changelog '%s' cannot be found" % changelog)
except ChangelogParseError:
raise LGPException("Malformed Debian changelog '%s'" % changelog)
def tree_set_changelog_version(tree: WorkingTree, build_version: Version,
subpath: str) -> None:
cl_path = osutils.pathjoin(subpath, "debian/changelog")
with tree.get_file(cl_path) as f:
cl = Changelog(f)
if Version(str(cl.version) + "~") > build_version:
return
cl.version = build_version
with open(tree.abspath(cl_path), "w") as f:
cl.write_to_open_file(f)
def _parse_deb_distrib(changelog='debian/changelog'):
clog = Changelog()
try:
clog.parse_changelog(open(changelog), max_blocks=1)
return clog.distributions
except IOError:
raise DistributionException("Debian changelog '%s' cannot be found" %
changelog)
except ChangelogParseError:
raise DistributionException("Malformed Debian changelog '%s'" %
changelog)
def assertUnicodeCommitInfo(self, changes):
wt = self.make_branch_and_tree(".")
changelog = Changelog()
author = "J. Maintainer <*****@*****.**>"
changelog.new_block(changes=changes, author=author)
message, authors, thanks, bugs = get_commit_info_from_changelog(
changelog, wt.branch, _lplib=MockLaunchpad())
self.assertEqual(
u'[ \xc1. Hacker ]\n'
u'* First ch\xe1nge, LP: #12345\n'
u'* Second change, thanks to \xde. Hacker', message)
self.assertEqual([author, u'\xc1. Hacker'], authors)
self.assertEqual(text_type, type(authors[0]))
self.assertEqual([u'\xde. Hacker'], thanks)
self.assertEqual(['https://launchpad.net/bugs/12345 fixed'], bugs)
def munge_lp_bug_numbers(repo):
debian_changelog = os.path.join(repo.working_dir, 'debian', 'changelog')
with ExitStack() as resources:
infp = resources.enter_context(
open(debian_changelog, 'r', encoding='utf-8'))
outfp = resources.enter_context(atomic(debian_changelog))
changelog = Changelog(infp)
# Iterate through every line in the top changelog block. Because we
# want to modify the existing LP bug numbers, and because the API
# doesn't give us direct access to those lines, we need to pop the
# hood, reach in, and manipulate them ourselves.
for i, line in enumerate(changelog[0]._changes):
munged = re.sub('LP: #([0-9]+)', 'LP:\\1', line)
changelog[0]._changes[i] = munged
changelog.write_to_open_file(outfp)
def test_get_commit_message_info(self):
wt = self.make_branch_and_tree(".")
changelog = Changelog()
changes = [" [ A. Hacker ]", " * First change, LP: #12345",
" * Second change, thanks to B. Hacker"]
author = "J. Maintainer <*****@*****.**"
changelog.new_block(changes=changes, author=author)
message, authors, thanks, bugs = \
get_commit_info_from_changelog(changelog, wt.branch,
_lplib=MockLaunchpad())
self.assertEqual("\n".join(strip_changelog_message(changes)), message)
self.assertEqual([author]+find_extra_authors(changes), authors)
self.assertEqual(unicode, type(authors[0]))
self.assertEqual(find_thanks(changes), thanks)
self.assertEqual(find_bugs_fixed(changes, wt.branch,
_lplib=MockLaunchpad()), bugs)
def find_patch_base(tree):
"""Find the base revision to apply patches to.
Args:
tree: Tree to find the patch base for
Returns:
A revision string
"""
with tree.get_file("debian/changelog") as f:
cl = Changelog(f, max_blocks=1)
package = cl.package
upstream_version = cl.version.upstream_version
possible_tags = [
"upstream-%s" % upstream_version,
"upstream/%s" % upstream_version,
"%s" % upstream_version,
"v%s" % upstream_version,
"%s-%s" % (package, upstream_version),
]
tags = tree.branch.tags.get_tag_dict()
for possible_tag in possible_tags:
if possible_tag in tags:
return tags[possible_tag]
# TODO(jelmer): Do something clever, like look for the last merge?
return None
def get_latest_changelog_entry(local_tree, subpath=""):
if control_files_in_root(local_tree, subpath):
path = os.path.join(subpath, "changelog")
else:
path = os.path.join(subpath, "debian", "changelog")
with local_tree.get_file(path) as f:
cl = Changelog(f, max_blocks=1)
return cl[0]
def test_get_commit_info_none(self):
wt = self.make_branch_and_tree(".")
changelog = Changelog()
message, authors, thanks, bugs = get_commit_info_from_changelog(
changelog, wt.branch, _lplib=MockLaunchpad())
self.assertEqual(None, message)
self.assertEqual([], authors)
self.assertEqual([], thanks)
self.assertEqual([], bugs)
def assertChangelogPackage(changelog_filename):
with open(changelog_filename) as f:
package = Changelog(f).get_package()
image_dir = os.path.basename(os.path.dirname(changelog_filename))
assert package == image_dir, \
'Changelog package name %s matches directory name %s' % (
package, image_dir)
def test_matches_package_version(self):
if not os.path.exists("debian/changelog"):
self.skipTest("no debian/changelog available. "
"Running outside of source tree?")
with open("debian/changelog", "r") as f:
cl = Changelog(f, max_blocks=1)
package_version = str(cl.version)
package_version = re.match(r'^\d+\.\d+', package_version)[0]
self.assertEqual(package_version, version_string)
def get_debian_version(self, path: str) -> "Version":
try:
fn_changelog = join(path, 'debian', 'changelog')
with open(fn_changelog, 'r') as fd:
changelog = Changelog(fd)
return Version(changelog.version.full_version)
except (EnvironmentError, ChangelogParseError) as ex:
self.debug('Failed open %r: %s' % (fn_changelog, ex))
return Version('0')
def check_4_1_5():
# If epoch has changed
with open('debian/changelog', 'r') as f:
cl = Changelog(f, max_blocks=2)
epochs = set()
for block in cl:
epochs.add(block.version.epoch)
if len(epochs) > 1:
# Maybe they did email debian-devel@; we don't know.
raise UpgradeCheckUnable("5.6.12", "last release changes epoch")
def make_changes(self, local_tree):
# TODO(jelmer): Don't call UI implementation, refactor brz-debian
cmd_merge_upstream().run(directory=local_tree.basedir,
snapshot=self._snapshot)
if self._build_verify:
build(local_tree.basedir)
with local_tree.get_file('debian/changelog') as f:
cl = Changelog(f.read())
self._upstream_version = cl.version.upstream_version
subprocess.check_call(["debcommit", "-a"], cwd=local_tree.basedir)
def distill(self, target):
"""Extract the source to a tree rooted at the given location.
The passed location cannot already exist. If it does then
FileExists will be raised.
:param target: a string containing the location at which to
place the tree containing the buildable source.
"""
from debmutate.debcargo import parse_debcargo_source_name
if os.path.exists(target):
raise bzr_errors.FileExists(target)
with self.tree.get_file(
os.path.join(
self.subpath,
'debian/changelog' if not self.top_level else 'changelog'),
'r') as f:
cl = Changelog(f, max_blocks=1)
package = cl.package
version = cl.version
if not package.startswith('rust-'):
raise NotImplementedError
debcargo_path = [self.subpath]
if not self.top_level:
debcargo_path.append('debian')
debcargo_path.append('debcargo.toml')
try:
debcargo_text = self.tree.get_file_text(
os.path.join(*debcargo_path))
except bzr_errors.NoSuchFile:
semver_suffix = False
else:
from toml.decoder import loads as loads_toml
debcargo = loads_toml(debcargo_text.decode())
semver_suffix = debcargo.get('semver_suffix')
crate, crate_semver_version = parse_debcargo_source_name(
package, semver_suffix)
if '-' in crate:
crate = cargo_translate_dashes(crate)
crate_version = unmangle_debcargo_version(version.upstream_version)
if crate_semver_version is not None:
note('Using crate name: %s, version %s (semver: %s)', crate,
crate_version, crate_semver_version)
else:
note('Using crate name: %s, version %s', crate, crate_version)
try:
subprocess.check_call([
'debcargo', 'package', '--changelog-ready', '--config',
self.tree.abspath(os.path.join(
*debcargo_path)), '--directory', target, crate
] + ([crate_version] if crate_version else []))
except subprocess.CalledProcessError:
raise DebcargoError()
def debcommit_release(tree, committer=None, subpath="", message=None):
tag_name = tree_debian_tag_name(tree, tree.branch, subpath=subpath)
cl_path = posixpath.join(subpath, "debian/changelog")
if tag_name is None:
raise UnreleasedChanges(cl_path)
if message is None:
cl = Changelog(tree.get_file(cl_path), max_blocks=1)
message = "releasing package %s version %s" % (cl[0].package,
cl[0].version)
revid = tree.commit(committer=committer, message=message)
tree.branch.tags.set_tag(tag_name, revid)
return tag_name
def assertChangelogPackage(image_dir):
try:
with open(os.path.join(image_dir, 'changelog')) as f:
package = Changelog(f).get_package()
except IOError as io_e:
if io_e.errno == 2:
raise AssertionError('%s must have a changelog file' % image_dir)
raise
assert package == os.path.basename(image_dir), \
'Changelog package name %s matches directory name %s' % (
package, os.path.basename(image_dir))
def check(self, path: str) -> None:
""" the real check """
super(UniventionPackageCheck, self).check(path)
fn = os.path.join(path, 'debian', 'changelog')
try:
with open(fn, 'r') as stream:
changelog = Changelog(stream, strict=True)
except EnvironmentError as ex:
self.addmsg('0007-1', 'failed to open and read file: %s' % ex, fn)
return
except ChangelogParseError as ex:
self.addmsg('0007-1', ex, fn)
return
for change in changelog[0].changes():
if REticket.search(change):
break
else:
self.addmsg(
'0007-2',
'latest changelog entry does not contain bug/ticket/issue number',
fn)
last = None
for nr, block in enumerate(changelog):
if last:
if mktime_tz(parsedate_tz(last.date)) <= mktime_tz(
parsedate_tz(block.date)):
if nr < RECENT_ENTRIES:
self.addmsg(
'0007-3',
'not strict-monotonically increasing by time: %s <= %s'
% (last.date, block.date), fn)
else:
self.addmsg(
'0007-5',
'old not strict-monotonically increasing by time: %s <= %s'
% (last.date, block.date), fn)
if last.version <= block.version:
if nr < RECENT_ENTRIES:
self.addmsg(
'0007-4',
'not strict-monotonically increasing by version: %s <= %s'
% (last.version, block.version), fn)
else:
self.addmsg(
'0007-6',
'old not strict-monotonically increasing by version: %s <= %s'
% (last.version, block.version), fn)
last = block
def test_add_new(self):
tree = self.make_branch_and_tree(".")
tree.lock_write()
self.addCleanup(tree.unlock)
tree.mkdir("debian")
changelog_add_new_version(tree, "1.0", "sid", None, "somepkg")
# changelog_add_new_version will version the changelog if it was created
cl = Changelog(open('debian/changelog'))
self.assertEquals(cl._blocks[0].package, "somepkg")
self.assertEquals(cl._blocks[0].distributions, "UNRELEASED")
self.assertEquals(cl._blocks[0].version, Version("1.0-1"))
self.assertEquals([], list(tree.filter_unversioned_files(["debian/changelog"])))
def link_upstream_tarball(releaseType):
#Find out the tarball link name
upstream_name = os.path.basename( os.getcwd() )
#paragraphs = deb822.Packages.iter_paragraphs(open('./debian/copyright', 'r'));
#upstream_name = next(paragraphs)['Upstream-Name']
changelog = Changelog()
changelog.parse_changelog(open('./debian/changelog', 'r'))
src_package_name = changelog.get_package()
upstream_version = changelog.get_version().upstream_version
#Handle packages with updated tarballs
#e.g. 5.0.0a version instead of 5.0.0
last_char = upstream_version[-1]
if last_char.isalpha():
real_upstream_version = upstream_version.rstrip(last_char)
else:
real_upstream_version = upstream_version
link_name = '../' + src_package_name + '_' + upstream_version + '.orig.tar.xz'
#Find out the tarball link target path
cwd = os.path.dirname(os.path.realpath(__file__))
config_tarball_loc = json.load(open(cwd + "/../conf/tarball-locations.json"))
config_versions = json.load(open(cwd + "/../conf/versions.json"))
link_target = os.path.expanduser(config_tarball_loc[releaseType])
link_target += '/' + config_versions[releaseType] + '/'
link_target += upstream_name + '-' + real_upstream_version + ".tar.xz"
#Create the link
try:
os.symlink(link_target,link_name)
except:
pass
def only_changes_last_changelog_block(
tree: WorkingTree, basis_tree: Tree, changelog_path: str, changes
) -> bool:
"""Check whether the only change in a tree is to the last changelog entry.
Args:
tree: Tree to analyze
changelog_path: Path to the changelog file
changes: Changes in the tree
Returns:
boolean
"""
with tree.lock_read(), basis_tree.lock_read():
changes_seen = False
for change in changes:
if change.path[1] == "":
continue
if change.path[1] == changelog_path:
changes_seen = True
continue
if not tree.has_versioned_directories() and is_inside(
change.path[1], changelog_path
):
continue
return False
if not changes_seen:
return False
try:
new_cl = Changelog(tree.get_file_text(changelog_path))
except NoSuchFile:
return False
try:
old_cl = Changelog(basis_tree.get_file_text(changelog_path))
except NoSuchFile:
return True
if old_cl.distributions != "UNRELEASED":
return False
del new_cl._blocks[0]
del old_cl._blocks[0]
return str(new_cl) == str(old_cl)
def generate_changelog_file(self):
changes = Changelog()
for version, scheduled_at, change, distribution in \
self.db.changelog_entries(self.build.id):
changes.new_block(
package=self.deb_name,
version=version,
distributions=distribution,
urgency='low',
author=config.maintainer,
date=scheduled_at.strftime('%a, %d %b %Y %H:%M:%S %z'))
changes.add_change('\n * ' + change + '\n')
with open(self.debian_file('changelog'), 'w') as f:
changes.write_to_open_file(f)
def get_package_version(dirname):
try:
from debian.changelog import Changelog
except ImportError:
from debian_bundle.changelog import Changelog
changelog = os.path.join(dirname, 'debian', 'changelog')
ch = Changelog(open(changelog))
package = ch.package
version = str(ch.version).split(':')[-1]
return package, version
def generate_changelog(self, package):
"""Generate a Debian changelog for the catkin package.
Args:
package (catkin_pkg.package.Package)
Returns:
debian.Changelog
"""
package_path = self.get_package_path(package)
package_changelog = catkin_changelog.get_changelog_from_path(package_path)
debian_changelog = Changelog()
package_name = self.catkin_to_apt_name(package.name)
maintainer = '{} <{}>'.format(
package.maintainers[0].name,
package.maintainers[0].email
)
def transfer_version_change(change):
debian_changelog.add_change(str(change))
def transfer_version_block(v):
version = v[0]
date = v[1]
changes = v[2]
full_version = version + '-0' + self.ros_os_version
debian_changelog.new_block(
package=package_name,
version=Version(full_version),
distributions=self.ros_os_version,
urgency='high',
author=maintainer,
date=self._datetime_to_rfc2822(date),
)
debian_changelog.add_change('')
map(transfer_version_change, changes)
debian_changelog.add_change('')
if package_changelog is not None:
map(transfer_version_block, package_changelog.foreach_version())
else:
# If CHANGELOG.rst is missing, generate a bare changelog
version = str(package.version)
date = datetime.datetime.now()
changes = []
block = (version, date, changes)
transfer_version_block(block)
return debian_changelog
# stdlib
from sys import stdout
# 3rd party
from debian.changelog import Changelog, Version
changelog = Changelog()
# from tagim import __version__
changelog.new_block(package='python-tagim', # will likely need a tagim package that depends on this library
version=Version('0.1'),
distributions='unstable',
urgency='low',
author='Hobson Lane <*****@*****.**>', # name and e-mail must match your GPG key
date='Thu, 26 Jan 2012 08:29:40 +1100', # must be in the format of `date -R`
)
changelog.add_change('')
changelog.add_change(' * Welcome to tagim')
changelog.add_change(' * Features')
changelog.add_change(' - tag images with text embedded in EXIF comment field')
changelog.add_change(' - chose random image from selected folder or tree of folders and display on desktop background at prescribed intervals')
changelog.add_change('')
stdout.write(changelog)
class Versions(object):
def __init__(self):
self.setup_py_path = os.path.join(RHIZI_SOURCE_REPO, 'setup.py')
self.debian_changelog_path = os.path.join(RHIZI_SOURCE_REPO, 'res/debian/pkg__rhizi-common/changelog')
self.package_json_path = os.path.join(RHIZI_SOURCE_REPO, 'package.json')
self.build_ant_path = os.path.join(RHIZI_SOURCE_REPO, 'build.ant')
self.bower_json_path = os.path.join(RHIZI_SOURCE_REPO, 'bower.json')
self.filenames = [self.setup_py_path, self.debian_changelog_path,
self.package_json_path, self.build_ant_path,
self.bower_json_path]
self.reload()
def reload(self):
changelog = open(self.debian_changelog_path).read()
self.debian_changelog = Changelog(changelog)
self.debian = self.debian_changelog.full_version
self.setup_py_text = open(self.setup_py_path).read()
setup_py_results = re.findall(r'version\s*=\s*["\']([0-9]*\.[0-9]*\.[0-9]*)',
self.setup_py_text)
assert len(setup_py_results) == 1
self.setup_py = setup_py_results[0]
self.package_json_json = json.load(open(self.package_json_path),
object_pairs_hook=collections.OrderedDict)
self.package_json = self.package_json_json['version']
build = minidom.parse(self.build_ant_path)
self.build_ant_et = build
build_ant_versions = [x.attributes['value'].value for x in
build.getElementsByTagName('property')
if x.attributes['name'].value == 'pkg_version']
assert len(build_ant_versions) == 1
self.build_ant = build_ant_versions[0]
self.bower_json_json = json.load(open(self.bower_json_path),
object_pairs_hook=collections.OrderedDict)
self.bower_json = self.bower_json_json['version']
self.version = self.debian
def ensure_synced(self):
"""
setup.py
debian - res/debian/pkg__rhizi-common/changelog
package.json
"""
if self.setup_py != self.debian:
print("setup.py {} != debian {}".format(self.setup_py, self.debian))
raise SystemExit
if self.package_json != self.debian:
print("package.json {} != debian {}".format(self.package_json, self.debian))
raise SystemExit
if self.build_ant != self.debian:
print("build.ant {} != debian {}".format(self.build_ant, self.debian))
raise SystemExit
if self.bower_json != self.debian:
print("bower.json {} != debian {}".format(self.bower_json, self.debian))
raise SystemExit
def bump_version(self, debian_changelog):
old_ver = self.setup_py
new_ver = self.next_micro()
# debian changelog
now = datetime.now(tz=tzlocal()).strftime("%a, %d %b %Y %H:%M:%S %z")
self.debian_changelog.new_block(
version=new_ver,
author='{} <{}>'.format(check_output('git config user.name'.split()).strip().decode('utf-8'),
check_output('git config user.email'.split()).strip().decode('utf-8')),
package="rhizi",
distributions="unstable",
urgency='low',
changes=[' * {}'.format(c.decode('utf-8')) for c in debian_changelog],
date=now)
with open(self.debian_changelog_path, 'w+') as fd:
fd.write(str(self.debian_changelog))
# build.ant - not using minidom since it doesn't keep whitespace, too
# much churn
replace(self.build_ant_path, old_ver, new_ver)
# setup.py
replace(self.setup_py_path, old_ver, new_ver)
# package.json
self.package_json_json['version'] = new_ver
with open(self.package_json_path, 'w+') as fd:
json.dump(self.package_json_json, fd,
indent=2, separators=(',', ': '))
# bower.json
self.bower_json_json['version'] = new_ver
with open(self.bower_json_path, 'w+') as fd:
json.dump(self.bower_json_json, fd,
indent=2, separators=(',', ': '))
# update internal versions
self.reload()
def next_micro(self):
major, minor, micro = map(int, self.setup_py.split('.'))
return '{}.{}.{}'.format(major, minor, micro + 1)
def by_tag(self):
all = [x.strip() for x in check_output('git tag'.split()).split()]
return sorted([x for x in all if x.startswith(b'v-')],
key=lambda v: list(map(int, v[2:].split(b'.'))))[-1][2:].decode('utf-8')
def _create_changelog(self, temp_dir, *args, **kwargs):
changelog = Changelog()
changelog.new_block()
changelog.set_version(self.version)
changelog.set_package(self.package)
changelog.set_distributions('all')
changelog.set_urgency('low')
changelog.set_author(self.maintainer)
changelog.set_date(_format_debian_date(self.date))
changelog.add_change(' * Release of %s' % self.version)
return changelog
def generate_debian_package(args, config):
debfile = Deb822(
open("debian/control"),
fields=["Build-Depends", "Build-Depends-Indep"])
rel_str = debfile.get("Build-Depends")
if debfile.has_key("Build-Depends-Indep"):
rel_str = rel_str + "," + debfile.get("Build-Depends-Indep")
relations = PkgRelation.parse_relations(rel_str)
cache = Cache()
# Check if all required packages are installed
for dep in relations:
if not check_deb_dependency_installed(cache, dep):
# Install not found dependencies
print("Dependency not matched: " + str(dep))
if not install_dependency(cache, dep):
print("Dependency cannot be installed: " + PkgRelation.str([dep
]))
exit(1)
changelog = Changelog(open("debian/changelog"))
old_changelog = Changelog(open("debian/changelog"))
dist = os.popen("lsb_release -c").read()
dist = dist[dist.rfind(":") + 1::].replace("\n", "").replace(
"\t", "").replace(" ", "")
new_version = get_debian_version(args, dist)
changelog.new_block(version=new_version,
package=changelog.package,
distributions="testing",
changes=["\n Generating new package version\n"],
author=changelog.author,
date=strftime("%a, %d %b %Y %H:%M:%S %z"),
urgency=changelog.urgency)
changelog.write_to_open_file(open("debian/changelog", 'w'))
# Execute commands defined in config:
if config.has_key("prebuild-command"):
print("Executing prebuild-command: " + str(config["prebuild-command"]))
if os.system(config["prebuild-command"]) != 0:
print("Failed to execute prebuild command")
exit(1)
if os.system("dpkg-buildpackage -uc -us") != 0:
print("Error generating package")
exit(1)
if os.system("sudo dpkg -i ../*" + new_version + "_*.deb") != 0:
print("Packages are not installable")
exit(1)
files = glob.glob("../*" + new_version + "_*.deb")
if args.command == "upload":
for f in files:
if f is files[-1]:
is_last = True
else:
is_last = False
if new_version.find("~") == -1:
upload_package(args, config, dist, f)
upload_package(args, config, dist + "-dev", f, publish=is_last)
if args.clean:
files = glob.glob("../*" + new_version + "*")
for f in files:
os.remove(f)
# Write old changelog to let everything as it was
old_changelog.write_to_open_file(open("debian/changelog", 'w'))
def parse_changelog(self):
c = Changelog()
with open(self.changelog_file, 'r') as f:
c.parse_changelog(f)
return c
def changelog(dpath, ctx, env):
change = ctx.get('message', 'Autogenerated by py2dsp v{}'.format(VERSION))
version = "{}-{}".format(ctx['version'], ctx['debian_revision'])
distribution = ctx.get('distribution', 'UNRELEASED')
fpath = join(dpath, 'debian', 'changelog')
if exists(fpath):
with open(fpath, encoding='utf-8') as fp:
line = fp.readline()
if ctx['version'] in line or 'UNRELEASED' in line:
log.debug('changelog doesn\'t need an update')
return
else:
yield from execute(['dch', '--force-distribution', '--distribution', distribution,
'--newversion', version, '-m', change], cwd=dpath)
return
now = datetime.utcnow()
changelog = Changelog()
changelog.new_block(package=ctx['src_name'],
version=Version(version),
distributions=distribution,
urgency='low',
author=ctx['creator'],
date=now.strftime('%a, %d %b %Y %H:%M:%S +0000'))
changelog.add_change('')
changelog.add_change(' * {}'.format(change))
changelog.add_change('')
with open(fpath, 'w', encoding='utf-8') as fp:
changelog.write_to_open_file(fp)
return True
