test

5 files changed, 1220 insertions, 15 deletions

diff --git a/src/luarocks/manif/writer.tl b/src/luarocks/manif/writer.tl
new file mode 100644
index 00000000..625fba79
--- /dev/null
+++ b/src/luarocks/manif/writer.tl
@@ -0,0 +1,499 @@
+
+local record writer
+end
+
+local cfg = require("luarocks.core.cfg")
+local search = require("luarocks.search")
+local repos = require("luarocks.repos")
+local deps = require("luarocks.deps")
+local vers = require("luarocks.core.vers")
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local dir = require("luarocks.dir")
+local fetch = require("luarocks.fetch")
+local path = require("luarocks.path")
+local persist = require("luarocks.persist")
+local manif = require("luarocks.manif")
+local queries = require("luarocks.queries")
+
+--- Update storage table to account for items provided by a package.
+-- @param storage table: a table storing items in the following format:
+-- keys are item names and values are arrays of packages providing each item,
+-- where a package is specified as string `name/version`.
+-- @param items table: a table mapping item names to paths.
+-- @param name string: package name.
+-- @param version string: package version.
+local function store_package_items(storage, name, version, items)
+   assert(type(storage) == "table")
+   assert(type(items) == "table")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local package_identifier = name.."/"..version
+
+   for item_name, path in pairs(items) do  -- luacheck: ignore 431
+      if not storage[item_name] then
+         storage[item_name] = {}
+      end
+
+      table.insert(storage[item_name], package_identifier)
+   end
+end
+
+--- Update storage table removing items provided by a package.
+-- @param storage table: a table storing items in the following format:
+-- keys are item names and values are arrays of packages providing each item,
+-- where a package is specified as string `name/version`.
+-- @param items table: a table mapping item names to paths.
+-- @param name string: package name.
+-- @param version string: package version.
+local function remove_package_items(storage, name, version, items)
+   assert(type(storage) == "table")
+   assert(type(items) == "table")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local package_identifier = name.."/"..version
+
+   for item_name, path in pairs(items) do  -- luacheck: ignore 431
+      local key = item_name
+      local all_identifiers = storage[key]
+      if not all_identifiers then
+         key = key .. ".init"
+         all_identifiers = storage[key]
+      end
+
+      if all_identifiers then
+         for i, identifier in ipairs(all_identifiers) do
+            if identifier == package_identifier then
+               table.remove(all_identifiers, i)
+               break
+            end
+         end
+
+         if #all_identifiers == 0 then
+            storage[key] = nil
+         end
+      else
+         util.warning("Cannot find entry for " .. item_name .. " in manifest -- corrupted manifest?")
+      end
+   end
+end
+
+--- Process the dependencies of a manifest table to determine its dependency
+-- chains for loading modules. The manifest dependencies information is filled
+-- and any dependency inconsistencies or missing dependencies are reported to
+-- standard error.
+-- @param manifest table: a manifest table.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for no trees.
+local function update_dependencies(manifest, deps_mode)
+   assert(type(manifest) == "table")
+   assert(type(deps_mode) == "string")
+
+   if not manifest.dependencies then manifest.dependencies = {} end
+   local mdeps = manifest.dependencies
+
+   for pkg, versions in pairs(manifest.repository) do
+      for version, repositories in pairs(versions) do
+         for _, repo in ipairs(repositories) do
+            if repo.arch == "installed" then
+               local rd = {}
+               repo.dependencies = rd
+               deps.scan_deps(rd, mdeps, pkg, version, deps_mode)
+               rd[pkg] = nil
+            end
+         end
+      end
+   end
+end
+
+
+
+--- Sort function for ordering rock identifiers in a manifest's
+-- modules table. Rocks are ordered alphabetically by name, and then
+-- by version which greater first.
+-- @param a string: Version to compare.
+-- @param b string: Version to compare.
+-- @return boolean: The comparison result, according to the
+-- rule outlined above.
+local function sort_pkgs(a, b)
+   assert(type(a) == "string")
+   assert(type(b) == "string")
+
+   local na, va = a:match("(.*)/(.*)$")
+   local nb, vb = b:match("(.*)/(.*)$")
+
+   return (na == nb) and vers.compare_versions(va, vb) or na < nb
+end
+
+--- Sort items of a package matching table by version number (higher versions first).
+-- @param tbl table: the package matching table: keys should be strings
+-- and values arrays of strings with packages names in "name/version" format.
+local function sort_package_matching_table(tbl)
+   assert(type(tbl) == "table")
+
+   if next(tbl) then
+      for item, pkgs in pairs(tbl) do
+         if #pkgs > 1 then
+            table.sort(pkgs, sort_pkgs)
+            -- Remove duplicates from the sorted array.
+            local prev = nil
+            local i = 1
+            while pkgs[i] do
+               local curr = pkgs[i]
+               if curr == prev then
+                  table.remove(pkgs, i)
+               else
+                  prev = curr
+                  i = i + 1
+               end
+            end
+         end
+      end
+   end
+end
+
+--- Filter manifest table by Lua version, removing rockspecs whose Lua version
+-- does not match.
+-- @param manifest table: a manifest table.
+-- @param lua_version string or nil: filter by Lua version
+-- @param repodir string: directory of repository being scanned
+-- @param cache table: temporary rockspec cache table
+local function filter_by_lua_version(manifest, lua_version, repodir, cache)
+   assert(type(manifest) == "table")
+   assert(type(repodir) == "string")
+   assert((not cache) or type(cache) == "table")
+
+   cache = cache or {}
+   lua_version = vers.parse_version(lua_version)
+   for pkg, versions in pairs(manifest.repository) do
+      local to_remove = {}
+      for version, repositories in pairs(versions) do
+         for _, repo in ipairs(repositories) do
+            if repo.arch == "rockspec" then
+               local pathname = dir.path(repodir, pkg.."-"..version..".rockspec")
+               local rockspec, err = cache[pathname]
+               if not rockspec then
+                  rockspec, err = fetch.load_local_rockspec(pathname, true)
+               end
+               if rockspec then
+                  cache[pathname] = rockspec
+                  for _, dep in ipairs(rockspec.dependencies) do
+                     if dep.name == "lua" then
+                        if not vers.match_constraints(lua_version, dep.constraints) then
+                           table.insert(to_remove, version)
+                        end
+                        break
+                     end
+                  end
+               else
+                  util.printerr("Error loading rockspec for "..pkg.." "..version..": "..err)
+               end
+            end
+         end
+      end
+      if next(to_remove) then
+         for _, incompat in ipairs(to_remove) do
+            versions[incompat] = nil
+         end
+         if not next(versions) then
+            manifest.repository[pkg] = nil
+         end
+      end
+   end
+end
+
+--- Store search results in a manifest table.
+-- @param results table: The search results as returned by search.disk_search.
+-- @param manifest table: A manifest table (must contain repository, modules, commands tables).
+-- It will be altered to include the search results.
+-- @return boolean or (nil, string): true in case of success, or nil followed by an error message.
+local function store_results(results, manifest)
+   assert(type(results) == "table")
+   assert(type(manifest) == "table")
+
+   for name, versions in pairs(results) do
+      local pkgtable = manifest.repository[name] or {}
+      for version, entries in pairs(versions) do
+         local versiontable = {}
+         for _, entry in ipairs(entries) do
+            local entrytable = {}
+            entrytable.arch = entry.arch
+            if entry.arch == "installed" then
+               local rock_manifest, err = manif.load_rock_manifest(name, version)
+               if not rock_manifest then return nil, err end
+
+               entrytable.modules = repos.package_modules(name, version)
+               store_package_items(manifest.modules, name, version, entrytable.modules)
+               entrytable.commands = repos.package_commands(name, version)
+               store_package_items(manifest.commands, name, version, entrytable.commands)
+            end
+            table.insert(versiontable, entrytable)
+         end
+         pkgtable[version] = versiontable
+      end
+      manifest.repository[name] = pkgtable
+   end
+   sort_package_matching_table(manifest.modules)
+   sort_package_matching_table(manifest.commands)
+   return true
+end
+
+--- Commit a table to disk in given local path.
+-- @param where string: The directory where the table should be saved.
+-- @param name string: The filename.
+-- @param tbl table: The table to be saved.
+-- @return boolean or (nil, string): true if successful, or nil and a
+-- message in case of errors.
+local function save_table(where, name, tbl)
+   assert(type(where) == "string")
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(tbl) == "table")
+
+   local filename = dir.path(where, name)
+   local ok, err = persist.save_from_table(filename..".tmp", tbl)
+   if ok then
+      ok, err = fs.replace_file(filename, filename..".tmp")
+   end
+   return ok, err
+end
+
+function writer.make_rock_manifest(name, version)
+   local install_dir = path.install_dir(name, version)
+   local tree = {}
+   for _, file in ipairs(fs.find(install_dir)) do
+      local full_path = dir.path(install_dir, file)
+      local walk = tree
+      local last
+      local last_name
+      for filename in file:gmatch("[^\\/]+") do
+         local next = walk[filename]
+         if not next then
+            next = {}
+            walk[filename] = next
+         end
+         last = walk
+         last_name = filename
+         walk = next
+      end
+      if fs.is_file(full_path) then
+         local sum, err = fs.get_md5(full_path)
+         if not sum then
+            return nil, "Failed producing checksum: "..tostring(err)
+         end
+         last[last_name] = sum
+      end
+   end
+   local rock_manifest = { rock_manifest=tree }
+   manif.rock_manifest_cache[name.."/"..version] = rock_manifest
+   save_table(install_dir, "rock_manifest", rock_manifest )
+   return true
+end
+
+-- Writes a 'rock_namespace' file in a locally installed rock directory.
+-- @param name string: the rock name, without a namespace
+-- @param version string: the rock version
+-- @param namespace string?: the namespace
+-- @return true if successful (or unnecessary, if there is no namespace),
+-- or nil and an error message.
+function writer.make_namespace_file(name, version, namespace)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   assert(type(namespace) == "string" or not namespace)
+   if not namespace then
+      return true
+   end
+   local fd, err = io.open(path.rock_namespace_file(name, version), "w")
+   if not fd then
+      return nil, err
+   end
+   local ok, err = fd:write(namespace)
+   if not ok then
+      return nil, err
+   end
+   fd:close()
+   return true
+end
+
+--- Scan a LuaRocks repository and output a manifest file.
+-- A file called 'manifest' will be written in the root of the given
+-- repository directory.
+-- @param repo A local repository directory.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for the default dependency mode from the configuration.
+-- @param remote boolean: 'true' if making a manifest for a rocks server.
+-- @return boolean or (nil, string): True if manifest was generated,
+-- or nil and an error message.
+function writer.make_manifest(repo, deps_mode, remote)
+   assert(type(repo) == "string")
+   assert(type(deps_mode) == "string")
+
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   if not fs.is_dir(repo) then
+      return nil, "Cannot access repository at "..repo
+   end
+
+   local query = queries.all("any")
+   local results = search.disk_search(repo, query)
+   local manifest = { repository = {}, modules = {}, commands = {} }
+
+   manif.cache_manifest(repo, nil, manifest)
+
+   local ok, err = store_results(results, manifest)
+   if not ok then return nil, err end
+
+   if remote then
+      local cache = {}
+      for luaver in util.lua_versions() do
+         local vmanifest = { repository = {}, modules = {}, commands = {} }
+         local ok, err = store_results(results, vmanifest)
+         filter_by_lua_version(vmanifest, luaver, repo, cache)
+         if not cfg.no_manifest then
+            save_table(repo, "manifest-"..luaver, vmanifest)
+         end
+      end
+   else
+      update_dependencies(manifest, deps_mode)
+   end
+
+   if cfg.no_manifest then
+      -- We want to have cache updated; but exit before save_table is called
+      return true
+   end
+   return save_table(repo, "manifest", manifest)
+end
+
+--- Update manifest file for a local repository
+-- adding information about a version of a package installed in that repository.
+-- @param name string: Name of a package from the repository.
+-- @param version string: Version of a package from the repository.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository is used.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for using the default dependency mode from the configuration.
+-- @return boolean or (nil, string): True if manifest was updated successfully,
+-- or nil and an error message.
+function writer.add_to_manifest(name, version, repo, deps_mode)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
+   assert(type(deps_mode) == "string")
+
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   local manifest, err = manif.load_manifest(rocks_dir)
+   if not manifest then
+      util.printerr("No existing manifest. Attempting to rebuild...")
+      -- Manifest built by `writer.make_manifest` should already
+      -- include information about given name and version,
+      -- no need to update it.
+      return writer.make_manifest(rocks_dir, deps_mode)
+   end
+
+   local results = {[name] = {[version] = {{arch = "installed", repo = rocks_dir}}}}
+
+   local ok, err = store_results(results, manifest)
+   if not ok then return nil, err end
+
+   update_dependencies(manifest, deps_mode)
+
+   if cfg.no_manifest then
+      return true
+   end
+   return save_table(rocks_dir, "manifest", manifest)
+end
+
+--- Update manifest file for a local repository
+-- removing information about a version of a package.
+-- @param name string: Name of a package removed from the repository.
+-- @param version string: Version of a package removed from the repository.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository is used.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for using the default dependency mode from the configuration.
+-- @return boolean or (nil, string): True if manifest was updated successfully,
+-- or nil and an error message.
+function writer.remove_from_manifest(name, version, repo, deps_mode)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
+   assert(type(deps_mode) == "string")
+
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   local manifest, err = manif.load_manifest(rocks_dir)
+   if not manifest then
+      util.printerr("No existing manifest. Attempting to rebuild...")
+      -- Manifest built by `writer.make_manifest` should already
+      -- include up-to-date information, no need to update it.
+      return writer.make_manifest(rocks_dir, deps_mode)
+   end
+
+   local package_entry = manifest.repository[name]
+   if package_entry == nil or package_entry[version] == nil then
+      -- entry is already missing from repository, no need to do anything
+      return true
+   end
+
+   local version_entry = package_entry[version][1]
+   if not version_entry then
+      -- manifest looks corrupted, rebuild
+      return writer.make_manifest(rocks_dir, deps_mode)
+   end
+
+   remove_package_items(manifest.modules, name, version, version_entry.modules)
+   remove_package_items(manifest.commands, name, version, version_entry.commands)
+
+   package_entry[version] = nil
+   manifest.dependencies[name][version] = nil
+
+   if not next(package_entry) then
+      -- No more versions of this package.
+      manifest.repository[name] = nil
+      manifest.dependencies[name] = nil
+   end
+
+   update_dependencies(manifest, deps_mode)
+
+   if cfg.no_manifest then
+      return true
+   end
+   return save_table(rocks_dir, "manifest", manifest)
+end
+
+--- Report missing dependencies for all rocks installed in a repository.
+-- @param repo string or nil: Pathname of a local repository. If not given,
+-- the default local repository is used.
+-- @param deps_mode string: Dependency mode: "one" for the current default tree,
+-- "all" for all trees, "order" for all trees with priority >= the current default,
+-- "none" for using the default dependency mode from the configuration.
+function writer.check_dependencies(repo, deps_mode)
+   local rocks_dir = path.rocks_dir(repo or cfg.root_dir)
+   assert(type(deps_mode) == "string")
+   if deps_mode == "none" then deps_mode = cfg.deps_mode end
+
+   local manifest = manif.load_manifest(rocks_dir)
+   if not manifest then
+      return
+   end
+
+   for name, versions in util.sortedpairs(manifest.repository) do
+      for version, version_entries in util.sortedpairs(versions, vers.compare_versions) do
+         for _, entry in ipairs(version_entries) do
+            if entry.arch == "installed" then
+               if manifest.dependencies[name] and manifest.dependencies[name][version] then
+                  deps.report_missing_dependencies(name, version, manifest.dependencies[name][version], deps_mode, util.get_rocks_provided())
+               end
+            end
+         end
+      end
+   end
+end
+
+return writer
diff --git a/src/luarocks/repos.tl b/src/luarocks/repos.tl
new file mode 100644
index 00000000..14f1658c
--- /dev/null
+++ b/src/luarocks/repos.tl
@@ -0,0 +1,695 @@
+
+--- Functions for managing the repository on disk.
+local record repos
+end
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local cfg = require("luarocks.core.cfg")
+local util = require("luarocks.util")
+local dir = require("luarocks.dir")
+local manif = require("luarocks.manif")
+local vers = require("luarocks.core.vers")
+
+local unpack = unpack or table.unpack  -- luacheck: ignore 211
+
+--- Get type and name of an item (a module or a command) provided by a file.
+-- @param deploy_type string: rock manifest subtree the file comes from ("bin", "lua", or "lib").
+-- @param file_path string: path to the file relatively to deploy_type subdirectory.
+-- @return (string, string): item type ("module" or "command") and name.
+local function get_provided_item(deploy_type: string, file_path: string): string, string
+   local item_type = deploy_type == "bin" and "command" or "module"
+   local item_name = item_type == "command" and file_path or path.path_to_module(file_path)
+   return item_type, item_name
+end
+
+-- Tree of files installed by a package are stored
+-- in its rock manifest. Some of these files have to
+-- be deployed to locations where Lua can load them as
+-- modules or where they can be used as commands.
+-- These files are characterised by pair
+-- (deploy_type, file_path), where deploy_type is the first
+-- component of the file path and file_path is the rest of the
+-- path. Only files with deploy_type in {"lua", "lib", "bin"}
+-- are deployed somewhere.
+-- Each deployed file provides an "item". An item is
+-- characterised by pair (item_type, item_name).
+-- item_type is "command" for files with deploy_type
+-- "bin" and "module" for deploy_type in {"lua", "lib"}.
+-- item_name is same as file_path for commands
+-- and is produced using path.path_to_module(file_path)
+-- for modules.
+
+--- Get all installed versions of a package.
+-- @param name string: a package name.
+-- @return table or nil: An array of strings listing installed
+-- versions of a package, or nil if none is available.
+local function get_installed_versions(name: string): {string}
+   assert(not name:match("/"))
+
+   local dirs = fs.list_dir(path.versions_dir(name))
+   return (dirs and #dirs > 0) and dirs or nil
+end
+
+--- Check if a package exists in a local repository.
+-- Version numbers are compared as exact string comparison.
+-- @param name string: name of package
+-- @param version string: package version in string format
+-- @return boolean: true if a package is installed,
+-- false otherwise.
+function repos.is_installed(name: string, version: string): boolean
+   assert(not name:match("/"))
+
+   return fs.is_dir(path.install_dir(name, version))
+end
+
+function repos.recurse_rock_manifest_entry(entry, action): boolean,  string
+   assert(type(action) == "function")
+
+   if entry == nil then
+      return true
+   end
+
+   local function do_recurse_rock_manifest_entry(tree, parent_path)
+
+      for file, sub in pairs(tree) do
+         local sub_path = (parent_path and (parent_path .. "/") or "") .. file
+         local ok, err  -- luacheck: ignore 231
+
+         if type(sub) == "table" then
+            ok, err = do_recurse_rock_manifest_entry(sub, sub_path)
+         else
+            ok, err = action(sub_path)
+         end
+
+         if err then return nil, err end
+      end
+      return true
+   end
+   return do_recurse_rock_manifest_entry(entry)
+end
+
+local function store_package_data(result, rock_manifest, deploy_type)
+   if rock_manifest[deploy_type] then
+      repos.recurse_rock_manifest_entry(rock_manifest[deploy_type], function(file_path)
+         local _, item_name = get_provided_item(deploy_type, file_path)
+         result[item_name] = file_path
+         return true
+      end)
+   end
+end
+
+--- Obtain a table of modules within an installed package.
+-- @param name string: The package name; for example "luasocket"
+-- @param version string: The exact version number including revision;
+-- for example "2.0.1-1".
+-- @return table: A table of modules where keys are module names
+-- and values are file paths of files providing modules
+-- relative to "lib" or "lua" rock manifest subtree.
+-- If no modules are found or if package name or version
+-- are invalid, an empty table is returned.
+function repos.package_modules(name, version)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local result = {}
+   local rock_manifest = manif.load_rock_manifest(name, version)
+   if not rock_manifest then return result end
+   store_package_data(result, rock_manifest, "lib")
+   store_package_data(result, rock_manifest, "lua")
+   return result
+end
+
+--- Obtain a table of command-line scripts within an installed package.
+-- @param name string: The package name; for example "luasocket"
+-- @param version string: The exact version number including revision;
+-- for example "2.0.1-1".
+-- @return table: A table of commands where keys and values are command names
+-- as strings - file paths of files providing commands
+-- relative to "bin" rock manifest subtree.
+-- If no commands are found or if package name or version
+-- are invalid, an empty table is returned.
+function repos.package_commands(name, version)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local result = {}
+   local rock_manifest = manif.load_rock_manifest(name, version)
+   if not rock_manifest then return result end
+   store_package_data(result, rock_manifest, "bin")
+   return result
+end
+
+
+--- Check if a rock contains binary executables.
+-- @param name string: name of an installed rock
+-- @param version string: version of an installed rock
+-- @return boolean: returns true if rock contains platform-specific
+-- binary executables, or false if it is a pure-Lua rock.
+function repos.has_binaries(name, version)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+
+   local rock_manifest = manif.load_rock_manifest(name, version)
+   if rock_manifest and rock_manifest.bin then
+      for bin_name, md5 in pairs(rock_manifest.bin) do
+         -- TODO verify that it is the same file. If it isn't, find the actual command.
+         if fs.is_actual_binary(dir.path(cfg.deploy_bin_dir, bin_name)) then
+            return true
+         end
+      end
+   end
+   return false
+end
+
+function repos.run_hook(rockspec, hook_name)
+   assert(rockspec:type() == "rockspec")
+   assert(type(hook_name) == "string")
+
+   local hooks = rockspec.hooks
+   if not hooks then
+      return true
+   end
+
+   if cfg.hooks_enabled == false then
+      return nil, "This rockspec contains hooks, which are blocked by the 'hooks_enabled' setting in your LuaRocks configuration."
+   end
+
+   if not hooks.substituted_variables then
+      util.variable_substitutions(hooks, rockspec.variables)
+      hooks.substituted_variables = true
+   end
+   local hook = hooks[hook_name]
+   if hook then
+      util.printout(hook)
+      if not fs.execute(hook) then
+         return nil, "Failed running "..hook_name.." hook."
+      end
+   end
+   return true
+end
+
+function repos.should_wrap_bin_scripts(rockspec)
+   assert(rockspec:type() == "rockspec")
+
+   if cfg.wrap_bin_scripts ~= nil then
+      return cfg.wrap_bin_scripts
+   end
+   if rockspec.deploy and rockspec.deploy.wrap_bin_scripts == false then
+      return false
+   end
+   return true
+end
+
+local function find_suffixed(file, suffix)
+   local filenames = {file}
+   if suffix and suffix ~= "" then
+      table.insert(filenames, 1, file .. suffix)
+   end
+
+   for _, filename in ipairs(filenames) do
+      if fs.exists(filename) then
+         return filename
+      end
+   end
+
+   return nil, table.concat(filenames, ", ") .. " not found"
+end
+
+local function check_suffix(filename, suffix)
+   local suffixed_filename, err = find_suffixed(filename, suffix)
+   if not suffixed_filename then
+      return ""
+   end
+   return suffixed_filename:sub(#filename + 1)
+end
+
+-- Files can be deployed using versioned and non-versioned names.
+-- Several items with same type and name can exist if they are
+-- provided by different packages or versions. In any case
+-- item from the newest version of lexicographically smallest package
+-- is deployed using non-versioned name and others use versioned names.
+
+local function get_deploy_paths(name, version, deploy_type, file_path, repo)
+   assert(type(name) == "string")
+   assert(type(version) == "string")
+   assert(type(deploy_type) == "string")
+   assert(type(file_path) == "string")
+
+   repo = repo or cfg.root_dir
+   local deploy_dir = path["deploy_" .. deploy_type .. "_dir"](repo)
+   local non_versioned = dir.path(deploy_dir, file_path)
+   local versioned = path.versioned_name(non_versioned, deploy_dir, name, version)
+   return { nv = non_versioned, v = versioned }
+end
+
+local function check_spot_if_available(name, version, deploy_type, file_path)
+   local item_type, item_name = get_provided_item(deploy_type, file_path)
+   local cur_name, cur_version = manif.get_current_provider(item_type, item_name)
+
+   -- older versions of LuaRocks (< 3) registered "foo.init" files as "foo"
+   -- (which caused problems, so that behavior was changed). But look for that
+   -- in the manifest anyway for backward compatibility.
+   if not cur_name and deploy_type == "lua" and item_name:match("%.init$") then
+      cur_name, cur_version = manif.get_current_provider(item_type, (item_name:gsub("%.init$", "")))
+   end
+
+   if (not cur_name)
+      or (name < cur_name)
+      or (name == cur_name and (version == cur_version
+                                or vers.compare_versions(version, cur_version))) then
+      return "nv", cur_name, cur_version, item_name
+   else
+      -- Existing version has priority, deploy new version using versioned name.
+      return "v", cur_name, cur_version, item_name
+   end
+end
+
+local function backup_existing(should_backup, target)
+   if not should_backup then
+      fs.delete(target)
+      return
+   end
+   if fs.exists(target) then
+      local backup = target
+      repeat
+         backup = backup.."~"
+      until not fs.exists(backup) -- Slight race condition here, but shouldn't be a problem.
+
+      util.warning(target.." is not tracked by this installation of LuaRocks. Moving it to "..backup)
+      local move_ok, move_err = os.rename(target, backup)
+      if not move_ok then
+         return nil, move_err
+      end
+      return backup
+   end
+end
+
+local function prepare_op_install()
+   local mkdirs = {}
+   local rmdirs = {}
+
+   local function memoize_mkdir(d)
+      if mkdirs[d] then
+         return true
+      end
+      local ok, err = fs.make_dir(d)
+      if not ok then
+         return nil, err
+      end
+      mkdirs[d] = true
+      return true
+   end
+
+   local function op_install(op)
+      local ok, err = memoize_mkdir(dir.dir_name(op.dst))
+      if not ok then
+         return nil, err
+      end
+
+      local backup, err = backup_existing(op.backup, op.dst)
+      if err then
+         return nil, err
+      end
+      if backup then
+         op.backup_file = backup
+      end
+
+      ok, err = op.fn(op.src, op.dst, op.backup)
+      if not ok then
+         return nil, err
+      end
+
+      rmdirs[dir.dir_name(op.src)] = true
+      return true
+   end
+
+   local function done_op_install()
+      for d, _ in pairs(rmdirs) do
+         fs.remove_dir_tree_if_empty(d)
+      end
+   end
+
+   return op_install, done_op_install
+end
+
+local function rollback_install(op)
+   fs.delete(op.dst)
+   if op.backup_file then
+      os.rename(op.backup_file, op.dst)
+   end
+   fs.remove_dir_tree_if_empty(dir.dir_name(op.dst))
+   return true
+end
+
+local function op_rename(op)
+   if op.suffix then
+      local suffix = check_suffix(op.src, op.suffix)
+      op.src = op.src .. suffix
+      op.dst = op.dst .. suffix
+   end
+
+   if fs.exists(op.src) then
+      fs.make_dir(dir.dir_name(op.dst))
+      fs.delete(op.dst)
+      local ok, err = os.rename(op.src, op.dst)
+      fs.remove_dir_tree_if_empty(dir.dir_name(op.src))
+      return ok, err
+   else
+      return true
+   end
+end
+
+local function rollback_rename(op)
+   return op_rename({ src = op.dst, dst = op.src })
+end
+
+local function prepare_op_delete()
+   local deletes = {}
+   local rmdirs = {}
+
+   local function done_op_delete()
+      for _, f in ipairs(deletes) do
+         os.remove(f)
+      end
+
+      for d, _ in pairs(rmdirs) do
+         fs.remove_dir_tree_if_empty(d)
+      end
+   end
+
+   local function op_delete(op)
+      if op.suffix then
+         local suffix = check_suffix(op.name, op.suffix)
+         op.name = op.name .. suffix
+      end
+
+      table.insert(deletes, op.name)
+
+      rmdirs[dir.dir_name(op.name)] = true
+   end
+
+   return op_delete, done_op_delete
+end
+
+local function rollback_ops(ops, op_fn, n)
+   for i = 1, n do
+      op_fn(ops[i])
+   end
+end
+
+--- Double check that all files referenced in `rock_manifest` are installed in `repo`.
+function repos.check_everything_is_installed(name, version, rock_manifest, repo, accept_versioned)
+   local missing = {}
+   local suffix = cfg.wrapper_suffix or ""
+   for _, category in ipairs({"bin", "lua", "lib"}) do
+      if rock_manifest[category] then
+         repos.recurse_rock_manifest_entry(rock_manifest[category], function(file_path)
+            local paths = get_deploy_paths(name, version, category, file_path, repo)
+            if category == "bin" then
+               if (fs.exists(paths.nv) or fs.exists(paths.nv .. suffix))
+               or (accept_versioned and (fs.exists(paths.v) or fs.exists(paths.v .. suffix))) then
+                  return
+               end
+            else
+               if fs.exists(paths.nv) or (accept_versioned and fs.exists(paths.v)) then
+                  return
+               end
+            end
+            table.insert(missing, paths.nv)
+         end)
+      end
+   end
+   if #missing > 0 then
+      return nil, "failed deploying files. " ..
+                  "The following files were not installed:\n" ..
+                  table.concat(missing, "\n")
+   end
+   return true
+end
+
+--- Deploy a package from the rocks subdirectory.
+-- @param name string: name of package
+-- @param version string: exact package version in string format
+-- @param wrap_bin_scripts bool: whether commands written in Lua should be wrapped.
+-- @param deps_mode: string: Which trees to check dependencies for:
+-- "one" for the current default tree, "all" for all trees,
+-- "order" for all trees with priority >= the current default, "none" for no trees.
+function repos.deploy_files(name, version, wrap_bin_scripts, deps_mode)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   assert(type(wrap_bin_scripts) == "boolean")
+
+   local rock_manifest, load_err = manif.load_rock_manifest(name, version)
+   if not rock_manifest then return nil, load_err end
+
+   local repo = cfg.root_dir
+   local renames = {}
+   local installs = {}
+
+   local function install_binary(source, target)
+      if wrap_bin_scripts and fs.is_lua(source) then
+         return fs.wrap_script(source, target, deps_mode, name, version)
+      else
+         return fs.copy_binary(source, target)
+      end
+   end
+
+   local function move_lua(source, target)
+      return fs.move(source, target, "read")
+   end
+
+   local function move_lib(source, target)
+      return fs.move(source, target, "exec")
+   end
+
+   if rock_manifest.bin then
+      local source_dir = path.bin_dir(name, version)
+      repos.recurse_rock_manifest_entry(rock_manifest.bin, function(file_path)
+         local source = dir.path(source_dir, file_path)
+         local paths = get_deploy_paths(name, version, "bin", file_path, repo)
+         local mode, cur_name, cur_version = check_spot_if_available(name, version, "bin", file_path)
+
+         if mode == "nv" and cur_name then
+            local cur_paths = get_deploy_paths(cur_name, cur_version, "bin", file_path, repo)
+            table.insert(renames, { src = cur_paths.nv, dst = cur_paths.v, suffix = cfg.wrapper_suffix })
+         end
+         local target = mode == "nv" and paths.nv or paths.v
+         local backup = name ~= cur_name or version ~= cur_version
+         if wrap_bin_scripts and fs.is_lua(source) then
+            target = target .. (cfg.wrapper_suffix or "")
+         end
+         table.insert(installs, { fn = install_binary, src = source, dst = target, backup = backup })
+      end)
+   end
+
+   if rock_manifest.lua then
+      local source_dir = path.lua_dir(name, version)
+      repos.recurse_rock_manifest_entry(rock_manifest.lua, function(file_path)
+         local source = dir.path(source_dir, file_path)
+         local paths = get_deploy_paths(name, version, "lua", file_path, repo)
+         local mode, cur_name, cur_version = check_spot_if_available(name, version, "lua", file_path)
+
+         if mode == "nv" and cur_name then
+            local cur_paths = get_deploy_paths(cur_name, cur_version, "lua", file_path, repo)
+            table.insert(renames, { src = cur_paths.nv, dst = cur_paths.v })
+            cur_paths = get_deploy_paths(cur_name, cur_version, "lib", file_path:gsub("%.lua$", "." .. cfg.lib_extension), repo)
+            table.insert(renames, { src = cur_paths.nv, dst = cur_paths.v })
+         end
+         local target = mode == "nv" and paths.nv or paths.v
+         local backup = name ~= cur_name or version ~= cur_version
+         table.insert(installs, { fn = move_lua, src = source, dst = target, backup = backup })
+      end)
+   end
+
+   if rock_manifest.lib then
+      local source_dir = path.lib_dir(name, version)
+      repos.recurse_rock_manifest_entry(rock_manifest.lib, function(file_path)
+         local source = dir.path(source_dir, file_path)
+         local paths = get_deploy_paths(name, version, "lib", file_path, repo)
+         local mode, cur_name, cur_version = check_spot_if_available(name, version, "lib", file_path)
+
+         if mode == "nv" and cur_name then
+            local cur_paths = get_deploy_paths(cur_name, cur_version, "lua", file_path:gsub("%.[^.]+$", ".lua"), repo)
+            table.insert(renames, { src = cur_paths.nv, dst = cur_paths.v })
+            cur_paths = get_deploy_paths(cur_name, cur_version, "lib", file_path, repo)
+            table.insert(renames, { src = cur_paths.nv, dst = cur_paths.v })
+         end
+         local target = mode == "nv" and paths.nv or paths.v
+         local backup = name ~= cur_name or version ~= cur_version
+         table.insert(installs, { fn = move_lib, src = source, dst = target, backup = backup })
+      end)
+   end
+
+   for i, op in ipairs(renames) do
+      local ok, err = op_rename(op)
+      if not ok then
+         rollback_ops(renames, rollback_rename, i - 1)
+         return nil, err
+      end
+   end
+   local op_install, done_op_install = prepare_op_install()
+   for i, op in ipairs(installs) do
+      local ok, err = op_install(op)
+      if not ok then
+         rollback_ops(installs, rollback_install, i - 1)
+         rollback_ops(renames, rollback_rename, #renames)
+         return nil, err
+      end
+   end
+   done_op_install()
+
+   local ok, err = repos.check_everything_is_installed(name, version, rock_manifest, repo, true)
+   if not ok then
+      return nil, err
+   end
+
+   local writer = require("luarocks.manif.writer")
+   return writer.add_to_manifest(name, version, nil, deps_mode)
+end
+
+local function add_to_double_checks(double_checks, name, version)
+   double_checks[name] = double_checks[name] or {}
+   double_checks[name][version] = true
+end
+
+local function double_check_all(double_checks, repo)
+   local errs = {}
+   for next_name, versions in pairs(double_checks) do
+      for next_version in pairs(versions) do
+         local rock_manifest, load_err = manif.load_rock_manifest(next_name, next_version)
+         local ok, err = repos.check_everything_is_installed(next_name, next_version, rock_manifest, repo, true)
+         if not ok then
+            table.insert(errs, err)
+         end
+      end
+   end
+   if next(errs) then
+      return nil, table.concat(errs, "\n")
+   end
+   return true
+end
+
+--- Delete a package from the local repository.
+-- @param name string: name of package
+-- @param version string: exact package version in string format
+-- @param deps_mode: string: Which trees to check dependencies for:
+-- "one" for the current default tree, "all" for all trees,
+-- "order" for all trees with priority >= the current default, "none" for no trees.
+-- @param quick boolean: do not try to fix the versioned name
+-- of another version that provides the same module that
+-- was deleted. This is used during 'purge', as every module
+-- will be eventually deleted.
+function repos.delete_version(name, version, deps_mode, quick)
+   assert(type(name) == "string" and not name:match("/"))
+   assert(type(version) == "string")
+   assert(type(deps_mode) == "string")
+
+   local rock_manifest, load_err = manif.load_rock_manifest(name, version)
+   if not rock_manifest then
+      if not quick then
+         local writer = require("luarocks.manif.writer")
+         writer.remove_from_manifest(name, version, nil, deps_mode)
+         return nil, "rock_manifest file not found for "..name.." "..version.." - removed entry from the manifest"
+      end
+      return nil, load_err
+   end
+
+   local repo = cfg.root_dir
+   local renames = {}
+   local deletes = {}
+
+   local double_checks = {}
+
+   if rock_manifest.bin then
+      repos.recurse_rock_manifest_entry(rock_manifest.bin, function(file_path)
+         local paths = get_deploy_paths(name, version, "bin", file_path, repo)
+         local mode, cur_name, cur_version, item_name = check_spot_if_available(name, version, "bin", file_path)
+         if mode == "v" then
+            table.insert(deletes, { name = paths.v, suffix = cfg.wrapper_suffix })
+         else
+            table.insert(deletes, { name = paths.nv, suffix = cfg.wrapper_suffix })
+
+            local next_name, next_version = manif.get_next_provider("command", item_name)
+            if next_name then
+               add_to_double_checks(double_checks, next_name, next_version)
+               local next_paths = get_deploy_paths(next_name, next_version, "bin", file_path, repo)
+               table.insert(renames, { src = next_paths.v, dst = next_paths.nv, suffix = cfg.wrapper_suffix })
+            end
+         end
+      end)
+   end
+
+   if rock_manifest.lua then
+      repos.recurse_rock_manifest_entry(rock_manifest.lua, function(file_path)
+         local paths = get_deploy_paths(name, version, "lua", file_path, repo)
+         local mode, cur_name, cur_version, item_name = check_spot_if_available(name, version, "lua", file_path)
+         if mode == "v" then
+            table.insert(deletes, { name = paths.v })
+         else
+            table.insert(deletes, { name = paths.nv })
+
+            local next_name, next_version = manif.get_next_provider("module", item_name)
+            if next_name then
+               add_to_double_checks(double_checks, next_name, next_version)
+               local next_lua_paths = get_deploy_paths(next_name, next_version, "lua", file_path, repo)
+               table.insert(renames, { src = next_lua_paths.v, dst = next_lua_paths.nv })
+               local next_lib_paths = get_deploy_paths(next_name, next_version, "lib", file_path:gsub("%.[^.]+$", ".lua"), repo)
+               table.insert(renames, { src = next_lib_paths.v, dst = next_lib_paths.nv })
+            end
+         end
+      end)
+   end
+
+   if rock_manifest.lib then
+      repos.recurse_rock_manifest_entry(rock_manifest.lib, function(file_path)
+         local paths = get_deploy_paths(name, version, "lib", file_path, repo)
+         local mode, cur_name, cur_version, item_name = check_spot_if_available(name, version, "lib", file_path)
+         if mode == "v" then
+            table.insert(deletes, { name = paths.v })
+         else
+            table.insert(deletes, { name = paths.nv })
+
+            local next_name, next_version = manif.get_next_provider("module", item_name)
+            if next_name then
+               add_to_double_checks(double_checks, next_name, next_version)
+               local next_lua_paths = get_deploy_paths(next_name, next_version, "lua", file_path:gsub("%.[^.]+$", ".lua"), repo)
+               table.insert(renames, { src = next_lua_paths.v, dst = next_lua_paths.nv })
+               local next_lib_paths = get_deploy_paths(next_name, next_version, "lib", file_path, repo)
+               table.insert(renames, { src = next_lib_paths.v, dst = next_lib_paths.nv })
+            end
+         end
+      end)
+   end
+
+   local op_delete, done_op_delete = prepare_op_delete()
+   for _, op in ipairs(deletes) do
+      op_delete(op)
+   end
+   done_op_delete()
+
+   if not quick then
+      for _, op in ipairs(renames) do
+         op_rename(op)
+      end
+
+      local ok, err = double_check_all(double_checks, repo)
+      if not ok then
+         return nil, err
+      end
+   end
+
+   fs.delete(path.install_dir(name, version))
+   if not get_installed_versions(name) then
+      fs.delete(dir.path(cfg.rocks_dir, name))
+   end
+
+   if quick then
+      return true
+   end
+
+   local writer = require("luarocks.manif.writer")
+   return writer.remove_from_manifest(name, version, nil, deps_mode)
+end
+
+return repos
diff --git a/src/luarocks/test.tl b/src/luarocks/test.tl
index 56bc8c74..b1a97495 100644
--- a/src/luarocks/test.tl
+++ b/src/luarocks/test.tl
@@ -17,7 +17,12 @@ local test_types = {
 local test_modules: {string | Test} = {}
 
 for _, test_type in ipairs(test_types) do
-   local mod: Test = require("luarocks.test." .. test_type)
+   local mod: Test
+   if test_type == "command" then
+      mod = require("luarocks.test.command")
+   elseif test_type == "busted" then
+      mod = require("luarocks.test.busted")
+   end
    table.insert(test_modules, mod)
    test_modules[test_type] = mod --!
    test_modules[mod] = test_type
@@ -65,7 +70,7 @@ function test.run_test_suite(rockspec_arg: string | Rockspec, test_type: string,
       "test_dependencies",
    }
    for _, dep_kind in ipairs(all_deps) do
-      if rockspec[dep_kind] and next(rockspec[dep_kind]) then
+      if rockspec[dep_kind] and next(rockspec[dep_kind]) then --! rockspec as {atring: any}
          local _, err, errcode = deps.fulfill_dependencies(rockspec, dep_kind, "all")
          if err then
             return nil, err, errcode
@@ -73,10 +78,17 @@ function test.run_test_suite(rockspec_arg: string | Rockspec, test_type: string,
       end
    end
 
-   local mod_name = "luarocks.test." .. test_type
-   local pok, test_mod = pcall(require, mod_name)
-   if not pok then
-      return nil, "failed loading test execution module " .. mod_name
+   local pok, test_mod: boolean --! Test type
+   if test_type == "command" then
+      pok, test_mod = pcall(require, "luarocks.test.command")
+      if not pok then
+         return nil, "failed loading test execution module luarocks.test.command"
+      end
+   elseif test_type == "busted" then
+      pok, test_mod = pcall(require, "luarocks.test.busted")
+      if not pok then
+         return nil, "failed loading test execution module luarocks.test.busted"
+      end
    end
 
    if prepare then
diff --git a/src/luarocks/test/busted.tl b/src/luarocks/test/busted.tl
index e2663ffa..0870d178 100644
--- a/src/luarocks/test/busted.tl
+++ b/src/luarocks/test/busted.tl
@@ -15,7 +15,7 @@ function busted.detect_type(): boolean
    return false
 end
 
-function busted.run_tests(test, args: {string}): boolean, string
+function busted.run_tests(test, args: {string}): boolean, string --! Test type
    if not test then
       test = {}
    end
diff --git a/src/luarocks/test/command.tl b/src/luarocks/test/command.tl
index bed6744e..d7781580 100644
--- a/src/luarocks/test/command.tl
+++ b/src/luarocks/test/command.tl
@@ -1,19 +1,18 @@
 
-local command = {}
+local record command
+end
 
 local fs = require("luarocks.fs")
 local cfg = require("luarocks.core.cfg")
 
-local unpack = table.unpack or unpack
-
-function command.detect_type()
+function command.detect_type(): boolean
    if fs.exists("test.lua") then
       return true
    end
    return false
 end
 
-function command.run_tests(test, args)
+function command.run_tests(test, args): boolean, string --! Test type
    if not test then
       test = {
          script = "test.lua"
@@ -24,7 +23,7 @@ function command.run_tests(test, args)
       test.script = "test.lua"
    end
 
-   local ok
+   local ok: boolean
 
    if test.script then
       if type(test.script) ~= "string" then
@@ -34,12 +33,12 @@ function command.run_tests(test, args)
          return nil, "Test script " .. test.script .. " does not exist"
       end
       local lua = fs.Q(cfg.variables["LUA"])  -- get lua interpreter configured
-      ok = fs.execute(lua, test.script, unpack(args))
+      ok = fs.execute(lua, test.script, table.unpack(args))
    elseif test.command then
       if type(test.command) ~= "string" then
          return nil, "Malformed rockspec: 'command' expects a string"
       end
-      ok = fs.execute(test.command, unpack(args))
+      ok = fs.execute(test.command, table.unpack(args))
    end
 
    if ok then