Kaydet (Commit) 227e8ffa authored tarafından Fred Drake's avatar Fred Drake

- rename check_provision() to split_revision()

- fix indentation to conform to the Python style guide
- add more tests and documentation
üst dd6f0463
...@@ -1181,11 +1181,7 @@ class DistributionMetadata: ...@@ -1181,11 +1181,7 @@ class DistributionMetadata:
value = [v.strip() for v in value] value = [v.strip() for v in value]
for v in value: for v in value:
import distutils.versionpredicate import distutils.versionpredicate
ver = distutils.versionpredicate.check_provision(v) distutils.versionpredicate.split_provision(v)
if ver:
import distutils.version
sv = distutils.version.StrictVersion()
sv.parse(ver.strip()[1:-1])
self.provides = value self.provides = value
def get_obsoletes(self): def get_obsoletes(self):
......
"""Module for parsing and testing package version predicate strings. """Module for parsing and testing package version predicate strings.
""" """
import re import re
import version import distutils.version
import operator import operator
re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)") re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)")
# (package) (rest) # (package) (rest)
...@@ -11,93 +12,153 @@ re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses ...@@ -11,93 +12,153 @@ re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$") re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
# (comp) (version) # (comp) (version)
def splitUp(pred): def splitUp(pred):
"""Parse a single version comparison. """Parse a single version comparison.
Return (comparison string, StrictVersion)
""" Return (comparison string, StrictVersion)
res = re_splitComparison.match(pred) """
if not res: res = re_splitComparison.match(pred)
raise ValueError, "Bad package restriction syntax: " + pred if not res:
comp, verStr = res.groups() raise ValueError("bad package restriction syntax: %r" % pred)
return (comp, version.StrictVersion(verStr)) comp, verStr = res.groups()
return (comp, distutils.version.StrictVersion(verStr))
compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq, compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
">": operator.gt, ">=": operator.ge, "!=": operator.ne} ">": operator.gt, ">=": operator.ge, "!=": operator.ne}
class VersionPredicate: class VersionPredicate:
"""Parse and test package version predicates. """Parse and test package version predicates.
>>> v = VersionPredicate("pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)") >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')
>>> print v
pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3) The `name` attribute provides the full dotted name that is given::
>>> v.satisfied_by("1.1")
True >>> v.name
>>> v.satisfied_by("1.4") 'pyepat.abc'
True
>>> v.satisfied_by("1.0") The str() of a `VersionPredicate` provides a normalized
False human-readable version of the expression::
>>> v.satisfied_by("4444.4")
False >>> print v
>>> v.satisfied_by("1555.1b3") pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)
False
>>> v = VersionPredicate("pat( == 0.1 ) ") The `satisfied_by()` method can be used to determine with a given
>>> v.satisfied_by("0.1") version number is included in the set described by the version
True restrictions::
>>> v.satisfied_by("0.2")
False >>> v.satisfied_by('1.1')
>>> v = VersionPredicate("p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)") True
Traceback (most recent call last): >>> v.satisfied_by('1.4')
... True
ValueError: invalid version number '1.2zb3' >>> v.satisfied_by('1.0')
False
""" >>> v.satisfied_by('4444.4')
False
def __init__(self, versionPredicateStr): >>> v.satisfied_by('1555.1b3')
"""Parse a version predicate string. False
"""
# Fields: `VersionPredicate` is flexible in accepting extra whitespace::
# name: package name
# pred: list of (comparison string, StrictVersion) >>> v = VersionPredicate(' pat( == 0.1 ) ')
>>> v.name
versionPredicateStr = versionPredicateStr.strip() 'pat'
if not versionPredicateStr: >>> v.satisfied_by('0.1')
raise ValueError, "Empty package restriction" True
match = re_validPackage.match(versionPredicateStr) >>> v.satisfied_by('0.2')
if not match: False
raise ValueError, "Bad package name in " + versionPredicateStr
self.name, paren = match.groups() If any version numbers passed in do not conform to the
paren = paren.strip() restrictions of `StrictVersion`, a `ValueError` is raised::
if paren:
match = re_paren.match(paren) >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
if not match: Traceback (most recent call last):
raise ValueError, "Expected parenthesized list: " + paren ...
str = match.groups()[0] ValueError: invalid version number '1.2zb3'
self.pred = [splitUp(aPred) for aPred in str.split(",")]
if not self.pred: It the module or package name given does not conform to what's
raise ValueError("Empty Parenthesized list in %r" allowed as a legal module or package name, `ValueError` is
% versionPredicateStr ) raised::
else:
self.pred=[] >>> v = VersionPredicate('foo-bar')
Traceback (most recent call last):
def __str__(self): ...
if self.pred: ValueError: expected parenthesized list: '-bar'
seq = [cond + " " + str(ver) for cond, ver in self.pred]
return self.name + " (" + ", ".join(seq) + ")" >>> v = VersionPredicate('foo bar (12.21)')
else: Traceback (most recent call last):
return self.name ...
ValueError: expected parenthesized list: 'bar (12.21)'
def satisfied_by(self, version):
"""True if version is compatible with all the predicates in self. """
The parameter version must be acceptable to the StrictVersion
constructor. It may be either a string or StrictVersion. def __init__(self, versionPredicateStr):
""" """Parse a version predicate string.
for cond, ver in self.pred: """
if not compmap[cond](version, ver): # Fields:
return False # name: package name
return True # pred: list of (comparison string, StrictVersion)
versionPredicateStr = versionPredicateStr.strip()
def check_provision(value): if not versionPredicateStr:
m = re.match("[a-zA-Z_]\w*(\.[a-zA-Z_]\w*)*(\s*\([^)]+\))?$", value) raise ValueError("empty package restriction")
match = re_validPackage.match(versionPredicateStr)
if not match:
raise ValueError("bad package name in %r" % versionPredicateStr)
self.name, paren = match.groups()
paren = paren.strip()
if paren:
match = re_paren.match(paren)
if not match:
raise ValueError("expected parenthesized list: %r" % paren)
str = match.groups()[0]
self.pred = [splitUp(aPred) for aPred in str.split(",")]
if not self.pred:
raise ValueError("empty parenthesized list in %r"
% versionPredicateStr)
else:
self.pred=[]
def __str__(self):
if self.pred:
seq = [cond + " " + str(ver) for cond, ver in self.pred]
return self.name + " (" + ", ".join(seq) + ")"
else:
return self.name
def satisfied_by(self, version):
"""True if version is compatible with all the predicates in self.
The parameter version must be acceptable to the StrictVersion
constructor. It may be either a string or StrictVersion.
"""
for cond, ver in self.pred:
if not compmap[cond](version, ver):
return False
return True
_provision_rx = None
def split_provision(value):
"""Return the name and optional version number of a provision.
The version number, if given, will be returned as a `StrictVersion`
instance, otherwise it will be `None`.
>>> split_provision('mypkg')
('mypkg', None)
>>> split_provision(' mypkg( 1.2 ) ')
('mypkg', StrictVersion ('1.2'))
"""
global _provision_rx
if _provision_rx is None:
_provision_rx = re.compile(
"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$")
value = value.strip()
m = _provision_rx.match(value)
if not m: if not m:
raise ValueError("illegal provides specification: %r" % value) raise ValueError("illegal provides specification: %r" % value)
ver = m.group(2) or None
if ver:
ver = distutils.version.StrictVersion(ver)
return m.group(1), ver
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment