From a1292cab06cc8f93365afd30d87a502b8c60bc03 Mon Sep 17 00:00:00 2001 From: V1K1NGbg Date: Thu, 22 Aug 2024 17:49:08 -0300 Subject: Teal: convert luarocks.remove --- src/luarocks/remove.lua | 135 ---------------------------------------------- src/luarocks/remove.tl | 140 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 140 insertions(+), 135 deletions(-) delete mode 100644 src/luarocks/remove.lua create mode 100644 src/luarocks/remove.tl (limited to 'src') diff --git a/src/luarocks/remove.lua b/src/luarocks/remove.lua deleted file mode 100644 index a24b54ba..00000000 --- a/src/luarocks/remove.lua +++ /dev/null @@ -1,135 +0,0 @@ -local 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 util = require("luarocks.util") -local cfg = require("luarocks.core.cfg") -local manif = require("luarocks.manif") -local queries = require("luarocks.queries") - ---- 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 skip_set = {} - skip_set[name] = {} - for version, _ in pairs(versions) do - skip_set[name][version] = true - end - - local local_rocks = {} - local query_all = queries.all() - search.local_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.dependencies, rockspec.rocks_provided, skip_set, 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 = {} - local query = queries.new(name, nil, version, false, nil, "~=") - search.local_manifest_search(results, cfg.rocks_dir, query) - local warn - if results[name] then - local ok, err = remove.remove_search_results(results, name, cfg.deps_mode, force, fast) - if not ok then -- downgrade failure to a warning - warn = err - end - end - - if not fast then - -- since we're not using --keep, this means that all files of the rock being installed - -- should be available as non-versioned variants. Double-check that: - local rock_manifest, load_err = manif.load_rock_manifest(name, version) - local ok, err = repos.check_everything_is_installed(name, version, rock_manifest, cfg.root_dir, false) - if not ok then - return nil, err - end - end - - return true, nil, warn -end - -return remove diff --git a/src/luarocks/remove.tl b/src/luarocks/remove.tl new file mode 100644 index 00000000..11d270a9 --- /dev/null +++ b/src/luarocks/remove.tl @@ -0,0 +1,140 @@ + +local record remove +end + +local search = require("luarocks.search") +local deps = require("luarocks.deps") +local fetch = require("luarocks.fetch") +local repos = require("luarocks.repos") +local repo_writer = require("luarocks.repo_writer") +local path = require("luarocks.path") +local util = require("luarocks.util") +local cfg = require("luarocks.core.cfg") +local manif = require("luarocks.manif") +local queries = require("luarocks.queries") + +local type Result = require("luarocks.core.types.result").Result + +--- 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: string, versions: {string: {Result}}, deps_mode: string): {Result} + local dependents: {Result} = {} + + local skip_set = {} + skip_set[name] = {} + for version, _ in pairs(versions) do + skip_set[name][version] = true + end + + local local_rocks = {} + local query_all = queries.all() + search.local_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.dependencies.queries, rockspec.rocks_provided, deps_mode, skip_set) + 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: string, versions: {string: any}, deps_mode: string): boolean, string + + for version, _ in pairs(versions) do + util.printout("Removing "..name.." "..version.."...") + local ok, err = repo_writer.delete_version(name, version, deps_mode) + if not ok then return nil, err end + end + + return true +end + +function remove.remove_search_results(results: {string : {string : {Result}}}, name: string, deps_mode: string, force: boolean, fast: boolean): boolean, string + 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) as {string | number}), ", ").."...") + 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: string, version: string, force: boolean, fast: boolean): boolean, string, string + local results = {} + local query = queries.new(name, nil, version, false, nil, "~=") + search.local_manifest_search(results, cfg.rocks_dir, query) + local warn: string + if results[name] then + local ok, err = remove.remove_search_results(results, name, cfg.deps_mode, force, fast) + if not ok then -- downgrade failure to a warning + warn = err + end + end + + if not fast then + -- since we're not using --keep, this means that all files of the rock being installed + -- should be available as non-versioned variants. Double-check that: + local rock_manifest, load_err = manif.load_rock_manifest(name, version) + local ok, err = repos.check_everything_is_installed(name, version, rock_manifest, cfg.root_dir, false) + if not ok then + return nil, err + end + end + + return true, nil, warn +end + +return remove -- cgit v1.2.3-55-g6feb