Adopt a new CLI parsing library from Sourcemeta Core (#435)

Signed-off-by: Juan Cruz Viotti <[email protected]>

Author: jviotti

DEPENDENCIES

@@ -1,5 +1,5 @@
 vendorpull https://github.com/sourcemeta/vendorpull dea311b5bfb53b6926a4140267959ae334d3ecf4
-core https://github.com/sourcemeta/core 2951f08dadba6003aea55a28e2871cd04c5adb75
+core https://github.com/sourcemeta/core 7d7de98576f3d5c27dd340fd9ecde769eacb7961
 jsonbinpack https://github.com/sourcemeta/jsonbinpack 3a5e2e37ad664be277a34145a9efc0ab14558421
 blaze https://github.com/sourcemeta/blaze c907bb924fd21391b02aa15a80316710a3355295
 curl https://github.com/curl/curl curl-8_14_0

src/CMakeLists.txt

@@ -24,6 +24,7 @@ target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::jsonpointer)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::jsonschema)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::yaml)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::alterschema)
+target_link_libraries(jsonschema_cli PRIVATE sourcemeta::core::options)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::jsonbinpack::compiler)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::jsonbinpack::runtime)
 target_link_libraries(jsonschema_cli PRIVATE sourcemeta::blaze::compiler)

src/command.h

@@ -1,20 +1,19 @@
 #ifndef SOURCEMETA_JSONSCHEMA_CLI_COMMAND_H_
 #define SOURCEMETA_JSONSCHEMA_CLI_COMMAND_H_
 
-#include <span>   // std::span
-#include <string> // std::string
+#include <sourcemeta/core/options.h>
 
 namespace sourcemeta::jsonschema::cli {
-auto fmt(const std::span<const std::string> &arguments) -> int;
-auto inspect(const std::span<const std::string> &arguments) -> int;
-auto bundle(const std::span<const std::string> &arguments) -> int;
-auto test(const std::span<const std::string> &arguments) -> int;
-auto lint(const std::span<const std::string> &arguments) -> int;
-auto validate(const std::span<const std::string> &arguments) -> int;
-auto metaschema(const std::span<const std::string> &arguments) -> int;
-auto compile(const std::span<const std::string> &arguments) -> int;
-auto encode(const std::span<const std::string> &arguments) -> int;
-auto decode(const std::span<const std::string> &arguments) -> int;
+auto fmt(const sourcemeta::core::Options &options) -> int;
+auto inspect(const sourcemeta::core::Options &options) -> int;
+auto bundle(const sourcemeta::core::Options &options) -> int;
+auto test(const sourcemeta::core::Options &options) -> int;
+auto lint(const sourcemeta::core::Options &options) -> int;
+auto validate(const sourcemeta::core::Options &options) -> int;
+auto metaschema(const sourcemeta::core::Options &options) -> int;
+auto compile(const sourcemeta::core::Options &options) -> int;
+auto encode(const sourcemeta::core::Options &options) -> int;
+auto decode(const sourcemeta::core::Options &options) -> int;
 } // namespace sourcemeta::jsonschema::cli
 
 #endif

src/command_bundle.cc

@@ -10,21 +10,19 @@
 #include "utils.h"
 
 auto sourcemeta::jsonschema::cli::bundle(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{
-      parse_options(arguments, {"h", "http", "w", "without-id"})};
+    const sourcemeta::core::Options &options) -> int {
   const auto dialect{default_dialect(options)};
 
-  if (options.at("").size() < 1) {
+  if (options.positional().size() < 1) {
     std::cerr
         << "error: This command expects a path to a schema. For example:\n\n"
         << "  jsonschema bundle path/to/schema.json\n";
     return EXIT_FAILURE;
   }
 
-  const std::filesystem::path schema_path{options.at("").front()};
-  const auto custom_resolver{resolver(
-      options, options.contains("h") || options.contains("http"), dialect)};
+  const std::filesystem::path schema_path{options.positional().front()};
+  const auto custom_resolver{
+      resolver(options, options.contains("http"), dialect)};
   auto schema{sourcemeta::core::read_yaml_or_json(schema_path)};
 
   sourcemeta::core::bundle(schema, sourcemeta::core::schema_official_walker,
@@ -33,7 +31,7 @@ auto sourcemeta::jsonschema::cli::bundle(
                                sourcemeta::core::weakly_canonical(schema_path))
                                .recompose());
 
-  if (options.contains("w") || options.contains("without-id")) {
+  if (options.contains("without-id")) {
     std::cerr << "warning: You are opting in to remove schema identifiers in "
                  "the bundled schema.\n";
     std::cerr << "The only legit use case of this advanced feature we know of "

src/command_compile.cc

@@ -12,20 +12,18 @@
 #include "utils.h"
 
 auto sourcemeta::jsonschema::cli::compile(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{parse_options(arguments, {"h", "http", "f", "fast"})};
-
-  if (options.at("").size() < 1) {
+    const sourcemeta::core::Options &options) -> int {
+  if (options.positional().size() < 1) {
     std::cerr
         << "error: This command expects a path to a schema. For example:\n\n"
         << "  jsonschema compile path/to/schema.json\n";
     return EXIT_FAILURE;
   }
 
-  const auto &schema_path{options.at("").at(0)};
+  const auto &schema_path{options.positional().at(0)};
   const auto dialect{default_dialect(options)};
-  const auto custom_resolver{resolver(
-      options, options.contains("h") || options.contains("http"), dialect)};
+  const auto custom_resolver{
+      resolver(options, options.contains("http"), dialect)};
 
   const auto schema{sourcemeta::core::read_yaml_or_json(schema_path)};
 
@@ -37,7 +35,7 @@ auto sourcemeta::jsonschema::cli::compile(
     return EXIT_FAILURE;
   }
 
-  const auto fast_mode{options.contains("f") || options.contains("fast")};
+  const auto fast_mode{options.contains("fast")};
   const auto schema_template{sourcemeta::blaze::compile(
       schema, sourcemeta::core::schema_official_walker, custom_resolver,
       sourcemeta::blaze::default_schema_compiler,

src/command_decode.cc

@@ -28,10 +28,8 @@ static auto has_data(std::ifstream &stream) -> bool {
 }
 
 auto sourcemeta::jsonschema::cli::decode(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{parse_options(arguments, {})};
-
-  if (options.at("").size() < 2) {
+    const sourcemeta::core::Options &options) -> int {
+  if (options.positional().size() < 2) {
     std::cerr
         << "error: This command expects a path to a binary file and an "
            "output path. For example:\n\n"
@@ -47,27 +45,27 @@ auto sourcemeta::jsonschema::cli::decode(
   const auto dialect{default_dialect(options)};
   sourcemeta::jsonbinpack::compile(
       schema, sourcemeta::core::schema_official_walker,
-      resolver(options, options.contains("h") || options.contains("http"),
-               dialect));
+      resolver(options, options.contains("http"), dialect));
   const auto encoding{sourcemeta::jsonbinpack::load(schema)};
 
   std::ifstream input_stream{
-      sourcemeta::core::weakly_canonical(options.at("").front()),
+      sourcemeta::core::weakly_canonical(options.positional().front()),
       std::ios::binary};
   assert(!input_stream.fail());
   assert(input_stream.is_open());
 
-  const std::filesystem::path output{options.at("").at(1)};
+  const std::filesystem::path output{options.positional().at(1)};
   std::ofstream output_stream(sourcemeta::core::weakly_canonical(output),
                               std::ios::binary);
   output_stream.exceptions(std::ios_base::badbit);
   sourcemeta::jsonbinpack::Decoder decoder{input_stream};
 
   if (output.extension() == ".jsonl") {
-    log_verbose(options)
-        << "Interpreting input as JSONL: "
-        << sourcemeta::core::weakly_canonical(options.at("").front()).string()
-        << "\n";
+    log_verbose(options) << "Interpreting input as JSONL: "
+                         << sourcemeta::core::weakly_canonical(
+                                options.positional().front())
+                                .string()
+                         << "\n";
 
     std::size_t count{0};
     while (has_data(input_stream)) {

src/command_encode.cc

@@ -16,10 +16,8 @@
 #include "utils.h"
 
 auto sourcemeta::jsonschema::cli::encode(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{parse_options(arguments, {})};
-
-  if (options.at("").size() < 2) {
+    const sourcemeta::core::Options &options) -> int {
+  if (options.positional().size() < 2) {
     std::cerr
         << "error: This command expects a path to a JSON document and an "
            "output path. For example:\n\n"
@@ -35,11 +33,10 @@ auto sourcemeta::jsonschema::cli::encode(
   const auto dialect{default_dialect(options)};
   sourcemeta::jsonbinpack::compile(
       schema, sourcemeta::core::schema_official_walker,
-      resolver(options, options.contains("h") || options.contains("http"),
-               dialect));
+      resolver(options, options.contains("http"), dialect));
   const auto encoding{sourcemeta::jsonbinpack::load(schema)};
 
-  const std::filesystem::path document{options.at("").front()};
+  const std::filesystem::path document{options.positional().front()};
   const auto original_size{std::filesystem::file_size(document)};
   std::cerr << "original file size: " << original_size << " bytes\n";
 
@@ -50,7 +47,7 @@ auto sourcemeta::jsonschema::cli::encode(
 
     auto stream{sourcemeta::core::read_file(document)};
     std::ofstream output_stream(
-        sourcemeta::core::weakly_canonical(options.at("").at(1)),
+        sourcemeta::core::weakly_canonical(options.positional().at(1)),
         std::ios::binary);
     output_stream.exceptions(std::ios_base::badbit);
     sourcemeta::jsonbinpack::Encoder encoder{output_stream};
@@ -70,9 +67,9 @@ auto sourcemeta::jsonschema::cli::encode(
               << "%\n";
   } else {
     const auto entry{
-        sourcemeta::core::read_yaml_or_json(options.at("").front())};
+        sourcemeta::core::read_yaml_or_json(options.positional().front())};
     std::ofstream output_stream(
-        sourcemeta::core::weakly_canonical(options.at("").at(1)),
+        sourcemeta::core::weakly_canonical(options.positional().at(1)),
         std::ios::binary);
     output_stream.exceptions(std::ios_base::badbit);
     sourcemeta::jsonbinpack::Encoder encoder{output_stream};

src/command_fmt.cc

@@ -9,27 +9,25 @@
 #include "command.h"
 #include "utils.h"
 
-auto sourcemeta::jsonschema::cli::fmt(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{
-      parse_options(arguments, {"c", "check", "k", "keep-ordering"})};
-
-  for (const auto &entry : for_each_json(options.at(""), parse_ignore(options),
-                                         parse_extensions(options))) {
+auto sourcemeta::jsonschema::cli::fmt(const sourcemeta::core::Options &options)
+    -> int {
+  for (const auto &entry :
+       for_each_json(options.positional(), parse_ignore(options),
+                     parse_extensions(options))) {
     if (entry.first.extension() == ".yaml" ||
         entry.first.extension() == ".yml") {
       std::cerr << "This command does not support YAML input files yet\n";
       return EXIT_FAILURE;
     }
 
-    if (options.contains("c") || options.contains("check")) {
+    if (options.contains("check")) {
       log_verbose(options) << "Checking: " << entry.first.string() << "\n";
       std::ifstream input{entry.first};
       std::ostringstream buffer;
       buffer << input.rdbuf();
       std::ostringstream expected;
 
-      if (options.contains("k") || options.contains("keep-ordering")) {
+      if (options.contains("keep-ordering")) {
         sourcemeta::core::prettify(entry.second, expected);
       } else {
         sourcemeta::core::prettify(entry.second, expected,
@@ -51,7 +49,7 @@ auto sourcemeta::jsonschema::cli::fmt(
       log_verbose(options) << "Formatting: " << entry.first.string() << "\n";
       std::ofstream output{entry.first};
 
-      if (options.contains("k") || options.contains("keep-ordering")) {
+      if (options.contains("keep-ordering")) {
         sourcemeta::core::prettify(entry.second, output);
       } else {
         sourcemeta::core::prettify(entry.second, output,

src/command_inspect.cc

@@ -127,22 +127,21 @@ auto operator<<(std::ostream &stream,
 }
 
 auto sourcemeta::jsonschema::cli::inspect(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{parse_options(arguments, {})};
-  if (options.at("").size() < 1) {
+    const sourcemeta::core::Options &options) -> int {
+  if (options.positional().size() < 1) {
     std::cerr
         << "error: This command expects a path to a schema. For example:\n\n"
         << "  jsonschema inspect path/to/schema.json\n";
     return EXIT_FAILURE;
   }
 
-  const std::filesystem::path schema_path{options.at("").front()};
+  const std::filesystem::path schema_path{options.positional().front()};
   const sourcemeta::core::JSON schema{
       sourcemeta::core::read_yaml_or_json(schema_path)};
 
   const auto dialect{default_dialect(options)};
-  const auto custom_resolver{resolver(
-      options, options.contains("h") || options.contains("http"), dialect)};
+  const auto custom_resolver{
+      resolver(options, options.contains("http"), dialect)};
   const auto identifier{sourcemeta::core::identify(
       schema, custom_resolver,
       sourcemeta::core::SchemaIdentificationStrategy::Strict, dialect)};
@@ -163,7 +162,7 @@ auto sourcemeta::jsonschema::cli::inspect(
                 sourcemeta::core::weakly_canonical(schema_path))
                 .recompose());
 
-  if (options.contains("json") || options.contains("j")) {
+  if (options.contains("json")) {
     sourcemeta::core::prettify(frame.to_json(), std::cout);
     std::cout << "\n";
   } else {

src/command_lint.cc

@@ -19,7 +19,7 @@ static auto disable_lint_rules(sourcemeta::core::SchemaTransformer &bundle,
                                const Options &options, Iterator first,
                                Iterator last) -> void {
   for (auto iterator = first; iterator != last; ++iterator) {
-    if (bundle.remove(*iterator)) {
+    if (bundle.remove(std::string{*iterator})) {
       sourcemeta::jsonschema::cli::log_verbose(options)
           << "Disabling rule: " << *iterator << "\n";
     } else {
@@ -86,11 +86,9 @@ static auto get_lint_callback(sourcemeta::core::JSON &errors_array,
   };
 }
 
-auto sourcemeta::jsonschema::cli::lint(
-    const std::span<const std::string> &arguments) -> int {
-  const auto options{
-      parse_options(arguments, {"f", "fix", "json", "j", "l", "list"})};
-  const bool output_json = options.contains("json") || options.contains("j");
+auto sourcemeta::jsonschema::cli::lint(const sourcemeta::core::Options &options)
+    -> int {
+  const bool output_json = options.contains("json");
 
   sourcemeta::core::SchemaTransformer bundle;
   sourcemeta::core::add(bundle, sourcemeta::core::AlterSchemaMode::Readability);
@@ -105,12 +103,7 @@ auto sourcemeta::jsonschema::cli::lint(
                        options.at("exclude").cend());
   }
 
-  if (options.contains("x")) {
-    disable_lint_rules(bundle, options, options.at("x").cbegin(),
-                       options.at("x").cend());
-  }
-
-  if (options.contains("list") || options.contains("l")) {
+  if (options.contains("list")) {
     std::vector<std::pair<std::reference_wrapper<const std::string>,
                           std::reference_wrapper<const std::string>>>
         rules;
@@ -139,12 +132,12 @@ auto sourcemeta::jsonschema::cli::lint(
   bool result{true};
   auto errors_array = sourcemeta::core::JSON::make_array();
   const auto dialect{default_dialect(options)};
-  const auto custom_resolver{resolver(
-      options, options.contains("h") || options.contains("http"), dialect)};
+  const auto custom_resolver{
+      resolver(options, options.contains("http"), dialect)};
 
-  if (options.contains("f") || options.contains("fix")) {
+  if (options.contains("fix")) {
     for (const auto &entry :
-         for_each_json(options.at(""), parse_ignore(options),
+         for_each_json(options.positional(), parse_ignore(options),
                        parse_extensions(options))) {
       log_verbose(options) << "Linting: " << entry.first.string() << "\n";
       if (entry.first.extension() == ".yaml" ||
@@ -184,7 +177,7 @@ auto sourcemeta::jsonschema::cli::lint(
     }
   } else {
     for (const auto &entry :
-         for_each_json(options.at(""), parse_ignore(options),
+         for_each_json(options.positional(), parse_ignore(options),
                        parse_extensions(options))) {
       log_verbose(options) << "Linting: " << entry.first.string() << "\n";