From c7b9fe0fc863ff09716ff592f3ae96fa3b0e0ca1 Mon Sep 17 00:00:00 2001 From: Hisham Muhammad Date: Wed, 31 Oct 2012 01:45:27 -0200 Subject: Clean up and make use of deps-mode / deps_mode consistent. --nodeps is now an alias to --deps-mode=none --- src/luarocks/build.lua | 4 ++-- src/luarocks/cfg.lua | 2 +- src/luarocks/command_line.lua | 6 ++++++ src/luarocks/deps.lua | 43 +++++++++++++++++++----------------------- src/luarocks/install.lua | 8 ++------ src/luarocks/make.lua | 4 ++-- src/luarocks/make_manifest.lua | 2 +- src/luarocks/manif.lua | 28 ++++++++++++++++----------- src/luarocks/manif_core.lua | 8 ++++---- src/luarocks/path.lua | 10 +++++----- src/luarocks/remove.lua | 14 +++++--------- 11 files changed, 64 insertions(+), 65 deletions(-) (limited to 'src') diff --git a/src/luarocks/build.lua b/src/luarocks/build.lua index d68acabd..d61d6611 100644 --- a/src/luarocks/build.lua +++ b/src/luarocks/build.lua @@ -326,10 +326,10 @@ function run(...) assert(type(version) == "string" or not version) if flags["pack-binary-rock"] then - return pack.pack_binary_rock(name, version, do_build, name, version, deps.flags_to_deps_mode(flags)) + return pack.pack_binary_rock(name, version, do_build, name, version, deps.get_deps_mode(flags)) else local ok, err = fs.check_command_permissions(flags) if not ok then return nil, err end - return do_build(name, version, deps.flags_to_deps_mode(flags)) + return do_build(name, version, deps.get_deps_mode(flags)) end end diff --git a/src/luarocks/cfg.lua b/src/luarocks/cfg.lua index 136ea6be..0e43768e 100644 --- a/src/luarocks/cfg.lua +++ b/src/luarocks/cfg.lua @@ -165,7 +165,7 @@ local defaults = { use_extensions = false, accept_unknown_fields = false, fs_use_modules = true, - use_trees = "one", + deps_mode = "one", lua_modules_path = "/share/lua/"..lua_version, lib_modules_path = "/lib/lua/"..lua_version, diff --git a/src/luarocks/command_line.lua b/src/luarocks/command_line.lua index d08ffdfe..b4b20f84 100644 --- a/src/luarocks/command_line.lua +++ b/src/luarocks/command_line.lua @@ -7,6 +7,7 @@ local cfg = require("luarocks.cfg") local fs = require("luarocks.fs") local path = require("luarocks.path") local dir = require("luarocks.dir") +local deps = require("luarocks.deps") --- Display an error message and exit. -- @param message string: The error message. @@ -50,6 +51,7 @@ function run_command(...) if flags["only-from"] then flags["only-server"] = flags["only-from"] end if flags["only-sources-from"] then flags["only-sources"] = flags["only-sources-from"] end if flags["to"] then flags["tree"] = flags["to"] end + if flags["nodeps"] then flags["deps-mode"] = "none" end cfg.flags = flags @@ -83,6 +85,10 @@ function run_command(...) if cfg.local_by_default then flags["local"] = true end + + if flags["deps-mode"] and not deps.check_dep_trees_flag(flags["deps-mode"]) then + return nil, "Invalid entry for --deps-mode." + end if flags["tree"] then if flags["tree"] == true then diff --git a/src/luarocks/deps.lua b/src/luarocks/deps.lua index a409920a..6d5f3fef 100644 --- a/src/luarocks/deps.lua +++ b/src/luarocks/deps.lua @@ -312,14 +312,14 @@ end -- @return table or nil: A table containing fields 'name' and 'version' -- representing an installed rock which matches the given dependency, -- or nil if it could not be matched. -local function match_dep(dep, blacklist, use_trees) +local function match_dep(dep, blacklist, deps_mode) assert(type(dep) == "table") local versions if dep.name == "lua" then versions = { cfg.lua_version } else - versions = manif_core.get_versions(dep.name, use_trees) + versions = manif_core.get_versions(dep.name, deps_mode) end if not versions then return nil @@ -361,13 +361,13 @@ end -- in table format and values are tables containing fields 'name' and -- version' representing matches, and a table of missing dependencies -- parsed as tables. -function match_deps(rockspec, blacklist, use_trees) +function match_deps(rockspec, blacklist, deps_mode) assert(type(rockspec) == "table") assert(type(blacklist) == "table" or not blacklist) local matched, missing, no_upgrade = {}, {}, {} for _, dep in ipairs(rockspec.dependencies) do - local found = match_dep(dep, blacklist and blacklist[dep.name] or nil, use_trees) + local found = match_dep(dep, blacklist and blacklist[dep.name] or nil, deps_mode) if found then if dep.name ~= "lua" then matched[dep] = found @@ -401,7 +401,7 @@ end -- @return boolean or (nil, string, [string]): True if no errors occurred, or -- nil and an error message if any test failed, followed by an optional -- error code. -function fulfill_dependencies(rockspec, use_trees) +function fulfill_dependencies(rockspec, deps_mode) local search = require("luarocks.search") local install = require("luarocks.install") @@ -433,7 +433,7 @@ function fulfill_dependencies(rockspec, use_trees) end end - local matched, missing, no_upgrade = match_deps(rockspec, nil, use_trees) + local matched, missing, no_upgrade = match_deps(rockspec, nil, deps_mode) if next(no_upgrade) then util.printerr("Missing dependencies for "..rockspec.name.." "..rockspec.version..":") @@ -467,7 +467,7 @@ function fulfill_dependencies(rockspec, use_trees) for _, dep in pairs(missing) do -- Double-check in case dependency was filled during recursion. - if not match_dep(dep, nil, use_trees) then + if not match_dep(dep, nil, deps_mode) then local rock = search.find_suitable_rock(dep) if not rock then return nil, "Could not satisfy dependency: "..show_dep(dep) @@ -640,7 +640,7 @@ end -- @param name string: Package name. -- @param version string: Package version. -- @return (table, table): The results and a table of missing dependencies. -function scan_deps(results, missing, manifest, name, version, use_trees) +function scan_deps(results, missing, manifest, name, version, deps_mode) assert(type(results) == "table") assert(type(missing) == "table") assert(type(manifest) == "table") @@ -669,9 +669,9 @@ function scan_deps(results, missing, manifest, name, version, use_trees) else rockspec = { dependencies = deplist } end - local matched, failures = match_deps(rockspec, nil, use_trees) + local matched, failures = match_deps(rockspec, nil, deps_mode) for _, match in pairs(matched) do - results, missing = scan_deps(results, missing, manifest, match.name, match.version, use_trees) + results, missing = scan_deps(results, missing, manifest, match.name, match.version, deps_mode) end if next(failures) then for _, failure in pairs(failures) do @@ -682,30 +682,25 @@ function scan_deps(results, missing, manifest, name, version, use_trees) return results, missing end -local valid_trees = { +local valid_deps_modes = { one = true, order = true, all = true, + none = true, } -function check_trees_flag(flag) - return valid_trees[flag] +function check_deps_mode_flag(flag) + return valid_deps_modes[flag] end -function flags_to_deps_mode(flags) - if flags["nodeps"] then - return "none" - elseif flags["trees"] then - return flags["trees"] +function get_deps_mode(flags) + if flags["deps-mode"] then + return flags["deps-mode"] else - return cfg.use_trees + return cfg.deps_mode end end function deps_mode_to_flag(deps_mode) - if deps_mode == "none" then - return "--nodeps" - else - return "--trees="..deps_mode - end + return "--deps-mode="..deps_mode end diff --git a/src/luarocks/install.lua b/src/luarocks/install.lua index 0ffb95ef..e633ea23 100644 --- a/src/luarocks/install.lua +++ b/src/luarocks/install.lua @@ -127,13 +127,9 @@ function run(...) if name:match("%.rockspec$") or name:match("%.src%.rock$") then util.printout("Using "..name.."... switching to 'build' mode") local build = require("luarocks.build") - local build_flags = {} - if flags["local"] then table.insert(build_flags, "--local") end - if flags["nodeps"] then table.insert(build_flags, "--nodeps") end - if flags["trees"] then table.insert(build_flags, "--trees="..flags["trees"]) end - return build.run(name, unpack(build_flags)) + return build.run(name, deps.get_deps_mode(flags), flags["local"] and "--local") elseif name:match("%.rock$") then - return install_binary_rock(name, deps.flags_to_deps_mode(flags)) + return install_binary_rock(name, deps.get_deps_mode(flags)) else local search = require("luarocks.search") local results, err = search.find_suitable_rock(search.make_query(name:lower(), version)) diff --git a/src/luarocks/make.lua b/src/luarocks/make.lua index 498445d8..69c2162f 100644 --- a/src/luarocks/make.lua +++ b/src/luarocks/make.lua @@ -63,10 +63,10 @@ function run(...) if not rspec then return nil, err end - return pack.pack_binary_rock(rspec.name, rspec.version, build.build_rockspec, rockspec, false, true, deps.flags_to_deps_mode(flags)) + return pack.pack_binary_rock(rspec.name, rspec.version, build.build_rockspec, rockspec, false, true, deps.get_deps_mode(flags)) else local ok, err = fs.check_command_permissions(flags) if not ok then return nil, err end - return build.build_rockspec(rockspec, false, true, deps.flags_to_deps_mode(flags)) + return build.build_rockspec(rockspec, false, true, deps.get_deps_mode(flags)) end end diff --git a/src/luarocks/make_manifest.lua b/src/luarocks/make_manifest.lua index e629b9de..845c9f8a 100644 --- a/src/luarocks/make_manifest.lua +++ b/src/luarocks/make_manifest.lua @@ -28,7 +28,7 @@ function run(...) util.printout("Making manifest for "..repo) - local ok, err = manif.make_manifest(repo, deps.flags_to_deps_mode(flags)) + local ok, err = manif.make_manifest(repo, deps.get_deps_mode(flags)) if ok then util.printout("Generating index.html for "..repo) index.make_index(repo) diff --git a/src/luarocks/manif.lua b/src/luarocks/manif.lua index b7554a33..414c3262 100644 --- a/src/luarocks/manif.lua +++ b/src/luarocks/manif.lua @@ -185,14 +185,17 @@ end -- and any dependency inconsistencies or missing dependencies are reported to -- standard error. -- @param manifest table: a manifest table. -local function update_dependencies(manifest, use_trees) +local function update_dependencies(manifest, deps_mode) + assert(type(manifest) == "table") + assert(type(deps_mode) == "string") + for pkg, versions in pairs(manifest.repository) do for version, repositories in pairs(versions) do local current = pkg.." "..version for _, repo in ipairs(repositories) do if repo.arch == "installed" then local missing - repo.dependencies, missing = deps.scan_deps({}, {}, manifest, pkg, version, use_trees) + repo.dependencies, missing = deps.scan_deps({}, {}, manifest, pkg, version, deps_mode) repo.dependencies[pkg] = nil if missing then for miss, err in pairs(missing) do @@ -214,9 +217,10 @@ end -- @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, use_trees) +local function store_results(results, manifest, deps_mode) assert(type(results) == "table") assert(type(manifest) == "table") + assert(type(deps_mode) == "string") for name, versions in pairs(results) do local pkgtable = manifest.repository[name] or {} @@ -239,7 +243,7 @@ local function store_results(results, manifest, use_trees) end manifest.repository[name] = pkgtable end - update_dependencies(manifest, use_trees) + update_dependencies(manifest, deps_mode) sort_package_matching_table(manifest.modules) sort_package_matching_table(manifest.commands) return true @@ -251,10 +255,11 @@ end -- @param repo A local repository directory. -- @return boolean or (nil, string): True if manifest was generated, -- or nil and an error message. -function make_manifest(repo, use_trees) +function make_manifest(repo, deps_mode) assert(type(repo) == "string") + assert(type(deps_mode) == "string") - if use_trees == "none" then use_trees = cfg.use_trees end + 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 @@ -267,7 +272,7 @@ function make_manifest(repo, use_trees) local manifest = { repository = {}, modules = {}, commands = {} } manif_core.manifest_cache[repo] = manifest - local ok, err = store_results(results, manifest, use_trees) + local ok, err = store_results(results, manifest, deps_mode) if not ok then return nil, err end return save_table(repo, "manifest", manifest) @@ -283,19 +288,20 @@ end -- the default local repository configured as cfg.rocks_dir is used. -- @return boolean or (nil, string): True if manifest was generated, -- or nil and an error message. -function update_manifest(name, version, repo, use_trees) +function update_manifest(name, version, repo, deps_mode) assert(type(name) == "string") assert(type(version) == "string") repo = path.rocks_dir(repo or cfg.root_dir) + assert(type(deps_mode) == "string") - if use_trees == "none" then use_trees = cfg.use_trees end + if deps_mode == "none" then deps_mode = cfg.deps_mode end util.printout("Updating manifest for "..repo) local manifest, err = load_manifest(repo) if not manifest then util.printerr("No existing manifest. Attempting to rebuild...") - local ok, err = make_manifest(repo, use_trees) + local ok, err = make_manifest(repo, deps_mode) if not ok then return nil, err end @@ -307,7 +313,7 @@ function update_manifest(name, version, repo, use_trees) local results = {[name] = {[version] = {{arch = "installed", repo = repo}}}} - local ok, err = store_results(results, manifest, use_trees) + local ok, err = store_results(results, manifest, deps_mode) if not ok then return nil, err end return save_table(repo, "manifest", manifest) diff --git a/src/luarocks/manif_core.lua b/src/luarocks/manif_core.lua index 6af99fe7..6424a1e8 100644 --- a/src/luarocks/manif_core.lua +++ b/src/luarocks/manif_core.lua @@ -53,18 +53,18 @@ end --- Get all versions of a package listed in a manifest file. -- @param name string: a package name. --- @param use_trees string: "one", to use only the currently +-- @param deps_mode string: "one", to use only the currently -- configured tree; "order" to select trees based on order -- (use the current tree and all trees below it on the list) -- or "all", to use all trees. -- @return table: An array of strings listing installed -- versions of a package. -function get_versions(name, use_trees) +function get_versions(name, deps_mode) assert(type(name) == "string") - assert(type(use_trees) == "string") + assert(type(deps_mode) == "string") local manifest = {} - path.map_trees(use_trees, function(tree) + path.map_trees(deps_mode, function(tree) local loaded = load_local_manifest(path.rocks_dir(tree)) if loaded then util.deep_merge(manifest, loaded) diff --git a/src/luarocks/path.lua b/src/luarocks/path.lua index 42d3b8f1..64a203ef 100644 --- a/src/luarocks/path.lua +++ b/src/luarocks/path.lua @@ -306,13 +306,13 @@ function use_tree(tree) cfg.deploy_lib_dir = deploy_lib_dir(tree) end -function map_trees(use_trees, fn, ...) +function map_trees(deps_mode, fn, ...) local result = {} - if use_trees == "one" then + if deps_mode == "one" then table.insert(result, (fn(cfg.root_dir, ...)) or 0) - elseif use_trees == "all" or use_trees == "order" then + elseif deps_mode == "all" or deps_mode == "order" then local use = false - if use_trees == "all" then + if deps_mode == "all" then use = true end for _, tree in ipairs(cfg.rocks_trees) do @@ -374,7 +374,7 @@ end -- @return boolean This function always succeeds. function run(...) local flags = util.parse_flags(...) - local deps_mode = deps.flags_to_deps_mode(flags) + local deps_mode = deps.get_deps_mode(flags) util.printout(cfg.export_lua_path:format(util.remove_path_dupes(package.path, ';'))) util.printout(cfg.export_lua_cpath:format(util.remove_path_dupes(package.cpath, ';'))) diff --git a/src/luarocks/remove.lua b/src/luarocks/remove.lua index 261dc1c4..126cfdc8 100644 --- a/src/luarocks/remove.lua +++ b/src/luarocks/remove.lua @@ -28,7 +28,7 @@ To override this check and force the removal, use --force. -- @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, use_trees) +local function check_dependents(name, versions, deps_mode) local dependents = {} local blacklist = {} blacklist[name] = {} @@ -44,7 +44,7 @@ local function check_dependents(name, versions, use_trees) 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, use_trees) + local _, missing = deps.match_deps(rockspec, blacklist, deps_mode) if missing[name] then table.insert(dependents, { name = rock_name, version = rock_version }) end @@ -78,16 +78,12 @@ end -- successful, nil and an error message otherwise. function run(...) local flags, name, version = util.parse_flags(...) - - if flags["trees"] and type(flags["trees"]) ~= "string" then - return nil, "Invalid entry for --trees." - end if type(name) ~= "string" then return nil, "Argument missing, see help." end - local use_trees = flags["trees"] or cfg.use_trees + local deps_mode = flags["deps-mode"] or cfg.deps_mode local ok, err = fs.check_command_permissions(flags) if not ok then return nil, err end @@ -106,7 +102,7 @@ function run(...) util.printout(name.." "..table.concat(util.keys(versions), ", ").."...") util.printout() - local dependents = check_dependents(name, versions, use_trees) + local dependents = check_dependents(name, versions, deps_mode) if #dependents == 0 or flags["force"] then if #dependents > 0 then @@ -118,7 +114,7 @@ function run(...) end local ok, err = delete_versions(name, versions) if not ok then return nil, err end - ok, err = manif.make_manifest(cfg.rocks_dir, use_trees) + ok, err = manif.make_manifest(cfg.rocks_dir, deps_mode) if not ok then return nil, err end else if not second then -- cgit v1.2.3-55-g6feb