remove old dep. manifest function

Author: mnicky

dist/depends.lua

@@ -767,103 +767,3 @@ function update_dependency_manifest(pkg, installed, to_install, dep_manifest)
 
     return dep_manifest
 end
-
--- Returns manifest with information about dependencies of given module
--- table 'dep_manifest' contains infromation about relevant modules and will be returned
--- table 'dep_cache' contains all information collected so far and is used like a cache
-function dependency_manifest(module, dep_manifest, dep_cache)
-    dep_manifest = dep_manifest or {}
-    dep_cache = dep_cache or {}
-    assert(type(module) == "string", "depends.dependency_manifest: Argument 'module' is not a string.")
-    assert(type(dep_cache) == "table", "depends.dependency_manifest: Argument 'dep_cache' is not a table.")
-    assert(type(dep_manifest) == "table", "depends.dependency_manifest: Argument 'dep_manifest' is not a table.")
-
-    local dep_manifest = utils.deepcopy(dep_manifest)
-    local dep_cache = utils.deepcopy(dep_cache)
-    local name, constraint = split_name_constraint(module)
-    local name_ver = name .. (constraint and "-" .. constraint or "")
-
-    -- if info about the module is in cache and cache not disabled, use it
-    if constraint and dep_cache[name_ver] and cfg.dep_cache then
-        dep_manifest[name_ver] = dep_cache[name_ver]
-    else
-        local manifest, err = mf.get_manifest()
-        if not manifest then return nil, "Error when getting manifest: " .. err end
-
-        -- find out available versions of package
-        local versions, err = package.retrieve_versions(name, manifest, not cfg.debug)
-        if not versions then return nil, err end
-
-        for _, version in pairs(versions) do
-            table.insert(manifest, version)
-        end
-
-        -- find the module's package
-        local candidates = find_packages(name_ver, manifest)
-        if #candidates == 0 then return nil, "Package '" .. name_ver .. "' not found." end
-
-        candidates = sort_by_versions(candidates)
-        name_ver = candidates[1].name .. "-" .. candidates[1].version
-
-        -- if info about the module isn't in cache or cache disabled, download it
-        if dep_cache[name_ver] and cfg.dep_cache then
-             dep_manifest[name_ver] = dep_cache[name_ver]
-        else
-            -- download the dependency info
-            local download_dir = sys.abs_path(sys.make_path(cfg.root_dir, cfg.temp_dir))
-            local downloaded_pkg, err = package.fetch_pkg(candidates[1], download_dir, not cfg.debug)
-            if not downloaded_pkg then return nil, err end
-
-            local distinfo = sys.make_path(downloaded_pkg.download_dir, "dist.info")
-            local dist_info, err = mf.load_distinfo(distinfo)
-            if not dist_info then return nil, "Error when loading dist.info file '" .. distinfo .. "': " .. err end
-
-            -- add information about this package to the cache
-            if not dep_manifest[name_ver] then dep_manifest[name_ver] = {} end
-            dep_manifest[name_ver].name = dist_info.name
-            dep_manifest[name_ver].version = dist_info.version
-            dep_manifest[name_ver].path = candidates[1].path
-            dep_manifest[name_ver].depends = dist_info.depends
-
-            -- add also to cache
-            dep_cache[name_ver] = dep_manifest[name_ver]
-        end
-    end
-
-    -- resolve dependencies
-    if dep_manifest[name_ver].depends then
-
-        if not dep_manifest[name_ver].satisfied_by then
-            dep_manifest[name_ver].satisfied_by = {}
-        end
-
-        -- collect all OS specific dependencies of pkg
-        for k, dep in pairs(dep_manifest[name_ver].depends) do
-            if type(dep) == "table" then
-                if k == cfg.arch then
-                    for _, os_specific_depend in pairs(dep) do
-                        table.insert(dep_manifest[name_ver].depends, os_specific_depend)
-                    end
-                end
-            end
-        end
-
-        -- get dependency information of this module's dependencies
-        for _, dep in ipairs(dep_manifest[name_ver].depends) do
-            if type(dep) ~= "table" then
-                local satisfying = dep_manifest[name_ver].satisfied_by[dep]
-                if satisfying then dep = satisfying end
-
-                dep_manifest, dep_cache_or_err, satisfying = dependency_manifest(dep, dep_manifest, dep_cache)
-                if not dep_manifest then return nil, dep_cache_or_err end
-                dep_cache = dep_cache_or_err
-
-                -- add 'satisfied-by' info
-                dep_manifest[name_ver].satisfied_by[dep] = satisfying
-                dep_cache[name_ver].satisfied_by[dep] = satisfying
-            end
-        end
-    end
-
-    return dep_manifest, dep_cache, name_ver
-end