mirror of
https://github.com/scummvm/dockerized-bb.git
synced 2026-06-20 05:46:00 +00:00
This script search for patterns in the tree and apply checks on it. Everything is configured in config.py There are checks for SVN, Git, Docker, Apple store and Web pages.
293 lines
7.4 KiB
Python
293 lines
7.4 KiB
Python
"""
|
|
This module implements the version sort of coreutils taken from Debian
|
|
"""
|
|
|
|
import re
|
|
from itertools import zip_longest
|
|
from functools import total_ordering
|
|
|
|
__all__ = [ "Version" ]
|
|
|
|
EXT_RE = re.compile(rb'(?:\.[A-Za-z~][A-Za-z0-9~]*)*$')
|
|
|
|
EMPTY_VERSION = object()
|
|
CURRENT_DIR = object()
|
|
PARENT_DIR = object()
|
|
|
|
HIDDEN_PREFIX = object()
|
|
|
|
@total_ordering
|
|
class VersionString(bytes):
|
|
"""
|
|
String part of a version used to create custom ordering rules
|
|
"""
|
|
__slots__ = []
|
|
|
|
# Not supposed to contain any digit
|
|
def __lt__(self, other):
|
|
#if super().__eq__(other):
|
|
if self == other:
|
|
return False
|
|
# If other is an int, use an empty bytes because it will get filled by 0s
|
|
if isinstance(other, int):
|
|
other = b''
|
|
if not isinstance(other, bytes):
|
|
return NotImplemented
|
|
|
|
# If one part is short, it's like a digit (next part is a digit)
|
|
for s, o in zip_longest(self, other, fillvalue=b'0'[0]):
|
|
if s == o:
|
|
continue
|
|
s_b = bytes([s])
|
|
o_b = bytes([o])
|
|
#if s_b.isdigit() and o_b.isdigit():
|
|
# continue
|
|
if s_b == b'~':
|
|
return True
|
|
if o_b == b'~':
|
|
return False
|
|
if s_b.isdigit():
|
|
return True
|
|
if o_b.isdigit():
|
|
return False
|
|
if s_b.isalpha() and o_b.isalpha():
|
|
return s < o
|
|
if s_b.isalpha():
|
|
return True
|
|
if o_b.isalpha():
|
|
return False
|
|
return s < o
|
|
|
|
@total_ordering
|
|
class Version:
|
|
"""
|
|
Version is a sorting helper implementing coreutils alternative of Debian version sorting algorithm
|
|
"""
|
|
__slots__ = ["vstring", "flag",
|
|
"compstring", "suffstring",
|
|
"components", "suffix"]
|
|
|
|
def __init__(self, vstring=None):
|
|
"""
|
|
Creates a Version using parse method
|
|
"""
|
|
if not vstring:
|
|
vstring = ""
|
|
self.parse(vstring)
|
|
|
|
def parse(self, s):
|
|
"""
|
|
Parse a version and setup the Version object for sorting
|
|
"""
|
|
self.vstring = s
|
|
if isinstance(s, str):
|
|
s = s.encode('utf-8')
|
|
|
|
self.flag = None
|
|
self.compstring = b''
|
|
self.suffstring = b''
|
|
self.components = list()
|
|
self.suffix = list()
|
|
|
|
if len(s) == 0:
|
|
self.flag = EMPTY_VERSION
|
|
return
|
|
|
|
if s == b'.':
|
|
self.flag = CURRENT_DIR
|
|
return
|
|
if s == b'..':
|
|
self.flag = PARENT_DIR
|
|
return
|
|
|
|
if s[0:1] == b'.':
|
|
self.flag = HIDDEN_PREFIX
|
|
s = s[1:]
|
|
|
|
suffix_s = EXT_RE.search(s).group(0)
|
|
s = s[:len(s)-len(suffix_s)]
|
|
|
|
components = self.__parse_components(s)
|
|
|
|
if suffix_s:
|
|
suffix = self.__parse_components(suffix_s)
|
|
else:
|
|
suffix = list()
|
|
|
|
self.compstring = s
|
|
self.components = components
|
|
self.suffstring = suffix_s
|
|
self.suffix = suffix
|
|
|
|
def __parse_components(self, s):
|
|
"""
|
|
Parses a part of the version, either main part of suffix part
|
|
"""
|
|
components = list()
|
|
buf = b''
|
|
in_digit = False
|
|
for b_i in s:
|
|
b = bytes([b_i])
|
|
if in_digit and not b.isdigit():
|
|
# Numeric part
|
|
components.append(int(buf, 10))
|
|
in_digit = False
|
|
buf = b''
|
|
elif not in_digit and b.isdigit():
|
|
components.append(VersionString(buf))
|
|
in_digit = True
|
|
buf = b''
|
|
buf += b
|
|
if buf:
|
|
if in_digit:
|
|
# Numeric part
|
|
components.append(int(buf, 10))
|
|
else:
|
|
components.append(VersionString(buf))
|
|
return components
|
|
|
|
def __eq__(self, other):
|
|
"""
|
|
Checks version equality, first by comparing components then by comparing string wise
|
|
"""
|
|
if not isinstance(other, Version):
|
|
return NotImplemented
|
|
|
|
if self.flag != other.flag:
|
|
return False
|
|
|
|
if self.compstring == other.compstring:
|
|
self_c = self.suffix
|
|
other_c = other.suffix
|
|
else:
|
|
self_c = self.components
|
|
other_c = other.components
|
|
|
|
if self_c == other_c:
|
|
return self.vstring == other.vstring
|
|
else:
|
|
return False
|
|
|
|
def __lt__(self, other):
|
|
"""
|
|
Where the sorting magic happens
|
|
"""
|
|
if not isinstance(other, Version):
|
|
return NotImplemented
|
|
# Simple case first
|
|
if self.vstring == other.vstring:
|
|
return False
|
|
|
|
# For following flags, if they are equals it's treated by vstring equality
|
|
if self.flag == EMPTY_VERSION:
|
|
return True
|
|
if other.flag == EMPTY_VERSION:
|
|
return False
|
|
|
|
if self.flag == CURRENT_DIR:
|
|
return True
|
|
if other.flag == CURRENT_DIR:
|
|
return False
|
|
|
|
if self.flag == PARENT_DIR:
|
|
return True
|
|
if other.flag == PARENT_DIR:
|
|
return False
|
|
|
|
if self.flag == HIDDEN_PREFIX and other.flag != HIDDEN_PREFIX:
|
|
return True
|
|
if other.flag == HIDDEN_PREFIX and self.flag != HIDDEN_PREFIX:
|
|
return False
|
|
|
|
if self.compstring == other.compstring:
|
|
self_c = self.suffix
|
|
other_c = other.suffix
|
|
else:
|
|
self_c = self.components
|
|
other_c = other.components
|
|
|
|
for self_p, other_p in zip_longest(self_c, other_c, fillvalue=VersionString()):
|
|
if self_p == other_p:
|
|
continue
|
|
return self_p < other_p
|
|
|
|
VERSIONS = [
|
|
"",
|
|
".",
|
|
"..",
|
|
".0",
|
|
".9",
|
|
".A",
|
|
".Z",
|
|
".a~",
|
|
".a",
|
|
".b~",
|
|
".b",
|
|
".z",
|
|
".zz~",
|
|
".zz",
|
|
".zz.~1~",
|
|
".zz.0",
|
|
"0",
|
|
"9",
|
|
"A",
|
|
"Z",
|
|
"a~",
|
|
"a",
|
|
"a.b~",
|
|
"a.b",
|
|
"a.bc~",
|
|
"a.bc",
|
|
"b~",
|
|
"b",
|
|
"gcc-c++-10.fc9.tar.gz",
|
|
"gcc-c++-10.fc9.tar.gz.~1~",
|
|
"gcc-c++-10.fc9.tar.gz.~2~",
|
|
"gcc-c++-10.8.12-0.7rc2.fc9.tar.bz2",
|
|
"gcc-c++-10.8.12-0.7rc2.fc9.tar.bz2.~1~",
|
|
"glibc-2-0.1.beta1.fc10.rpm",
|
|
"glibc-common-5-0.2.beta2.fc9.ebuild",
|
|
"glibc-common-5-0.2b.deb",
|
|
"glibc-common-11b.ebuild",
|
|
"glibc-common-11-0.6rc2.ebuild",
|
|
"libstdc++-0.5.8.11-0.7rc2.fc10.tar.gz",
|
|
"libstdc++-4a.fc8.tar.gz",
|
|
"libstdc++-4.10.4.20040204svn.rpm",
|
|
"libstdc++-devel-3.fc8.ebuild",
|
|
"libstdc++-devel-3a.fc9.tar.gz",
|
|
"libstdc++-devel-8.fc8.deb",
|
|
"libstdc++-devel-8.6.2-0.4b.fc8",
|
|
"nss_ldap-1-0.2b.fc9.tar.bz2",
|
|
"nss_ldap-1-0.6rc2.fc8.tar.gz",
|
|
"nss_ldap-1.0-0.1a.tar.gz",
|
|
"nss_ldap-10beta1.fc8.tar.gz",
|
|
"nss_ldap-10.11.8.6.20040204cvs.fc10.ebuild",
|
|
"z",
|
|
"zz~",
|
|
"zz",
|
|
"zz.~1~",
|
|
"zz.0",
|
|
"#.b#",
|
|
]
|
|
|
|
def test():
|
|
import random
|
|
|
|
randoms = list(VERSIONS)
|
|
random.shuffle(randoms)
|
|
|
|
verversions = sorted(randoms, key=Version)
|
|
assert(VERSIONS == verversions)
|
|
|
|
for i in range(len(VERSIONS)):
|
|
for j in range(len(VERSIONS)):
|
|
v1 = Version(VERSIONS[i])
|
|
v2 = Version(VERSIONS[j])
|
|
lt = v1 < v2
|
|
eq = v1 == v2
|
|
assert(lt == (i < j))
|
|
assert(eq == (i == j))
|
|
|
|
if __name__ == "__main__":
|
|
test()
|