fix commands

Author: Tsche

example/simple.cpp

@@ -5,13 +5,13 @@
 struct Test : rsl::config {
   bool from_config;
 
-  [[=option]]
+  [[=rsl::cli::option]]
   static void zoinks(){
     std::exit(1);
   }
 };
 
-struct Arguments : rsl::cli {
+struct Arguments : rsl::cli, rsl::config {
   [[=positional]] std::string text;
   Test foo;
   [[=positional]] char times = 5;
@@ -24,14 +24,25 @@ struct Arguments : rsl::cli {
 
   [[=option]]
   static void cmd(){
-    std::exit(1);
+    // std::exit(1);
   }
 };
 
 int main(int argc, char** argv) {
   static constexpr rsl::_cli_impl::Spec spec{^^Arguments};
   std::println("bases: {}, arguments: {}, commands: {}, options: {}",
     spec.bases.size(), spec.arguments.size(), spec.commands.size(), spec.options.size());
+    for (auto const& arg : spec.arguments) {
+      std::println("arg: {}", arg.name);
+    }
+
+    for (auto const& opt : spec.options) {
+      std::println("opt: {}", opt.name);
+    }
+
+    for (auto const& cmd : spec.commands) {
+      std::println("cmd: {}", cmd.name);
+    }
 
   auto args = rsl::load_config<Arguments>(argc, argv);
   std::println("text: {}, times: {}", args.text, args.times);

example/stateful.cpp

@@ -19,6 +19,7 @@ struct Arguments : rsl::cli {
 
 int main(int argc, char** argv) {
   auto args = Arguments(123);
-  rsl::parse_args(args, {argv, argv+argc});
+  args.parse_args(argc, argv);
+
   std::println("{}", args.durations);
 }

include/rsl/cli/option.hpp

@@ -123,7 +123,7 @@ struct Option {
         option.parameters.push_back(*parameter);
       } else {
         if (!arg.is_optional) {
-          parser.fail("Missing parameter {} of option {}", arg.name, name);
+          parser.set_error("Missing parameter {} of option {}", arg.name, name);
           break;
         }
       }

include/rsl/cli/parser.hpp

@@ -11,16 +11,16 @@ namespace rsl::_cli_impl {
 struct ArgParser {
   std::span<std::string_view> args;
   std::size_t cursor = 0;
+  std::string error;
 
   std::string_view current() const { return args[cursor]; }
 
   template <typename... Args>
-  [[noreturn]] void fail(std::format_string<Args...> fmt, Args&&... args) const {
-    std::println(fmt, std::forward<Args>(args)...);
-    std::exit(1);
+  void set_error(std::format_string<Args...> fmt, Args&&... args) {
+    error = std::format(fmt, std::forward<Args>(args)...);
   }
-
-  [[nodiscard]] bool valid() const noexcept { return cursor < args.size(); }
+  [[nodiscard]] bool has_error() const { return !error.empty(); }
+  [[nodiscard]] bool valid() const { return cursor < args.size() && !has_error(); }
 };
 
 template <typename T>

include/rsl/cli/spec.hpp

@@ -101,7 +101,7 @@ struct Spec {
         }
         for (auto command : subparser.commands) {
           command.name = std::define_static_string(std::string(name) + ':' + command.name);
-          options.push_back(command);
+          commands.push_back(command);
         }
       }
       return false;
@@ -197,58 +197,5 @@ struct Spec {
     commands  = define_static_array(parser.commands);
     options   = define_static_array(parser.options);
   }
-
-  bool parse_as_command(ArgParser& parser) const {
-    for (auto cmd : commands) {
-      if (auto unevaluated = cmd.parse(parser); unevaluated) {
-        (*unevaluated)(nullptr);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  std::optional<Option::Unevaluated> parse_as_option(ArgParser& parser) const {
-    for (auto opt : options) {
-      if (auto unevaluated = opt.parse(parser); unevaluated) {
-        return unevaluated;
-      }
-    }
-
-    return {};
-  }
-
-  std::vector<Argument::Unevaluated> parse_arguments(ArgParser& parser) const {
-    std::vector<Argument::Unevaluated> parsed_args;
-    for (auto arg : arguments) {
-      auto argument = arg.parse(parser);
-      if (!argument) {
-        if (!arg.is_optional) {
-          std::println("Missing required argument {}", arg.name);
-          std::exit(1);
-        }
-        // failed to parse argument - bail out
-        return parsed_args;
-      }
-      parsed_args.push_back(*argument);
-    }
-    return parsed_args;
-  }
-
-  std::vector<Option::Unevaluated> parse_options(ArgParser& parser) const {
-    std::vector<Option::Unevaluated> parsed_opts{};
-    while (parser.valid()) {
-      if (parse_as_command(parser)) {
-        continue;
-      }
-
-      auto unevaluated = parse_as_option(parser);
-      if (!unevaluated) {
-        parser.fail("Could not find option `{}`", parser.current());
-      }
-      parsed_opts.push_back(*unevaluated);
-    }
-    return parsed_opts;
-  }
 };
 }  // namespace rsl::_cli_impl