1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
import re
from distutils.version import StrictVersion
from looseversion import LooseVersion
class MozillaVersionCompareMixin:
def __cmp__(self, other):
# We expect this function to never be called.
raise AssertionError()
def _cmp(self, other):
has_esr = set()
if isinstance(other, LooseModernMozillaVersion) and str(other).endswith("esr"):
# If other version ends with esr, coerce through MozillaVersion ending up with
# a StrictVersion if possible
has_esr.add("other")
other = MozillaVersion(str(other)[:-3]) # strip ESR from end of string
if isinstance(self, LooseModernMozillaVersion) and str(self).endswith("esr"):
# If our version ends with esr, coerce through MozillaVersion ending up with
# a StrictVersion if possible
has_esr.add("self")
self = MozillaVersion(str(self)[:-3]) # strip ESR from end of string
if isinstance(other, LooseModernMozillaVersion) or isinstance(
self, LooseModernMozillaVersion
):
# If we're still LooseVersion for self or other, run LooseVersion compare
# Being sure to pass through Loose Version type first
val = LooseVersion._cmp(
LooseModernMozillaVersion(str(self)),
LooseModernMozillaVersion(str(other)),
)
else:
# No versions are loose, therefore we can use StrictVersion
val = StrictVersion._cmp(self, other)
if has_esr.isdisjoint(set(["other", "self"])) or has_esr.issuperset(
set(["other", "self"])
):
# If both had esr string or neither, then _cmp() was accurate
return val
elif val != 0:
# cmp is accurate here even if esr is present in only 1 compare, since
# versions are not equal
return val
elif "other" in has_esr:
return -1 # esr is not greater than non esr
return 1 # non esr is greater than esr
class ModernMozillaVersion(MozillaVersionCompareMixin, StrictVersion):
"""A version class that is slightly less restrictive than StrictVersion.
Instead of just allowing "a" or "b" as prerelease tags, it allows any
alpha. This allows us to support the once-shipped "3.6.3plugin1" and
similar versions."""
version_re = re.compile(
r"""^(\d+) \. (\d+) (\. (\d+))?
([a-zA-Z]+(\d+))?$""",
re.VERBOSE,
)
class AncientMozillaVersion(MozillaVersionCompareMixin, StrictVersion):
"""A version class that is slightly less restrictive than StrictVersion.
Instead of just allowing "a" or "b" as prerelease tags, it allows any
alpha. This allows us to support the once-shipped "3.6.3plugin1" and
similar versions.
It also supports versions w.x.y.z by transmuting to w.x.z, which
is useful for versions like 1.5.0.x and 2.0.0.y"""
version_re = re.compile(
r"""^(\d+) \. (\d+) \. \d (\. (\d+))
([a-zA-Z]+(\d+))?$""",
re.VERBOSE,
)
class LooseModernMozillaVersion(MozillaVersionCompareMixin, LooseVersion):
"""A version class that is more restrictive than LooseVersion.
This class reduces the valid strings to "esr", "a", "b" and "rc" in order
to support esr. StrictVersion requires a trailing number after all strings."""
component_re = re.compile(r"(\d+ | a | b | rc | esr | \.)", re.VERBOSE)
def __repr__(self):
return "LooseModernMozillaVersion ('%s')" % str(self)
def MozillaVersion(version):
try:
return ModernMozillaVersion(version)
except ValueError:
pass
try:
if version.count(".") == 3:
return AncientMozillaVersion(version)
except ValueError:
pass
try:
return LooseModernMozillaVersion(version)
except ValueError:
pass
raise ValueError("Version number %s is invalid." % version)
def getPrettyVersion(version):
version = re.sub(r"a([0-9]+)$", r" Alpha \1", version)
version = re.sub(r"b([0-9]+)$", r" Beta \1", version)
version = re.sub(r"rc([0-9]+)$", r" RC \1", version)
return version
|
