Automatic package generation from unchanged Git remotes

src/dds/repo/remote.cpp

                      semver::version      version,
                      const lm::pair_list& pairs) {
         if (pairs.find("git")) {
-            std::string url;
-            std::string ref;
+            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(name), version, git_remote_listing{url, ref}})
-                      .second;
+            auto did_insert = out.emplace(remote_listing{std::move(name),
+                                                         version,
+                                                         git_remote_listing{url, ref, auto_id}})
+                                  .second;
             if (!did_insert) {
                 spdlog::warn("Duplicate remote package defintion for {} {}",
                              name,
     }
 };
 
-temporary_sdist do_pull_sdist(const git_remote_listing& git) {
+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);
                         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.name << '\n'                    //
+                 << "Version: " << listing.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();
 }  // namespace
 
 temporary_sdist remote_listing::pull_sdist() const {
-    auto tsd = visit([](auto&& actual) { return do_pull_sdist(actual); });
+    auto tsd = visit([&](auto&& actual) { return do_pull_sdist(*this, actual); });
     if (tsd.sdist.manifest.name != name) {
         throw std::runtime_error(
             fmt::format("The name in the generated sdist ('{}') does not match the name listed in "

src/dds/repo/remote.hpp

 #include <dds/sdist.hpp>
 #include <dds/temp.hpp>
 #include <semver/version.hpp>
+#include <libman/library.hpp>
 
 #include <set>
 #include <string>
 };
 
 struct git_remote_listing {
-    std::string url;
-    std::string ref;
+    std::string              url;
+    std::string              ref;
+    std::optional<lm::usage> auto_lib;
 
     void clone(path_ref path) const;
 };

src/libman/library.cpp

 
     library ret;
 
-    std::vector<std::string> uses_strs;
-    std::vector<std::string> links_strs;
-
     std::string _type_;
     read(fmt::format("Reading library manifest file '{}'", fpath.string()),
          pairs,
          read_opt("Path", ret.linkable_path),
          read_accumulate("Include-Path", ret.include_paths),
          read_accumulate("Preprocessor-Define", ret.preproc_defs),
-         read_accumulate("Uses", uses_strs),
-         read_accumulate("Links", links_strs),
+         read_accumulate("Uses", ret.uses, &split_usage_string),
+         read_accumulate("Links", ret.links, &split_usage_string),
          read_accumulate("Special-Uses", ret.special_uses));
 
-    for (auto&& uses_str : uses_strs) {
-        ret.uses.push_back(split_usage_string(uses_str));
-    }
-
-    for (auto&& links_str : links_strs) {
-        ret.links.push_back(split_usage_string(links_str));
-    }
-
     auto make_absolute = [&](path_ref p) { return fpath.parent_path() / p; };
     std::transform(ret.include_paths.begin(),
                    ret.include_paths.end(),

src/libman/parse.hpp

     static nested_kvlist parse(std::string_view s);
 };
 
+struct unchanged {
+    template <typename Item>
+    auto operator()(Item&& item) const {
+        return item;
+    }
+};
+
 template <typename What>
 class read_required {
     std::string_view _key;
     }
 };
 
-template <typename T>
+template <typename T, typename Transform = unchanged>
 class read_opt {
     std::string_view _key;
     T&               _ref;
     bool             _did_read = false;
+    Transform        _tr;
 
 public:
-    read_opt(std::string_view key, T& ref)
+    read_opt(std::string_view key, T& ref, Transform tr = unchanged())
         : _key(key)
-        , _ref(ref) {}
+        , _ref(ref)
+        , _tr(std::move(tr)) {}
 
     int operator()(std::string_view context, std::string_view key, std::string_view value) {
         if (key != _key) {
             throw std::runtime_error(std::string(context) + ": Duplicated key '" + std::string(key)
                                      + "' is not allowed.");
         }
-        _ref = T(value);
+        _ref = T(_tr(value));
         return 1;
     }
 };
     }
 };
 
+struct read_empty_set_true {
+    std::string_view _key;
+    bool&            _bool;
+    bool             _seen = false;
+
+    bool operator()(std::string_view context, std::string_view key, std::string_view value) {
+        if (key != _key) {
+            return false;
+        }
+        if (value != "") {
+            throw std::runtime_error(std::string(context) + ": Key '" + std::string(key)
+                                     + "' does not expected a value (Got '" + std::string(value)
+                                     + "').");
+        }
+        if (_seen) {
+            throw std::runtime_error(std::string(context) + ": Duplicated key '" + std::string(key)
+                                     + "'");
+        }
+        _bool = true;
+        _seen = true;
+        return true;
+    }
+};
+
 class read_check_eq {
     std::string_view _key;
     std::string_view _expect;
     }
 };
 
-template <typename Container>
+template <typename Container, typename Transform = unchanged>
 class read_accumulate {
     std::string_view _key;
     Container&       _items;
+    Transform        _tr;
 
 public:
+    read_accumulate(std::string_view key, Container& c, Transform tr)
+        : _key(key)
+        , _items(c)
+        , _tr(std::move(tr)) {}
+
     read_accumulate(std::string_view key, Container& c)
         : _key(key)
-        , _items(c) {}
+        , _items(c)
+        , _tr(unchanged()) {}
 
     int operator()(std::string_view, std::string_view key, std::string_view value) const {
         if (key == _key) {
-            _items.emplace_back(value);
+            _items.emplace_back(_tr(value));
             return 1;
         }
         return 0;

tests/deps/git-remote/package.dds

 Version: 0.0.0
 
 Depends: neo-buffer 0.1.0
+Depends: range-v3 0.9.1

tests/deps/git-remote/remote.dds

-Remote-Package: neo-buffer 0.1.0; git url=https://github.com/vector-of-bool/neo-buffer.git ref=develop
+Remote-Package: neo-buffer 0.1.0; git url=https://github.com/vector-of-bool/neo-buffer.git ref=develop
+Remote-Package: range-v3 0.9.1; git url=https://github.com/ericniebler/range-v3.git ref=0.9.1 auto=Niebler/range-v3