--- /dev/null
+# This module defines the immutable Version type.
+# Initialize it with Version(string). It defines attributes
+# epoch, upstream, and debian.
+# Comparison operations are defined on Versions and follow the same rules
+# as dpkg.
+
+# Copyright (C) 1998 Richard Braakman
+#
+# This program is free software. It is distributed under the terms of
+# the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, you can find it on the World Wide
+# Web at http://www.gnu.org/copyleft/gpl.html, or write to the Free
+# Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+import string
+import re
+
+# TODO: Is the regexp very slow? Find out. It could be simplified
+# at the cost of some extra string slicing by the caller.
+
+# python can be just as incomprehensible as perl!
+version_format = re.compile(r"^(\d+:)?([\w][\w+.:\-]*?)(-[\w+.]+)?$")
+
+# The regexp above breaks down into three parts:
+# (\d+:)? Optional epoch
+# ([\w][\w+.:\-]*?) Upstream version number
+# (-[\w+.]+)? Optional Debian revision
+# The *? notation at the end of the upstream version number means the
+# regexp engine should attempt a minimum-length match, rather than
+# maximum-length. This prevents the upstream-version pattern from
+# gobbling up the Debian revision.
+
+# A non-numeric sequence followed by a numeric sequence.
+# The comparison code uses it to consume the version string according
+# to the algorithm in the Policy manual, two steps at a time.
+compare_format = re.compile(r"([^\d]*)(\d*)")
+
+# An alphabetic sequence followed by a non-alphabetic sequence.
+# This way, the non-numeric parts are divided into parts just
+# like the entire version string is.
+alph_compare_format = re.compile(r"([a-zA-Z]*)([^a-zA-Z]*)")
+
+# Compare non-numeric parts of version strings x and y.
+# It differs from the normal cmp, because non-alphabetic characters
+# must sort newer than alphabetic ones.
+def alphcmp(x, y):
+ while len(x) > 0 and len(y) > 0:
+ # The match is guaranteed not to fail, because the regexp can match
+ # a zero-length string.
+ (xalph, xnonalph) = alph_compare_format.match(x).groups()
+ (yalph, ynonalph) = alph_compare_format.match(y).groups()
+ if xalph == yalph:
+ if xnonalph == ynonalph:
+ x = x[len(xalph) + len(xnonalph):]
+ y = y[len(yalph) + len(ynonalph):]
+ else:
+ return cmp(xnonalph, ynonalph)
+ else:
+ common = min(len(xalph), len(yalph))
+ if xalph[:common] == yalph[:common]:
+ if len(xalph) == common:
+ if xnonalph == '':
+ return -1 # y is the longer string
+ else:
+ return 1 # xnonalph will sort newer than yalph's tail
+ else:
+ if ynonalph == '':
+ return 1 # x is the longer string
+ else:
+ return -1 # ynonalph will sort newer than xalph's tail
+ else:
+ return cmp(xalph[:common], yalph[:common])
+
+ # One of the strings is exhausted. The longer string counts as newer.
+ return cmp(len(x), len(y))
+
+
+# Compare the version strings x and y. Return positive if x is
+# newer than y, and negative if x is older than y. The caller
+# guarantees that they are not equal.
+def versioncmp(x, y):
+ while len(x) > 0 and len(y) > 0:
+ # The match is guaranteed not to fail, because the regexp can match
+ # a zero-length string.
+ (xnondigit, xdigit) = compare_format.match(x).groups()
+ (ynondigit, ydigit) = compare_format.match(y).groups()
+ if xnondigit == ynondigit:
+ if xdigit == ydigit:
+ x = x[len(xnondigit) + len(xdigit):]
+ y = y[len(ynondigit) + len(ydigit):]
+ # Count an empty digit string as zero. (i.e. 1.1 versus 1.)
+ elif xdigit == '':
+ return cmp(0, string.atoi(ydigit))
+ elif ydigit == '':
+ return cmp(string.atoi(xdigit), 0)
+ else:
+ return cmp(string.atoi(xdigit), string.atoi(ydigit))
+ else:
+ return alphcmp(xnondigit, ynondigit)
+
+ # One of the strings is exhausted. The longer string counts as newer.
+ return cmp(len(x), len(y))
+
+compare_cache = {}
+
+def cache_versioncmp(x, y):
+ if compare_cache.has_key((x, y)):
+ return compare_cache[(x, y)]
+ c = versioncmp(x, y)
+ compare_cache[(x, y)] = c
+ compare_cache[(y, x)] = -c
+ return c
+
+# A version is an immutable object. It is created with Version(string)
+# and is not changed thereafter. This is not enforced.
+class Version:
+ # A Version object is defined by an epoch (stored in self.epoch
+ # as an integer), an upstream version (stored in self.upstream as
+ # a string), and a debian revision (stroed in self.debian as
+ # a string).
+ # self.debian may be None to indicate that the version number does
+ # not have a Debian revision.
+ def __init__(self, version):
+ # See Policy manual, chapter 4.
+ match = version_format.match(version)
+ if not match:
+ raise ValueError, version
+ (epoch, upstream, debian) = match.group(1, 2, 3)
+ if epoch:
+ # slice off the colon
+ self.epoch = string.atoi(epoch[:-1])
+ else:
+ self.epoch = 0
+ self.upstream = upstream
+ if debian:
+ # slice off the leading hyphen
+ self.debian = debian[1:]
+ else:
+ self.debian = None
+
+ # This function compares two versions. We use the earlier/later
+ # relationship defined in the policy manual as our ordering
+ # relationship. Thus, the function should return a negative
+ # number if self is earlier than other, zero if they are equal,
+ # and a positive number if self is later than other.
+ def __cmp__(self, other):
+ if self.epoch == other.epoch:
+ if self.upstream == other.upstream:
+ if self.debian == other.debian:
+ return 0
+ # "The absence of a <debian_revision> compares earlier than
+ # the presence of one". (Policy manual chapter 4)
+ elif self.debian and not other.debian:
+ return 1
+ elif not self.debian and other.debian:
+ return -1
+ else:
+ return cache_versioncmp(self.debian, other.debian)
+ else:
+ return cache_versioncmp(self.upstream, other.upstream)
+ else:
+ return cmp(self.epoch, other.epoch)
+
+ # Return a good hash value when this object is used as a key
+ # in a dictionary. Only immutable objects should define a
+ # hash function.
+ def __hash__(self):
+ return hash(self.epoch) ^ hash(self.upstream) ^ hash(self.debian)
+
+ # This should return a string representation of this object.
+ # We represent a version string by recombining the epoch,
+ # upstream version, and debian revision.
+ def __str__(self):
+ # We normally leave out an epoch of 0, but we do add it if
+ # the upstream version contains a colon (:), in order to
+ # keep it a valid version string.
+ if self.epoch != 0 or string.find(self.upstream, ':') >= 0:
+ if self.debian:
+ return '%d:%s-%s' % (self.epoch, self.upstream, self.debian)
+ else:
+ return '%d:%s' % (self.epoch, self.upstream)
+ elif self.debian:
+ return self.upstream + '-' + self.debian
+ else:
+ return self.upstream
+
+ # This should return a string that is a valid Python expression
+ # for recreating this value. It is the "official" representation.
+ # Useful for debugging.
+ def __repr__(self):
+ return 'Version(' + `str(self)` + ')'
+
+ # Cheap comparison, when only equality is asked for.
+ def equals(self, other):
+ return self.upstream == other.upstream and \
+ self.debian == other.debian and \
+ self.epoch == other.epoch
+
+version_cache = {}
+
+def make(version):
+ if version_cache.has_key(version):
+ return version_cache[version]
+ else:
+ v = Version(version)
+ version_cache[version] = v
+ return v
projects / maemian / blobdiff