alunizaje/StartGamedev-160604-osx/tools/zbstudio.app/Contents/ZeroBraneStudio/lualibs/dist/package.lua

-- Package functions

module ("dist.package", package.seeall)

local cfg = require "dist.config"
local git = require "dist.git"
local sys = require "dist.sys"
local mf = require "dist.manifest"
local utils = require "dist.utils"
local depends = require "dist.depends"

-- Return whether the package in given 'pkg_dir' is of a source type.
function is_source_type(pkg_dir)
    assert(type(pkg_dir) == "string", "package.is_source_type: Argument 'pkg_dir' is not a string.")
    pkg_dir = sys.abs_path(pkg_dir)
    return utils.to_boolean(sys.exists(sys.make_path(pkg_dir, "CMakeLists.txt")))
end

-- Ensure proper arch and type for the given source 'dist_info' table and return it.
-- WARNING: this function should be used only for 'dist_info' tables of modules that are of a source type!
function ensure_source_arch_and_type(dist_info)
    assert(type(dist_info) == "table", "package.ensure_source_arch_and_type: Argument 'dist_info' is not a table.")
    dist_info.arch = dist_info.arch or "Universal"
    dist_info.type = dist_info.type or "source"
    return dist_info
end

-- Remove package from 'pkg_distinfo_dir' of 'deploy_dir'.
function remove_pkg(pkg_distinfo_dir, deploy_dir)
    deploy_dir = deploy_dir or cfg.root_dir
    assert(type(pkg_distinfo_dir) == "string", "package.remove_pkg: Argument 'pkg_distinfo_dir' is not a string.")
    assert(type(deploy_dir) == "string", "package.remove_pkg: Argument 'deploy_dir' is not a string.")
    deploy_dir = sys.abs_path(deploy_dir)

    local abs_pkg_distinfo_dir = sys.make_path(deploy_dir, pkg_distinfo_dir)

    -- check for 'dist.info'
    local info, err = mf.load_distinfo(sys.make_path(abs_pkg_distinfo_dir, "dist.info"))
    if not info then return nil, "Error removing package from '" .. pkg_distinfo_dir .. "' - it doesn't contain valid 'dist.info' file." end
    if not info.files then return nil, "File '" .. sys.make_path(pkg_distinfo_dir, "dist.info") .."' doesn't contain list of installed files." end

    -- remove files installed as components of this package
    for _, component in ipairs(cfg.components) do
        if info.files[component] then
            for i = #info.files[component], 1, -1 do
                local f = info.files[component][i]
                f = sys.make_path(deploy_dir,f)
                if sys.is_file(f) then
                    sys.delete(f)
                elseif sys.is_dir(f) then
                    local dir_files, err = sys.get_file_list(f)
                    if not dir_files then return nil, "Error removing package in '" .. abs_pkg_distinfo_dir .. "': " .. err end
                    if #dir_files == 0 then sys.delete(f) end
                end
                -- delete also all parent directories if empty
                local parents = sys.parents_up_to(f, deploy_dir)
                for _, parent in ipairs(parents) do
                    if sys.is_dir(parent) then
                        local dir_files, err = sys.get_file_list(parent)
                        if not dir_files then return nil, "Error removing package in '" .. abs_pkg_distinfo_dir .. "': " .. err end
                        if #dir_files == 0 then
                            sys.delete(parent)
                        end
                    end
                end
            end
        end
    end

    -- remove removed components also from 'dist.info'
    for _, component in ipairs(cfg.components) do
        info.files[component] = nil
    end

    -- delete the package information from deploy_dir
    local ok = sys.delete(abs_pkg_distinfo_dir)
    if not ok then return nil, "Error removing package in '" .. abs_pkg_distinfo_dir .. "'." end

    -- if the package was not completely removed (e.g. some components remain),
    -- save the new version of its 'dist.info'
    local comp_num = 0
    for _, _ in pairs(info.files) do comp_num  = comp_num + 1 end
    if comp_num ~= 0 then
        sys.make_dir(abs_pkg_distinfo_dir)
        local ok, err = mf.save_distinfo(info, sys.make_path(abs_pkg_distinfo_dir, "dist.info"))
        if not ok then return nil, "Error resaving the 'dist.info': " .. err end
    end

    return ok
end

-- Install package from 'pkg_dir' to 'deploy_dir', using optional CMake 'variables'.
-- Optional 'preserve_pkg_dir' argument specified whether to preserve the 'pkg_dir'.
function install_pkg(pkg_dir, deploy_dir, variables, preserve_pkg_dir)
    deploy_dir = deploy_dir or cfg.root_dir
    variables = variables or {}
    preserve_pkg_dir = preserve_pkg_dir or false

    assert(type(pkg_dir) == "string", "package.install_pkg: Argument 'pkg_dir' is not a string.")
    assert(type(deploy_dir) == "string", "package.install_pkg: Argument 'deploy_dir' is not a string.")
    assert(type(variables) == "table", "package.install_pkg: Argument 'variables' is not a table.")
    assert(type(preserve_pkg_dir) == "boolean", "package.install_pkg: Argument 'preserve_pkg_dir' is not a boolean.")

    pkg_dir = sys.abs_path(pkg_dir)
    deploy_dir = sys.abs_path(deploy_dir)

    -- check for dist.info
    local info, err = mf.load_distinfo(sys.make_path(pkg_dir, "dist.info"))
    if not info then return nil, "Error installing: the directory '" .. pkg_dir .. "' doesn't exist or doesn't contain valid 'dist.info' file." end

    -- check if the package is source
    if is_source_type(pkg_dir) then info = ensure_source_arch_and_type(info) end

    -- check package's architecture
    if not (info.arch == "Universal" or info.arch == cfg.arch) then
        return nil, "Error installing '" .. info.name .. "-" .. info.version .. "': architecture '" .. info.arch .. "' is not suitable for this machine."
    end

    -- check package's type
    if not (info.type == "all" or info.type == "source" or info.type == cfg.type) then
        return nil, "Error installing '" .. info.name .. "-" .. info.version .. "': architecture type '" .. info.type .. "' is not suitable for this machine."
    end

    local ok, err

    -- if package is of binary type, just deploy it
    if info.type ~= "source" then
        ok, err = deploy_binary_pkg(pkg_dir, deploy_dir)

    -- else build and then deploy
    else

        -- check if we have cmake
        ok = utils.system_dependency_available("cmake", "cmake --version")
        if not ok then return nil, "Error when installing: Command 'cmake' not available on the system." end

        -- set cmake variables
        local cmake_variables = {}

        -- set variables from config file
        for k, v in pairs(cfg.variables) do
            cmake_variables[k] = v
        end

        -- set variables specified as argument
        for k, v in pairs(variables) do
            cmake_variables[k] = v
        end

        cmake_variables.CMAKE_INCLUDE_PATH = table.concat({cmake_variables.CMAKE_INCLUDE_PATH or "", sys.make_path(deploy_dir, "include")}, ";")
        cmake_variables.CMAKE_LIBRARY_PATH = table.concat({cmake_variables.CMAKE_LIBRARY_PATH or "", sys.make_path(deploy_dir, "lib"), sys.make_path(deploy_dir, "bin")}, ";")
        cmake_variables.CMAKE_PROGRAM_PATH = table.concat({cmake_variables.CMAKE_PROGRAM_PATH or "", sys.make_path(deploy_dir, "bin")}, ";")

        -- build the package and deploy it
        ok, err = build_pkg(pkg_dir, deploy_dir, cmake_variables)
        if not ok then return nil, err end

    end

    -- delete directory of fetched package
    if not (cfg.debug or preserve_pkg_dir) then sys.delete(pkg_dir) end

    return ok, err
end

-- Build and deploy package from 'src_dir' to 'deploy_dir' using 'variables'.
-- Return directory to which the package was built or nil on error.
-- 'variables' is table of optional CMake variables.
function build_pkg(src_dir, deploy_dir, variables)
    deploy_dir = deploy_dir or cfg.root_dir
    variables = variables or {}

    assert(type(src_dir) == "string", "package.build_pkg: Argument 'src_dir' is not a string.")
    assert(type(deploy_dir) == "string", "package.build_pkg: Argument 'deploy_dir' is not a string.")
    assert(type(variables) == "table", "package.build_pkg: Argument 'variables' is not a table.")

    src_dir = sys.abs_path(src_dir)
    deploy_dir = sys.abs_path(deploy_dir)

    -- check for dist.info
    local info, err = mf.load_distinfo(sys.make_path(src_dir, "dist.info"))
    if not info then return nil, "Error building package from '" .. src_dir .. "': it doesn't contain valid 'dist.info' file." end
    local pkg_name = info.name .. "-" .. info.version

    -- set machine information
    info.arch = cfg.arch
    info.type = cfg.type

    -- create CMake build dir
    local cmake_build_dir = sys.abs_path(sys.make_path(deploy_dir, cfg.temp_dir, pkg_name .. "-CMake-build"))
    sys.make_dir(cmake_build_dir)

    -- create cmake cache
    variables["CMAKE_INSTALL_PREFIX"] = deploy_dir
    local cache_file = io.open(sys.make_path(cmake_build_dir, "cache.cmake"), "w")
    if not cache_file then return nil, "Error creating CMake cache file in '" .. cmake_build_dir .. "'" end

    -- Fill in cache variables
    for k,v in pairs(variables) do
        cache_file:write("SET(" .. k .. " " .. sys.quote(v):gsub("\\+", "/") .. " CACHE STRING \"\" FORCE)\n")
    end

    -- If user cache file is provided then append it
    if cfg.cache_file ~= "" then
        local user_cache = io.open(sys.abs_path(cfg.cache_file), "r")
        if user_cache then
            cache_file:write(user_cache:read("*all").."\n")
            user_cache:close()
        end
    end
    cache_file:close()

    src_dir = sys.abs_path(src_dir)
    print("Building " .. sys.extract_name(src_dir) .. "...")

    -- set cmake cache command
    local cache_command = cfg.cache_command
    if cfg.debug then cache_command = cache_command .. " " .. cfg.cache_debug_options end

    -- set cmake build command
    local build_command = cfg.build_command
    if cfg.debug then build_command = build_command .. " " .. cfg.build_debug_options end

    -- set the cmake cache
    local ok = sys.exec("cd " .. sys.quote(cmake_build_dir) .. " && " .. cache_command .. " " .. sys.quote(src_dir))
    if not ok then return nil, "Error preloading the CMake cache script '" .. sys.make_path(cmake_build_dir, "cache.cmake") .. "'" end

    -- build with cmake
    ok = sys.exec("cd " .. sys.quote(cmake_build_dir) .. " && " .. build_command)
    if not ok then return nil, "Error building with CMake in directory '" .. cmake_build_dir .. "'" end

    -- if this is only simulation, exit sucessfully, skipping the next actions
    if cfg.simulate then
        return true, "Simulated build and deployment of package '" .. pkg_name .. "' sucessfull."
    end

    -- table to collect files installed in the components
    info.files = {}

    -- install the components
    for _, component in ipairs(cfg.components) do
        local strip_option = ""
        if not cfg.debug and component ~= "Library" then strip_option = cfg.strip_option end

        local ok = sys.exec("cd " .. sys.quote(cmake_build_dir) .. " && " .. cfg.cmake .. " " .. strip_option .. " " ..cfg.install_component_command:gsub("#COMPONENT#", component))

        if not ok then return nil, "Error when installing the component '" .. component .. "' with CMake in directory '" .. cmake_build_dir .. "'" end

        local install_mf = sys.make_path(cmake_build_dir, "install_manifest_" .. component .. ".txt")
        local mf, err
        local component_files = {}

        -- collect files installed in this component
        if sys.exists(install_mf) then
            mf, err = io.open(install_mf, "r")
            if not mf then return nil, "Error when opening the CMake installation manifest '" .. install_mf .. "': " .. err end
            for line in mf:lines() do
                line = sys.check_separators(line)
                local file = line:gsub(utils.escape_magic(deploy_dir .. sys.path_separator()), "")
                table.insert(component_files, file)
            end
            mf:close()

            -- add list of component files to the 'dist.info'
            if #component_files > 0 then info.files[component] = component_files end
        end
    end
--    if bookmark == 0 then return nil, "Package did not install any files!" end

    -- test with ctest
    if cfg.test then
        print("Testing " .. sys.extract_name(src_dir) .. " ...")
        ok = sys.exec("cd " .. sys.quote(deploy_dir) .. " && " .. cfg.test_command)
        if not ok then return nil, "Error when testing the module '" .. pkg_name .. "' with CTest." end
    end

    -- save modified 'dist.info' file
    local pkg_distinfo_dir = sys.make_path(deploy_dir, cfg.distinfos_dir, pkg_name)
    sys.make_dir(pkg_distinfo_dir)
    ok, err = mf.save_distinfo(info, sys.make_path(pkg_distinfo_dir, "dist.info"))
    if not ok then return nil, err end

    -- clean up
    if not cfg.debug then sys.delete(cmake_build_dir) end

    return true, "Package '" .. pkg_name .. "' successfully builded and deployed to '" .. deploy_dir .. "'."
end

-- Deploy binary package from 'pkg_dir' to 'deploy_dir' by copying.
function deploy_binary_pkg(pkg_dir, deploy_dir)
    deploy_dir = deploy_dir or cfg.root_dir

    assert(type(pkg_dir) == "string", "package.deploy_binary_pkg: Argument 'pkg_dir' is not a string.")
    assert(type(deploy_dir) == "string", "package.deploy_binary_pkg: Argument 'deploy_dir' is not a string.")

    pkg_dir = sys.abs_path(pkg_dir)
    deploy_dir = sys.abs_path(deploy_dir)

    -- check for dist.info
    local info, err = mf.load_distinfo(sys.make_path(pkg_dir, "dist.info"))
    if not info then return nil, "Error deploying package from '" .. pkg_dir .. "': it doesn't contain valid 'dist.info' file." end
    local pkg_name = info.name .. "-" .. info.version

    -- if this is only simulation, exit sucessfully, skipping the next actions
    if cfg.simulate then
        return true, "Simulated deployment of package '" .. pkg_name .. "' sucessfull."
    end

    -- copy all components of the module to the deploy_dir
    for _, component in ipairs(cfg.components) do
        if info.files[component] then
            for _, file in ipairs(info.files[component]) do
                local dest_dir = sys.make_path(deploy_dir, sys.parent_dir(file))

                local ok, err = sys.make_dir(dest_dir)
                if not ok then return nil, "Error when deploying package '" .. pkg_name .. "': cannot create directory '" .. dest_dir .. "': " .. err end

                ok, err = sys.copy(sys.make_path(pkg_dir, file), dest_dir)
                if not ok then return nil, "Error when deploying package '" .. pkg_name .. "': cannot copy file '" .. file .. "' to the directory '" .. dest_dir .. "': " .. err end
            end
        end
    end

    -- copy dist.info to register the module as installed
    local pkg_distinfo_dir = sys.make_path(deploy_dir, cfg.distinfos_dir, pkg_name)
    sys.make_dir(pkg_distinfo_dir)
    ok, err = mf.save_distinfo(info, sys.make_path(pkg_distinfo_dir, "dist.info"))
    if not ok then return nil, err end

    return true, "Package '" .. pkg_name .. "' successfully deployed to '" .. deploy_dir .. "'."
end

-- Fetch package (table 'pkg') to download_dir. Return the original 'pkg' table
-- with 'pkg.download_dir' containing path to the directory of the
-- downloaded package.
--
-- When optional 'suppress_printing' parameter is set to true, then messages
-- for the user won't be printed during run of this function.
--
-- If the 'pkg' already contains the information about download directory (pkg.download_dir),
-- we assume the package was already downloaded there and won't download it again.
function fetch_pkg(pkg, download_dir, suppress_printing)
    download_dir = download_dir or sys.current_dir()
    suppress_printing = suppress_printing or false
    assert(type(pkg) == "table", "package.fetch_pkg: Argument 'pkg' is not a table.")
    assert(type(download_dir) == "string", "package.fetch_pkg: Argument 'download_dir' is not a string.")
    assert(type(suppress_printing) == "boolean", "package.fetch_pkg: Argument 'suppress_printing' is not a boolean.")
    assert(type(pkg.name) == "string", "package.fetch_pkg: Argument 'pkg.name' is not a string.")
    assert(type(pkg.version) == "string", "package.fetch_pkg: Argument 'pkg.version' is not a string.")

    -- if the package is already downloaded don't download it again
    if pkg.download_dir then return pkg end

    assert(type(pkg.path) == "string", "package.fetch_pkg: Argument 'pkg.path' is not a string.")
    download_dir = sys.abs_path(download_dir)

    local pkg_full_name = pkg.name .. "-" .. pkg.version
    local repo_url = pkg.path
    local clone_dir = sys.abs_path(sys.make_path(download_dir, pkg_full_name))
    pkg.download_dir = clone_dir

    -- check if download_dir already exists, assuming the package was already downloaded
    if sys.exists(sys.make_path(clone_dir, "dist.info")) then
        if cfg.cache and not utils.cache_timeout_expired(cfg.cache_timeout, clone_dir) then
            if not suppress_printing then print("'" .. pkg_full_name .. "' already in cache, skipping downloading (use '-cache=false' to force download).") end
            return pkg
        else
            sys.delete(sys.make_path(clone_dir))
        end
    end

    local bin_tag = pkg.version .. "-" .. cfg.arch .. "-" .. cfg.type
    local use_binary = false

    if cfg.binary then
        -- check if binary version of the module for this arch & type available
        local avail_tags, err = git.get_remote_tags(repo_url)
        if not avail_tags then return nil, err end

        if utils.contains(avail_tags, bin_tag) then
            use_binary = true
        end
    end

    -- init the git repository
    local ok, err = git.create_repo(clone_dir)
    if not ok then return nil, err end

    -- Fetch the desired ref (from the pkg's remote repo) and checkout into it.

    if use_binary then

        if not suppress_printing then print("Getting " .. pkg_full_name .. " (binary)...") end

        -- We fetch the binary tag.
        local sha
        if ok then sha, err = git.fetch_tag(clone_dir, repo_url, bin_tag) end
        if sha then ok, err = git.checkout_sha(sha, clone_dir) end

    elseif cfg.source then

        if not suppress_printing then print("Getting " .. pkg_full_name .. " (source)...") end

        -- If we want the 'scm' version, we fetch the 'master' branch, otherwise
        -- we fetch the tag, matching the desired package version.
        if ok and pkg.version ~= "scm" then
            local sha
            sha, err = git.fetch_tag(clone_dir, repo_url, pkg.version)
            if sha then ok, err = git.checkout_sha(sha, clone_dir) end
        elseif ok then
            local sha
            sha, err = git.fetch_branch(clone_dir, repo_url, "master")
            if sha then ok, err = git.checkout_sha(sha, clone_dir) end
        end

    else
        ok = false
        if cfg.binary then
            err = "Binary version of module not available and using source modules disabled."
        else
            err = "Using both binary and source modules disabled."
        end
    end

    if not ok then
        -- clean up
        if not cfg.debug then sys.delete(clone_dir) end
        return nil, "Error fetching package '" .. pkg_full_name .. "' from '" .. pkg.path .. "' to '" .. download_dir .. "': " .. err
    end

    -- delete '.git' directory
    if not cfg.debug then sys.delete(sys.make_path(clone_dir, ".git")) end

    return pkg
end

-- Return table with information about available versions of 'package'.
--
-- When optional 'suppress_printing' parameter is set to true, then messages
-- for the user won't be printed during run of this function.
function retrieve_versions(package, manifest, suppress_printing)
    suppress_printing = suppress_printing or false
    assert(type(package) == "string", "package.retrieve_versions: Argument 'string' is not a string.")
    assert(type(manifest) == "table", "package.retrieve_versions: Argument 'manifest' is not a table.")
    assert(type(suppress_printing) == "boolean", "package.retrieve_versions: Argument 'suppress_printing' is not a boolean.")

    -- get package table
    local pkg_name = depends.split_name_constraint(package)
    local tmp_packages = depends.find_packages(pkg_name, manifest)

    if #tmp_packages == 0 then
        return nil, "No suitable candidate for package '" .. package .. "' found."
    else
        package = tmp_packages[1]
    end

    -- if the package's already downloaded, we assume it's desired to install the downloaded version
    if package.download_dir then
        local pkg_type = "binary"
        if is_source_type(package.download_dir) then pkg_type = "source" end
        if not suppress_printing then print("Using " .. package.name .. "-" .. package.version .. " (" .. pkg_type .. ") provided by " .. package.download_dir) end
        return {package}
    end

    if not suppress_printing then print("Finding out available versions of " .. package.name .. "...") end

    -- get available versions
    local tags, err = git.get_remote_tags(package.path)
    if not tags then return nil, "Error when retrieving versions of package '" .. package.name .. "': " .. err end

    -- filter out tags of binary packages
    local versions = utils.filter(tags, function (tag) return tag:match("^[^%-]+%-?[^%-]*$") and true end)

    packages = {}

    -- create package information
    for _, version in pairs(versions) do
        pkg = {}
        pkg.name = package.name
        pkg.version = version
        pkg.path = package.path
        table.insert(packages, pkg)
    end

    return packages
end

-- Return table with information from package's dist.info and path to downloaded
-- package. Optional argument 'deploy_dir' is used just as a temporary
-- place to place the downloaded packages into.
--
-- When optional 'suppress_printing' parameter is set to true, then messages
-- for the user won't be printed during the execution of this function.
function retrieve_pkg_info(package, deploy_dir, suppress_printing)
    deploy_dir = deploy_dir or cfg.root_dir
    assert(type(package) == "table", "package.retrieve_pkg_info: Argument 'package' is not a table.")
    assert(type(deploy_dir) == "string", "package.retrieve_pkg_info: Argument 'deploy_dir' is not a string.")
    deploy_dir = sys.abs_path(deploy_dir)

    local tmp_dir = sys.abs_path(sys.make_path(deploy_dir, cfg.temp_dir))

    -- download the package
    local fetched_pkg, err = fetch_pkg(package, tmp_dir, suppress_printing)
    if not fetched_pkg then return nil, "Error when retrieving the info about '" .. package.name .. "': " .. err end

    -- load information from 'dist.info'
    local info, err = mf.load_distinfo(sys.make_path(fetched_pkg.download_dir, "dist.info"))
    if not info then return nil, err end

    -- add other attributes
    if package.path then info.path = package.path end
    if package.was_scm_version then info.was_scm_version = package.was_scm_version end

    -- set default arch/type if not explicitly stated and package is of source type
    if is_source_type(fetched_pkg.download_dir) then
        info = ensure_source_arch_and_type(info)
    elseif not (info.arch and info.type) then
        return nil, fetched_pkg.download_dir .. ": binary package missing arch or type in 'dist.info'."
    end

    return info, fetched_pkg.download_dir
end

-- Return manifest, augmented with info about all available versions
-- of package 'pkg'. Optional argument 'deploy_dir' is used just as a temporary
-- place to place the downloaded packages into.
-- Optional argument 'installed' is manifest of all installed packages. When
-- specified, info from installed packages won't be downloaded from repo,
-- but the dist.info from installed package will be used.
function get_versions_info(pkg, manifest, deploy_dir, installed)
    deploy_dir = deploy_dir or cfg.root_dir
    assert(type(pkg) == "string", "package.get_versions_info: Argument 'pkg' is not a string.")
    assert(type(manifest) == "table", "package.get_versions_info: Argument 'manifest' is not a table.")
    assert(type(deploy_dir) == "string", "package.get_versions_info: Argument 'deploy_dir' is not a string.")
    deploy_dir = sys.abs_path(deploy_dir)

    -- find all available versions of package
    local versions, err = retrieve_versions(pkg, manifest)
    if not versions then return nil, err end

    -- collect info about all retrieved versions
    local infos = {}
    for _, version in pairs(versions) do

        local info, path_or_err
        local installed_version = {}

        -- find out whether this 'version' is installed so we can use it's dist.info
        if type(installed) == "table" then installed_version = depends.find_packages(version.name .. "-" .. version.version, installed) end

        -- get info
        if #installed_version > 0 then
            print("Using dist.info from installed " .. version.name .. "-" .. version.version)
            info = installed_version[1]
            info.path = version.path
            info.from_installed = true  -- flag that dist.info of installed package was used
        else
            info, path_or_err = retrieve_pkg_info(version, deploy_dir)
            if not info then return nil, path_or_err end
            sys.delete(path_or_err)
        end
        table.insert(infos, info)
    end

    -- found and add an implicit 'scm' version
    local pkg_name = depends.split_name_constraint(pkg)
    local found = depends.find_packages(pkg_name, manifest)
    if #found == 0 then return nil, "No suitable candidate for package '" .. pkg .. "' found." end
    local scm_info, path_or_err = retrieve_pkg_info({name = pkg_name, version = "scm", path = found[1].path})
    if not scm_info then return nil, path_or_err end
    sys.delete(path_or_err)
    scm_info.version = "scm"
    table.insert(infos, scm_info)

    local tmp_manifest = utils.deepcopy(manifest)

    -- add collected info to the temp. manifest, replacing existing tables
    for _, info in pairs(infos) do
        local already_in_manifest = false
        -- find if this version is already in manifest
        for idx, pkg in ipairs(tmp_manifest) do
            -- if yes, replace it
            if pkg.name == info.name and pkg.version == info.version then
                tmp_manifest[idx] = info
                already_in_manifest = true
                break
            end
        end
        -- if not, just normally add to the manifest
        if not already_in_manifest then
            table.insert(tmp_manifest, info)
        end
    end

    return tmp_manifest
end