implement json5 comments, more work on spec

Author: Tsche

example/simple.cpp

@@ -2,22 +2,22 @@
 
 #include <rsl/config>
 
-struct Arguments : rsl::config {
-  // static inline std::string config_path = "foo";
-  [[=positional]] std::string text;
+struct Test : rsl::config {
   bool from_config;
+  
+  [[=option]]
+  static void zoinks(){}
+};
+
+struct Arguments : rsl::cli {
+  [[=positional]] std::string text;
+  Test foo;
   [[=positional]] int times = 5;
 
   [[=option]]
   void test(int x) {
     std::println("text: {}, times: {}, x: {}", text, times, x);
   }
-
-  // [[=option]]
-  // static void config(std::string cfg_path) {
-  //   std::println("config() invoked");
-  //   Arguments::config_path = cfg_path;
-  // }
 };
 
 int main(int argc, char** argv) {

include/rsl/cli/spec.hpp

@@ -13,6 +13,7 @@
 #include "annotations.hpp"
 
 namespace rsl {
+struct cli;
 struct config;
 }
 
@@ -35,11 +36,11 @@ struct Spec {
     std::vector<Spec> subcommands;
 
     consteval void parse(std::meta::info r) {
-      // for (auto base : bases_of(r)) {
-      //   bases.emplace_back(type_of(base));
-      // }
-
       auto ctx             = std::meta::access_context::current();
+      for (auto base : bases_of(r, ctx)) {
+        parse_base(r, base);
+      }
+
       std::size_t nsdm_idx = bases_of(r, ctx).size();
       for (auto member : members_of(r, ctx)) {
         if (!has_identifier(member) || !is_public(member)) {
@@ -53,19 +54,21 @@ struct Spec {
       }
     }
 
-    consteval void parse_base(std::meta::info r) {
-      if (extract<bool>(substitute(^^std::derived_from, {dealias(r), ^^config}))) {
-        for (auto fnc_template : members_of(^^config, std::meta::access_context::current()) |
-                                     std::views::filter(std::meta::is_function_template)) {
-          if (!can_substitute(fnc_template, {r})) {
+    consteval void parse_base(std::meta::info self, std::meta::info r) {
+      if (extract<bool>(substitute(^^std::convertible_to, {type_of(r), ^^config}))) {
+        // special case built-in bases. These need to access the child type
+
+        for (auto fnc_template : members_of(type_of(r), std::meta::access_context::current())) {
+          if (!is_function_template(fnc_template) || !can_substitute(fnc_template, {self})) {
             continue;
           }
 
-          auto fnc = substitute(fnc_template, {r});
+          auto fnc = substitute(fnc_template, {self});
           if (meta::has_annotation<annotations::Option>(fnc)) {
             commands.emplace_back(identifier_of(fnc_template), fnc);
           }
         }
+        bases.push_back({});
       }
     }
 
@@ -150,7 +153,7 @@ struct Spec {
   };
 
   rsl::string_view name;
-  rsl::span<rsl::span<Argument const>> bases;
+  rsl::span<rsl::span<Argument const> const> bases;
   rsl::span<Argument const> arguments;
   rsl::span<Option const> commands;
   rsl::span<Option const> options;
@@ -159,9 +162,14 @@ struct Spec {
     auto type   = is_type(r) ? r : type_of(r);
     auto parser = Parser();
     parser.parse(type);
-    parser.parse_base(type);
+    // parser.parse_base(type);
     parser.validate();
-    // bases     = define_static_array(parser.bases);
+    std::vector<rsl::span<Argument const>> meta_bases;
+    for (auto base : parser.bases) {
+      meta_bases.push_back(rsl::span(define_static_array(base)));
+    }
+
+    bases     = define_static_array(meta_bases);
     arguments = define_static_array(parser.arguments);
     commands  = define_static_array(parser.commands);
     options   = define_static_array(parser.options);

include/rsl/config

@@ -32,26 +32,17 @@ public:
 };
 
 class config {
-  static std::string& get_config_path();
   static void print_help(_cli_impl::Spec const& spec,
                          std::string_view program_name,
                          std::string_view description);
 
 public:
   static constexpr auto option     = annotations::option;
-  static constexpr auto positional = annotations::positional;
   static constexpr auto value      = rsl::placeholders::_0;
 
   using shorthand   = annotations::Shorthand;
   using description = annotations::Description;
 
-  static std::string_view config_path() { return get_config_path(); }
-
-  template <typename T>
-  [[= option]] static void config_path(std::string new_path) {
-    get_config_path() = new_path;
-  }
-
   template <typename T>
   [[= option]] [[noreturn]]
   static void help() {
@@ -66,6 +57,31 @@ public:
   }
 };
 
+class cli : public config {
+  static std::string& get_config_path();
+public:
+  static constexpr auto option     = annotations::option;
+  static constexpr auto positional = annotations::positional;
+  static constexpr auto value      = rsl::placeholders::_0;
+
+  using shorthand   = annotations::Shorthand;
+  using description = annotations::Description;
+
+  static std::string_view config_path() { return get_config_path(); }
+
+  template <typename T>
+  [[= option]] 
+  static void config_path(std::string new_path) {
+    get_config_path() = new_path;
+  }
+
+  template <typename T>
+  [[= option]] [[noreturn]]
+  static void help() {
+    config::template help<T>();
+  }
+};
+
 template <typename T>
 T load_config(std::vector<std::string_view> args_in) {
   static constexpr _cli_impl::Spec spec{^^T};

include/rsl/json5/json5.hpp

@@ -80,6 +80,7 @@ struct Parser {
   std::string_view::iterator cursor = std::begin(file);
 
   void skip_whitespace();
+  bool skip_comment();
   void expect_consume(char c);
   void maybe_consume(char c);
   void parse_until(std::vector<char> delims, std::string& out);

src/cli.cpp

@@ -3,7 +3,7 @@
 #include <rsl/config>
 
 namespace rsl {
-std::string& config::get_config_path() {
+std::string& cli::get_config_path() {
   static std::string config_path{ std::filesystem::current_path() / "settings.json5" };
   return config_path;
 }

src/json5/parser.cpp

@@ -32,9 +32,42 @@ void Parser::expect_more() const {
   }
 }
 
+bool Parser::skip_comment() {
+  if (cursor == file.end()){
+    return false;
+  }
+
+  if (*cursor == '/') {
+    ++cursor;
+    expect_more();
+    std::string content;
+    if (*cursor == '/') {
+      ++cursor;
+      parse_until({'\n'}, content);
+    } else if (*cursor == '*') {
+      ++cursor;
+      parse_until({'*', '/'}, content);
+    } else {
+      // roll back - this parse was invalid
+      --cursor;
+      return false;
+    }
+    // TODO we probably want to keep comments to round-trip properly
+    // std::println("Comment: {}", content);
+    return true;
+  }
+  return false;
+}
+
 void Parser::skip_whitespace() {
   while (is_whitespace(*cursor))
     cursor++;
+  
+  if (skip_comment()) {
+    // comment found - recurse
+    skip_whitespace();
+  }
+  
 };
 
 void Parser::expect_consume(char c) {