[WIP] Introduce a new --default-dialect option for most commands

See: #218
Signed-off-by: Juan Cruz Viotti <jv@jviotti.com>

Author: jviotti

docs/bundle.markdown

@@ -5,7 +5,7 @@ Bundling
 jsonschema bundle <schema.json|.yaml>
   [--http/-h] [--verbose/-v] [--resolve/-r <schemas-or-directories> ...]
   [--extension/-e <extension>] [--ignore/-i <schemas-or-directories>]
-  [--without-id/-w]
+  [--without-id/-w] [--default-dialect, -l <uri>]
 ```
 
 A schema may contain references to remote schemas outside the scope of the

docs/decode.markdown

@@ -3,6 +3,7 @@ Decode
 
 ```sh
 jsonschema decode <output.binpack> <output.json|.jsonl>
+  [--default-dialect, -l <uri>]
 ```
 
 This command decodes a JSON document using [JSON

docs/encode.markdown

@@ -3,6 +3,7 @@ Encode
 
 ```sh
 jsonschema encode <document.json|.jsonl> <output.binpack>
+  [--default-dialect, -l <uri>]
 ```
 
 This command encodes a JSON document using [JSON

docs/inspect.markdown

@@ -3,6 +3,7 @@ Framing
 
 ```sh
 jsonschema inspect <schema.json|.yaml> [--json/-j] [--verbose/-v]
+  [--default-dialect, -l <uri>]
 ```
 
 To evaluate a schema, an implementation will first scan it to determine the

docs/lint.markdown

@@ -5,7 +5,7 @@ Linting
 jsonschema lint [schemas-or-directories...]
   [--fix/-f] [--json/-j] [--verbose/-v] [--extension/-e <extension>]
   [--ignore/-i <schemas-or-directories>] [--disable/-d <rule-name>]
-  [--keep-ordering/-k]
+  [--keep-ordering/-k] [--default-dialect, -l <uri>]
 ```
 
 JSON Schema is a surprisingly expressive schema language. Like with traditional

docs/metaschema.markdown

@@ -8,6 +8,7 @@ Metaschema
 jsonschema metaschema [schemas-or-directories...]
   [--verbose/-v] [--http/-h] [--extension/-e <extension>]
   [--ignore/-i <schemas-or-directories>] [--trace/-t]
+  [--default-dialect, -l <uri>]
 ```
 
 Ensure that a schema or a set of schemas are considered valid with regards to

docs/test.markdown

@@ -8,6 +8,7 @@ Testing
 jsonschema test [schemas-or-directories...]
   [--http/-h] [--verbose/-v] [--resolve/-r <schemas-or-directories> ...]
   [--extension/-e <extension>] [--ignore/-i <schemas-or-directories>]
+  [--default-dialect, -l <uri>]
 ```
 
 Schemas are code. As such, you should run an automated unit testing suite

docs/validate.markdown

@@ -7,8 +7,8 @@ Validating
 ```sh
 jsonschema validate <schema.json|.yaml> <instance.json|.jsonl|.yaml...> [--http/-h]
   [--verbose/-v] [--resolve/-r <schemas-or-directories> ...] [--benchmark/-b]
-  [--extension/-e <extension>] [--ignore/-i <schemas-or-directories>] [--trace/-t] 
-  [--fast/-f]
+  [--extension/-e <extension>] [--ignore/-i <schemas-or-directories>] [--trace/-t]
+  [--fast/-f] [--default-dialect, -l <uri>]
 ```
 
 The most popular use case of JSON Schema is to validate JSON documents. The

src/command_bundle.cc

@@ -11,6 +11,7 @@ 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 auto dialect{default_dialect(options)};
 
   if (options.at("").size() < 1) {
     std::cerr
@@ -23,13 +24,17 @@ auto sourcemeta::jsonschema::cli::bundle(
 
   sourcemeta::core::bundle(
       schema, sourcemeta::core::schema_official_walker,
-      resolver(options, options.contains("h") || options.contains("http")));
+      resolver(options, options.contains("h") || options.contains("http"),
+               dialect),
+      dialect);
 
   if (options.contains("w") || options.contains("without-id")) {
     log_verbose(options) << "Removing schema identifiers\n";
     sourcemeta::core::unidentify(
         schema, sourcemeta::core::schema_official_walker,
-        resolver(options, options.contains("h") || options.contains("http")));
+        resolver(options, options.contains("h") || options.contains("http"),
+                 dialect),
+        dialect);
   }
 
   sourcemeta::core::prettify(schema, std::cout,

src/command_decode.cc

@@ -42,9 +42,11 @@ auto sourcemeta::jsonschema::cli::decode(
     "$schema": "https://json-schema.org/draft/2020-12/schema"
   })JSON")};
 
+  const auto dialect{default_dialect(options)};
   sourcemeta::jsonbinpack::compile(
       schema, sourcemeta::core::schema_official_walker,
-      resolver(options, options.contains("h") || options.contains("http")));
+      resolver(options, options.contains("h") || options.contains("http"),
+               dialect));
   const auto encoding{sourcemeta::jsonbinpack::load(schema)};
 
   std::ifstream input_stream{sourcemeta::jsonschema::cli::safe_weakly_canonical(

src/command_encode.cc

@@ -29,9 +29,11 @@ auto sourcemeta::jsonschema::cli::encode(
     "$schema": "https://json-schema.org/draft/2020-12/schema"
   })JSON")};
 
+  const auto dialect{default_dialect(options)};
   sourcemeta::jsonbinpack::compile(
       schema, sourcemeta::core::schema_official_walker,
-      resolver(options, options.contains("h") || options.contains("http")));
+      resolver(options, options.contains("h") || options.contains("http"),
+               dialect));
   const auto encoding{sourcemeta::jsonbinpack::load(schema)};
 
   const std::filesystem::path document{options.at("").front()};

src/command_inspect.cc

@@ -22,8 +22,13 @@ auto sourcemeta::jsonschema::cli::inspect(
 
   sourcemeta::core::SchemaFrame frame{
       sourcemeta::core::SchemaFrame::Mode::Instances};
+
+  const auto dialect{default_dialect(options)};
   frame.analyse(schema, sourcemeta::core::schema_official_walker,
-                resolver(options));
+                resolver(options,
+                         options.contains("h") || options.contains("http"),
+                         dialect),
+                dialect);
 
   if (options.contains("json") || options.contains("j")) {
     sourcemeta::core::prettify(frame.to_json(), std::cout);

src/command_lint.cc

@@ -61,6 +61,7 @@ auto sourcemeta::jsonschema::cli::lint(
 
   bool result{true};
   auto errors_array = sourcemeta::core::JSON::make_array();
+  const auto dialect{default_dialect(options)};
 
   if (options.contains("f") || options.contains("fix")) {
     for (const auto &entry :
@@ -75,7 +76,10 @@ auto sourcemeta::jsonschema::cli::lint(
 
       auto copy = entry.second;
       bundle.apply(copy, sourcemeta::core::schema_official_walker,
-                   resolver(options));
+                   resolver(options,
+                            options.contains("h") || options.contains("http"),
+                            dialect),
+                   dialect);
       std::ofstream output{entry.first};
       if (options.contains("k") || options.contains("keep-ordering")) {
         sourcemeta::core::prettify(copy, output);
@@ -91,7 +95,8 @@ auto sourcemeta::jsonschema::cli::lint(
     log_verbose(options) << "Linting: " << entry.first.string() << "\n";
     const bool subresult = bundle.check(
         entry.second, sourcemeta::core::schema_official_walker,
-        resolver(options),
+        resolver(options, options.contains("h") || options.contains("http"),
+                 dialect),
         [&](const auto &pointer, const auto &name, const auto &message) {
           if (output_json) {
             auto error_obj = sourcemeta::core::JSON::make_object();
@@ -114,7 +119,8 @@ auto sourcemeta::jsonschema::cli::lint(
             sourcemeta::core::stringify(pointer, std::cout);
             std::cout << "\"\n";
           }
-        });
+        },
+        dialect);
 
     if (!subresult) {
       result = false;

src/command_metaschema.cc

@@ -18,8 +18,10 @@ auto sourcemeta::jsonschema::cli::metaschema(
     const std::span<const std::string> &arguments) -> int {
   const auto options{parse_options(arguments, {"h", "http", "t", "trace"})};
   const auto trace{options.contains("t") || options.contains("trace")};
+  const auto default_dialect_option{default_dialect(options)};
   const auto custom_resolver{
-      resolver(options, options.contains("h") || options.contains("http"))};
+      resolver(options, options.contains("h") || options.contains("http"),
+               default_dialect_option)};
   bool result{true};
   sourcemeta::blaze::Evaluator evaluator;
 
@@ -37,16 +39,17 @@ auto sourcemeta::jsonschema::cli::metaschema(
       return EXIT_FAILURE;
     }
 
-    const auto dialect{sourcemeta::core::dialect(entry.second)};
+    const auto dialect{
+        sourcemeta::core::dialect(entry.second, default_dialect_option)};
     assert(dialect.has_value());
 
-    const auto metaschema{
-        sourcemeta::core::metaschema(entry.second, custom_resolver)};
+    const auto metaschema{sourcemeta::core::metaschema(
+        entry.second, custom_resolver, default_dialect_option)};
     if (!cache.contains(dialect.value())) {
       const auto metaschema_template{sourcemeta::blaze::compile(
           metaschema, sourcemeta::core::schema_official_walker, custom_resolver,
           sourcemeta::blaze::default_schema_compiler,
-          sourcemeta::blaze::Mode::Exhaustive)};
+          sourcemeta::blaze::Mode::Exhaustive, default_dialect_option)};
       cache.insert({dialect.value(), metaschema_template});
     }
 

src/command_test.cc

@@ -44,8 +44,9 @@ auto sourcemeta::jsonschema::cli::test(
     const std::span<const std::string> &arguments) -> int {
   const auto options{parse_options(arguments, {"h", "http"})};
   bool result{true};
-  const auto test_resolver{
-      resolver(options, options.contains("h") || options.contains("http"))};
+  const auto dialect{default_dialect(options)};
+  const auto test_resolver{resolver(
+      options, options.contains("h") || options.contains("http"), dialect)};
   const auto verbose{options.contains("verbose") || options.contains("v")};
   sourcemeta::blaze::Evaluator evaluator;
 
@@ -117,7 +118,8 @@ auto sourcemeta::jsonschema::cli::test(
     try {
       schema_template = sourcemeta::blaze::compile(
           schema, sourcemeta::core::schema_official_walker, test_resolver,
-          sourcemeta::blaze::default_schema_compiler);
+          sourcemeta::blaze::default_schema_compiler,
+          sourcemeta::blaze::Mode::FastValidation, dialect);
     } catch (const sourcemeta::core::SchemaReferenceError &error) {
       if (error.location() == sourcemeta::core::Pointer{"$ref"} &&
           error.id() == schema_uri.recompose()) {

src/command_validate.cc

@@ -39,8 +39,9 @@ auto sourcemeta::jsonschema::cli::validate(
   }
 
   const auto &schema_path{options.at("").at(0)};
-  const auto custom_resolver{
-      resolver(options, options.contains("h") || options.contains("http"))};
+  const auto dialect{default_dialect(options)};
+  const auto custom_resolver{resolver(
+      options, options.contains("h") || options.contains("http"), dialect)};
 
   const auto schema{sourcemeta::jsonschema::cli::read_file(schema_path)};
 
@@ -54,14 +55,14 @@ auto sourcemeta::jsonschema::cli::validate(
   }
 
   const auto fast_mode{options.contains("f") || options.contains("fast")};
-
   const auto benchmark{options.contains("b") || options.contains("benchmark")};
   const auto trace{options.contains("t") || options.contains("trace")};
   const auto schema_template{sourcemeta::blaze::compile(
       schema, sourcemeta::core::schema_official_walker, custom_resolver,
       sourcemeta::blaze::default_schema_compiler,
       fast_mode ? sourcemeta::blaze::Mode::FastValidation
-                : sourcemeta::blaze::Mode::Exhaustive)};
+                : sourcemeta::blaze::Mode::Exhaustive,
+      dialect)};
   sourcemeta::blaze::Evaluator evaluator;
 
   bool result{true};

src/main.cc

@@ -16,9 +16,11 @@
 constexpr std::string_view USAGE_DETAILS{R"EOF(
 Global Options:
 
-   --verbose, -v    Enable verbose output
-   --resolve, -r    Import the given JSON Schema (or directory of schemas)
-                    into the resolution context
+   --verbose, -v                  Enable verbose output
+   --resolve, -r                  Import the given JSON Schema (or directory of schemas)
+                                  into the resolution context
+   --default-dialect, -l <uri>    Specify the URI for the default dialect to be used
+                                  if the `$schema` keyword is not set
 
 Commands:
 

src/utils.cc

@@ -273,7 +273,9 @@ static auto fallback_resolver(
 }
 
 auto resolver(const std::map<std::string, std::vector<std::string>> &options,
-              const bool remote) -> sourcemeta::core::SchemaResolver {
+              const bool remote,
+              const std::optional<std::string> &default_dialect)
+    -> sourcemeta::core::SchemaResolver {
   sourcemeta::core::SchemaMapResolver dynamic_resolver{
       [remote, &options](std::string_view identifier) {
         if (remote) {
@@ -289,7 +291,7 @@ auto resolver(const std::map<std::string, std::vector<std::string>> &options,
                        parse_extensions(options))) {
       log_verbose(options) << "Importing schema into the resolution context: "
                            << entry.first.string() << "\n";
-      dynamic_resolver.add(entry.second);
+      dynamic_resolver.add(entry.second, default_dialect);
     }
   }
 
@@ -299,7 +301,7 @@ auto resolver(const std::map<std::string, std::vector<std::string>> &options,
                        parse_extensions(options))) {
       log_verbose(options) << "Importing schema into the resolution context: "
                            << entry.first.string() << "\n";
-      dynamic_resolver.add(entry.second);
+      dynamic_resolver.add(entry.second, default_dialect);
     }
   }
 
@@ -375,4 +377,19 @@ auto safe_weakly_canonical(const std::filesystem::path &input)
              : std::filesystem::weakly_canonical(input);
 }
 
+auto default_dialect(
+    const std::map<std::string, std::vector<std::string>> &options)
+    -> std::optional<std::string> {
+
+  if (options.contains("default-dialect")) {
+    return options.at("default-dialect").front();
+  }
+
+  if (options.contains("l")) {
+    return options.at("l").front();
+  }
+
+  return std::nullopt;
+}
+
 } // namespace sourcemeta::jsonschema::cli

src/utils.h

@@ -37,7 +37,9 @@ auto print(const sourcemeta::blaze::TraceOutput &output, std::ostream &stream)
     -> void;
 
 auto resolver(const std::map<std::string, std::vector<std::string>> &options,
-              const bool remote = false) -> sourcemeta::core::SchemaResolver;
+              const bool remote,
+              const std::optional<std::string> &default_dialect)
+    -> sourcemeta::core::SchemaResolver;
 
 auto log_verbose(const std::map<std::string, std::vector<std::string>> &options)
     -> std::ostream &;
@@ -53,6 +55,10 @@ auto parse_ignore(
 auto safe_weakly_canonical(const std::filesystem::path &input)
     -> std::filesystem::path;
 
+auto default_dialect(
+    const std::map<std::string, std::vector<std::string>> &options)
+    -> std::optional<std::string>;
+
 } // namespace sourcemeta::jsonschema::cli
 
 #endif

test/CMakeLists.txt

@@ -62,6 +62,7 @@ add_jsonschema_test_unix(validate/pass_draft6)
 add_jsonschema_test_unix(validate/pass_draft7)
 add_jsonschema_test_unix(validate/pass_2019_09)
 add_jsonschema_test_unix(validate/pass_2020_12)
+add_jsonschema_test_unix(validate/pass_2020_12_default_dialect)
 add_jsonschema_test_unix(validate/pass_2020_12_fast)
 add_jsonschema_test_unix(validate/fail_draft4)
 add_jsonschema_test_unix(validate/fail_draft6)
@@ -101,6 +102,7 @@ add_jsonschema_test_unix(metaschema/fail_non_schema)
 add_jsonschema_test_unix(metaschema/pass_cwd)
 add_jsonschema_test_unix(metaschema/pass_single)
 add_jsonschema_test_unix(metaschema/pass_2020_12)
+add_jsonschema_test_unix(metaschema/pass_2020_12_default_dialect)
 
 # Test
 add_jsonschema_test_unix(test/fail_resolve_directory_non_schema)
@@ -133,6 +135,7 @@ add_jsonschema_test_unix(test/pass_empty)
 add_jsonschema_test_unix(test/pass_empty_verbose)
 add_jsonschema_test_unix(test/pass_single_yaml)
 add_jsonschema_test_unix(test/pass_single_resolve)
+add_jsonschema_test_unix(test/pass_single_resolve_default_dialect)
 add_jsonschema_test_unix(test/pass_single_resolve_verbose)
 add_jsonschema_test_unix(test/pass_single_resolve_fragment)
 add_jsonschema_test_unix(test/pass_single_resolve_fragment_verbose)
@@ -150,6 +153,7 @@ add_jsonschema_test_unix(bundle/pass_resolve_directory)
 add_jsonschema_test_unix(bundle/pass_resolve_directory_verbose)
 add_jsonschema_test_unix(bundle/pass_resolve_metaschema)
 add_jsonschema_test_unix(bundle/pass_resolve_single)
+add_jsonschema_test_unix(bundle/pass_resolve_single_default_dialect)
 add_jsonschema_test_unix(bundle/pass_resolve_yaml)
 add_jsonschema_test_unix(bundle/pass_resolve_with_ignore)
 add_jsonschema_test_unix(bundle/pass_without_id)
@@ -165,6 +169,7 @@ add_jsonschema_test_unix(bundle/fail_bigint)
 
 # Inspect
 add_jsonschema_test_unix(inspect/pass)
+add_jsonschema_test_unix(inspect/pass_default_dialect)
 add_jsonschema_test_unix(inspect/pass_yaml)
 add_jsonschema_test_unix(inspect/pass_json_output)
 add_jsonschema_test_unix(inspect/fail_no_schema)
@@ -176,6 +181,7 @@ add_jsonschema_test_unix(lint/pass_lint_fix)
 add_jsonschema_test_unix(lint/pass_lint_fix_keep_ordering)
 add_jsonschema_test_unix(lint/pass_lint_no_fix)
 add_jsonschema_test_unix(lint/fail_lint)
+add_jsonschema_test_unix(lint/fail_lint_default_dialect)
 add_jsonschema_test_unix(lint/fail_lint_yaml)
 add_jsonschema_test_unix(lint/fail_lint_fix_yaml)
 add_jsonschema_test_unix(lint/fail_lint_fix_yml)