shadowfacts/fonttools
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #768 from anthrotype/bumpversion

Browse Source 
don't compute git version at runtime; bump version with custom 'release' command
This commit is contained in:
Cosimo Lupo 2016-12-15 08:49:45 +00:00 committed by GitHub
commit 4e3b5ed2cd
9 changed files with 237 additions and 2382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
.travis/install.sh
View File

@ -63,9 +63,3 @@ if [[ "${TOXENV}" != "jython" ]]; then
source ~/.venv/bin/activate
pip install -r dev-requirements.txt
fi
# Travis by default only clones a 'shallow' repository with --depth=50.
# When building the distribution packages, we use git to determine the
# package version string (via versioneer), hence we need to fetch the
# whole repo, and not just the last 50 commits.
git fetch --unshallow

11
Lib/fontTools/__init__.py
View File

@ -2,18 +2,9 @@ from __future__ import print_function, division, absolute_import
from fontTools.misc.py23 import *
import logging
from fontTools.misc.loggingTools import configLogger
from ._version import get_versions
log = logging.getLogger(__name__)
v = get_versions()
if v["error"]:
__import__('warnings').warn("versioneer: %s" % v['error'], RuntimeWarning)
__version__ = "3.3.0"
else:
__version__ = v['version']
del get_versions, v
version = __version__
version = __version__ = "3.3.1.dev0"
__all__ = ["version", "log", "configLogger"]

520
Lib/fontTools/_version.py
View File

@ -1,520 +0,0 @@
# This file helps to compute a version number in source trees obtained from
# git-archive tarball (such as those provided by githubs download-from-tag
# feature). Distribution tarballs (built by setup.py sdist) and build
# directories (produced by setup.py build) will contain a much shorter file
# that just contains the computed version number.
# This file is released into the public domain. Generated by
# versioneer-0.17 (https://github.com/warner/python-versioneer)
"""Git implementation of _version.py."""
import errno
import os
import re
import subprocess
import sys
def get_keywords():
"""Get the keywords needed to look up the version information."""
# these strings will be replaced by git during git-archive.
# setup.py/versioneer.py will grep for the variable names, so they must
# each be defined on a line of their own. _version.py will just call
# get_keywords().
git_refnames = "$Format:%d$"
git_full = "$Format:%H$"
git_date = "$Format:%ci$"
keywords = {"refnames": git_refnames, "full": git_full, "date": git_date}
return keywords
class VersioneerConfig:
"""Container for Versioneer configuration parameters."""
def get_config():
"""Create, populate and return the VersioneerConfig() object."""
# these strings are filled in when 'setup.py versioneer' creates
# _version.py
cfg = VersioneerConfig()
cfg.VCS = "git"
cfg.style = "pep440"
cfg.tag_prefix = ""
cfg.parentdir_prefix = "fonttools-"
cfg.versionfile_source = "Lib/fontTools/_version.py"
cfg.verbose = False
return cfg
class NotThisMethod(Exception):
"""Exception raised if a method is not valid for the current scenario."""
LONG_VERSION_PY = {}
HANDLERS = {}
def register_vcs_handler(vcs, method): # decorator
"""Decorator to mark a method as the handler for a particular VCS."""
def decorate(f):
"""Store f in HANDLERS[vcs][method]."""
if vcs not in HANDLERS:
HANDLERS[vcs] = {}
HANDLERS[vcs][method] = f
return f
return decorate
def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False,
env=None):
"""Call the given command(s)."""
assert isinstance(commands, list)
p = None
for c in commands:
try:
dispcmd = str([c] + args)
# remember shell=False, so use git.cmd on windows, not just git
p = subprocess.Popen([c] + args, cwd=cwd, env=env,
stdout=subprocess.PIPE,
stderr=(subprocess.PIPE if hide_stderr
else None))
break
except EnvironmentError:
e = sys.exc_info()[1]
if e.errno == errno.ENOENT:
continue
if verbose:
print("unable to run %s" % dispcmd)
print(e)
return None, None
else:
if verbose:
print("unable to find command, tried %s" % (commands,))
return None, None
stdout = p.communicate()[0].strip()
if sys.version_info[0] >= 3:
stdout = stdout.decode()
if p.returncode != 0:
if verbose:
print("unable to run %s (error)" % dispcmd)
print("stdout was %s" % stdout)
return None, p.returncode
return stdout, p.returncode
def versions_from_parentdir(parentdir_prefix, root, verbose):
"""Try to determine the version from the parent directory name.
Source tarballs conventionally unpack into a directory that includes both
the project name and a version string. We will also support searching up
two directory levels for an appropriately named parent directory
"""
rootdirs = []
for i in range(3):
dirname = os.path.basename(root)
if dirname.startswith(parentdir_prefix):
return {"version": dirname[len(parentdir_prefix):],
"full-revisionid": None,
"dirty": False, "error": None, "date": None}
else:
rootdirs.append(root)
root = os.path.dirname(root) # up a level
if verbose:
print("Tried directories %s but none started with prefix %s" %
(str(rootdirs), parentdir_prefix))
raise NotThisMethod("rootdir doesn't start with parentdir_prefix")
@register_vcs_handler("git", "get_keywords")
def git_get_keywords(versionfile_abs):
"""Extract version information from the given file."""
# the code embedded in _version.py can just fetch the value of these
# keywords. When used from setup.py, we don't want to import _version.py,
# so we do it with a regexp instead. This function is not used from
# _version.py.
keywords = {}
try:
f = open(versionfile_abs, "r")
for line in f.readlines():
if line.strip().startswith("git_refnames ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["refnames"] = mo.group(1)
if line.strip().startswith("git_full ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["full"] = mo.group(1)
if line.strip().startswith("git_date ="):
mo = re.search(r'=\s*"(.*)"', line)
if mo:
keywords["date"] = mo.group(1)
f.close()
except EnvironmentError:
pass
return keywords
@register_vcs_handler("git", "keywords")
def git_versions_from_keywords(keywords, tag_prefix, verbose):
"""Get version information from git keywords."""
if not keywords:
raise NotThisMethod("no keywords at all, weird")
date = keywords.get("date")
if date is not None:
# git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant
# datestamp. However we prefer "%ci" (which expands to an "ISO-8601
# -like" string, which we must then edit to make compliant), because
# it's been around since git-1.5.3, and it's too difficult to
# discover which version we're using, or to work around using an
# older one.
date = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
refnames = keywords["refnames"].strip()
if refnames.startswith("$Format"):
if verbose:
print("keywords are unexpanded, not using")
raise NotThisMethod("unexpanded keywords, not a git-archive tarball")
refs = set([r.strip() for r in refnames.strip("()").split(",")])
# starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of
# just "foo-1.0". If we see a "tag: " prefix, prefer those.
TAG = "tag: "
tags = set([r[len(TAG):] for r in refs if r.startswith(TAG)])
if not tags:
# Either we're using git < 1.8.3, or there really are no tags. We use
# a heuristic: assume all version tags have a digit. The old git %d
# expansion behaves like git log --decorate=short and strips out the
# refs/heads/ and refs/tags/ prefixes that would let us distinguish
# between branches and tags. By ignoring refnames without digits, we
# filter out many common branch names like "release" and
# "stabilization", as well as "HEAD" and "master".
tags = set([r for r in refs if re.search(r'\d', r)])
if verbose:
print("discarding '%s', no digits" % ",".join(refs - tags))
if verbose:
print("likely tags: %s" % ",".join(sorted(tags)))
for ref in sorted(tags):
# sorting will prefer e.g. "2.0" over "2.0rc1"
if ref.startswith(tag_prefix):
r = ref[len(tag_prefix):]
if verbose:
print("picking %s" % r)
return {"version": r,
"full-revisionid": keywords["full"].strip(),
"dirty": False, "error": None,
"date": date}
# no suitable tags, so version is "0+unknown", but full hex is still there
if verbose:
print("no suitable tags, using unknown + full revision id")
return {"version": "0+unknown",
"full-revisionid": keywords["full"].strip(),
"dirty": False, "error": "no suitable tags", "date": None}
@register_vcs_handler("git", "pieces_from_vcs")
def git_pieces_from_vcs(tag_prefix, root, verbose, run_command=run_command):
"""Get version from 'git describe' in the root of the source tree.
This only gets called if the git-archive 'subst' keywords were *not*
expanded, and _version.py hasn't already been rewritten with a short
version string, meaning we're inside a checked out source tree.
"""
GITS = ["git"]
if sys.platform == "win32":
GITS = ["git.cmd", "git.exe"]
out, rc = run_command(GITS, ["rev-parse", "--git-dir"], cwd=root,
hide_stderr=True)
if rc != 0:
if verbose:
print("Directory %s not under git control" % root)
raise NotThisMethod("'git rev-parse --git-dir' returned error")
# if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty]
# if there isn't one, this yields HEX[-dirty] (no NUM)
describe_out, rc = run_command(GITS, ["describe", "--tags", "--dirty",
"--always", "--long",
"--match", "%s*" % tag_prefix],
cwd=root)
# --long was added in git-1.5.5
if describe_out is None:
raise NotThisMethod("'git describe' failed")
describe_out = describe_out.strip()
full_out, rc = run_command(GITS, ["rev-parse", "HEAD"], cwd=root)
if full_out is None:
raise NotThisMethod("'git rev-parse' failed")
full_out = full_out.strip()
pieces = {}
pieces["long"] = full_out
pieces["short"] = full_out[:7] # maybe improved later
pieces["error"] = None
# parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty]
# TAG might have hyphens.
git_describe = describe_out
# look for -dirty suffix
dirty = git_describe.endswith("-dirty")
pieces["dirty"] = dirty
if dirty:
git_describe = git_describe[:git_describe.rindex("-dirty")]
# now we have TAG-NUM-gHEX or HEX
if "-" in git_describe:
# TAG-NUM-gHEX
mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe)
if not mo:
# unparseable. Maybe git-describe is misbehaving?
pieces["error"] = ("unable to parse git-describe output: '%s'"
% describe_out)
return pieces
# tag
full_tag = mo.group(1)
if not full_tag.startswith(tag_prefix):
if verbose:
fmt = "tag '%s' doesn't start with prefix '%s'"
print(fmt % (full_tag, tag_prefix))
pieces["error"] = ("tag '%s' doesn't start with prefix '%s'"
% (full_tag, tag_prefix))
return pieces
pieces["closest-tag"] = full_tag[len(tag_prefix):]
# distance: number of commits since tag
pieces["distance"] = int(mo.group(2))
# commit: short hex revision ID
pieces["short"] = mo.group(3)
else:
# HEX: no tags
pieces["closest-tag"] = None
count_out, rc = run_command(GITS, ["rev-list", "HEAD", "--count"],
cwd=root)
pieces["distance"] = int(count_out) # total number of commits
# commit date: see ISO-8601 comment in git_versions_from_keywords()
date = run_command(GITS, ["show", "-s", "--format=%ci", "HEAD"],
cwd=root)[0].strip()
pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1)
return pieces
def plus_or_dot(pieces):
"""Return a + if we don't already have one, else return a ."""
if "+" in pieces.get("closest-tag", ""):
return "."
return "+"
def render_pep440(pieces):
"""Build up version string, with post-release "local version identifier".
Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you
get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty
Exceptions:
1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += plus_or_dot(pieces)
rendered += "%d.g%s" % (pieces["distance"], pieces["short"])
if pieces["dirty"]:
rendered += ".dirty"
else:
# exception #1
rendered = "0+untagged.%d.g%s" % (pieces["distance"],
pieces["short"])
if pieces["dirty"]:
rendered += ".dirty"
return rendered
def render_pep440_pre(pieces):
"""TAG[.post.devDISTANCE] -- No -dirty.
Exceptions:
1: no tags. 0.post.devDISTANCE
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"]:
rendered += ".post.dev%d" % pieces["distance"]
else:
# exception #1
rendered = "0.post.dev%d" % pieces["distance"]
return rendered
def render_pep440_post(pieces):
"""TAG[.postDISTANCE[.dev0]+gHEX] .
The ".dev0" means dirty. Note that .dev0 sorts backwards
(a dirty tree will appear "older" than the corresponding clean one),
but you shouldn't be releasing software with -dirty anyways.
Exceptions:
1: no tags. 0.postDISTANCE[.dev0]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += ".post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
rendered += plus_or_dot(pieces)
rendered += "g%s" % pieces["short"]
else:
# exception #1
rendered = "0.post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
rendered += "+g%s" % pieces["short"]
return rendered
def render_pep440_old(pieces):
"""TAG[.postDISTANCE[.dev0]] .
The ".dev0" means dirty.
Eexceptions:
1: no tags. 0.postDISTANCE[.dev0]
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"] or pieces["dirty"]:
rendered += ".post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
else:
# exception #1
rendered = "0.post%d" % pieces["distance"]
if pieces["dirty"]:
rendered += ".dev0"
return rendered
def render_git_describe(pieces):
"""TAG[-DISTANCE-gHEX][-dirty].
Like 'git describe --tags --dirty --always'.
Exceptions:
1: no tags. HEX[-dirty] (note: no 'g' prefix)
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
if pieces["distance"]:
rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
else:
# exception #1
rendered = pieces["short"]
if pieces["dirty"]:
rendered += "-dirty"
return rendered
def render_git_describe_long(pieces):
"""TAG-DISTANCE-gHEX[-dirty].
Like 'git describe --tags --dirty --always -long'.
The distance/hash is unconditional.
Exceptions:
1: no tags. HEX[-dirty] (note: no 'g' prefix)
"""
if pieces["closest-tag"]:
rendered = pieces["closest-tag"]
rendered += "-%d-g%s" % (pieces["distance"], pieces["short"])
else:
# exception #1
rendered = pieces["short"]
if pieces["dirty"]:
rendered += "-dirty"
return rendered
def render(pieces, style):
"""Render the given version pieces into the requested style."""
if pieces["error"]:
return {"version": "unknown",
"full-revisionid": pieces.get("long"),
"dirty": None,
"error": pieces["error"],
"date": None}
if not style or style == "default":
style = "pep440" # the default
if style == "pep440":
rendered = render_pep440(pieces)
elif style == "pep440-pre":
rendered = render_pep440_pre(pieces)
elif style == "pep440-post":
rendered = render_pep440_post(pieces)
elif style == "pep440-old":
rendered = render_pep440_old(pieces)
elif style == "git-describe":
rendered = render_git_describe(pieces)
elif style == "git-describe-long":
rendered = render_git_describe_long(pieces)
else:
raise ValueError("unknown style '%s'" % style)
return {"version": rendered, "full-revisionid": pieces["long"],
"dirty": pieces["dirty"], "error": None,
"date": pieces.get("date")}
def get_versions():
"""Get version information or return default if unable to do so."""
# I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have
# __file__, we can work backwards from there to the root. Some
# py2exe/bbfreeze/non-CPython implementations don't do __file__, in which
# case we can only use expanded keywords.
cfg = get_config()
verbose = cfg.verbose
try:
return git_versions_from_keywords(get_keywords(), cfg.tag_prefix,
verbose)
except NotThisMethod:
pass
try:
root = os.path.realpath(__file__)
# versionfile_source is the relative path from the top of the source
# tree (where the .git directory might live) to this file. Invert
# this to find the root from __file__.
for i in cfg.versionfile_source.split('/'):
root = os.path.dirname(root)
except NameError:
return {"version": "0+unknown", "full-revisionid": None,
"dirty": None,
"error": "unable to find root of source tree",
"date": None}
try:
pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose)
return render(pieces, cfg.style)
except NotThisMethod:
pass
try:
if cfg.parentdir_prefix:
return versions_from_parentdir(cfg.parentdir_prefix, root, verbose)
except NotThisMethod:
pass
return {"version": "0+unknown", "full-revisionid": None,
"dirty": None,
"error": "unable to compute version", "date": None}

4
Lib/fontTools/misc/py23.py
View File

@ -188,8 +188,8 @@ def open(file, mode='r', buffering=-1, encoding=None, errors=None,
One difference is that the 'opener' keyword argument is only supported in
Python 3. Here we pass the value of 'opener' only when it is not None.
This causes Python 2 to raise TypeError, complaining about the number of
expected arguments, so it must be avoided if py2 or py2-3 contexts.
This causes Python 2 to raise TypeError, complaining about the number of
expected arguments, so it must be avoided in py2 or py2-3 contexts.
Another difference between 2 and 3, this time on Windows, has to do with
opening files by name or by file descriptor.

3
MANIFEST.in
View File

@ -14,6 +14,3 @@ include run-tests.sh
recursive-include Lib/fontTools testdata/*.ttx testdata/*.otx testdata/*.fea
recursive-include Lib/fontTools testdata/*.lwfn testdata/*.pfa testdata/*.pfb
recursive-include Lib/fontTools testdata/*.xml testdata/*.designspace testdata/*.bin
include versioneer.py
include Lib/fontTools/_version.py

20
NEWS
View File

@ -1,18 +1,22 @@
## TTX/FontTools Version 3.3.0
- [setup] We no longer use versioneer.py to compute fonttools version from git
metadata, as this has caused issues for some users (#767). Now we bump the
version strings manually with a custom `release` command of setup.py script.
## TTX/FontTools Version 3.3.0 (2016-12-06)
- [ttLib] Implemented STAT table from OpenType 1.8 (#758)
- [cffLib] Fixed decompilation of CFF fonts containing non-standard key/value pairs in FontDict (issue #740; PR #744)
- [py23] minor: in `round3` function, allow the second argument to be `None` (#757)
- The standalone `sstruct` and `xmlWriter` modules, deprecated since vesion 3.2.0, have been removed. They can be imported from the `fontTools.misc` package.
## TTX/FontTools Version 3.2.3
## TTX/FontTools Version 3.2.3 (2016-12-02)
- [py23] optimized performance of round3 function; added backport for py35 math.isclose() (9d8dacb)
- [subset] fixed issue with 'narrow' (UCS-2) Python 2 builds and --text/--text-file options containing non-BMP chararcters (16d0e5e)
- [varLib] fixed issuewhen normalizing location values (8fa2ee1, #749)
- [inspect] Made it compatible with both python2 and python3 (167ee60, #748). Thanks @pnemade
## TTX/FontTools Version 3.2.2
## TTX/FontTools Version 3.2.2 (2016-11-24)
- [varLib] Do not emit null axes in fvar (1bebcec). Thanks @robmck-ms
- [varLib] Handle fonts without GPOS (7915a45)
@ -20,12 +24,12 @@
- [subset] Fix subsetting MathVariants (78d3cbe)
- [OS/2] Fix "Private Use (plane 15)" range (08a0d55). Thanks @mashabow
## TTX/FontTools Version 3.2.1
## TTX/FontTools Version 3.2.1 (2016-11-03)
- [OS/2] fix checking `fsSelection` bits matching `head.macStyle` bits
- [varLib] added `--build-HVAR` option to generate `HVAR` table for fonts with TrueType outlines. For `CFF2`, it is enabled by default.
## TTX/FontTools Version 3.2.0
## TTX/FontTools Version 3.2.0 (2016-11-02)
- [varLib] Improve support for OpenType 1.8 Variable Fonts:
* Implement GDEF's VariationStore
@ -44,18 +48,18 @@
- [versioning] Use versioneer instead of setuptools_scm to dynamically load version info from a git checkout at import time.
- [feaLib] Support backslash-prefixed glyph names.
## TTX/FontTools Version 3.1.2
## TTX/FontTools Version 3.1.2 (2016-09-27)
- restore Makefile as an alternative way to build/check/install
- README.md: update instructions for installing package from source, and for running test suite
- NEWS: Change log was out of sync with tagged release
## TTX/FontTools Version 3.1.1
## TTX/FontTools Version 3.1.1 (2016-09-27)
- Fix 'ttLibVersion' attribute in TTX files still showing '3.0' instead of '3.1'.
- Use setuptools_scm to manage package versions.
## TTX/FontTools Version 3.1.0
## TTX/FontTools Version 3.1.0 (2016-09-26)
- [feaLib] New library to parse and compile Adobe FDK OpenType Feature files.
- [mtiLib] New library to parse and compile Monotype 'FontDame' OpenType Layout Tables files.

33
setup.cfg
View File

@ -1,9 +1,28 @@
[bumpversion]
current_version = 3.3.0
current_version = 3.3.1.dev0
commit = True
tag = True
tag = False
tag_name = {new_version}
files = Lib/fontTools/__init__.py
parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\.(?P<release>[a-z]+)(?P<dev>\d+))?
serialize =
{major}.{minor}.{patch}.{release}{dev}
{major}.{minor}.{patch}
[bumpversion:part:release]
optional_value = final
values =
dev
final
[bumpversion:part:dev]
[bumpversion:file:Lib/fontTools/__init__.py]
search = __version__ = "{current_version}"
replace = __version__ = "{new_version}"
[bumpversion:file:setup.py]
search = version="{current_version}"
replace = version="{new_version}"
[wheel]
universal = 1
@ -31,11 +50,3 @@ addopts =
--doctest-modules
--doctest-ignore-import-errors
[versioneer]
VCS = git
style = pep440
versionfile_source = Lib/fontTools/_version.py
versionfile_build = fontTools/_version.py
tag_prefix =
parentdir_prefix = fonttools-

205
setup.py
View File

@ -1,9 +1,12 @@
#! /usr/bin/env python
from __future__ import print_function
import io
import sys
from setuptools import setup, find_packages
import versioneer
from setuptools import setup, find_packages, Command
from distutils import log
import subprocess as sp
import contextlib
# Force distutils to use py_compile.compile() function with 'doraise' argument
# set to True, in order to raise an exception on compilation errors
@ -19,6 +22,8 @@ needs_pytest = {'pytest', 'test'}.intersection(sys.argv)
pytest_runner = ['pytest_runner'] if needs_pytest else []
needs_wheel = {'bdist_wheel'}.intersection(sys.argv)
wheel = ['wheel'] if needs_wheel else []
needs_bumpversion = {'release'}.intersection(sys.argv)
bumpversion = ['bumpversion'] if needs_bumpversion else []
# Trove classifiers for PyPI
classifiers = {"classifiers": [
@ -43,9 +48,197 @@ fonts. The package also contains a tool called "TTX" which converts
TrueType/OpenType fonts to and from an XML-based format.
"""
@contextlib.contextmanager
def capture_logger(name):
""" Context manager to capture a logger output with a StringIO stream.
"""
import logging
logger = logging.getLogger(name)
try:
import StringIO
stream = StringIO.StringIO()
except ImportError:
stream = io.StringIO()
handler = logging.StreamHandler(stream)
logger.addHandler(handler)
try:
yield stream
finally:
logger.removeHandler(handler)
class release(Command):
"""
Tag a new release with a single command, using the 'bumpversion' tool
to update all the version strings in the source code.
The version scheme conforms to 'SemVer' and PEP 440 specifications.
Firstly, the pre-release '.devN' suffix is dropped to signal that this is
a stable release. If '--major' or '--minor' options are passed, the
the first or second 'semver' digit is also incremented. Major is usually
for backward-incompatible API changes, while minor is used when adding
new backward-compatible functionalities. No options imply 'patch' or bug-fix
release.
A new header is also added to the changelog file ("NEWS"), containing the
new version string and the current 'YYYY-MM-DD' date.
All changes are committed, and an annotated git tag is generated. With the
--sign option, the tag is GPG-signed with the user's default key.
Finally, the 'patch' part of the version string is bumped again, and a
pre-release suffix '.dev0' is appended to mark the opening of a new
development cycle.
Links:
- http://semver.org/
- https://www.python.org/dev/peps/pep-0440/
- https://github.com/peritus/bumpversion
"""
description = "update version strings for release"
user_options = [
("major", None, "bump the first digit (incompatible API changes)"),
("minor", None, "bump the second digit (new backward-compatible features)"),
("sign", "s", "make a GPG-signed tag, using the default key"),
("allow-dirty", None, "don't abort if working directory is dirty"),
]
changelog_name = "NEWS"
changelog_header = u"## TTX/FontTools Version "
changelog_date_fmt = "%Y-%m-%d"
commit_message = "Release {new_version}"
tag_name = "{new_version}"
version_files = [
"setup.cfg",
"setup.py",
"Lib/fontTools/__init__.py",
]
def initialize_options(self):
self.minor = False
self.major = False
self.sign = False
self.allow_dirty = False
def finalize_options(self):
if all([self.major, self.minor]):
from distutils.errors import DistutilsOptionError
raise DistutilsOptionError("--major/--minor are mutually exclusive")
self.part = "major" if self.major else "minor" if self.minor else None
def run(self):
if self.part is not None:
log.info("bumping '%s' version" % self.part)
self.bumpversion(self.part, commit=False)
release_version = self.bumpversion(
"release", commit=False, allow_dirty=True)
else:
log.info("stripping pre-release suffix")
release_version = self.bumpversion("release")
log.info(" version = %s" % release_version)
changes = self.format_changelog(release_version)
self.git_commit(release_version)
self.git_tag(release_version, changes, self.sign)
log.info("bumping 'patch' version and pre-release suffix")
next_dev_version = self.bumpversion('patch', commit=True)
log.info(" version = %s" % next_dev_version)
def git_commit(self, version):
""" Stage and commit all relevant version files, and format the commit
message with specified 'version' string.
"""
files = self.version_files + [self.changelog_name]
log.info("committing changes")
for f in files:
log.info(" %s" % f)
if self.dry_run:
return
sp.check_call(["git", "add"] + files)
msg = self.commit_message.format(new_version=version)
sp.check_call(["git", "commit", "-m", msg], stdout=sp.PIPE)
def git_tag(self, version, message, sign=False):
""" Create annotated git tag with given 'version' and 'message'.
Optionally 'sign' the tag with the user's GPG key.
"""
log.info("creating %s git tag '%s'" % (
"signed" if sign else "annotated", version))
if self.dry_run:
return
# create an annotated (or signed) tag from the new version
tag_opt = "-s" if sign else "-a"
tag_name = self.tag_name.format(new_version=version)
proc = sp.Popen(
["git", "tag", tag_opt, "-F", "-", tag_name], stdin=sp.PIPE)
# use the latest changes from the changelog file as the tag message
tag_message = u"%s\n\n%s" % (tag_name, message)
proc.communicate(tag_message.encode('utf-8'))
if proc.returncode != 0:
sys.exit(proc.returncode)
def bumpversion(self, part, commit=False, message=None, allow_dirty=None):
""" Run bumpversion.main() with the specified arguments, and return the
new computed version string (cf. 'bumpversion --help' for more info)
"""
import bumpversion
args = (
(['--verbose'] if self.verbose > 1 else []) +
(['--dry-run'] if self.dry_run else []) +
(['--allow-dirty'] if (allow_dirty or self.allow_dirty) else []) +
(['--commit'] if commit else ['--no-commit']) +
(['--message', message] if message is not None else []) +
['--list', part]
)
log.debug("$ bumpversion %s" % " ".join(a.replace(" ", "\\ ") for a in args))
with capture_logger("bumpversion.list") as out:
bumpversion.main(args)
last_line = out.getvalue().splitlines()[-1]
new_version = last_line.replace("new_version=", "")
return new_version
def format_changelog(self, version):
""" Write new header at beginning of changelog file with the specified
'version' and the current date.
Return the changelog content for the current release.
"""
from datetime import datetime
log.info("formatting changelog")
changes = []
with io.open(self.changelog_name, "r+", encoding="utf-8") as f:
for ln in f:
if ln.startswith(self.changelog_header):
break
else:
changes.append(ln)
if not self.dry_run:
f.seek(0)
content = f.read()
f.seek(0)
f.write(u"%s%s (%s)\n\n%s" % (
self.changelog_header,
version,
datetime.today().strftime(self.changelog_date_fmt),
content))
return u"".join(changes)
setup(
name="fonttools",
version=versioneer.get_version(),
version="3.3.1.dev0",
description="Tools to manipulate font files",
author="Just van Rossum",
author_email="just@letterror.com",
@ -61,7 +254,7 @@ setup(
data_files=[
('share/man/man1', ["Doc/ttx.1"])
] if sys.platform.startswith('linux') else [],
setup_requires=pytest_runner + wheel,
setup_requires=pytest_runner + wheel + bumpversion,
tests_require=[
'pytest>=2.8',
],
@ -74,6 +267,8 @@ setup(
"pyftinspect = fontTools.inspect:main"
]
},
cmdclass=versioneer.get_cmdclass(),
cmdclass={
"release": release,
},
**classifiers
)

1817
versioneer.py
View File

File diff suppressed because it is too large Load Diff