1 files changed, 38 insertions, 340 deletions

diff --git a/src/luarocks/deps.lua b/src/luarocks/deps.lua
index dcebec9b..015e2527 100644
--- a/src/luarocks/deps.lua
+++ b/src/luarocks/deps.lua
@@ -1,344 +1,40 @@
 
---- Dependency handling functions.
--- Dependencies are represented in LuaRocks through strings with
--- a package 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, LuaRocks 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 LuaRocks provides some
--- insights on what these criteria are.
+--- High-level dependency related functions.
 local deps = {}
-package.loaded["luarocks.deps"] = deps
 
-local cfg = require("luarocks.cfg")
-local manif_core = require("luarocks.manif_core")
+local cfg = require("luarocks.core.cfg")
+local manif = require("luarocks.manif")
 local path = require("luarocks.path")
 local dir = require("luarocks.dir")
 local util = require("luarocks.util")
-
-local operators = {
-   ["=="] = "==",
-   ["~="] = "~=",
-   [">"] = ">",
-   ["<"] = "<",
-   [">="] = ">=",
-   ["<="] = "<=",
-   ["~>"] = "~>",
-   -- plus some convenience translations
-   [""] = "==",
-   ["="] = "==",
-   ["!="] = "~="
-}
-
-local deltas = {
-   scm =    1100,
-   cvs =    1000,
-   rc =    -1000,
-   pre =   -10000,
-   beta =  -100000,
-   alpha = -1000000
-}
-
-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 deps.parse_version(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
-            util.printerr("Warning: version number '"..vstring.."' could not be parsed.")
-            version[i] = 0
-            break
-         end
-         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 deps.compare_versions(a, b)
-   return deps.parse_version(a) > deps.parse_version(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 parse_constraint(input)
-   assert(type(input) == "string")
-
-   local no_upgrade, op, version, rest = input:match("^(@?)([<>=~!]*)%s*([%w%.%_%-]+)[%s,]*(.*)")
-   local _op = operators[op]
-   version = deps.parse_version(version)
-   if not _op then
-      return nil, "Encountered bad constraint operator: '"..tostring(op).."' in '"..input.."'"
-   end
-   if not version then 
-      return nil, "Could not parse version from constraint: '"..input.."'"
-   end
-   return { op = _op, version = version, no_upgrade = no_upgrade=="@" and true or nil }, 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 deps.parse_constraints(input)
-   assert(type(input) == "string")
-
-   local constraints, constraint, oinput = {}, nil, input
-   while #input > 0 do
-      constraint, input = parse_constraint(input)
-      if constraint then
-         table.insert(constraints, constraint)
-      else
-         return nil, "Failed to parse constraint '"..tostring(oinput).."' with error: ".. input
-      end
-   end
-   return constraints
-end
-
---- Convert a dependency from string to table format.
--- For example, a string "foo >= 1.0, < 2.0"
--- is converted to a table in the format
--- {name = "foo", constraints = {{op = ">=", version={1,0}},
--- {op = "<", version={2,0}}}}. Version tables use a metatable
--- allowing later comparison through relational operators.
--- @param dep string: A dependency in string format
--- as entered in rockspec files.
--- @return table or nil: A table representing the same dependency relation,
--- or nil if the input string is invalid.
-function deps.parse_dep(dep)
-   assert(type(dep) == "string")
-
-   local name, rest = dep:match("^%s*([a-zA-Z0-9][a-zA-Z0-9%.%-%_]*)%s*(.*)")
-   if not name then return nil, "failed to extract dependency name from '"..tostring(dep).."'" end
-   local constraints, err = deps.parse_constraints(rest)
-   if not constraints then return nil, err end
-   return { name = name, constraints = constraints }
-end
-
---- Convert a version table to a string.
--- @param v table: The version table
--- @param internal boolean or nil: Whether to display versions in their
--- internal representation format or how they were specified.
--- @return string: The dependency information pretty-printed as a string.
-function deps.show_version(v, internal)
-   assert(type(v) == "table")
-   assert(type(internal) == "boolean" or not internal)
-
-   return (internal
-           and table.concat(v, ":")..(v.revision and tostring(v.revision) or "")
-           or v.string)
-end
-
---- Convert a dependency in table format to a string.
--- @param dep table: The dependency in table format
--- @param internal boolean or nil: Whether to display versions in their
--- internal representation format or how they were specified.
--- @return string: The dependency information pretty-printed as a string.
-function deps.show_dep(dep, internal)
-   assert(type(dep) == "table")
-   assert(type(internal) == "boolean" or not internal)
-
-   if #dep.constraints > 0 then
-      local pretty = {}
-      for _, c in ipairs(dep.constraints) do
-         table.insert(pretty, c.op .. " " .. deps.show_version(c.version, internal))
-      end
-      return dep.name.." "..table.concat(pretty, ", ")
-   else
-      return dep.name
-   end
-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 partial_match(version, requested)
-   assert(type(version) == "string" or type(version) == "table")
-   assert(type(requested) == "string" or type(version) == "table")
-
-   if type(version) ~= "table" then version = deps.parse_version(version) end
-   if type(requested) ~= "table" then requested = deps.parse_version(requested) end
-   if not version or not requested then return false end
-   
-   for i, ri in ipairs(requested) do
-      local vi = version[i] or 0
-      if ri ~= vi 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 deps.match_constraints(version, constraints)
-   assert(type(version) == "table")
-   assert(type(constraints) == "table")
-   local ok = true
-   setmetatable(version, version_mt)
-   for _, constr in pairs(constraints) do
-      if type(constr.version) == "string" then
-         constr.version = deps.parse_version(constr.version)
-      end
-      local constr_version, constr_op = constr.version, constr.op
-      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 = partial_match(version, constr_version)
-      end
-      if not ok then break end
-   end
-   return ok
-end
+local vers = require("luarocks.vers")
 
 --- Attempt to match a dependency to an installed rock.
 -- @param dep table: A dependency parsed in table format.
 -- @param blacklist table: Versions that can't be accepted. Table where keys
 -- are program versions and values are 'true'.
+-- @param rocks_provided table: A table of auto-dependencies provided 
+-- by this Lua implementation for the given dependency.
 -- @return string or nil: latest installed version of the rock matching the dependency
 -- or nil if it could not be matched.
-local function match_dep(dep, blacklist, deps_mode)
+local function match_dep(dep, blacklist, deps_mode, rocks_provided)
    assert(type(dep) == "table")
-
+   assert(type(rocks_provided) == "table")
+  
    local versions
-   if cfg.rocks_provided[dep.name] then
-      -- provided rocks have higher priority than manifest's rocks
-      versions = { cfg.rocks_provided[dep.name] }
+   local provided = rocks_provided[dep.name]
+   if provided then
+      -- Provided rocks have higher priority than manifest's rocks.
+      versions = { provided }
    else
-      versions = manif_core.get_versions(dep.name, deps_mode)
+      versions = manif.get_versions(dep.name, deps_mode)
    end
 
    local latest_version
    for _, vstring in ipairs(versions) do
       if not blacklist or not blacklist[vstring] then
-         local version = deps.parse_version(vstring)
-         if deps.match_constraints(version, dep.constraints) then
+         local version = vers.parse_version(vstring)
+         if vers.match_constraints(version, dep.constraints) then
             if not latest_version or version > latest_version then
                latest_version = version
             end
@@ -366,9 +62,9 @@ function deps.match_deps(rockspec, blacklist, deps_mode)
    local matched, missing, no_upgrade = {}, {}, {}
    
    for _, dep in ipairs(rockspec.dependencies) do
-      local found = match_dep(dep, blacklist and blacklist[dep.name] or nil, deps_mode)
+      local found = match_dep(dep, blacklist and blacklist[dep.name] or nil, deps_mode, rockspec.rocks_provided)
       if found then
-         if not cfg.rocks_provided[dep.name] then
+         if not rockspec.rocks_provided[dep.name] then
             matched[dep] = {name = dep.name, version = found}
          end
       else
@@ -393,10 +89,10 @@ local function values_set(tbl)
    return set
 end
 
-local function rock_status(name, deps_mode)
+local function rock_status(name, deps_mode, rocks_provided)
    local search = require("luarocks.search")
-   local installed = match_dep(search.make_query(name), nil, deps_mode)
-   local installation_type = cfg.rocks_provided[name] and "provided by VM" or "installed"
+   local installed = match_dep(search.make_query(name), nil, deps_mode, rocks_provided)
+   local installation_type = rocks_provided[name] and "provided by VM" or "installed"
    return installed and installed.." "..installation_type or "not installed"
 end
 
@@ -405,19 +101,21 @@ end
 -- @param version string: package version.
 -- @param dependencies table: array of dependencies.
 -- @param deps_mode string: Which trees to check dependencies for:
+-- @param rocks_provided table: A table of auto-dependencies provided 
+-- by this Lua implementation for the given dependency.
 -- "one" for the current default tree, "all" for all trees,
 -- "order" for all trees with priority >= the current default, "none" for no trees.
-function deps.report_missing_dependencies(name, version, dependencies, deps_mode)
+function deps.report_missing_dependencies(name, version, dependencies, deps_mode, rocks_provided)
    local first_missing_dep = true
 
    for _, dep in ipairs(dependencies) do
-      if not match_dep(dep, nil, deps_mode) then
+      if not match_dep(dep, nil, deps_mode, rocks_provided) then
          if first_missing_dep then
             util.printout(("Missing dependencies for %s %s:"):format(name, version))
             first_missing_dep = false
          end
 
-         util.printout(("   %s (%s)"):format(deps.show_dep(dep), rock_status(dep.name, deps_mode)))
+         util.printout(("   %s (%s)"):format(vers.show_dep(dep), rock_status(dep.name, deps_mode, rocks_provided)))
       end
    end
 end
@@ -432,7 +130,7 @@ end
 function deps.fulfill_dependencies(rockspec, deps_mode)
 
    local search = require("luarocks.search")
-   local install = require("luarocks.install")
+   local install = require("luarocks.cmd.install")
 
    if rockspec.supported_platforms then
       if not deps.platforms_set then
@@ -440,7 +138,8 @@ function deps.fulfill_dependencies(rockspec, deps_mode)
       end
       local supported = nil
       for _, plat in pairs(rockspec.supported_platforms) do
-         local neg, plat = plat:match("^(!?)(.*)")
+         local neg
+         neg, plat = plat:match("^(!?)(.*)")
          if neg == "!" then
             if deps.platforms_set[plat] then
                return nil, "This rockspec for "..rockspec.package.." does not support "..plat.." platforms."
@@ -461,23 +160,23 @@ function deps.fulfill_dependencies(rockspec, deps_mode)
       end
    end
 
-   deps.report_missing_dependencies(rockspec.name, rockspec.version, rockspec.dependencies, deps_mode)
+   deps.report_missing_dependencies(rockspec.name, rockspec.version, rockspec.dependencies, deps_mode, rockspec.rocks_provided)
 
    local first_missing_dep = true
 
    for _, dep in ipairs(rockspec.dependencies) do
-      if not match_dep(dep, nil, deps_mode) then
+      if not match_dep(dep, nil, deps_mode, rockspec.rocks_provided) then
          if first_missing_dep then
             util.printout()
             first_missing_dep = false
          end
 
          util.printout(("%s %s depends on %s (%s)"):format(
-            rockspec.name, rockspec.version, deps.show_dep(dep), rock_status(dep.name, deps_mode)))
+            rockspec.name, rockspec.version, vers.show_dep(dep), rock_status(dep.name, deps_mode, rockspec.rocks_provided)))
 
          if dep.constraints[1] and dep.constraints[1].no_upgrade then
             util.printerr("This version of "..rockspec.name.." is designed for use with")
-            util.printerr(deps.show_dep(dep)..", but is configured to avoid upgrading it")
+            util.printerr(vers.show_dep(dep)..", but is configured to avoid upgrading it")
             util.printerr("automatically. Please upgrade "..dep.name.." with")
             util.printerr("   luarocks install "..dep.name)
             util.printerr("or choose an older version of "..rockspec.name.." with")
@@ -487,7 +186,7 @@ function deps.fulfill_dependencies(rockspec, deps_mode)
 
          local url, search_err = search.find_suitable_rock(dep)
          if not url then
-            return nil, "Could not satisfy dependency "..deps.show_dep(dep)..": "..search_err
+            return nil, "Could not satisfy dependency "..vers.show_dep(dep)..": "..search_err
          end
          util.printout("Installing "..url)
          local ok, install_err, errcode = install.command({deps_mode = deps_mode}, url)
@@ -717,7 +416,10 @@ function deps.scan_deps(results, manifest, name, version, deps_mode)
       end
       dependencies_name[version] = rockspec.dependencies
    else
-      rockspec = { dependencies = deplist }
+      rockspec = {
+         dependencies = deplist,
+         rocks_provided = setmetatable({}, { __index = cfg.rocks_provided_3_0 })
+      }
    end
    local matched = deps.match_deps(rockspec, nil, deps_mode)
    results[name] = version
@@ -745,8 +447,4 @@ function deps.get_deps_mode(flags)
    end
 end
 
-function deps.deps_mode_to_flag(deps_mode)
-   return "--deps-mode="..deps_mode
-end
-
 return deps