build

5 files changed, 267 insertions, 7 deletions

diff --git a/src/luarocks/core/types/build.d.tl b/src/luarocks/core/types/build.d.tl
index b67396f7..b643dc92 100644
--- a/src/luarocks/core/types/build.d.tl
+++ b/src/luarocks/core/types/build.d.tl
@@ -2,10 +2,10 @@ local record build
 
    interface Build
       record Install
-         lua: {string: string}
-         lib: {string: string}
-         conf: {string: string}
-         bin: {string: string}
+         lua: {(string|integer): string}
+         lib: {(string|integer): string}
+         conf: {(string|integer): string}
+         bin: {(string|integer): string}
       end
       
       type: string
diff --git a/src/luarocks/download.tl b/src/luarocks/download.tl
new file mode 100644
index 00000000..43a57d8f
--- /dev/null
+++ b/src/luarocks/download.tl
@@ -0,0 +1,69 @@
+local record download
+end
+
+local path = require("luarocks.path")
+local fetch = require("luarocks.fetch")
+local search = require("luarocks.search")
+local queries = require("luarocks.queries")
+local fs = require("luarocks.fs")
+local dir = require("luarocks.dir")
+local util = require("luarocks.util")
+
+local function get_file(filename: string): string, string
+   local protocol, pathname = dir.split_url(filename)
+   if protocol == "file" then
+      local ok, err = fs.copy(pathname, fs.current_dir(), "read")
+      if ok then
+         return pathname
+      else
+         return nil, err
+      end
+   else
+      -- discard third result
+      local ok, err = fetch.fetch_url(filename)
+      return ok, err
+   end
+end
+
+function download.download(arch: string, name: string, namespace: string, version: string, all, check_lua_versions: boolean): string, string
+   local substring = (all and name == "")
+   local query = queries.new(name, namespace, version, substring, arch)
+   local search_err: string
+
+   if all then
+      local results = search.search_repos(query)
+      local has_result = false
+      local all_ok = true
+      local any_err = ""
+      for name, result in pairs(results) do  -- luacheck: ignore 422
+         for version, items in pairs(result) do  -- luacheck: ignore 422
+            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: string
+      url, search_err = search.find_rock_checking_lua_versions(query, check_lua_versions)
+      if url then
+         return get_file(url)
+      end
+   end
+   local rock = util.format_rock_name(name, namespace, version)
+   return nil, "Could not find a result named "..rock..(search_err and ": "..search_err or ".")
+end
+
+return download
diff --git a/src/luarocks/fs.d.tl b/src/luarocks/fs.d.tl
index f9997db1..1e593c40 100644
--- a/src/luarocks/fs.d.tl
+++ b/src/luarocks/fs.d.tl
@@ -63,8 +63,10 @@ local record fs
    apply_patch: function(string, string, boolean): boolean, string
    copy_contents: function(string, string): boolean, string
    remove_dir_if_empty: function(string)
-   --command
+   -- command
    execute_env: function({any: any}, string, ...:string): boolean
+   -- pack
+   zip: function(string, string, string): boolean, string
 end
 
 return fs
diff --git a/src/luarocks/pack.tl b/src/luarocks/pack.tl
new file mode 100644
index 00000000..c9ebae2e
--- /dev/null
+++ b/src/luarocks/pack.tl
@@ -0,0 +1,189 @@
+
+-- Create rock files, packing sources or binaries.
+local record pack
+end
+
+local queries = require("luarocks.queries")
+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 signing = require("luarocks.signing")
+
+local type t = require("luarocks.core.types.tree")
+local type Tree = t.Tree
+
+local type q = require("luarocks.core.types.query")
+local type Query = q.Query
+
+
+--- 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: string): string, string
+
+   local rockspec, errload = fetch.load_rockspec(rockspec_file)
+   if errload then
+      return nil, "Error loading rockspec: "..errload
+   end
+   rockspec_file = rockspec.local_abs_filename
+
+   local name_version = rockspec.name .. "-" .. rockspec.version
+   local rock_file = fs.absolute_name(name_version .. ".src.rock")
+
+   local temp_dir, err = fs.make_temp_dir("pack-"..name_version)
+   if not temp_dir then
+      return nil, "Failed creating temporary directory: "..err
+   end
+   util.schedule_function(fs.delete, temp_dir)
+
+   local source_file, source_dir = fetch.fetch_sources(rockspec, true, temp_dir)
+   if not source_file then
+      return nil, source_dir
+   end
+   local ok, errchange = fs.change_dir(source_dir)
+   if not ok then return nil, errchange end
+
+   fs.delete(rock_file)
+   fs.copy(rockspec_file, source_dir, "read")
+   ok, err = fs.zip(rock_file, dir.base_name(rockspec_file), dir.base_name(source_file))
+   if not ok then
+      return nil, "Failed packing "..rock_file.." - "..err
+   end
+   fs.pop_dir()
+
+   return rock_file
+end
+
+local function copy_back_files(name: string, version: string, file_tree: {string: any}, deploy_dir: string, pack_dir: string, perms?: string): boolean, string
+   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 sub is {string: any} then
+         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.
+function pack.pack_installed_rock(query: Query, tree: string | Tree)
+
+   local name, version, repo, repo_url = search.pick_installed_rock(query, tree)
+   if not name then
+      return nil, version
+   end
+
+   local root = path.root_from_rocks_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(repo), dir.path(temp_dir, "lib"), "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(repo), dir.path(temp_dir, "lua"), "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)
+   ok, err = fs.zip(rock_file, unpack(fs.list_dir()))
+   if not ok then
+      return nil, "Failed packing " .. rock_file .. " - " .. err
+   end
+   fs.pop_dir()
+   fs.delete(temp_dir)
+   return rock_file
+end
+
+function pack.report_and_sign_local_file(file, err, sign)
+   if err then
+      return nil, err
+   end
+   local sigfile
+   if sign then
+      sigfile, err = signing.sign_file(file)
+      util.printout()
+   end
+   util.printout("Packed: "..file)
+   if sigfile then
+      util.printout("Signature stored in: "..sigfile)
+   end
+   if err then
+      return nil, err
+   end
+   return true
+end
+
+function pack.pack_binary_rock(name, namespace, version, sign, 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
+   local query = queries.new(rname, namespace, rversion)
+   local file, err = pack.pack_installed_rock(query, temp_dir)
+   return pack.report_and_sign_local_file(file, err, sign)
+end
+
+return pack
diff --git a/src/luarocks/search.tl b/src/luarocks/search.tl
index 5681fa54..3737b26a 100644
--- a/src/luarocks/search.tl
+++ b/src/luarocks/search.tl
@@ -254,7 +254,7 @@ function search.find_suitable_rock(query: Query): string, string, string
    end
 end
 
-function search.find_rock_checking_lua_versions(query: Query, check_lua_versions): string, string
+function search.find_rock_checking_lua_versions(query: Query, check_lua_versions: boolean): string, string
    local url, err, errcode = search.find_suitable_rock(query)
    if url then
       return url
@@ -304,7 +304,7 @@ function search.find_rock_checking_lua_versions(query: Query, check_lua_versions
    return nil, err
 end
 
-function search.find_src_or_rockspec(name: string, namespace: string, version: string, check_lua_versions): string, string
+function search.find_src_or_rockspec(name: string, namespace: string, version: string, check_lua_versions: boolean): string, string
    local query = queries.new(name, namespace, version, false, "src|rockspec")
    local url, err = search.find_rock_checking_lua_versions(query, check_lua_versions)
    if not url then