-- Working with manifest and dist.info files
|
|
module ("dist.manifest", package.seeall)
|
|
local cfg = require "dist.config"
|
local git = require "dist.git"
|
local sys = require "dist.sys"
|
local utils = require "dist.utils"
|
|
-- Return the manifest table from 'manifest_file'. If the manifest is in cache,
|
-- then the cached version is used. You can set the cache timeout value in
|
-- 'config.cache_timeout' variable.
|
-- If optional 'force_no_cache' parameter is true, then the cache is not used.
|
function get_manifest(manifest_file, force_no_cache)
|
manifest_file = manifest_file or sys.make_path(cfg.root_dir, cfg.manifest_file)
|
force_no_cache = force_no_cache or false
|
|
assert(type(manifest_file) == "string", "manifest.get_manifest: Argument 'manifest_file' is not a string.")
|
assert(type(force_no_cache) == "boolean", "manifest.get_manifest: Argument 'force_no_cache' is not a boolean.")
|
manifest_file = sys.abs_path(manifest_file)
|
|
-- download new manifest to the cache if not present or cache not used or cache expired
|
if not sys.exists(manifest_file) or force_no_cache or not cfg.cache or utils.cache_timeout_expired(cfg.cache_timeout, manifest_file) then
|
local manifest_dest = sys.parent_dir(manifest_file) or sys.current_dir()
|
local ok, err = download_manifest(manifest_dest, cfg.repos)
|
if not ok then return nil, "Error when downloading manifest: " .. err end
|
end
|
|
-- load manifest from cache
|
local status, ret = load_manifest(manifest_file)
|
if not status then return nil, "Error when loading manifest: " .. ret end
|
|
return ret
|
end
|
|
-- Download manifest from the table of git 'repository_urls' to 'dest_dir' and return true on success
|
-- and nil and error message on error.
|
function download_manifest(dest_dir, repository_urls)
|
dest_dir = dest_dir or sys.make_path(cfg.root_dir, cfg.cache_dir)
|
repository_urls = repository_urls or cfg.repos
|
if type(repository_urls) == "string" then repository_urls = {repository_urls} end
|
|
assert(type(dest_dir) == "string", "manifest.download_manifest: Argument 'dest_dir' is not a string.")
|
assert(type(repository_urls) == "table", "manifest.download_manifest: Argument 'repository_urls' is not a table or string.")
|
dest_dir = sys.abs_path(dest_dir)
|
|
-- define used files and directories
|
local manifest_filename = sys.extract_name(cfg.manifest_file)
|
local manifest_file = sys.make_path(dest_dir, manifest_filename)
|
local temp_dir = sys.make_path(cfg.root_dir, cfg.temp_dir)
|
|
-- ensure that destination directory exists
|
local ok, err = sys.make_dir(dest_dir)
|
if not ok then return nil, err end
|
|
-- retrieve manifests from repositories and collect them into one manifest table
|
local manifest = {}
|
|
if #repository_urls == 0 then return nil, "No repository url specified." end
|
|
print("Downloading repository information...")
|
for k, repo in pairs(repository_urls) do
|
local clone_dir = sys.make_path(temp_dir, "repository_" .. tostring(k))
|
|
-- clone the repo and add its '.gitmodules' file to the manifest table
|
|
ok, err = git.create_repo(clone_dir)
|
|
local sha
|
if ok then sha, err = git.fetch_branch(clone_dir, repo, "master") end
|
if sha then ok, err = git.checkout_sha(sha, clone_dir) end
|
|
if not (ok and sha) then
|
if not cfg.debug then sys.delete(clone_dir) end
|
return nil, "Error when downloading the manifest from repository with url: '" .. repo .. "': " .. err
|
else
|
for _, pkg in pairs(load_gitmodules(sys.make_path(clone_dir, ".gitmodules"))) do
|
table.insert(manifest, pkg)
|
end
|
end
|
if not cfg.debug then sys.delete(clone_dir) end
|
end
|
|
-- save the new manifest table to the file
|
ok, err = save_manifest(manifest, manifest_file)
|
if not ok then return nil, err end
|
|
return true
|
end
|
|
-- A secure loadfile function
|
-- If file code chunk has upvalues, the first upvalue is set to the given
|
-- environement, if that parameter is given, or to the value of the global environment.
|
local function secure_loadfile(file, env)
|
assert(type(file) == "string", "secure_loadfile: Argument 'file' is not a string.")
|
|
-- use the given (or create a new) restricted environment
|
local env = env or {}
|
|
-- load the file and run in a protected call with the restricted env
|
-- setfenv is deprecated in lua 5.2 in favor of giving env in arguments
|
-- the additional loadfile arguments are simply ignored for previous lua versions
|
local f, err = loadfile(file, 'bt', env)
|
if f then
|
if setfenv ~= nil then
|
setfenv(f, env)
|
end
|
return pcall(f)
|
else
|
return nil, err
|
end
|
end
|
|
-- Load and return manifest table from the manifest file.
|
-- If manifest file not present, return nil.
|
function load_manifest(manifest_file)
|
manifest_file = manifest_file or sys.make_path(cfg.root_dir, cfg.manifest_file)
|
|
return secure_loadfile(sys.abs_path(manifest_file))
|
end
|
|
-- Load '.gitmodules' file and returns manifest table.
|
-- If the file is not present, return nil.
|
function load_gitmodules(gitmodules_file)
|
gitmodules_file = gitmodules_file or sys.make_path(cfg.root_dir, cfg.manifest_file)
|
assert(type(gitmodules_file) == "string", "manifest.load_gitmodules: Argument 'gitmodules_file' is not a string.")
|
gitmodules_file = sys.abs_path(gitmodules_file)
|
|
if sys.exists(gitmodules_file) then
|
-- load the .gitmodules file
|
local file, err = io.open(gitmodules_file, "r")
|
if not file then return nil, "Error when opening the .gitmodules file '" .. gitmodules_file .. "':" .. err end
|
|
local mf_text = file:read("*a")
|
file:close()
|
if not mf_text then return nil, "Error when reading the .gitmodules file '" .. gitmodules_file .. "':" .. err end
|
|
manifest = {}
|
for url in mf_text:gmatch("git://%S+/%S+") do
|
pkg = {name = url:match("git://%S+/(%S+)%.git") or url:match("git://%S+/(%S+)"), version = "scm", path = url}
|
table.insert(manifest, pkg)
|
end
|
|
return manifest
|
else
|
return nil, "Error when loading the .gitmodules: file '" .. gitmodules_file .. "' doesn't exist."
|
end
|
end
|
|
-- Save manifest table to the 'file'
|
function save_manifest(manifest_table, file)
|
assert(type(manifest_table) == "table", "manifest.save_distinfo: Argument 'manifest_table' is not a table.")
|
assert(type(file) == "string", "manifest.save_distinfo: Argument 'file' is not a string.")
|
file = sys.abs_path(file)
|
|
-- Print table 'tbl' to io stream 'file'.
|
local function print_table(file, tbl, in_nested_table)
|
for k, v in pairs(tbl) do
|
-- print key
|
if in_nested_table then file:write("\t\t") end
|
if type(k) ~= "number" then
|
file:write("['" .. k .. "']" .. " = ")
|
end
|
-- print value
|
if type(v) == "table" then
|
file:write("{\n")
|
print_table(file, v, true)
|
if in_nested_table then file:write("\t") end
|
file:write("\t}")
|
else
|
if in_nested_table then file:write("\t") end
|
if type(v) == "string" then
|
file:write('[[' .. v .. ']]')
|
else
|
file:write(tostring(v))
|
end
|
end
|
file:write(",\n")
|
end
|
end
|
|
local manifest_file = io.open(file, "w")
|
if not manifest_file then return nil, "Error when saving manifest: cannot open the file '" .. file .. "'." end
|
|
manifest_file:write('return {\n')
|
print_table(manifest_file, manifest_table)
|
manifest_file:write('},\ntrue')
|
manifest_file:close()
|
|
return true
|
end
|
|
-- Load and return package info table from the distinfo_file file.
|
-- If file not present, return nil.
|
function load_distinfo(distinfo_file)
|
assert(type(distinfo_file) == "string", "manifest.load_distinfo: Argument 'distinfo_file' is not a string.")
|
distinfo_file = sys.abs_path(distinfo_file)
|
|
-- load the distinfo file
|
local distinfo_env = {}
|
local status, ret = secure_loadfile(distinfo_file, distinfo_env)
|
if not status then return nil, "Error when loading package info: " .. ret end
|
|
return distinfo_env
|
end
|
|
-- Save distinfo table to the 'file'
|
function save_distinfo(distinfo_table, file)
|
assert(type(distinfo_table) == "table", "manifest.save_distinfo: Argument 'distinfo_table' is not a table.")
|
assert(type(file) == "string", "manifest.save_distinfo: Argument 'file' is not a string.")
|
file = sys.abs_path(file)
|
|
-- Print table 'tbl' to io stream 'file'.
|
local function print_table(file, tbl, in_nested_table)
|
for k, v in pairs(tbl) do
|
-- print key
|
if type(k) ~= "number" then
|
file:write(k .. " = ")
|
end
|
-- print value
|
if type(v) == "table" then
|
file:write("{\n")
|
print_table(file, v, true)
|
file:write("}\n")
|
elseif type(v) == "string" then
|
if in_nested_table then
|
file:write('[[' .. v .. ']]')
|
else
|
file:write('"' .. v .. '"')
|
end
|
else
|
file:write(v)
|
end
|
if in_nested_table then
|
file:write(",")
|
end
|
file:write("\n")
|
end
|
end
|
|
local distinfo_file = io.open(file, "w")
|
if not distinfo_file then return nil, "Error when saving dist-info table: cannot open the file '" .. file .. "'." end
|
|
print_table(distinfo_file, distinfo_table)
|
distinfo_file:close()
|
|
return true
|
end
|
