Keep only command driver functions in luarocks.cmd

5 files changed, 36 insertions, 1086 deletions

diff --git a/src/luarocks/cmd/build.lua b/src/luarocks/cmd/build.lua
index f3b054d2..d050e6a3 100644
--- a/src/luarocks/cmd/build.lua
+++ b/src/luarocks/cmd/build.lua
@@ -1,23 +1,22 @@
 
 --- Module implementing the LuaRocks "build" command.
 -- Builds a rock, compiling its C parts if any.
-local build = {}
+local cmd_build = {}
 
 local pack = require("luarocks.pack")
 local path = require("luarocks.path")
 local util = require("luarocks.util")
-local repos = require("luarocks.repos")
 local fetch = require("luarocks.fetch")
 local fs = require("luarocks.fs")
 local dir = require("luarocks.dir")
 local deps = require("luarocks.deps")
-local writer = require("luarocks.manif.writer")
 local remove = require("luarocks.remove")
 local cfg = require("luarocks.core.cfg")
+local build = require("luarocks.build")
 
-build.help_summary = "Build/compile a rock."
-build.help_arguments = "[--pack-binary-rock] [--keep] {<rockspec>|<rock>|<name> [<version>]}"
-build.help = [[
+cmd_build.help_summary = "build/compile a rock."
+cmd_build.help_arguments = "[--pack-binary-rock] [--keep] {<rockspec>|<rock>|<name> [<version>]}"
+cmd_build.help = [[
 Build and install a rock, compiling its C parts if any.
 Argument may be a rockspec file, a source rock file
 or the name of a rock to be fetched from a repository.
@@ -39,328 +38,6 @@ or the name of a rock to be fetched from a repository.
 
 ]]..util.deps_mode_help()
 
---- Install files to a given location.
--- Takes a table where the array part is a list of filenames to be copied.
--- In the hash part, other keys, if is_module_path is set, are identifiers
--- in Lua module format, to indicate which subdirectory the file should be
--- copied to. For example, install_files({["foo.bar"] = "src/bar.lua"}, "boo")
--- will copy src/bar.lua to boo/foo.
--- @param files table or nil: A table containing a list of files to copy in
--- the format described above. If nil is passed, this function is a no-op.
--- Directories should be delimited by forward slashes as in internet URLs.
--- @param location string: The base directory files should be copied to.
--- @param is_module_path boolean: True if string keys in files should be
--- interpreted as dotted module paths.
--- @param perms string: Permissions of the newly created files installed.
--- Directories are always created with the default permissions.
--- @return boolean or (nil, string): True if succeeded or 
--- nil and an error message.
-local function install_files(files, location, is_module_path, perms)
-   assert(type(files) == "table" or not files)
-   assert(type(location) == "string")
-   if files then
-      for k, file in pairs(files) do
-         local dest = location
-         local filename = dir.base_name(file)
-         if type(k) == "string" then
-            local modname = k
-            if is_module_path then
-               dest = dir.path(location, path.module_to_path(modname))
-               local ok, err = fs.make_dir(dest)
-               if not ok then return nil, err end
-               if filename:match("%.lua$") then
-                  local basename = modname:match("([^.]+)$")
-                  filename = basename..".lua"
-               end
-            else
-               dest = dir.path(location, dir.dir_name(modname))
-               local ok, err = fs.make_dir(dest)
-               if not ok then return nil, err end
-               filename = dir.base_name(modname)
-            end
-         else
-            local ok, err = fs.make_dir(dest)
-            if not ok then return nil, err end
-         end
-         local ok = fs.copy(dir.path(file), dir.path(dest, filename), perms)
-         if not ok then
-            return nil, "Failed copying "..file
-         end
-      end
-   end
-   return true
-end
-
---- Write to the current directory the contents of a table,
--- where each key is a file name and its value is the file content.
--- @param files table: The table of files to be written.
-local function extract_from_rockspec(files)
-   for name, content in pairs(files) do
-      local fd = io.open(dir.path(fs.current_dir(), name), "w+")
-      fd:write(content)
-      fd:close()
-   end
-end
-
---- Applies patches inlined in the build.patches section
--- and extracts files inlined in the build.extra_files section
--- of a rockspec. 
--- @param rockspec table: A rockspec table.
--- @return boolean or (nil, string): True if succeeded or 
--- nil and an error message.
-function build.apply_patches(rockspec)
-   assert(type(rockspec) == "table")
-
-   local build_spec = rockspec.build
-   if build_spec.extra_files then
-      extract_from_rockspec(build_spec.extra_files)
-   end
-   if build_spec.patches then
-      extract_from_rockspec(build_spec.patches)
-      for patch, patchdata in util.sortedpairs(build_spec.patches) do
-         util.printout("Applying patch "..patch.."...")
-         local ok, err = fs.apply_patch(tostring(patch), patchdata)
-         if not ok then
-            return nil, "Failed applying patch "..patch
-         end
-      end
-   end
-   return true
-end
-
-local function install_default_docs(name, version)
-   local patterns = { "readme", "license", "copying", ".*%.md" }
-   local dest = dir.path(path.install_dir(name, version), "doc")
-   local has_dir = false
-   for file in fs.dir() do
-      for _, pattern in ipairs(patterns) do
-         if file:lower():match("^"..pattern) then
-            if not has_dir then
-               fs.make_dir(dest)
-               has_dir = true
-            end
-            fs.copy(file, dest, cfg.perm_read)
-            break
-         end
-      end
-   end
-end
-
-local function check_macosx_deployment_target(rockspec)
-   local target = rockspec.build.macosx_deployment_target
-   local function minor(version) 
-      return tonumber(version and version:match("^[^.]+%.([^.]+)"))
-   end
-   local function patch_variable(var, target)
-      if rockspec.variables[var]:match("MACOSX_DEPLOYMENT_TARGET") then
-         rockspec.variables[var] = (rockspec.variables[var]):gsub("MACOSX_DEPLOYMENT_TARGET=[^ ]*", "MACOSX_DEPLOYMENT_TARGET="..target)
-      else
-         rockspec.variables[var] = "env MACOSX_DEPLOYMENT_TARGET="..target.." "..rockspec.variables[var]
-      end
-   end
-   if cfg.platforms.macosx and rockspec:format_is_at_least("3.0") and target then
-      local version = util.popen_read("sw_vers -productVersion")
-      local versionminor = minor(version)
-      local targetminor = minor(target)
-      if targetminor > versionminor then
-         return nil, ("This rock requires Mac OSX 10.%d, and you are running 10.%d."):format(targetminor, versionminor)
-      end
-      patch_variable("CC", target)
-      patch_variable("LD", target)
-   end
-   return true
-end
-
---- Build and install a rock given a rockspec.
--- @param rockspec_file string: local or remote filename of a rockspec.
--- @param need_to_fetch boolean: true if sources need to be fetched,
--- false if the rockspec was obtained from inside a source rock.
--- @param minimal_mode boolean: true if there's no need to fetch,
--- unpack or change dir (this is used by "luarocks make"). Implies
--- need_to_fetch = false.
--- @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.
--- @param build_only_deps boolean: true to build the listed dependencies only.
--- @return (string, string) or (nil, string, [string]): Name and version of
--- installed rock if succeeded or nil and an error message followed by an error code.
-function build.build_rockspec(rockspec_file, need_to_fetch, minimal_mode, deps_mode, build_only_deps)
-   assert(type(rockspec_file) == "string")
-   assert(type(need_to_fetch) == "boolean")
-
-   local rockspec, err, errcode = fetch.load_rockspec(rockspec_file)
-   if err then
-      return nil, err, errcode
-   elseif not rockspec.build then
-      return nil, "Rockspec error: build table not specified"
-   elseif not rockspec.build.type then
-      return nil, "Rockspec error: build type not specified"
-   end
-
-   local ok
-   if not build_only_deps then
-      ok, err, errcode = deps.check_external_deps(rockspec, "build")
-      if err then
-         return nil, err, errcode
-      end
-   end
-
-   if deps_mode == "none" then
-      util.printerr("Warning: skipping dependency checks.")
-   else
-      local ok, err, errcode = deps.fulfill_dependencies(rockspec, deps_mode)
-      if err then
-         return nil, err, errcode
-      end
-   end
-
-   local name, version = rockspec.name, rockspec.version
-   if build_only_deps then
-      util.printout("Stopping after installing dependencies for " ..name.." "..version)
-      util.printout()
-      return name, version
-   end   
-
-   if repos.is_installed(name, version) then
-      repos.delete_version(name, version, deps_mode)
-   end
-
-   if not minimal_mode then
-      local source_dir
-      if need_to_fetch then
-         ok, source_dir, errcode = fetch.fetch_sources(rockspec, true)
-         if not ok then
-            return nil, source_dir, errcode
-         end
-         local ok, err = fs.change_dir(source_dir)
-         if not ok then return nil, err end
-      elseif rockspec.source.file then
-         local ok, err = fs.unpack_archive(rockspec.source.file)
-         if not ok then
-            return nil, err
-         end
-      end
-      fs.change_dir(rockspec.source.dir)
-   end
-   
-   local dirs = {
-      lua = { name = path.lua_dir(name, version), is_module_path = true, perms = cfg.perm_read },
-      lib = { name = path.lib_dir(name, version), is_module_path = true, perms = cfg.perm_exec },
-      conf = { name = path.conf_dir(name, version), is_module_path = false, perms = cfg.perm_read },
-      bin = { name = path.bin_dir(name, version), is_module_path = false, perms = cfg.perm_exec },
-   }
-   
-   for _, d in pairs(dirs) do
-      local ok, err = fs.make_dir(d.name)
-      if not ok then return nil, err end
-   end
-   local rollback = util.schedule_function(function()
-      fs.delete(path.install_dir(name, version))
-      fs.remove_dir_if_empty(path.versions_dir(name))
-   end)
-
-   local build_spec = rockspec.build
-   
-   if not minimal_mode then
-      ok, err = build.apply_patches(rockspec)
-      if err then
-         return nil, err
-      end
-   end
-   
-   ok, err = check_macosx_deployment_target(rockspec)
-   if not ok then
-      return nil, err
-   end
-   
-   if build_spec.type ~= "none" then
-
-      -- Temporary compatibility
-      if build_spec.type == "module" then
-         util.printout("Do not use 'module' as a build type. Use 'builtin' instead.")
-         build_spec.type = "builtin"
-      end
-
-      if cfg.accepted_build_types and util.array_contains(cfg.accepted_build_types, build_spec.type) then
-         return nil, "This rockspec uses the '"..build_spec.type.."' build type, which is blocked by the 'accepted_build_types' setting in your LuaRocks configuration."
-      end
-
-      local build_type
-      ok, build_type = pcall(require, "luarocks.build." .. build_spec.type)
-      if not ok or not type(build_type) == "table" then
-         return nil, "Failed initializing build back-end for build type '"..build_spec.type.."': "..build_type
-      end
-  
-      ok, err = build_type.run(rockspec)
-      if not ok then
-         return nil, "Build error: " .. err
-      end
-   end
-
-   if build_spec.install then
-      for id, install_dir in pairs(dirs) do
-         ok, err = install_files(build_spec.install[id], install_dir.name, install_dir.is_module_path, install_dir.perms)
-         if not ok then 
-            return nil, err
-         end
-      end
-   end
-   
-   local copy_directories = build_spec.copy_directories
-   local copying_default = false
-   if not copy_directories then
-      copy_directories = {"doc"}
-      copying_default = true
-   end
-
-   local any_docs = false
-   for _, copy_dir in pairs(copy_directories) do
-      if fs.is_dir(copy_dir) then
-         local dest = dir.path(path.install_dir(name, version), copy_dir)
-         fs.make_dir(dest)
-         fs.copy_contents(copy_dir, dest)
-         any_docs = true
-      else
-         if not copying_default then
-            return nil, "Directory '"..copy_dir.."' not found"
-         end
-      end
-   end
-   
-   if not any_docs then
-      install_default_docs(name, version)
-   end
-   
-   for _, d in pairs(dirs) do
-      fs.remove_dir_if_empty(d.name)
-   end
-
-   fs.pop_dir()
-   
-   fs.copy(rockspec.local_filename, path.rockspec_file(name, version), cfg.perm_read)
-   if need_to_fetch then
-      fs.pop_dir()
-   end
-
-   ok, err = writer.make_rock_manifest(name, version)
-   if err then return nil, err end
-
-   ok, err = repos.deploy_files(name, version, repos.should_wrap_bin_scripts(rockspec), deps_mode)
-   if err then return nil, err end
-   
-   util.remove_scheduled_function(rollback)
-   rollback = util.schedule_function(function()
-      repos.delete_version(name, version, deps_mode)
-   end)
-
-   ok, err = repos.run_hook(rockspec, "post_install")
-   if err then return nil, err end
-
-   util.announce_install(rockspec)
-   util.remove_scheduled_function(rollback)
-   return name, version
-end
-
 --- Build and install a rock.
 -- @param rock_file string: local or remote filename of a rock.
 -- @param need_to_fetch boolean: true if sources need to be fetched,
@@ -371,7 +48,7 @@ end
 -- @param build_only_deps boolean: true to build the listed dependencies only.
 -- @return boolean or (nil, string, [string]): True if build was successful,
 -- or false and an error message and an optional error code.
-function build.build_rock(rock_file, need_to_fetch, deps_mode, build_only_deps)
+local function build_rock(rock_file, need_to_fetch, deps_mode, build_only_deps)
    assert(type(rock_file) == "string")
    assert(type(need_to_fetch) == "boolean")
 
@@ -393,13 +70,11 @@ local function do_build(name, version, deps_mode, build_only_deps)
    if name:match("%.rockspec$") then
       return build.build_rockspec(name, true, false, deps_mode, build_only_deps)
    elseif name:match("%.src%.rock$") then
-      return build.build_rock(name, false, deps_mode, build_only_deps)
+      return build_rock(name, false, deps_mode, build_only_deps)
    elseif name:match("%.all%.rock$") then
-      local install = require("luarocks.install")
-      local install_fun = build_only_deps and install.install_binary_rock_deps or install.install_binary_rock
-      return install_fun(name, deps_mode)
+      return build_rock(name, true, deps_mode, build_only_deps)
    elseif name:match("%.rock$") then
-      return build.build_rock(name, true, deps_mode, build_only_deps)
+      return build_rock(name, true, deps_mode, build_only_deps)
    elseif not name:match(dir.separator) then
       local search = require("luarocks.search")
       return search.act_on_src_or_rockspec(do_build, name:lower(), version, nil, deps_mode, build_only_deps)
@@ -415,7 +90,7 @@ end
 -- also be given.
 -- @return boolean or (nil, string, exitcode): True if build was successful; nil and an
 -- error message otherwise. exitcode is optionally returned.
-function build.command(flags, name, version)
+function cmd_build.command(flags, name, version)
    if type(name) ~= "string" then
       return nil, "Argument missing. "..util.see_help("build")
    end
@@ -440,4 +115,4 @@ function build.command(flags, name, version)
    end
 end
 
-return build
+return cmd_build
diff --git a/src/luarocks/cmd/download.lua b/src/luarocks/cmd/download.lua
index 557d1b65..9c119f6e 100644
--- a/src/luarocks/cmd/download.lua
+++ b/src/luarocks/cmd/download.lua
@@ -1,89 +1,27 @@
 
 --- Module implementing the luarocks "download" command.
 -- Download a rock from the repository.
-local download = {}
+local cmd_download = {}
 
 local util = require("luarocks.util")
-local path = require("luarocks.path")
-local fetch = require("luarocks.fetch")
-local search = require("luarocks.search")
-local fs = require("luarocks.fs")
-local dir = require("luarocks.dir")
-local cfg = require("luarocks.core.cfg")
+local download = require("luarocks.download")
 
-download.help_summary = "Download a specific rock file from a rocks server."
-download.help_arguments = "[--all] [--arch=<arch> | --source | --rockspec] [<name> [<version>]]"
-
-download.help = [[
+cmd_download.help_summary = "Download a specific rock file from a rocks server."
+cmd_download.help_arguments = "[--all] [--arch=<arch> | --source | --rockspec] [<name> [<version>]]"
+cmd_download.help = [[
 --all          Download all files if there are multiple matches.
 --source       Download .src.rock if available.
 --rockspec     Download .rockspec if available.
 --arch=<arch>  Download rock for a specific architecture.
 ]]
 
-local function get_file(filename)
-   local protocol, pathname = dir.split_url(filename)
-   if protocol == "file" then
-      local ok, err = fs.copy(pathname, fs.current_dir(), cfg.perm_read)
-      if ok then
-         return pathname
-      else
-         return nil, err
-      end
-   else
-      return fetch.fetch_url(filename)
-   end
-end
-
-function download.download(arch, name, version, all)
-   local query = search.make_query(name, version)
-   if arch then query.arch = arch end
-   local search_err
-
-   if all then
-      if name == "" then query.exact_name = false end
-      local results = search.search_repos(query)
-      local has_result = false
-      local all_ok = true
-      local any_err = ""
-      for name, result in pairs(results) do
-         for version, items in pairs(result) do
-            for _, item in ipairs(items) do
-               -- Ignore provided rocks.
-               if item.arch ~= "installed" then
-                  has_result = true
-                  local filename = path.make_url(item.repo, name, version, item.arch)
-                  local ok, err = get_file(filename)
-                  if not ok then
-                     all_ok = false
-                     any_err = any_err .. "\n" .. err
-                  end
-               end
-            end
-         end
-      end
-
-      if has_result then
-         return all_ok, any_err
-      end
-   else
-      local url
-      url, search_err = search.find_suitable_rock(query)
-      if url then
-         return get_file(url)
-      end
-   end
-   return nil, "Could not find a result named "..name..(version and " "..version or "")..
-      (search_err and ": "..search_err or ".")
-end
-
 --- Driver function for the "download" command.
 -- @param name string: a rock name.
 -- @param version string or nil: if the name of a package is given, a
 -- version may also be passed.
 -- @return boolean or (nil, string): true if successful or nil followed
 -- by an error message.
-function download.command(flags, name, version)
+function cmd_download.command(flags, name, version)
    assert(type(version) == "string" or not version)
    if type(name) ~= "string" and not flags["all"] then
       return nil, "Argument missing. "..util.see_help("download")
@@ -104,4 +42,4 @@ function download.command(flags, name, version)
    return dl and true, err
 end
 
-return download
+return cmd_download
diff --git a/src/luarocks/cmd/pack.lua b/src/luarocks/cmd/pack.lua
index 655cbf37..e43e5b3f 100644
--- a/src/luarocks/cmd/pack.lua
+++ b/src/luarocks/cmd/pack.lua
@@ -1,168 +1,20 @@
 
 --- Module implementing the LuaRocks "pack" command.
 -- Creates a rock, packing sources or binaries.
-local pack = {}
+local cmd_pack = {}
 
-local unpack = unpack or table.unpack
-
-local path = require("luarocks.path")
-local repos = require("luarocks.repos")
-local fetch = require("luarocks.fetch")
-local fs = require("luarocks.fs")
-local cfg = require("luarocks.core.cfg")
 local util = require("luarocks.util")
-local dir = require("luarocks.dir")
-local manif = require("luarocks.manif")
-local search = require("luarocks.search")
+local pack = require("luarocks.pack")
 
-pack.help_summary = "Create a rock, packing sources or binaries."
-pack.help_arguments = "{<rockspec>|<name> [<version>]}"
-pack.help = [[
+cmd_pack.help_summary = "Create a rock, packing sources or binaries."
+cmd_pack.help_arguments = "{<rockspec>|<name> [<version>]}"
+cmd_pack.help = [[
 Argument may be a rockspec file, for creating a source rock,
 or the name of an installed package, for creating a binary rock.
 In the latter case, the app version may be given as a second
 argument.
 ]]
 
---- Create a source rock.
--- Packages a rockspec and its required source files in a rock
--- file with the .src.rock extension, which can later be built and
--- installed with the "build" command.
--- @param rockspec_file string: An URL or pathname for a rockspec file.
--- @return string or (nil, string): The filename of the resulting
--- .src.rock file; or nil and an error message.
-function pack.pack_source_rock(rockspec_file)
-   assert(type(rockspec_file) == "string")
-
-   local rockspec, err = fetch.load_rockspec(rockspec_file)
-   if err then
-      return nil, "Error loading rockspec: "..err
-   end
-   rockspec_file = rockspec.local_filename
-
-   local name_version = rockspec.name .. "-" .. rockspec.version
-   local rock_file = fs.absolute_name(name_version .. ".src.rock")
-
-   local source_file, source_dir = fetch.fetch_sources(rockspec, false)
-   if not source_file then
-      return nil, source_dir
-   end
-   local ok, err = fs.change_dir(source_dir)
-   if not ok then return nil, err end
-
-   fs.delete(rock_file)
-   fs.copy(rockspec_file, source_dir, cfg.perm_read)
-   if not fs.zip(rock_file, dir.base_name(rockspec_file), dir.base_name(source_file)) then
-      return nil, "Failed packing "..rock_file
-   end
-   fs.pop_dir()
-
-   return rock_file
-end
-
-local function copy_back_files(name, version, file_tree, deploy_dir, pack_dir, perms)
-   local ok, err = fs.make_dir(pack_dir)
-   if not ok then return nil, err end
-   for file, sub in pairs(file_tree) do
-      local source = dir.path(deploy_dir, file)
-      local target = dir.path(pack_dir, file)
-      if type(sub) == "table" then
-         local ok, err = copy_back_files(name, version, sub, source, target)
-         if not ok then return nil, err end
-      else
-         local versioned = path.versioned_name(source, deploy_dir, name, version)
-         if fs.exists(versioned) then
-            fs.copy(versioned, target, perms)
-         else
-            fs.copy(source, target, perms)
-         end
-      end
-   end
-   return true
-end
-
--- @param name string: Name of package to pack.
--- @param version string or nil: A version number may also be passed.
--- @param tree string or nil: An optional tree to pick the package from.
--- @return string or (nil, string): The filename of the resulting
--- .src.rock file; or nil and an error message.
-local function do_pack_binary_rock(name, version, tree)
-   assert(type(name) == "string")
-   assert(type(version) == "string" or not version)
-
-   local repo, repo_url
-   name, version, repo, repo_url = search.pick_installed_rock(name, version, tree)
-   if not name then
-      return nil, version
-   end
-
-   local root = path.root_dir(repo_url)
-   local prefix = path.install_dir(name, version, root)
-   if not fs.exists(prefix) then
-      return nil, "'"..name.." "..version.."' does not seem to be an installed rock."
-   end
-   
-   local rock_manifest, err = manif.load_rock_manifest(name, version, root)
-   if not rock_manifest then return nil, err end
-
-   local name_version = name .. "-" .. version
-   local rock_file = fs.absolute_name(name_version .. "."..cfg.arch..".rock")
-   
-   local temp_dir = fs.make_temp_dir("pack")
-   fs.copy_contents(prefix, temp_dir)
-
-   local is_binary = false
-   if rock_manifest.lib then
-      local ok, err = copy_back_files(name, version, rock_manifest.lib, path.deploy_lib_dir(root), dir.path(temp_dir, "lib"), cfg.perm_exec)
-      if not ok then return nil, "Failed copying back files: " .. err end
-      is_binary = true
-   end
-   if rock_manifest.lua then
-      local ok, err = copy_back_files(name, version, rock_manifest.lua, path.deploy_lua_dir(root), dir.path(temp_dir, "lua"), cfg.perm_read)
-      if not ok then return nil, "Failed copying back files: " .. err end
-   end
-   
-   local ok, err = fs.change_dir(temp_dir)
-   if not ok then return nil, err end
-   if not is_binary and not repos.has_binaries(name, version) then
-      rock_file = rock_file:gsub("%."..cfg.arch:gsub("%-","%%-").."%.", ".all.")
-   end
-   fs.delete(rock_file)
-   if not fs.zip(rock_file, unpack(fs.list_dir())) then
-      return nil, "Failed packing "..rock_file
-   end
-   fs.pop_dir()
-   fs.delete(temp_dir)
-   return rock_file
-end
-
-function pack.pack_binary_rock(name, version, cmd, ...)
-
-   -- The --pack-binary-rock option for "luarocks build" basically performs
-   -- "luarocks build" on a temporary tree and then "luarocks pack". The
-   -- alternative would require refactoring parts of luarocks.build and
-   -- luarocks.pack, which would save a few file operations: the idea would be
-   -- to shave off the final deploy steps from the build phase and the initial
-   -- collect steps from the pack phase.
-
-   local temp_dir, err = fs.make_temp_dir("luarocks-build-pack-"..dir.base_name(name))
-   if not temp_dir then
-      return nil, "Failed creating temporary directory: "..err
-   end
-   util.schedule_function(fs.delete, temp_dir)
-
-   path.use_tree(temp_dir)
-   local ok, err = cmd(...)
-   if not ok then
-      return nil, err
-   end
-   local rname, rversion = path.parse_name(name)
-   if not rname then
-      rname, rversion = name, version
-   end
-   return do_pack_binary_rock(rname, rversion, temp_dir)
-end
-
 --- Driver function for the "pack" command.
 -- @param arg string:  may be a rockspec file, for creating a source rock,
 -- or the name of an installed package, for creating a binary rock.
@@ -170,7 +22,7 @@ end
 -- version may also be passed.
 -- @return boolean or (nil, string): true if successful or nil followed
 -- by an error message.
-function pack.command(flags, arg, version)
+function cmd_pack.command(flags, arg, version)
    assert(type(version) == "string" or not version)
    if type(arg) ~= "string" then
       return nil, "Argument missing. "..util.see_help("pack")
@@ -180,7 +32,7 @@ function pack.command(flags, arg, version)
    if arg:match(".*%.rockspec") then
       file, err = pack.pack_source_rock(arg)
    else
-      file, err = do_pack_binary_rock(arg:lower(), version, flags["tree"])
+      file, err = pack.pack_installed_rock(arg:lower(), version, flags["tree"])
    end
    if err then
       return nil, err
@@ -190,4 +42,4 @@ function pack.command(flags, arg, version)
    end
 end
 
-return pack
+return cmd_pack
diff --git a/src/luarocks/cmd/remove.lua b/src/luarocks/cmd/remove.lua
index e7f37604..08d49058 100644
--- a/src/luarocks/cmd/remove.lua
+++ b/src/luarocks/cmd/remove.lua
@@ -1,20 +1,18 @@
 
 --- Module implementing the LuaRocks "remove" command.
 -- Uninstalls rocks.
-local remove = {}
+local cmd_remove = {}
 
-local search = require("luarocks.search")
-local deps = require("luarocks.deps")
-local fetch = require("luarocks.fetch")
-local repos = require("luarocks.repos")
-local path = require("luarocks.path")
+local remove = require("luarocks.remove")
 local util = require("luarocks.util")
 local cfg = require("luarocks.core.cfg")
 local fs = require("luarocks.fs")
+local search = require("luarocks.search")
+local path = require("luarocks.path")
 
-remove.help_summary = "Uninstall a rock."
-remove.help_arguments = "[--force|--force-fast] <name> [<version>]"
-remove.help = [[
+cmd_remove.help_summary = "Uninstall a rock."
+cmd_remove.help_arguments = "[--force|--force-fast] <name> [<version>]"
+cmd_remove.help = [[
 Argument is the name of a rock to be uninstalled.
 If a version is not given, try to remove all versions at once.
 Will only perform the removal if it does not break dependencies.
@@ -24,110 +22,6 @@ use --force-fast.
 
 ]]..util.deps_mode_help()
 
---- Obtain a list of packages that depend on the given set of packages
--- (where all packages of the set are versions of one program).
--- @param name string: the name of a program
--- @param versions array of string: the versions to be deleted.
--- @return array of string: an empty table if no packages depend on any
--- of the given list, or an array of strings in "name/version" format.
-local function check_dependents(name, versions, deps_mode)
-   local dependents = {}
-   local blacklist = {}
-   blacklist[name] = {}
-   for version, _ in pairs(versions) do
-      blacklist[name][version] = true
-   end
-   local local_rocks = {}
-   local query_all = search.make_query("")
-   query_all.exact_name = false
-   search.manifest_search(local_rocks, cfg.rocks_dir, query_all)
-   local_rocks[name] = nil
-   for rock_name, rock_versions in pairs(local_rocks) do
-      for rock_version, _ in pairs(rock_versions) do
-         local rockspec, err = fetch.load_rockspec(path.rockspec_file(rock_name, rock_version))
-         if rockspec then
-            local _, missing = deps.match_deps(rockspec, blacklist, deps_mode)
-            if missing[name] then
-               table.insert(dependents, { name = rock_name, version = rock_version })
-            end
-         end
-      end
-   end
-   return dependents
-end
-
---- Delete given versions of a program.
--- @param name string: the name of a program
--- @param versions array of string: the versions to be deleted.
--- @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.
--- @return boolean or (nil, string): true on success or nil and an error message.
-local function delete_versions(name, versions, deps_mode) 
-
-   for version, _ in pairs(versions) do
-      util.printout("Removing "..name.." "..version.."...")
-      local ok, err = repos.delete_version(name, version, deps_mode)
-      if not ok then return nil, err end
-   end
-   
-   return true
-end
-
-function remove.remove_search_results(results, name, deps_mode, force, fast)
-   local versions = results[name]
-
-   local version = next(versions)
-   local second = next(versions, version)
-   
-   local dependents = {}
-   if not fast then
-      util.printout("Checking stability of dependencies in the absence of")
-      util.printout(name.." "..table.concat(util.keys(versions), ", ").."...")
-      util.printout()
-      dependents = check_dependents(name, versions, deps_mode)
-   end
-   
-   if #dependents > 0 then
-      if force or fast then
-         util.printerr("The following packages may be broken by this forced removal:")
-         for _, dependent in ipairs(dependents) do
-            util.printerr(dependent.name.." "..dependent.version)
-         end
-         util.printerr()
-      else
-         if not second then
-            util.printerr("Will not remove "..name.." "..version..".")
-            util.printerr("Removing it would break dependencies for: ")
-         else
-            util.printerr("Will not remove installed versions of "..name..".")
-            util.printerr("Removing them would break dependencies for: ")
-         end
-         for _, dependent in ipairs(dependents) do
-            util.printerr(dependent.name.." "..dependent.version)
-         end
-         util.printerr()
-         util.printerr("Use --force to force removal (warning: this may break modules).")
-         return nil, "Failed removing."
-      end
-   end
-   
-   local ok, err = delete_versions(name, versions, deps_mode)
-   if not ok then return nil, err end
-
-   util.printout("Removal successful.")
-   return true
-end
-
-function remove.remove_other_versions(name, version, force, fast)
-   local results = {}
-   search.manifest_search(results, cfg.rocks_dir, { name = name, exact_name = true, constraints = {{ op = "~=", version = version}} })
-   if results[name] then
-      return remove.remove_search_results(results, name, cfg.deps_mode, force, fast)
-   end
-   return true
-end
-
 --- Driver function for the "remove" command.
 -- @param name string: name of a rock. If a version is given, refer to
 -- a specific version; otherwise, try to remove all versions.
@@ -135,7 +29,7 @@ end
 -- may also be given.
 -- @return boolean or (nil, string, exitcode): True if removal was
 -- successful, nil and an error message otherwise. exitcode is optionally returned.
-function remove.command(flags, name, version)
+function cmd_remove.command(flags, name, version)
    if type(name) ~= "string" then
       return nil, "Argument missing. "..util.see_help("remove")
    end
@@ -162,4 +56,4 @@ function remove.command(flags, name, version)
    return remove.remove_search_results(results, name, deps_mode, flags["force"], flags["force-fast"])
 end
 
-return remove
+return cmd_remove
diff --git a/src/luarocks/cmd/search.lua b/src/luarocks/cmd/search.lua
index 44eff694..109fe805 100644
--- a/src/luarocks/cmd/search.lua
+++ b/src/luarocks/cmd/search.lua
@@ -3,11 +3,6 @@
 -- Queries LuaRocks servers.
 local search = {}
 
-
-local dir = require("luarocks.dir")
-local path = require("luarocks.path")
-local manif = require("luarocks.manif")
-local deps = require("luarocks.deps")
 local cfg = require("luarocks.core.cfg")
 local util = require("luarocks.util")
 
@@ -22,354 +17,6 @@ search.help = [[
           this platform, do not filter by name.
 ]]
 
---- Convert the arch field of a query table to table format.
--- @param query table: A query table.
-local function query_arch_as_table(query)
-   local format = type(query.arch)
-   if format == "table" then
-      return
-   elseif format == "nil" then
-      local accept = {}
-      accept["src"] = true
-      accept["all"] = true
-      accept["rockspec"] = true
-      accept["installed"] = true
-      accept[cfg.arch] = true
-      query.arch = accept
-   elseif format == "string" then
-      local accept = {}
-      for a in query.arch:gmatch("[%w_-]+") do
-         accept[a] = true
-      end
-      query.arch = accept
-   end
-end
-
---- Store a search result (a rock or rockspec) in the results table.
--- @param results table: The results table, where keys are package names and
--- values are tables matching version strings to arrays of
--- tables with fields "arch" and "repo".
--- @param name string: Package name.
--- @param version string: Package version.
--- @param arch string: Architecture of rock ("all", "src" or platform
--- identifier), "rockspec" or "installed"
--- @param repo string: Pathname of a local repository of URL of
--- rocks server.
-local function store_result(results, name, version, arch, repo)
-   assert(type(results) == "table")
-   assert(type(name) == "string")
-   assert(type(version) == "string")
-   assert(type(arch) == "string")
-   assert(type(repo) == "string")
-   
-   if not results[name] then results[name] = {} end
-   if not results[name][version] then results[name][version] = {} end
-   table.insert(results[name][version], {
-      arch = arch,
-      repo = repo
-   })
-end
-
---- Test the name field of a query.
--- If query has a boolean field exact_name set to false,
--- then substring match is performed; otherwise, exact string
--- comparison is done.
--- @param query table: A query in dependency table format.
--- @param name string: A package name.
--- @return boolean: True if names match, false otherwise.
-local function match_name(query, name)
-   assert(type(query) == "table")
-   assert(type(name) == "string")
-   if query.exact_name == false then
-      return name:find(query.name, 0, true) and true or false
-   else
-      return name == query.name
-   end
-end
-
---- Store a match in a results table if version matches query.
--- Name, version, arch and repository path are stored in a given
--- table, optionally checking if version and arch (if given) match
--- a query.
--- @param results table: The results table, where keys are package names and
--- values are tables matching version strings to arrays of
--- tables with fields "arch" and "repo".
--- @param repo string: URL or pathname of the repository.
--- @param name string: The name of the package being tested.
--- @param version string: The version of the package being tested.
--- @param arch string: The arch of the package being tested.
--- @param query table: A table describing the query in dependency
--- format (for example, {name = "filesystem", exact_name = false,
--- constraints = {op = "~>", version = {1,0}}}, arch = "rockspec").
--- If the arch field is omitted, the local architecture (cfg.arch)
--- is used. The special value "any" is also recognized, returning all
--- matches regardless of architecture.
-local function store_if_match(results, repo, name, version, arch, query)
-   if match_name(query, name) then
-      if query.arch[arch] or query.arch["any"] then
-         if deps.match_constraints(deps.parse_version(version), query.constraints) then
-            store_result(results, name, version, arch, repo)
-         end
-      end
-   end
-end
-
---- Perform search on a local repository.
--- @param repo string: The pathname of the local repository.
--- @param query table: A table describing the query in dependency
--- format (for example, {name = "filesystem", exact_name = false,
--- constraints = {op = "~>", version = {1,0}}}, arch = "rockspec").
--- If the arch field is omitted, the local architecture (cfg.arch)
--- is used. The special value "any" is also recognized, returning all
--- matches regardless of architecture.
--- @param results table or nil: If given, this table will store the
--- results; if not given, a new table will be created.
--- @return table: The results table, where keys are package names and
--- values are tables matching version strings to arrays of
--- tables with fields "arch" and "repo".
--- If a table was given in the "results" parameter, that is the result value.
-function search.disk_search(repo, query, results)
-   assert(type(repo) == "string")
-   assert(type(query) == "table")
-   assert(type(results) == "table" or not results)
-   
-   local fs = require("luarocks.fs")
-     
-   if not results then
-      results = {}
-   end
-   query_arch_as_table(query)
-   
-   for name in fs.dir(repo) do
-      local pathname = dir.path(repo, name)
-      local rname, rversion, rarch = path.parse_name(name)
-
-      if rname and (pathname:match(".rockspec$") or pathname:match(".rock$")) then
-         store_if_match(results, repo, rname, rversion, rarch, query)
-      elseif fs.is_dir(pathname) then
-         for version in fs.dir(pathname) do
-            if version:match("-%d+$") then
-               store_if_match(results, repo, name, version, "installed", query)
-            end
-         end
-      end
-   end
-   return results
-end
-
---- Perform search on a rocks server or tree.
--- @param results table: The results table, where keys are package names and
--- values are tables matching version strings to arrays of
--- tables with fields "arch" and "repo".
--- @param repo string: The URL of a rocks server or
--- the pathname of a rocks tree (as returned by path.rocks_dir()).
--- @param query table: A table describing the query in dependency
--- format (for example, {name = "filesystem", exact_name = false,
--- constraints = {op = "~>", version = {1,0}}}, arch = "rockspec").
--- If the arch field is omitted, the local architecture (cfg.arch)
--- is used. The special value "any" is also recognized, returning all
--- matches regardless of architecture.
--- @param lua_version string: Lua version in "5.x" format, defaults to installed version.
--- @return true or, in case of errors, nil, an error message and an optional error code.
-function search.manifest_search(results, repo, query, lua_version)
-   assert(type(results) == "table")
-   assert(type(repo) == "string")
-   assert(type(query) == "table")
-   
-   query_arch_as_table(query)
-   local manifest, err, errcode = manif.load_manifest(repo, lua_version)
-   if not manifest then
-      return nil, err, errcode
-   end
-   for name, versions in pairs(manifest.repository) do
-      for version, items in pairs(versions) do
-         for _, item in ipairs(items) do
-            store_if_match(results, repo, name, version, item.arch, query)
-         end
-      end
-   end
-   return true
-end
-
---- Search on all configured rocks servers.
--- @param query table: A dependency query.
--- @param lua_version string: Lua version in "5.x" format, defaults to installed version.
--- @return table: A table where keys are package names
--- and values are tables matching version strings to arrays of
--- tables with fields "arch" and "repo".
-function search.search_repos(query, lua_version)
-   assert(type(query) == "table")
-
-   local results = {}
-   for _, repo in ipairs(cfg.rocks_servers) do
-      if not cfg.disabled_servers[repo] then
-         if type(repo) == "string" then
-            repo = { repo }
-         end
-         for _, mirror in ipairs(repo) do
-            local protocol, pathname = dir.split_url(mirror)
-            if protocol == "file" then
-               mirror = pathname
-            end
-            local ok, err, errcode = search.manifest_search(results, mirror, query, lua_version)
-            if errcode == "network" then
-               cfg.disabled_servers[repo] = true
-            end
-            if ok then
-               break
-            else
-               util.warning("Failed searching manifest: "..err)
-            end
-         end
-      end
-   end
-   -- search through rocks in cfg.rocks_provided
-   local provided_repo = "provided by VM or rocks_provided"
-   for name, versions in pairs(cfg.rocks_provided) do
-      store_if_match(results, provided_repo, name, versions, "installed", query)
-   end
-   return results
-end
-
---- Prepare a query in dependency table format.
--- @param name string: The query name.
--- @param version string or nil: 
--- @return table: A query in table format
-function search.make_query(name, version)
-   assert(type(name) == "string")
-   assert(type(version) == "string" or not version)
-   
-   local query = {
-      name = name,
-      constraints = {}
-   }
-   if version then
-      table.insert(query.constraints, { op = "==", version = deps.parse_version(version)})
-   end
-   return query
-end
-
---- Get the URL for the latest in a set of versions.
--- @param name string: The package name to be used in the URL.
--- @param versions table: An array of version informations, as stored
--- in search results tables.
--- @return string or nil: the URL for the latest version if one could
--- be picked, or nil.
-local function pick_latest_version(name, versions)
-   assert(type(name) == "string")
-   assert(type(versions) == "table")
-
-   local vtables = {}
-   for v, _ in pairs(versions) do
-      table.insert(vtables, deps.parse_version(v))
-   end
-   table.sort(vtables)
-   local version = vtables[#vtables].string
-   local items = versions[version]
-   if items then
-      local pick = 1
-      for i, item in ipairs(items) do
-         if (item.arch == 'src' and items[pick].arch == 'rockspec')
-         or (item.arch ~= 'src' and item.arch ~= 'rockspec') then
-            pick = i
-         end
-      end
-      return path.make_url(items[pick].repo, name, version, items[pick].arch)
-   end
-   return nil
-end
-
--- Find out which other Lua versions provide rock versions matching a query,
--- @param query table: A dependency query matching a single rock.
--- @return table: array of Lua versions supported, in "5.x" format.
-local function supported_lua_versions(query)
-   local results = {}
-
-   for lua_version in util.lua_versions() do
-      if lua_version ~= cfg.lua_version then
-         if search.search_repos(query, lua_version)[query.name] then
-            table.insert(results, lua_version)
-         end
-      end
-   end
-
-   return results
-end
-
---- Attempt to get a single URL for a given search for a rock.
--- @param query table: A dependency query matching a single rock.
--- @return string or (nil, string): URL for latest matching version
--- of the rock if it was found, or nil followed by an error message.
-function search.find_suitable_rock(query)
-   assert(type(query) == "table")
-   
-   local results = search.search_repos(query)
-   local first_rock = next(results)
-   if not first_rock then
-      if cfg.rocks_provided[query.name] == nil then
-         -- Check if constraints are satisfiable with other Lua versions.
-         local lua_versions = supported_lua_versions(query)
-
-         if #lua_versions ~= 0 then
-            -- Build a nice message in "only Lua 5.x and 5.y but not 5.z." format
-            for i, lua_version in ipairs(lua_versions) do
-               lua_versions[i] = "Lua "..lua_version
-            end
-
-            local versions_message = "only "..table.concat(lua_versions, " and ")..
-               " but not Lua "..cfg.lua_version.."."
-
-            if #query.constraints == 0 then
-               return nil, query.name.." supports "..versions_message
-            elseif #query.constraints == 1 and query.constraints[1].op == "==" then
-               return nil, query.name.." "..query.constraints[1].version.string.." supports "..versions_message
-            else
-               return nil, "Matching "..query.name.." versions support "..versions_message
-            end
-         end
-      end
-
-      return nil, "No results matching query were found."
-   elseif next(results, first_rock) then
-      -- Shouldn't happen as query must match only one package.
-      return nil, "Several rocks matched query."
-   elseif cfg.rocks_provided[query.name] ~= nil then
-      -- Do not install versions listed in cfg.rocks_provided.
-      return nil, "Rock "..query.name.." "..cfg.rocks_provided[query.name]..
-         " was found but it is provided by VM or 'rocks_provided' in the config file."
-   else
-      return pick_latest_version(query.name, results[first_rock])
-   end
-end
-
---- Print a list of rocks/rockspecs on standard output.
--- @param results table: A table where keys are package names and versions
--- are tables matching version strings to an array of rocks servers.
--- @param porcelain boolean or nil: A flag to force machine-friendly output.
-function search.print_results(results, porcelain)
-   assert(type(results) == "table")
-   assert(type(porcelain) == "boolean" or not porcelain)
-   
-   for package, versions in util.sortedpairs(results) do
-      if not porcelain then
-         util.printout(package)
-      end
-      for version, repos in util.sortedpairs(versions, deps.compare_versions) do
-         for _, repo in ipairs(repos) do
-            repo.repo = dir.normalize(repo.repo)
-            if porcelain then
-               util.printout(package, version, repo.arch, repo.repo)
-            else
-               util.printout("   "..version.." ("..repo.arch..") - "..repo.repo)
-            end
-         end
-      end
-      if not porcelain then
-         util.printout()
-      end
-   end
-end
-
 --- Splits a list of search results into two lists, one for "source" results
 -- to be used with the "build" command, and one for "binary" results to be
 -- used with the "install" command.
@@ -385,69 +32,13 @@ local function split_source_and_binary_results(results)
             if repo.arch == "all" or repo.arch == cfg.arch then
                where = binaries
             end
-            store_result(where, name, version, repo.arch, repo.repo)
+            search.store_result(where, name, version, repo.arch, repo.repo)
          end
       end
    end
    return sources, binaries
 end
 
---- Given a name and optionally a version, try to find in the rocks
--- servers a single .src.rock or .rockspec file that satisfies
--- the request, and run the given function on it; or display to the
--- user possibilities if it couldn't narrow down a single match.
--- @param action function: A function that takes a .src.rock or
--- .rockspec URL as a parameter.
--- @param name string: A rock name
--- @param version string or nil: A version number may also be given.
--- @return The result of the action function, or nil and an error message. 
-function search.act_on_src_or_rockspec(action, name, version, ...)
-   assert(type(action) == "function")
-   assert(type(name) == "string")
-   assert(type(version) == "string" or not version)
-
-   local query = search.make_query(name, version)
-   query.arch = "src|rockspec"
-   local url, err = search.find_suitable_rock(query)
-   if not url then
-      return nil, "Could not find a result named "..name..(version and " "..version or "")..": "..err
-   end
-   return action(url, ...)
-end
-
-function search.pick_installed_rock(name, version, given_tree)
-   local results = {}
-   local query = search.make_query(name, version)
-   query.exact_name = true
-   local tree_map = {}
-   local trees = cfg.rocks_trees
-   if given_tree then
-      trees = { given_tree }
-   end
-   for _, tree in ipairs(trees) do
-      local rocks_dir = path.rocks_dir(tree)
-      tree_map[rocks_dir] = tree
-      search.manifest_search(results, rocks_dir, query)
-   end
-
-   if not next(results) then --
-      return nil,"cannot find package "..name.." "..(version or "").."\nUse 'list' to find installed rocks."
-   end
-
-   version = nil
-   local repo_url
-   local package, versions = util.sortedpairs(results)()
-   --question: what do we do about multiple versions? This should
-   --give us the latest version on the last repo (which is usually the global one)
-   for vs, repositories in util.sortedpairs(versions, deps.compare_versions) do
-      if not version then version = vs end
-      for _, rp in ipairs(repositories) do repo_url = rp.repo end
-   end
-
-   local repo = tree_map[repo_url]
-   return name, version, repo, repo_url
-end
-
 --- Driver function for "search" command.
 -- @param name string: A substring of a rock name to search.
 -- @param version string or nil: a version may also be passed.