Move catalog to its own dir, and start adding subcommands for it

src/dds/repo/catalog.cpp → src/dds/catalog/catalog.cpp

 
 void migrate_repodb_1(sqlite3::database& db) {
     db.exec(R"(
-        CREATE TABLE dds_repo_pkgs (
+        CREATE TABLE dds_cat_pkgs (
             pkg_id INTEGER PRIMARY KEY AUTOINCREMENT,
             name TEXT NOT NULL,
             version TEXT NOT NULL,
                     lm_name NOT NULL
                     AND lm_namespace NOT NULL
                 )
-                !=
+                +
                 (
                     lm_name ISNULL
                     AND lm_namespace ISNULL
                 )
+                = 1
             )
         );
 
-        CREATE TABLE dds_repo_pkg_deps (
+        CREATE TABLE dds_cat_pkg_deps (
             dep_id INTEGER PRIMARY KEY AUTOINCREMENT,
-            pkg_id INTEGER NOT NULL REFERENCES dds_repo_pkgs(pkg_id),
+            pkg_id INTEGER NOT NULL REFERENCES dds_cat_pkgs(pkg_id),
             dep_name TEXT NOT NULL,
             low TEXT NOT NULL,
             high TEXT NOT NULL,
     sqlite3::transaction_guard tr{db};
     db.exec(R"(
         PRAGMA foreign_keys = 1;
-        CREATE TABLE IF NOT EXISTS dds_repo_meta AS
+        CREATE TABLE IF NOT EXISTS dds_cat_meta AS
             WITH init(meta) AS (VALUES ('{"version": 0}'))
             SELECT * FROM init;
     )");
-    auto meta_st     = db.prepare("SELECT meta FROM dds_repo_meta");
+    auto meta_st     = db.prepare("SELECT meta FROM dds_cat_meta");
     auto [meta_json] = sqlite3::unpack_single<std::string>(meta_st);
 
     auto meta = nlohmann::json::parse(meta_json);
         migrate_repodb_1(db);
     }
     meta["version"] = 1;
-    exec(db, "UPDATE dds_repo_meta SET meta=?", std::forward_as_tuple(meta.dump()));
+    exec(db, "UPDATE dds_cat_meta SET meta=?", std::forward_as_tuple(meta.dump()));
 }
 
 }  // namespace
     sqlite3::exec(  //
         _stmt_cache,
         R"(
-            INSERT INTO dds_repo_pkgs (
+            INSERT INTO dds_cat_pkgs (
                 name,
                 version,
                 git_url,
 
     auto  db_pkg_id  = _db.last_insert_rowid();
     auto& new_dep_st = _stmt_cache(R"(
-        INSERT INTO dds_repo_pkg_deps (
+        INSERT INTO dds_cat_pkg_deps (
             pkg_id,
             dep_name,
             low,
                _stmt_cache,
                R"(
                 SELECT name, version
-                  FROM dds_repo_pkgs
+                  FROM dds_cat_pkgs
                  WHERE name = ?
                 )"_sql,
                std::tie(sv))  //
                R"(
                 WITH this_pkg_id AS (
                     SELECT pkg_id
-                      FROM dds_repo_pkgs
+                      FROM dds_cat_pkgs
                      WHERE name = ? AND version = ?
                 )
                 SELECT dep_name, low
-                  FROM dds_repo_pkg_deps
+                  FROM dds_cat_pkg_deps
                  WHERE pkg_id IN this_pkg_id
               ORDER BY dep_name
                 )"_sql,

src/dds/repo/catalog.test.cpp → src/dds/catalog/catalog.test.cpp

-#include <dds/repo/catalog.hpp>
+#include <dds/catalog/catalog.hpp>
 
 #include <catch2/catch.hpp>
 

src/dds/dds.main.cpp

 #include <dds/build.hpp>
+#include <dds/catalog/catalog.hpp>
 #include <dds/repo/remote.hpp>
 #include <dds/repo/repo.hpp>
 #include <dds/sdist.hpp>
                    dds::fs::current_path()};
 };
 
+/*
+ ######     ###    ########    ###    ##        #######   ######
+##    ##   ## ##      ##      ## ##   ##       ##     ## ##    ##
+##        ##   ##     ##     ##   ##  ##       ##     ## ##
+##       ##     ##    ##    ##     ## ##       ##     ## ##   ####
+##       #########    ##    ######### ##       ##     ## ##    ##
+##    ## ##     ##    ##    ##     ## ##       ##     ## ##    ##
+ ######  ##     ##    ##    ##     ## ########  #######   ######
+*/
+
+struct cli_catalog {
+    cli_base&     base;
+    args::Command cmd{base.cmd_group, "catalog", "Manage the package catalog"};
+    common_flags  _common{cmd};
+
+    args::Group cat_group{cmd, "Catalog subcommands"};
+
+    struct catalog_path_flag : path_flag {
+        catalog_path_flag(args::Group& cmd)
+            : path_flag(cmd,
+                        "catalog-path",
+                        "Path to the catalog database",
+                        {"catalog", 'c'},
+                        args::Options::Required) {}
+    };
+
+    struct {
+        cli_catalog&  parent;
+        args::Command cmd{parent.cat_group, "create", "Create a catalog database"};
+
+        catalog_path_flag path{cmd};
+
+        int run() {
+            // Simply opening the DB will initialize the catalog
+            dds::catalog::open(path.Get());
+            return 0;
+        }
+    } create{*this};
+
+    struct {
+        cli_catalog&  parent;
+        args::Command cmd{parent.cat_group, "import", "Import json data into a catalog"};
+
+        catalog_path_flag                 path{cmd};
+        args::PositionalList<std::string> json_paths{cmd,
+                                                     "json",
+                                                     "Path to the JSON files to import"};
+
+        int run() {
+            auto cat = dds::catalog::open(path.Get());
+            for (const auto& json_fpath : json_paths.Get()) {
+                cat.import_json_file(json_fpath);
+            }
+            return 0;
+        }
+    } import{*this};
+
+    struct {
+        cli_catalog&  parent;
+        args::Command cmd{parent.cat_group, "get", "Obtain an sdist from a catalog listing"};
+
+        catalog_path_flag                 path{cmd};
+        args::PositionalList<std::string> requirements{cmd,
+                                                       "requirement",
+                                                       "The package IDs to obtain"};
+
+        int run() { return 23; }
+    } get{*this};
+
+    int run() {
+        if (create.cmd) {
+            return create.run();
+        } else if (import.cmd) {
+            return import.run();
+        } else if (get.cmd) {
+            return get.run();
+        } else {
+            assert(false);
+            std::terminate();
+        }
+    }
+};
+
 /*
 ########  ######## ########   #######
 ##     ## ##       ##     ## ##     ##
 
         int run() {
             auto list_contents = [&](dds::repository repo) {
-                auto same_name
-                    = [](auto&& a, auto&& b) { return a.manifest.pk_id.name == b.manifest.pk_id.name; };
+                auto same_name = [](auto&& a, auto&& b) {
+                    return a.manifest.pk_id.name == b.manifest.pk_id.name;
+                };
 
                 auto all         = repo.iter_sdists();
                 auto grp_by_name = all                             //
     args::Flag     build_apps{cmd, "build_apps", "Build applications", {"apps", 'A'}};
     args::Flag     export_{cmd, "export", "Generate a library export", {"export", 'E'}};
     toolchain_flag tc_filepath{cmd};
+
     args::Flag enable_warnings{cmd,
                                "enable_warnings",
                                "Enable compiler warnings",
     spdlog::set_pattern("[%H:%M:%S] [%^%-5l%$] %v");
     args::ArgumentParser parser("DDS - The drop-dead-simple library manager");
 
-    cli_base  cli{parser};
-    cli_build build{cli};
-    cli_sdist sdist{cli};
-    cli_repo  repo{cli};
-    cli_deps  deps{cli};
+    cli_base    cli{parser};
+    cli_build   build{cli};
+    cli_sdist   sdist{cli};
+    cli_repo    repo{cli};
+    cli_deps    deps{cli};
+    cli_catalog catalog{cli};
     try {
         parser.ParseCLI(argc, argv);
     } catch (const args::Help&) {
             return repo.run();
         } else if (deps.cmd) {
             return deps.run();
+        } else if (catalog.cmd) {
+            return catalog.run();
         } else {
             assert(false);
             std::terminate();