spec walk subobjects, start json5 serialization customization point

Author: Tsche

include/rsl/cli/spec.hpp

@@ -15,7 +15,7 @@
 namespace rsl {
 struct cli;
 struct config;
-}
+}  // namespace rsl
 
 namespace rsl::_cli_impl {
 
@@ -35,8 +35,12 @@ struct Spec {
     // but cannot be used in combination with variadic or optional arguments
     std::vector<Spec> subcommands;
 
+    bool allow_positional;
+
+    consteval explicit Parser(bool allow_positional = true) : allow_positional(allow_positional) {}
+
     consteval void parse(std::meta::info r) {
-      auto ctx             = std::meta::access_context::current();
+      auto ctx = std::meta::access_context::current();
       for (auto base : bases_of(r, ctx)) {
         parse_base(r, base);
       }
@@ -77,12 +81,30 @@ struct Spec {
         return false;
       }
 
-      if (!meta::has_annotation(r, ^^annotations::Positional)) {
-        return false;
+      if (meta::has_annotation(r, ^^annotations::Positional)) {
+        if (!allow_positional) {
+          compile_error("Positional arguments are only supported at the config root.");
+        }
+        arguments.emplace_back(idx, r);
+        return true;
       }
 
-      arguments.emplace_back(idx, r);
-      return true;
+      if (extract<bool>(substitute(^^std::derived_from, {type_of(r), ^^config}))) {
+        auto name = identifier_of(r);
+
+        auto subparser = Parser(false);
+        subparser.parse(type_of(r));
+
+        for (auto option : subparser.options) {
+          option.name = std::define_static_string(std::string(name) + ':' + option.name);
+          options.push_back(option);
+        }
+        for (auto command : subparser.commands) {
+          command.name = std::define_static_string(std::string(name) + ':' + command.name);
+          options.push_back(command);
+        }
+      }
+      return false;
     }
 
     consteval bool parse_command(std::meta::info r) {

include/rsl/json5/json5.hpp

@@ -8,9 +8,12 @@
 #include <rsl/_impl/default_construct.hpp>
 
 namespace rsl::json5 {
-struct Parser;
-struct Value;
+template <typename T>
+struct Serializer;
 
+struct Value;
+template <typename T>
+using Tag = std::type_identity<T>;
 using Object = std::unordered_map<std::string, Value>;
 using Array  = std::vector<Value>;
 
@@ -31,8 +34,9 @@ struct Value {
       throw std::runtime_error("unimplemented");
     } else if constexpr (std::is_aggregate_v<T>) {
       return as_aggregate<T>();
+    } else {
+      return Serializer<T>::deserialize(*this);
     }
-    throw std::runtime_error("unimplemented");
   }
 
   template <typename T>
@@ -98,4 +102,15 @@ struct Parser {
 
 Value load(std::string_view path);
 
+template <typename T>
+Value from(T const& obj) {
+  return Serializer<T>::serialize(obj);
+}
+
+template <typename T>
+T to(Value const& json) {
+  return Serializer<T>::deserialize(json);
+}
+
+
 }  // namespace rsl::json5

include/rsl/json5/serializer.hpp

@@ -0,0 +1,42 @@
+#include "json5.hpp"
+
+namespace rsl::json5 {
+template <typename T>
+struct Serializer {
+  static T deserialize(Value const& json) 
+  requires requires { {from_json(Tag<T>{}, json)} -> std::convertible_to<T>;}
+  {
+    return from_json(Tag<T>{}, json);
+  }
+
+  static Value serialize(T const& obj) 
+  requires requires { {to_json(Tag<T>{}, obj)} -> std::convertible_to<Value>;}
+  {
+    return to_json(Tag<T>{}, obj);
+  }
+};
+
+template <>
+struct Serializer<bool> {
+  static bool deserialize(Value const& json);
+  static Value serialize(bool obj);
+};
+
+template <>
+struct Serializer<std::string> {
+  static std::string deserialize(Value const& json);
+  static Value serialize(std::string obj);
+};
+
+template <typename T>
+  requires std::integral<T> || std::floating_point<T>
+struct Serializer<T> {
+  static T deserialize(Value const& json) {
+    return json.template as_number<T>();
+  }
+
+  static Value serialize(T obj) {
+    throw "unimplemented";
+  }
+};
+}

src/json5/CMakeLists.txt

@@ -1,3 +1,4 @@
 target_sources(rsl_config PRIVATE 
   parser.cpp
+  serializer.cpp
 )

src/json5/parser.cpp

@@ -191,9 +191,9 @@ Array Value::as_array() const {
 }
 
 bool Value::as_bool() const {
-  if (raw == "true")
+  if (raw == "true" || raw == "1")
     return true;
-  if (raw == "false")
+  if (raw == "false" || raw == "0")
     return false;
   throw std::runtime_error("Could not extract as bool");
 }

src/json5/serializer.cpp

@@ -0,0 +1,22 @@
+#include <rsl/json5/serializer.hpp>
+
+namespace rsl::json5 {
+bool Serializer<bool>::deserialize(Value const& json) {
+  return json.as_bool();
+}
+
+Value Serializer<bool>::serialize(bool obj) {
+  throw "unimplemented";
+}
+
+std::string Serializer<std::string>::deserialize(Value const& json) {
+  std::string content;
+  if (!Parser(json.raw).try_string(content)) {
+    throw std::runtime_error("Could not extract as string.");
+  }
+  return content;
+}
+Value Serializer<std::string>::serialize(std::string obj) {
+  throw "unimplemented";
+}
+}