recordings: use better command parser to also specify json dump options

OpenBrickProtocolFoundation · May 24, 2024 · 28843cd · 28843cd
1 parent 9c73774
commit 28843cd
Show file tree

Hide file tree

Showing 2 changed files with 56 additions and 30 deletions.
diff --git a/src/recordings/executable/command_line_arguments.hpp b/src/recordings/executable/command_line_arguments.hpp
@@ -7,44 +7,65 @@
 #include <stdexcept>
 #include <string>
 
-enum class Command { Info, Dump };
+
+struct Dump {
+    bool ensure_ascii;
+    bool pretty_print;
+};
+
+struct Info { };
+
 
 struct CommandLineArguments final {
 private:
 public:
     std::filesystem::path recording_path{};
-    Command command{ Command::Info };
+    std::variant<Dump, Info> value;
+
 
     CommandLineArguments(int argc, char** argv) {
         argparse::ArgumentParser parser{ argc >= 1 ? argv[0] //NOLINT(cppcoreguidelines-pro-bounds-pointer-arithmetic)
                                                    : "oopetris_recording_utility",
                                          "0.0.1", argparse::default_arguments::all };
 
-        parser.add_argument("command")
-                .help("specify the command")
-                .default_value(std::string{ "info" })
-                .choices("info", "i", "dump", "d")
-                .required();
 
         parser.add_argument("-r", "--recording").help("the path of a recorded game file").required();
+
+
+        // git add subparser
+        argparse::ArgumentParser dump_parser("dump");
+        dump_parser.add_description("Dump JSON value");
+        dump_parser.add_argument("-a", "--ensure-ascii")
+                .help("Only use ASCII characters and escape sequences (\\uXXXX)")
+                .flag();
+        dump_parser.add_argument("-p", "--pretty-print").help("Pretty print the JSON").flag();
+
+        argparse::ArgumentParser info_parser("info");
+        info_parser.add_description("Print hHuman readable Info");
+
+
+        parser.add_subparser(dump_parser);
+        parser.add_subparser(info_parser);
+
         try {
 
             parser.parse_args(argc, argv);
 
-            recording_path = parser.get("--recording");
+            this->recording_path = parser.get("--recording");
 
-            const auto command_string = parser.get<std::string>("command");
+            if (parser.is_subcommand_used(dump_parser)) {
+                const auto ensure_ascii = dump_parser.get<bool>("--ensure-ascii");
+                const auto pretty_print = dump_parser.get<bool>("--pretty-print");
 
+                this->value = Dump{ .ensure_ascii = ensure_ascii, .pretty_print = pretty_print };
 
-            if (command_string == "info" or command_string == "i") {
-                command = Command::Info;
-            } else if (command_string == "dump" || command_string == "d") {
-                command = Command::Dump;
+            } else if (parser.is_subcommand_used(info_parser)) {
+                this->value = Info{};
             } else {
-                throw std::runtime_error(fmt::format("Unknown command: '{}'", command_string));
+                throw std::runtime_error("Unknown or no subcommand used");
             }
-        } catch (const std::exception& err) {
-            std::cerr << err.what();
+        } catch (const std::exception& error) {
+            std::cerr << error.what();
             std::exit(1);
         }
     }

diff --git a/src/recordings/executable/main.cpp b/src/recordings/executable/main.cpp
@@ -12,13 +12,23 @@ void print_info(const recorder::RecordingReader& recording_reader) {
     std::cerr << "NOT IMPLEMENTED\n";
 }
 
-void dump_json(const recorder::RecordingReader& recording_reader) {
+void dump_json(const recorder::RecordingReader& recording_reader, bool pretty_print, bool ensure_ascii) {
 
     nlohmann::json json_value;
 
     nlohmann::adl_serializer<recorder::RecordingReader>::to_json(json_value, recording_reader);
 
-    json_value.dump();
+    int indent = -1;
+    char indent_char = ' ';
+    if (pretty_print) {
+        indent = 4;
+    }
+
+    std::cout << json_value.dump(indent, indent_char, ensure_ascii);
+
+    if (pretty_print) {
+        std::cout << "\n";
+    }
 }
 
 
@@ -45,18 +55,13 @@ int main(int argc, char** argv) noexcept {
 
     const auto recording_reader = std::move(parsed.value());
 
-    switch (arguments.command) {
-        case Command::Info:
-            print_info(recording_reader);
-            return 0;
-        case Command::Dump:
-            dump_json(recording_reader);
-            return 0;
-        default:
-            std::cerr << "Unknown command: ?\n";
-
-            return 1;
-    }
+    std::visit(
+            helper::overloaded{ [&recording_reader](const Dump& dump) {
+                                   dump_json(recording_reader, dump.pretty_print, dump.ensure_ascii);
+                               },
+                                [&recording_reader](const Info& /* info */) { print_info(recording_reader); } },
+            arguments.value
+    );
 
 
     return 0;