Removed the old remote loading code

src/dds/catalog/catalog.hpp

@@ -2,7 +2,6 @@
 
 #include <dds/deps.hpp>
 #include <dds/package_id.hpp>
-#include <dds/repo/remote.hpp>
 #include <dds/util/fs.hpp>
 #include <dds/catalog/git.hpp>
 
@@ -11,6 +10,7 @@
 #include <neo/sqlite3/statement_cache.hpp>
 #include <neo/sqlite3/transaction.hpp>
 
+#include <variant>
 #include <vector>
 
 namespace dds {

src/dds/dds.main.cpp

@@ -1,7 +1,6 @@
 #include <dds/build.hpp>
 #include <dds/catalog/catalog.hpp>
 #include <dds/catalog/get.hpp>
-#include <dds/repo/remote.hpp>
 #include <dds/repo/repo.hpp>
 #include <dds/sdist.hpp>
 #include <dds/toolchain/from_dds.hpp>

src/dds/repo/remote.cpp

@@ -1,135 +0,0 @@
-#include "./remote.hpp"
-
-#include <dds/deps.hpp>
-#include <dds/proc.hpp>
-#include <dds/repo/repo.hpp>
-#include <dds/sdist.hpp>
-#include <dds/temp.hpp>
-#include <dds/toolchain/toolchain.hpp>
-#include <dds/util/shlex.hpp>
-
-#include <spdlog/spdlog.h>
-
-#include <libman/parse.hpp>
-
-#include <algorithm>
-
-using namespace dds;
-
-namespace {
-
-struct read_listing_item {
-    std::string_view                                    _key;
-    std::set<remote_listing, remote_listing_compare_t>& out;
-
-    bool operator()(std::string_view context, std::string_view key, std::string_view value) {
-        if (key != _key) {
-            return false;
-        }
-
-        auto nested = lm::nested_kvlist::parse(value);
-        auto pk_id  = package_id::parse(nested.primary);
-        put_listing(context, std::move(pk_id), nested.pairs);
-        return true;
-    }
-
-    void put_listing(std::string_view context, package_id pk_id, const lm::pair_list& pairs) {
-        if (pairs.find("git")) {
-            std::string              url;
-            std::string              ref;
-            std::optional<lm::usage> auto_id;
-            lm::read(fmt::format("{}: Parsing Git remote listing", context),
-                     pairs,
-                     lm::read_required("url", url),
-                     lm::read_required("ref", ref),
-                     lm::read_check_eq("git", ""),
-                     lm::read_opt("auto", auto_id, &lm::split_usage_string),
-                     lm::reject_unknown());
-            auto did_insert = out.emplace(remote_listing{std::move(pk_id),
-                                                         git_remote_listing{url, ref, auto_id}})
-                                  .second;
-            if (!did_insert) {
-                spdlog::warn("Duplicate remote package defintion for {}", pk_id.to_string());
-            }
-        } else {
-            throw std::runtime_error(
-                fmt::format("Unable to determine remote type of package {}", pk_id.to_string()));
-        }
-    }
-};
-
-temporary_sdist do_pull_sdist(const remote_listing& listing, const git_remote_listing& git) {
-    auto tmpdir = dds::temporary_dir::create();
-    using namespace std::literals;
-    spdlog::info("Cloning repository: {} [{}] ...", git.url, git.ref);
-    auto command = {"git"s,
-                    "clone"s,
-                    "--depth=1"s,
-                    "--branch"s,
-                    git.ref,
-                    git.url,
-                    tmpdir.path().generic_string()};
-    auto git_res = run_proc(command);
-    if (!git_res.okay()) {
-        throw std::runtime_error(
-            fmt::format("Git clone operation failed [Git command: {}] [Exitted {}]:\n{}",
-                        quote_command(command),
-                        git_res.retc,
-                        git_res.output));
-    }
-    spdlog::info("Create sdist from clone ...");
-    if (git.auto_lib.has_value()) {
-        spdlog::info("Generating library data automatically");
-        auto pkg_strm = dds::open(tmpdir.path() / "package.dds", std::ios::binary | std::ios::out);
-        pkg_strm << "Name: " << listing.pk_id.name << '\n'                    //
-                 << "Version: " << listing.pk_id.version.to_string() << '\n'  //
-                 << "Namespace: " << git.auto_lib->namespace_;
-        auto lib_strm = dds::open(tmpdir.path() / "library.dds", std::ios::binary | std::ios::out);
-        lib_strm << "Name: " << git.auto_lib->name;
-    }
-
-    sdist_params params;
-    params.project_dir = tmpdir.path();
-    auto sd_tmp_dir    = dds::temporary_dir::create();
-    params.dest_path   = sd_tmp_dir.path();
-    params.force       = true;
-    auto sd            = create_sdist(params);
-    return {sd_tmp_dir, sd};
-}
-
-}  // namespace
-
-temporary_sdist remote_listing::pull_sdist() const {
-    auto tsd = visit([&](auto&& actual) { return do_pull_sdist(*this, actual); });
-    if (!(tsd.sdist.manifest.pk_id == pk_id)) {
-        throw std::runtime_error(fmt::format(
-            "The package name@version in the generated sdist does not match the name listed in "
-            "the remote listing file (expected '{}', but got '{}')",
-            pk_id.to_string(),
-            tsd.sdist.manifest.pk_id.to_string()));
-    }
-    return tsd;
-}
-
-remote_directory remote_directory::load_from_file(path_ref filepath) {
-    auto        kvs = lm::parse_file(filepath);
-    listing_set listings;
-    lm::read(fmt::format("Loading remote package listing from {}", filepath.string()),
-             kvs,
-             read_listing_item{"Remote-Package", listings},
-             lm::reject_unknown());
-    return {std::move(listings)};
-}
-
-const remote_listing* remote_directory::find(std::string_view name, semver::version ver) const
-    noexcept {
-    auto found = _remotes.find(std::tie(name, ver));
-    if (found == _remotes.end()) {
-        return nullptr;
-    }
-    return &*found;
-}
-
-void remote_directory::ensure_all_local(const repository&) const {
-    spdlog::critical("Dependency download is not fully implemented!");
-}

src/dds/repo/remote.hpp

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <dds/util/fs.hpp>
-
-#include <dds/sdist.hpp>
-#include <dds/temp.hpp>
-#include <dds/catalog/git.hpp>
-#include <dds/catalog/get.hpp>
-
-#include <libman/library.hpp>
-#include <semver/version.hpp>
-
-#include <set>
-#include <string>
-#include <tuple>
-#include <utility>
-#include <variant>
-
-namespace dds {
-
-struct remote_listing {
-    package_id                       pk_id;
-    std::variant<git_remote_listing> remote;
-
-    template <typename Func>
-    decltype(auto) visit(Func&& fn) const {
-        return std::visit(std::forward<Func>(fn), remote);
-    }
-
-    temporary_sdist pull_sdist() const;
-};
-
-inline constexpr struct remote_listing_compare_t {
-    using is_transparent = int;
-    bool operator()(const remote_listing& lhs, const remote_listing& rhs) const {
-        return lhs.pk_id < rhs.pk_id;
-    }
-    template <typename Name, typename Version>
-    bool operator()(const remote_listing& lhs, const std::tuple<Name, Version>& rhs) const {
-        auto&& [name, ver] = rhs;
-        return lhs.pk_id < package_id{name, ver};
-    }
-    template <typename Name, typename Version>
-    bool operator()(const std::tuple<Name, Version>& lhs, const remote_listing& rhs) const {
-        auto&& [name, ver] = lhs;
-        return package_id{name, ver} < rhs.pk_id;
-    }
-} remote_listing_compare;
-
-class remote_directory {
-    using listing_set = std::set<remote_listing, remote_listing_compare_t>;
-    listing_set _remotes;
-
-    remote_directory(listing_set s)
-        : _remotes(std::move(s)) {}
-
-public:
-    static remote_directory load_from_file(path_ref);
-
-    void ensure_all_local(const class repository& repo) const;
-
-    const remote_listing* find(std::string_view name, semver::version ver) const noexcept;
-};
-
-}  // namespace dds