-- Note: the code of this module is borrowed from the original LuaDist project
|
|
|
|
--- LuaDist version constraints functions
|
-- Peter Drahoš, LuaDist Project, 2010
|
-- Original Code borrowed from LuaRocks Project
|
|
--- Version constraints handling functions.
|
-- Dependencies are represented in LuaDist through strings with
|
-- a dist name followed by a comma-separated list of constraints.
|
-- Each constraint consists of an operator and a version number.
|
-- In this string format, version numbers are represented as
|
-- naturally as possible, like they are used by upstream projects
|
-- (e.g. "2.0beta3"). Internally, LuaDist converts them to a purely
|
-- numeric representation, allowing comparison following some
|
-- "common sense" heuristics. The precise specification of the
|
-- comparison criteria is the source code of this module, but the
|
-- test/test_deps.lua file included with LuaDist provides some
|
-- insights on what these criteria are.
|
|
module ("dist.constraints", package.seeall)
|
|
|
local operators = {
|
["=="] = "==",
|
["~="] = "~=",
|
[">"] = ">",
|
["<"] = "<",
|
[">="] = ">=",
|
["<="] = "<=",
|
["~>"] = "~>",
|
-- plus some convenience translations
|
[""] = "==",
|
["-"] = "==",
|
["="] = "==",
|
["!="] = "~="
|
}
|
|
local deltas = {
|
scm = -100,
|
rc = -1000,
|
pre = -10000,
|
beta = -100000,
|
alpha = -1000000,
|
work = -10000000,
|
}
|
|
local version_mt = {
|
--- Equality comparison for versions.
|
-- All version numbers must be equal.
|
-- If both versions have revision numbers, they must be equal;
|
-- otherwise the revision number is ignored.
|
-- @param v1 table: version table to compare.
|
-- @param v2 table: version table to compare.
|
-- @return boolean: true if they are considered equivalent.
|
__eq = function(v1, v2)
|
if #v1 ~= #v2 then
|
return false
|
end
|
for i = 1, #v1 do
|
if v1[i] ~= v2[i] then
|
return false
|
end
|
end
|
if v1.revision and v2.revision then
|
return (v1.revision == v2.revision)
|
end
|
return true
|
end,
|
--- Size comparison for versions.
|
-- All version numbers are compared.
|
-- If both versions have revision numbers, they are compared;
|
-- otherwise the revision number is ignored.
|
-- @param v1 table: version table to compare.
|
-- @param v2 table: version table to compare.
|
-- @return boolean: true if v1 is considered lower than v2.
|
__lt = function(v1, v2)
|
for i = 1, math.max(#v1, #v2) do
|
local v1i, v2i = v1[i] or 0, v2[i] or 0
|
if v1i ~= v2i then
|
return (v1i < v2i)
|
end
|
end
|
if v1.revision and v2.revision then
|
return (v1.revision < v2.revision)
|
end
|
return false
|
end
|
}
|
|
local version_cache = {}
|
setmetatable(version_cache, {
|
__mode = "kv"
|
})
|
|
--- Parse a version string, converting to table format.
|
-- A version table contains all components of the version string
|
-- converted to numeric format, stored in the array part of the table.
|
-- If the version contains a revision, it is stored numerically
|
-- in the 'revision' field. The original string representation of
|
-- the string is preserved in the 'string' field.
|
-- Returned version tables use a metatable
|
-- allowing later comparison through relational operators.
|
-- @param vstring string: A version number in string format.
|
-- @return table or nil: A version table or nil
|
-- if the input string contains invalid characters.
|
function parseVersion(vstring)
|
if not vstring then return nil end
|
assert(type(vstring) == "string")
|
|
local cached = version_cache[vstring]
|
if cached then
|
return cached
|
end
|
|
local version = {}
|
local i = 1
|
|
local function add_token(number)
|
version[i] = version[i] and version[i] + number/100000 or number
|
i = i + 1
|
end
|
|
-- trim leading and trailing spaces
|
vstring = vstring:match("^%s*(.*)%s*$")
|
version.string = vstring
|
-- store revision separately if any
|
local main, revision = vstring:match("(.*)%-(%d+)$")
|
if revision then
|
vstring = main
|
version.revision = tonumber(revision)
|
end
|
while #vstring > 0 do
|
-- extract a number
|
local token, rest = vstring:match("^(%d+)[%.%-%_]*(.*)")
|
if token then
|
add_token(tonumber(token))
|
else
|
-- extract a word
|
token, rest = vstring:match("^(%a+)[%.%-%_]*(.*)")
|
if not token then
|
return nil
|
end
|
local last = #version
|
version[i] = deltas[token] or (token:byte() / 1000)
|
end
|
vstring = rest
|
end
|
setmetatable(version, version_mt)
|
version_cache[vstring] = version
|
return version
|
end
|
|
--- Utility function to compare version numbers given as strings.
|
-- @param a string: one version.
|
-- @param b string: another version.
|
-- @return boolean: True if a > b.
|
function compareVersions(a, b)
|
return parseVersion(a) > parseVersion(b)
|
end
|
|
--- Consumes a constraint from a string, converting it to table format.
|
-- For example, a string ">= 1.0, > 2.0" is converted to a table in the
|
-- format {op = ">=", version={1,0}} and the rest, "> 2.0", is returned
|
-- back to the caller.
|
-- @param input string: A list of constraints in string format.
|
-- @return (table, string) or nil: A table representing the same
|
-- constraints and the string with the unused input, or nil if the
|
-- input string is invalid.
|
local function parseConstraint(input)
|
assert(type(input) == "string")
|
|
local op, version, rest = input:match("^([<>=~!]*)%s*([%w%.%_%-]+)[%s,]*(.*)")
|
op = operators[op]
|
version = parseVersion(version)
|
if not op or not version then return nil end
|
return { op = op, version = version }, rest
|
end
|
|
--- Convert a list of constraints from string to table format.
|
-- For example, a string ">= 1.0, < 2.0" is converted to a table in the format
|
-- {{op = ">=", version={1,0}}, {op = "<", version={2,0}}}.
|
-- Version tables use a metatable allowing later comparison through
|
-- relational operators.
|
-- @param input string: A list of constraints in string format.
|
-- @return table or nil: A table representing the same constraints,
|
-- or nil if the input string is invalid.
|
function parseConstraints(input)
|
assert(type(input) == "string")
|
|
local constraints, constraint = {}, nil
|
while #input > 0 do
|
constraint, input = parseConstraint(input)
|
if constraint then
|
table.insert(constraints, constraint)
|
else
|
return nil
|
end
|
end
|
return constraints
|
end
|
|
--- A more lenient check for equivalence between versions.
|
-- This returns true if the requested components of a version
|
-- match and ignore the ones that were not given. For example,
|
-- when requesting "2", then "2", "2.1", "2.3.5-9"... all match.
|
-- When requesting "2.1", then "2.1", "2.1.3" match, but "2.2"
|
-- doesn't.
|
-- @param version string or table: Version to be tested; may be
|
-- in string format or already parsed into a table.
|
-- @param requested string or table: Version requested; may be
|
-- in string format or already parsed into a table.
|
-- @return boolean: True if the tested version matches the requested
|
-- version, false otherwise.
|
local function partialMatch(version, requested)
|
assert(type(version) == "string" or type(version) == "table")
|
assert(type(requested) == "string" or type(version) == "table")
|
|
if type(version) ~= "table" then version = parseVersion(version) end
|
if type(requested) ~= "table" then requested = parseVersion(requested) end
|
if not version or not requested then return false end
|
|
for i = 1, #requested do
|
if requested[i] ~= version[i] then return false end
|
end
|
if requested.revision then
|
return requested.revision == version.revision
|
end
|
return true
|
end
|
|
--- Check if a version satisfies a set of constraints.
|
-- @param version table: A version in table format
|
-- @param constraints table: An array of constraints in table format.
|
-- @return boolean: True if version satisfies all constraints,
|
-- false otherwise.
|
function matchConstraints(version, constraints)
|
assert(type(version) == "table")
|
assert(type(constraints) == "table")
|
local ok = true
|
setmetatable(version, version_mt)
|
for _, constr in pairs(constraints) do
|
local constr_version = constr.version
|
setmetatable(constr.version, version_mt)
|
if constr.op == "==" then ok = version == constr_version
|
elseif constr.op == "~=" then ok = version ~= constr_version
|
elseif constr.op == ">" then ok = version > constr_version
|
elseif constr.op == "<" then ok = version < constr_version
|
elseif constr.op == ">=" then ok = version >= constr_version
|
elseif constr.op == "<=" then ok = version <= constr_version
|
elseif constr.op == "~>" then ok = partialMatch(version, constr_version)
|
end
|
if not ok then break end
|
end
|
return ok
|
end
|
|
--- Check if a version string is satisfied by a constraint string.
|
-- @param version string: A version in string format
|
-- @param constraints string: Constraints in string format.
|
-- @return boolean: True if version satisfies all constraints,
|
-- false otherwise.
|
function constraint_satisfied(version, constraints)
|
local const = parseConstraints(constraints)
|
local ver = parseVersion(version)
|
if const and ver then
|
return matchConstraints(ver, const)
|
end
|
return nil, "Error parsing versions."
|
end
|
