commit 1f58ca481f0ab812e7f41990e439f960e338c122 Author: Monty Taylor Date: Thu Jul 12 13:29:39 2012 -0500 Initial commit of PBR. PBR is a library to automatically do a bunch of standard things you want in your setup.py without you having to repeat them every time. It will set versions, process requirements files and generate AUTHORS and ChangeLog file all from git information. diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 00000000..d114d67d --- /dev/null +++ b/.coveragerc @@ -0,0 +1,6 @@ +[run] +branch = True +omit = /usr*,setup.py,*egg*,.tox/*,pbr/tests/* + +[report] +ignore-errors = True diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..54e1542e --- /dev/null +++ b/.gitignore @@ -0,0 +1,22 @@ +*.DS_Store +*.egg* +*.pyc +*.pyo +*.sqlite +.autogenerated +.coverage +.project +.pydevproject +.tox +AUTHORS +ChangeLog +MANIFEST +build/* +cover/* +coverage.xml +covhtml +dist/* +doc/build/* +doc/source/api/* +nosetests.xml +pbr/versioninfo diff --git a/.gitreview b/.gitreview new file mode 100644 index 00000000..8df29968 --- /dev/null +++ b/.gitreview @@ -0,0 +1,4 @@ +[gerrit] +host=review.openstack.org +port=29418 +project=openstack-dev/pbr.git diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 00000000..1a989b01 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,6 @@ +include pbr/versioninfo +include AUTHORS +include ChangeLog + +exclude .gitignore +exclude .gitreview diff --git a/README.rst b/README.rst new file mode 100644 index 00000000..752168b9 --- /dev/null +++ b/README.rst @@ -0,0 +1,138 @@ +.. toctree:: + :maxdepth 2 + +PBR: Python Build Reasonablness +=============================== + +PBR is a library that injects some useful and sensible default behaviors +into your setuptools run. It started off life as the chunks of code that +were copied between all of the OpenStack projects. Around the time that +OpenStack hit 18 different projects each with at least 3 active branches, +it seems like a good time to make that code into a proper re-usable library. + +PBR is only mildly configurable. The basic idea is that there's a decent +way to run things and if you do, you should reap the rewards, because then +it's simple and repeatable. If you want to do things differently, cool! But +you've already got the power of python at your fingertips, so you don't +really need PBR. + +What It Does +------------ + +PBR can and does do a bunch of things for you: + + * **Version**: Manage version number bad on git revisions and tags + * **AUTHORS**: Generate AUTHORS file from git log + * **ChangeLog**: Generate ChangeLog from git log + * **Sphinx Autodoc**: Generate autodoc stub files for your whole module + * **Requirements**: Store your dependencies in a pip requirements file + * **long_description**: Use your README file as a long_description + +Version +^^^^^^^ + +You can tell pbr to manage your version based on git tags. +Two different modes are supported, a pre-version mode, in +which there is a version your project is working towards a +release of, and post-version mode, in which the version +between releases is the previous release plus a counter. +In both cases, a release is indicated by tagging a revision. + +AUTHORS and ChangeLog +^^^^^^^^^^^^^^^^^^^^^ + +Why keep an AUTHORS or a ChangeLog file, when git already has all of the +information you need. AUTHORS generation supports filtering/combining based +on a standard .mailmap file, as well as looking through commit logs for +Signed-off-by lines. + +Sphinx Autodoc +^^^^^^^^^^^^^^ + +Sphinx can produce auto documentation indexes based on signatures and +docstrings of your project- but you have to give it index files to tell it +to autodoc each module. That's kind of repetitive and boring. PBR will +scan your project, find all of your modules, and generate all of the stub +files for you. + +Requirements +^^^^^^^^^^^^ + +You may not have noticed, but there are differences in how pip +requirements.txt files work and how distutils wants to be told about +requirements. The pip way is nicer, because it sure does make it easier to +popuplate a virtualenv for testing, or to just install everything you need. +Duplicating the information, though, is super lame. So PBR will let you +keep requirements.txt format files around describing the requirements for +your project, will parse them and split them up approprirately, and inject +them into the install_requires and/or tests_require and/or dependency_links +arguments to setup. Voila! + +long_description +^^^^^^^^^^^^^^^^ + +There is no need to maintain two long descriptions- and your README file is +probably a good long_description. So we'll just inject the contents of your +README.rst, README.txt or README file into your empty long_description. Yay +for you. + +Getting Started +--------------- + +Wow, you're still here? NEAT! + +Step one is to add:: + + setup_requires=['pbr'], + +to your setup call in setup.py. Next, change your version= line to:: + + version="#:", + +Don't argue, just do it - there is no valid reason to not use git tags to +manage your project version. Unless you want to be ornery, go to the main +__init__.py of the module that's the same name as your package - let's call +your package "hipsterbeard", and add this code:: + + from pbr import version + __version_info = version.VersionInfo('hipsterbeard') + __version__ = __version_info.deferred_version_string() + +You will now get version information, AUTHORS and ChangeLog and Sphinx stubs +generation, and long_description injetion. + +Now, if you're weird like openstack and make your python-package something +different than your top level code module (such as "I'm going to +install python-hipsterbeard and get a thing I can import called hipsterbeard") +you'll need to make two slight modifications. First, tell setup where to find +your version hooks:: + + version="#:hipsterbeard:__version_info" + +That's the form "Module.submodule:InstanceName" - sort of like nosetests. +Then:: + + from pbr import version + __version_info = version.VersionInfo('python-hipsterbeard') + __version__ = __version_info.deferred_version_string() + +goes in hipsterbeard/__init__.py. Mainly that's because pkg-resources needs +to look into the egg that setup.py install produced, but your code is called +something different, and there is really no other way to figure out what the +heck you're doing. + +Stop being weird next time. Seriously. + +Depends tracking is a little bit easier. The easiest version goes like +this:: + + install_requires=['#:tools/pip-requires'], + tests_require=['#:tools/test-requires'], + dependency_links=['#:tools/pip-requires', '#:tools/test-requires'], + +That will put the contents of tools/pip-requires into install_requires, +tools/test-requires into tests_require (please someone shoot whoever got the +pluralization backwards there) and will split out dependency link +information from both files into dependency_links. All three matchers will +do what they do on any number of entries that are prefixed by '#:' - so feel +free to use that for whatever you'd like. diff --git a/pbr/__init__.py b/pbr/__init__.py new file mode 100644 index 00000000..c3025764 --- /dev/null +++ b/pbr/__init__.py @@ -0,0 +1,20 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2012 OpenStack LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import version + +__version_info = version.VersionInfo('pbr') +__version__ = __version_info.deferred_version_string() diff --git a/pbr/cmdclass.py b/pbr/cmdclass.py new file mode 100644 index 00000000..f755325d --- /dev/null +++ b/pbr/cmdclass.py @@ -0,0 +1,163 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Utilities with minimum-depends for use in setup.py +""" + +import os + +from setuptools.command import sdist +from pbr import util + + +def parse_mailmap(mailmap='.mailmap'): + mapping = {} + if os.path.exists(mailmap): + fp = open(mailmap, 'r') + for l in fp: + l = l.strip() + if not l.startswith('#') and ' ' in l: + canonical_email, alias = [x for x in l.split(' ') + if x.startswith('<')] + mapping[alias] = canonical_email + return mapping + + +def canonicalize_emails(changelog, mapping): + """Takes in a string and an email alias mapping and replaces all + instances of the aliases in the string with their real email. + """ + for alias, email in mapping.iteritems(): + changelog = changelog.replace(alias, email) + return changelog + + +def write_git_changelog(): + """Write a changelog based on the git changelog.""" + if os.path.isdir('.git'): + git_log_cmd = 'git log --stat' + changelog = util.run_shell_command(git_log_cmd) + mailmap = parse_mailmap() + with open("ChangeLog", "w") as changelog_file: + changelog_file.write(canonicalize_emails(changelog, mailmap)) + + +def generate_authors(): + """Create AUTHORS file using git commits.""" + jenkins_email = 'jenkins@review.openstack.org' + old_authors = 'AUTHORS.in' + new_authors = 'AUTHORS' + if os.path.isdir('.git'): + # don't include jenkins email address in AUTHORS file + git_log_cmd = ("git log --format='%aN <%aE>' | sort -u | " + "grep -v " + jenkins_email) + changelog = util.run_shell_command(git_log_cmd) + mailmap = parse_mailmap() + with open(new_authors, 'w') as new_authors_fh: + new_authors_fh.write(canonicalize_emails(changelog, mailmap)) + if os.path.exists(old_authors): + with open(old_authors, "r") as old_authors_fh: + new_authors_fh.write('\n' + old_authors_fh.read()) + + +_rst_template = """%(heading)s +%(underline)s + +.. automodule:: %(module)s + :members: + :undoc-members: + :show-inheritance: +""" + + +def get_cmdclass(): + """Return dict of commands to run from setup.py.""" + + cmdclass = dict() + + def _find_modules(arg, dirname, files): + for filename in files: + if filename.endswith('.py') and filename != '__init__.py': + arg["%s.%s" % (dirname.replace('/', '.'), + filename[:-3])] = True + + class LocalSDist(sdist.sdist): + """Builds the ChangeLog and Authors files from VC first.""" + + def run(self): + write_git_changelog() + generate_authors() + # sdist.sdist is an old style class, can't use super() + sdist.sdist.run(self) + + cmdclass['sdist'] = LocalSDist + + # If Sphinx is installed on the box running setup.py, + # enable setup.py to build the documentation, otherwise, + # just ignore it + try: + from sphinx.setup_command import BuildDoc + + class LocalBuildDoc(BuildDoc): + def generate_autoindex(self): + print "**Autodocumenting from %s" % os.path.abspath(os.curdir) + modules = {} + option_dict = self.distribution.get_option_dict('build_sphinx') + source_dir = os.path.join(option_dict['source_dir'][1], 'api') + if not os.path.exists(source_dir): + os.makedirs(source_dir) + for pkg in self.distribution.packages: + if '.' not in pkg: + os.path.walk(pkg, _find_modules, modules) + module_list = modules.keys() + module_list.sort() + autoindex_filename = os.path.join(source_dir, 'autoindex.rst') + with open(autoindex_filename, 'w') as autoindex: + autoindex.write(""".. toctree:: + :maxdepth: 1 + +""") + for module in module_list: + output_filename = os.path.join(source_dir, + "%s.rst" % module) + heading = "The :mod:`%s` Module" % module + underline = "=" * len(heading) + values = dict(module=module, heading=heading, + underline=underline) + + print "Generating %s" % output_filename + with open(output_filename, 'w') as output_file: + output_file.write(_rst_template % values) + autoindex.write(" %s.rst\n" % module) + + def run(self): + if not os.getenv('SPHINX_DEBUG'): + self.generate_autoindex() + + for builder in ['html', 'man']: + self.builder = builder + self.finalize_options() + self.project = self.distribution.get_name() + self.version = self.distribution.get_version() + self.release = self.distribution.get_version() + BuildDoc.run(self) + cmdclass['build_sphinx'] = LocalBuildDoc + except ImportError: + pass + + return cmdclass diff --git a/pbr/requires.py b/pbr/requires.py new file mode 100644 index 00000000..1b243c2b --- /dev/null +++ b/pbr/requires.py @@ -0,0 +1,95 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Utilities with minimum-depends for use in setup.py +""" + +import os +import re +import sys + + +# Get requirements from the first file that exists +def get_reqs_from_files(requirements_files): + for requirements_file in requirements_files: + if os.path.exists(requirements_file): + return open(requirements_file, 'r').read().strip().split('\n') + return [] + + +def parse_requirements(*paths): + requirements = list() + for line in get_reqs_from_files(paths): + # For the requirements list, we need to inject only the portion + # after egg= so that distutils knows the package it's looking for + # such as: + # -e git://github.com/openstack/nova/master#egg=nova + if re.match(r'\s*-e\s+', line): + requirements.append(re.sub(r'\s*-e\s+.*#egg=(.*)$', r'\1', + line)) + # such as: + # http://github.com/openstack/nova/zipball/master#egg=nova + elif re.match(r'\s*https?:', line): + requirements.append(re.sub(r'\s*https?:.*#egg=(.*)$', r'\1', + line)) + # -f lines are for index locations, and don't get used here + elif re.match(r'\s*-f\s+', line): + pass + # argparse is part of the standard library starting with 2.7 + # adding it to the requirements list screws distro installs + elif line == 'argparse' and sys.version_info >= (2, 7): + pass + else: + requirements.append(line) + + return requirements + + +def parse_dependency_links(*links): + dependency_links = [] + # dependency_links inject alternate locations to find packages listed + # in requirements + for line in get_reqs_from_files(links): + # skip comments and blank lines + if re.match(r'(\s*#)|(\s*$)', line): + continue + # lines with -e or -f need the whole line, minus the flag + if re.match(r'\s*-[ef]\s+', line): + dependency_links.append(re.sub(r'\s*-[ef]\s+', '', line)) + # lines that are only urls can go in unmolested + elif re.match(r'\s*https?:', line): + dependency_links.append(line) + return dependency_links + + +def __inject_parsed_file(value, func): + TOKEN = '#:' + new_reqs = [] + for req in value: + if req.startswith(TOKEN): + req_file = req[len(TOKEN):] + new_reqs.extend(func(req_file)) + return new_reqs + + +def inject_requires(dist, attr, value): + value.extend(__inject_parsed_file(value, parse_requirements)) + + +def inject_dependency_links(dist, attr, value): + value.extend(__inject_parsed_file(value, parse_dependency_links)) diff --git a/pbr/setup.py b/pbr/setup.py new file mode 100644 index 00000000..b7355d51 --- /dev/null +++ b/pbr/setup.py @@ -0,0 +1,134 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Utilities with minimum-depends for use in setup.py +""" + +import datetime +import os + +from pbr.util import run_shell_command + + +def _get_git_branchname(): + branch_ref = run_shell_command("git symbolic-ref -q HEAD") + if branch_ref == "": + _branch_name = "HEAD" + else: + _branch_name = branch_ref[len("refs/heads/"):] + return _branch_name + + +def _get_git_current_tag(): + return run_shell_command("git tag --contains HEAD") + + +def _get_git_tag_info(): + return run_shell_command("git describe --tags") + + +def _get_git_next_version_suffix(branch_name): + datestamp = datetime.datetime.now().strftime('%Y%m%d') + if branch_name == 'milestone-proposed': + revno_prefix = "r" + else: + revno_prefix = "" + run_shell_command("git fetch origin +refs/meta/*:refs/remotes/meta/*") + milestone_cmd = "git show meta/openstack/release:%s" % branch_name + milestonever = run_shell_command(milestone_cmd) + if not milestonever: + milestonever = "" + post_version = _get_git_post_version() + # post version should look like: + # 0.1.1.4.gcc9e28a + # where the bit after the last . is the short sha, and the bit between + # the last and second to last is the revno count + (revno, sha) = post_version.split(".")[-2:] + first_half = "%(milestonever)s~%(datestamp)s" % locals() + second_half = "%(revno_prefix)s%(revno)s.%(sha)s" % locals() + return ".".join((first_half, second_half)) + + +def _get_git_post_version(): + current_tag = _get_git_current_tag() + if current_tag is not None: + return current_tag + else: + tag_info = _get_git_tag_info() + if tag_info is None: + base_version = "0.0" + cmd = "git --no-pager log --oneline" + out = run_shell_command(cmd) + revno = len(out.split("\n")) + sha = run_shell_command("git describe --always") + else: + tag_infos = tag_info.split("-") + base_version = "-".join(tag_infos[:-2]) + (revno, sha) = tag_infos[-2:] + return "%s.%s.%s" % (base_version, revno, sha) + + +def read_versioninfo(project): + """Read the versioninfo file. If it doesn't exist, we're in a github + zipball, and there's really no way to know what version we really + are, but that should be ok, because the utility of that should be + just about nil if this code path is in use in the first place.""" + versioninfo_path = os.path.join(project, 'versioninfo') + if os.path.exists(versioninfo_path): + with open(versioninfo_path, 'r') as vinfo: + version = vinfo.read().strip() + else: + version = "0.0.0" + return version + + +def write_versioninfo(project, version): + """Write a simple file containing the version of the package.""" + open(os.path.join(project, 'versioninfo'), 'w').write("%s\n" % version) + + +def get_pre_version(projectname, base_version): + """Return a version which is leading up to a version that will + be released in the future.""" + if os.path.isdir('.git'): + current_tag = _get_git_current_tag() + if current_tag is not None: + version = current_tag + else: + branch_name = os.getenv('BRANCHNAME', + os.getenv('GERRIT_REFNAME', + _get_git_branchname())) + version_suffix = _get_git_next_version_suffix(branch_name) + version = "%s~%s" % (base_version, version_suffix) + write_versioninfo(projectname, version) + return version + else: + version = read_versioninfo(projectname) + return version + + +def get_post_version(projectname): + """Return a version which is equal to the tag that's on the current + revision if there is one, or tag plus number of additional revisions + if the current revision has no tag.""" + + if os.path.isdir('.git'): + version = _get_git_post_version() + write_versioninfo(projectname, version) + return version + return read_versioninfo(projectname) diff --git a/pbr/tests/test_requires.py b/pbr/tests/test_requires.py new file mode 100644 index 00000000..b32c1c05 --- /dev/null +++ b/pbr/tests/test_requires.py @@ -0,0 +1,58 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# Copyright 2012 Hewlett-Packard Development Company, L.P. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import mox +import unittest2 + +from pbr import requires + +raw_reqs = [ + '-e git://github.com/openstack/nova/master#egg=nova', + 'http://github.com/openstack/glance/zipball/master#egg=glance', + '-f http://pypi.openstack.org', + '# Comment test', + 'setuptools', + 'mox>=7.5', + ] + +parsed_reqs = [ + 'nova', + 'glance', + '# Comment test', + 'setuptools', + 'mox>=7.5' + ] + + +class RequiresTestCase(unittest2.TestCase): + """Test cases for requirements parsing""" + + def setUp(self): + super(RequiresTestCase, self).setUp() + self.mox = mox.Mox() + + def tearDown(self): + self.mox.UnsetStubs() + + def test_parse_requirements(self): + self.mox.StubOutWithMock(requires, "get_reqs_from_files") + requires.get_reqs_from_files(mox.IgnoreArg()).AndReturn(raw_reqs) + self.mox.ReplayAll() + + self.assertEqual(requires.parse_requirements(mox.IgnoreArg()), + parsed_reqs) diff --git a/pbr/util.py b/pbr/util.py new file mode 100644 index 00000000..74e1c1e8 --- /dev/null +++ b/pbr/util.py @@ -0,0 +1,29 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import subprocess + + +def run_shell_command(cmd): + output = subprocess.Popen(["/bin/sh", "-c", cmd], + stdout=subprocess.PIPE) + out = output.communicate() + if len(out) == 0: + return None + if len(out[0].strip()) == 0: + return None + return out[0].strip() diff --git a/pbr/version.py b/pbr/version.py new file mode 100644 index 00000000..75b5c95d --- /dev/null +++ b/pbr/version.py @@ -0,0 +1,173 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2012 OpenStack LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +""" +Utilities for consuming the auto-generated versioninfo files. +""" + +import datetime +import pkg_resources +import os + +import setup + + +class _deferred_version_string(object): + """Internal helper class which provides delayed version calculation.""" + def __init__(self, version_info, prefix): + self.version_info = version_info + self.prefix = prefix + + def __str__(self): + return "%s%s" % (self.prefix, self.version_info.version_string()) + + def __repr__(self): + return "%s%s" % (self.prefix, self.version_info.version_string()) + + +class VersionInfo(object): + + def __init__(self, package, python_package=None, pre_version=None): + """Object that understands versioning for a package + :param package: name of the top level python namespace. For glance, + this would be "glance" for python-glanceclient, it + would be "glanceclient" + :param python_package: optional name of the project name. For + glance this can be left unset. For + python-glanceclient, this would be + "python-glanceclient" + :param pre_version: optional version that the project is working to + """ + self.package = package + if python_package is None: + self.python_package = package + else: + self.python_package = python_package + self.pre_version = pre_version + self.version = None + + def _generate_version(self): + """Defer to the openstack.common.setup routines for making a + version from git.""" + if self.pre_version is None: + return setup.get_post_version(self.python_package) + else: + return setup.get_pre_version(self.python_package, self.pre_version) + + def _newer_version(self, pending_version): + """Check to see if we're working with a stale version or not. + We expect a version string that either looks like: + 2012.2~f3~20120708.10.4426392 + which is an unreleased version of a pre-version, or: + 0.1.1.4.gcc9e28a + which is an unreleased version of a post-version, or: + 0.1.1 + Which is a release and which should match tag. + For now, if we have a date-embedded version, check to see if it's + old, and if so re-generate. Otherwise, just deal with it. + """ + try: + version_date = int(self.version.split("~")[-1].split('.')[0]) + if version_date < int(datetime.date.today().strftime('%Y%m%d')): + return self._generate_version() + else: + return pending_version + except Exception: + return pending_version + + def version_string_with_vcs(self, always=False): + """Return the full version of the package including suffixes indicating + VCS status. + + For instance, if we are working towards the 2012.2 release, + canonical_version_string should return 2012.2 if this is a final + release, or else something like 2012.2~f1~20120705.20 if it's not. + + :param always: if true, skip all version caching + """ + if always: + self.version = self._generate_version() + + if self.version is None: + + requirement = pkg_resources.Requirement.parse(self.python_package) + versioninfo = "%s/versioninfo" % self.package + try: + raw_version = pkg_resources.resource_string(requirement, + versioninfo) + self.version = self._newer_version(raw_version.strip()) + except (IOError, pkg_resources.DistributionNotFound): + self.version = self._generate_version() + + return self.version + + def canonical_version_string(self, always=False): + """Return the simple version of the package excluding any suffixes. + + For instance, if we are working towards the 2012.2 release, + canonical_version_string should return 2012.2 in all cases. + + :param always: if true, skip all version caching + """ + return self.version_string_with_vcs(always).split('~')[0] + + def version_string(self, always=False): + """Return the base version of the package. + + For instance, if we are working towards the 2012.2 release, + version_string should return 2012.2 if this is a final release, or + 2012.2-dev if it is not. + + :param always: if true, skip all version caching + """ + version_parts = self.version_string_with_vcs(always).split('~') + if len(version_parts) == 1: + return version_parts[0] + else: + return '%s-dev' % (version_parts[0],) + + def deferred_version_string(self, prefix=""): + """Generate an object which will expand in a string context to + the results of version_string(). We do this so that don't + call into pkg_resources every time we start up a program when + passing version information into the CONF constructor, but + rather only do the calculation when and if a version is requested + """ + return _deferred_version_string(self, prefix) + + +def inject_version(dist, attr, value): + version = dist.metadata.version + if version and version.startswith("#:"): + + # Inject cmdclass values here + import cmdclass + dist.cmdclass.update(cmdclass.get_cmdclass()) + + # Modify version number + if len(version[2:]) > 0: + (version_module, version_object) = version[2:].split(":") + else: + version_module = "%s" % dist.metadata.name + version_object = "__version_info" + vinfo = __import__(version_module).__dict__[version_object] + dist.metadata.version = vinfo.canonical_version_string(always=True) + + # Inject long_description + for readme in ("README.rst", "README.txt", "README"): + if dist.long_description is None and os.path.exists(readme): + dist.long_description = open(readme).read() + dist.include_package_data = True diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 00000000..ed820d79 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,16 @@ +[nosetests] +cover-package = pbr +cover-html = true +cover-erase = true +cover-inclusive = true +verbosity=2 +detailed-errors=1 +where = pbr/tests + +[build_sphinx] +source-dir = doc/source +build-dir = doc/build +all_files = 1 + +[upload_sphinx] +upload-dir = doc/build/html diff --git a/setup.py b/setup.py new file mode 100644 index 00000000..b0754aa1 --- /dev/null +++ b/setup.py @@ -0,0 +1,47 @@ +# Copyright 2011 OpenStack, LLC +# Copyright 2012 Hewlett-Packard Development Company, L.P. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import setuptools + +setuptools.setup( + name="pbr", + version="#:", + author='Hewlett-Packard Development Company, L.P.', + author_email='openstack@lists.launchpad.net', + description="Python Build Reasonablness", + license="Apache License, Version 2.0", + url="https://github.com/openstack-dev/pbr", + packages=setuptools.find_packages(exclude=['tests', 'tests.*']), + install_requires=['#:tools/pip-requires'], + tests_require=['#:tools/test-requires'], + dependency_links=['#:tools/pip-requires', '#:tools/test-requires'], + setup_requires=['setuptools_git>=0.4'], + test_suite="nose.collector", + classifiers=[ + "Environment :: Console", + "Intended Audience :: Developers", + "Intended Audience :: Information Technology", + "License :: OSI Approved :: Apache Software License", + "Operating System :: OS Independent", + "Programming Language :: Python" + ], + entry_points={ + "distutils.setup_keywords": [ + "version = pbr.version:inject_version", + "install_requires = pbr.requires:inject_requires", + "dependency_links = pbr.requires:inject_dependency_links", + ] + } +) diff --git a/tools/pip-requires b/tools/pip-requires new file mode 100644 index 00000000..160b3527 --- /dev/null +++ b/tools/pip-requires @@ -0,0 +1 @@ +setuptools_git>=0.4 diff --git a/tools/test-requires b/tools/test-requires new file mode 100644 index 00000000..a13ff6ea --- /dev/null +++ b/tools/test-requires @@ -0,0 +1,9 @@ +distribute>=0.6.24 + +mox +nose +nosexcover +openstack.nose_plugin +pep8==1.3 +sphinx>=1.1.2 +unittest2 diff --git a/tox.ini b/tox.ini new file mode 100644 index 00000000..f6f5d3d6 --- /dev/null +++ b/tox.ini @@ -0,0 +1,28 @@ +[tox] +envlist = py26,py27,pep8 + +[testenv] +setenv = VIRTUAL_ENV={envdir} + NOSE_WITH_OPENSTACK=1 + NOSE_OPENSTACK_COLOR=1 + NOSE_OPENSTACK_RED=0.05 + NOSE_OPENSTACK_YELLOW=0.025 + NOSE_OPENSTACK_SHOW_ELAPSED=1 + NOSE_OPENSTACK_STDOUT=1 +deps = -r{toxinidir}/tools/pip-requires + -r{toxinidir}/tools/test-requires +commands = nosetests {posargs} + +[testenv:pep8] +deps = pep8==1.3 +commands = pep8 --repeat --show-source --exclude=.tox,dist,doc,*egg . + +[testenv:cover] +setenv = NOSE_WITH_COVERAGE=1 + +[testenv:pyflakes] +deps = pyflakes +commands = pyflakes pbr/*.py setup.py + +[testenv:venv] +commands = {posargs}