| local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local string = _tl_compat and _tl_compat.string or string |
|
|
| local install = {} |
|
|
|
|
|
|
| local dir = require("luarocks.dir") |
| local path = require("luarocks.path") |
| local repos = require("luarocks.repos") |
| local fetch = require("luarocks.fetch") |
| local util = require("luarocks.util") |
| local fs = require("luarocks.fs") |
| local deps = require("luarocks.deps") |
| local repo_writer = require("luarocks.repo_writer") |
| local remove = require("luarocks.remove") |
| local search = require("luarocks.search") |
| local queries = require("luarocks.queries") |
| local cfg = require("luarocks.core.cfg") |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function install.add_to_parser(parser) |
| local cmd = parser:command("install", "Install a rock.", util.see_also()) |
|
|
| cmd:argument("rock", "The name of a rock to be fetched from a repository " .. |
| "or a filename of a locally available rock."): |
| action(util.namespaced_name_action) |
| cmd:argument("version", "Version of the rock."): |
| args("?") |
|
|
| cmd:flag("--keep", "Do not remove previously installed versions of the " .. |
| "rock after building a new one. This behavior can be made permanent by " .. |
| "setting keep_other_versions=true in the configuration file.") |
| cmd:flag("--force", "If --keep is not specified, force removal of " .. |
| "previously installed versions if it would break dependencies. " .. |
| "If rock is already installed, reinstall it anyway.") |
| cmd:flag("--force-fast", "Like --force, but performs a forced removal " .. |
| "without reporting dependency issues.") |
| cmd:flag("--only-deps --deps-only", "Install only the dependencies of the rock.") |
| cmd:flag("--no-doc", "Install the rock without its documentation.") |
| cmd:flag("--verify", "Verify signature of the rockspec or src.rock being " .. |
| "built. If the rockspec or src.rock is being downloaded, LuaRocks will " .. |
| "attempt to download the signature as well. Otherwise, the signature " .. |
| "file should be already available locally in the same directory.\n" .. |
| "You need the signer’s public key in your local keyring for this " .. |
| "option to work properly.") |
| cmd:flag("--check-lua-versions", "If the rock can't be found, check repository " .. |
| "and report if it is available for another Lua version.") |
| util.deps_mode_option(cmd) |
| cmd:flag("--no-manifest", "Skip creating/updating the manifest") |
| cmd:flag("--pin", "If the installed rock is a Lua module, create a " .. |
| "luarocks.lock file listing the exact versions of each dependency found for " .. |
| "this rock (recursively), and store it in the rock's directory. " .. |
| "Ignores any existing luarocks.lock file in the rock's sources.") |
|
|
| parser:flag("--pack-binary-rock"):hidden(true) |
| parser:option("--branch"):hidden(true) |
| parser:flag("--sign"):hidden(true) |
| end |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function install.install_binary_rock(rock_file, opts) |
|
|
| local namespace = opts.namespace |
| local deps_mode = opts.deps_mode |
|
|
| local name, version, arch = path.parse_name(rock_file) |
| if not name then |
| return nil, "Filename " .. rock_file .. " does not match format 'name-version-revision.arch.rock'." |
| end |
|
|
| if arch ~= "all" and arch ~= cfg.arch then |
| return nil, "Incompatible architecture " .. arch, "arch" |
| end |
| if repos.is_installed(name, version) then |
| if not (opts.force or opts.force_fast) then |
| util.printout(name .. " " .. version .. " is already installed in " .. path.root_dir(cfg.root_dir)) |
| util.printout("Use --force to reinstall.") |
| return name, version |
| end |
| repo_writer.delete_version(name, version, opts.deps_mode) |
| end |
|
|
| local install_dir = path.install_dir(name, version) |
|
|
| local rollback = util.schedule_function(function() |
| fs.delete(install_dir) |
| fs.remove_dir_if_empty(path.versions_dir(name)) |
| end) |
|
|
| local ok, err, errcode |
|
|
| local filename |
| filename, err, errcode = fetch.fetch_and_unpack_rock(rock_file, install_dir, opts.verify) |
| if not filename then return nil, err, errcode end |
|
|
| local rockspec |
| rockspec, err, errcode = fetch.load_rockspec(path.rockspec_file(name, version)) |
| if err then |
| return nil, "Failed loading rockspec for installed package: " .. err, errcode |
| end |
|
|
| if opts.deps_mode ~= "none" then |
| ok, err, errcode = deps.check_external_deps(rockspec, "install") |
| if not ok then return nil, err, errcode end |
| end |
|
|
| if deps_mode ~= "none" then |
| local deplock_dir = fs.exists(dir.path(".", "luarocks.lock")) and |
| "." or |
| install_dir |
| ok, err, errcode = deps.fulfill_dependencies(rockspec, "dependencies", deps_mode, opts.verify, deplock_dir) |
| if not ok then return nil, err, errcode end |
| end |
|
|
| ok, err = repo_writer.deploy_files(name, version, repos.should_wrap_bin_scripts(rockspec), deps_mode, namespace) |
| if not ok then return nil, err end |
|
|
| util.remove_scheduled_function(rollback) |
| rollback = util.schedule_function(function() |
| repo_writer.delete_version(name, version, deps_mode) |
| end) |
|
|
| ok, err = repos.run_hook(rockspec, "post_install") |
| if not ok then return nil, err end |
|
|
| util.announce_install(rockspec) |
| util.remove_scheduled_function(rollback) |
| return name, version |
| end |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function install.install_binary_rock_deps(rock_file, opts) |
|
|
| local name, version, arch = path.parse_name(rock_file) |
| if not name then |
| return nil, "Filename " .. rock_file .. " does not match format 'name-version-revision.arch.rock'." |
| end |
|
|
| if arch ~= "all" and arch ~= cfg.arch then |
| return nil, "Incompatible architecture " .. arch, "arch" |
| end |
|
|
| local install_dir = path.install_dir(name, version) |
|
|
| local oks, err, errcode = fetch.fetch_and_unpack_rock(rock_file, install_dir, opts.verify) |
| if not oks then return nil, err, errcode end |
|
|
| local rockspec |
| rockspec, err = fetch.load_rockspec(path.rockspec_file(name, version)) |
| if err then |
| return nil, "Failed loading rockspec for installed package: " .. err, errcode |
| end |
|
|
| local deplock_dir = fs.exists(dir.path(".", "luarocks.lock")) and |
| "." or |
| install_dir |
|
|
| local ok |
| ok, err, errcode = deps.fulfill_dependencies(rockspec, "dependencies", opts.deps_mode, opts.verify, deplock_dir) |
| if not ok then return nil, err, errcode end |
|
|
| util.printout() |
| util.printout("Successfully installed dependencies for " .. name .. " " .. version) |
|
|
| return name, version |
| end |
|
|
| local function install_rock_file_deps(filename, opts) |
|
|
| local name, version = install.install_binary_rock_deps(filename, opts) |
| if not name then return nil, version end |
|
|
| deps.check_dependencies(nil, opts.deps_mode) |
| return true |
| end |
|
|
| local function install_rock_file(filename, opts) |
|
|
| local name, version = install.install_binary_rock(filename, opts) |
| if not name then return nil, version end |
|
|
| if opts.no_doc then |
| util.remove_doc_dir(name, version) |
| end |
|
|
| if (not opts.keep) and not cfg.keep_other_versions then |
| local ok, err, warn = remove.remove_other_versions(name, version, opts.force, opts.force_fast) |
| if not ok then |
| return nil, err |
| elseif warn then |
| util.printerr(err) |
| end |
| end |
|
|
| deps.check_dependencies(nil, opts.deps_mode) |
| return true |
| end |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| function install.command(args) |
| if args.rock:match("%.rockspec$") or args.rock:match("%.src%.rock$") then |
| local build = require("luarocks.cmd.build") |
| return build.command(args) |
| elseif args.rock:match("%.rock$") then |
| local deps_mode = deps.get_deps_mode(args) |
| local opts = { |
| namespace = args.namespace, |
| keep = not not args.keep, |
| force = not not args.force, |
| force_fast = not not args.force_fast, |
| no_doc = not not args.no_doc, |
| deps_mode = deps_mode, |
| verify = not not args.verify, |
| } |
| if args.only_deps then |
| return install_rock_file_deps(args.rock, opts) |
| else |
| return install_rock_file(args.rock, opts) |
| end |
| else |
| local url, err = search.find_rock_checking_lua_versions( |
| queries.new(args.rock, args.namespace, args.version), |
| args.check_lua_versions) |
| if not url then |
| return nil, err |
| end |
| util.printout("Installing " .. url) |
| args.rock = url |
| return install.command(args) |
| end |
| end |
|
|
| install.needs_lock = function(args) |
| if args.pack_binary_rock then |
| return false |
| end |
| return true |
| end |
|
|
| deps.installer = install.command |
|
|
| return install |
|
|
