Implement --only for lint to opt-in to specific rules (#436)

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

Author: jviotti

docs/lint.markdown

@@ -5,7 +5,8 @@ Linting
 jsonschema lint [schemas-or-directories...] [--http/-h] [--fix/-f]
   [--json/-j] [--verbose/-v] [--resolve/-r <schemas-or-directories> ...]
   [--extension/-e <extension>] [--ignore/-i <schemas-or-directories>]
-  [--exclude/-x <rule-name>] [--list/-l] [--default-dialect/-d <uri>]
+  [--exclude/-x <rule-name>] [--only/-o <rule-name>] [--list/-l]
+  [--default-dialect/-d <uri>]
 ```
 
 JSON Schema is a surprisingly expressive schema language. Like with traditional
@@ -81,6 +82,12 @@ jsonschema lint path/to/my/schema_1.json path/to/my/schema_2.json
 jsonschema lint path/to/my/schema.json --exclude enum_with_type --exclude const_with_type
 ```
 
+### Lint with only a set of preselected rules
+
+```sh
+jsonschema lint path/to/my/schema.json --only enum_with_type --only const_with_type
+```
+
 ### Lint with JSON output
 
 ```sh

src/command_lint.cc

@@ -98,7 +98,30 @@ auto sourcemeta::jsonschema::cli::lint(const sourcemeta::core::Options &options)
   bundle.add<sourcemeta::blaze::ValidDefault>(
       sourcemeta::blaze::default_schema_compiler);
 
-  if (options.contains("exclude")) {
+  if (options.contains("only")) {
+    if (options.contains("exclude")) {
+      std::cerr << "error: Cannot use --only and --exclude at the same time\n";
+      return EXIT_FAILURE;
+    }
+
+    std::unordered_set<std::string_view> blacklist;
+    for (const auto &entry : bundle) {
+      blacklist.emplace(entry.first);
+    }
+
+    for (const auto &only : options.at("only")) {
+      log_verbose(options) << "Only enabling rule: " << only << "\n";
+      if (blacklist.erase(only) == 0) {
+        std::cerr << "error: The following linting rule does not exist\n";
+        std::cerr << "  " << only << "\n";
+        return EXIT_FAILURE;
+      }
+    }
+
+    for (const auto &name : blacklist) {
+      bundle.remove(std::string{name});
+    }
+  } else if (options.contains("exclude")) {
     disable_lint_rules(bundle, options, options.at("exclude").cbegin(),
                        options.at("exclude").cend());
   }

src/main.cc

@@ -73,7 +73,7 @@ Global Options:
 
    lint [schemas-or-directories...] [--fix/-f] [--json/-j]
         [--extension/-e <extension>] [--ignore/-i <schemas-or-directories>]
-        [--exclude/-x <rule-name>] [--list/-l]
+        [--exclude/-x <rule-name>] [--only/-o <rule-name>] [--list/-l]
 
        Lint the input schemas and potentially fix the reported issues.
        The --fix/-f option is not supported when passing YAML schemas.
@@ -134,6 +134,7 @@ auto jsonschema_main(const std::string &program, const std::string &command,
     app.flag("list", {"l"});
     app.option("extension", {"e"});
     app.option("exclude", {"x"});
+    app.option("only", {"o"});
     app.option("ignore", {"i"});
     app.parse(argc, argv, {.skip = 1});
     return sourcemeta::jsonschema::cli::lint(app);

test/CMakeLists.txt

@@ -256,9 +256,15 @@ add_jsonschema_test_unix(lint/pass_lint_examples_nested_with_id)
 add_jsonschema_test_unix(lint/pass_lint_list_exclude)
 add_jsonschema_test_unix(lint/pass_lint_list_long)
 add_jsonschema_test_unix(lint/pass_lint_list_short)
+add_jsonschema_test_unix(lint/pass_lint_list_only_one)
+add_jsonschema_test_unix(lint/pass_lint_list_only_many)
 add_jsonschema_test_unix(lint/pass_lint_fix_no_reformat)
 add_jsonschema_test_unix(lint/pass_lint_directory_resolve_many)
 add_jsonschema_test_unix(lint/pass_lint_direct_custom_extension)
+add_jsonschema_test_unix(lint/fail_lint_only)
+add_jsonschema_test_unix(lint/fail_lint_only_with_exclude)
+add_jsonschema_test_unix(lint/fail_lint_only_unknown)
+add_jsonschema_test_unix(lint/fail_lint_only_unknown_verbose)
 
 # Encode
 add_jsonschema_test_unix(encode/pass_schema_less)

test/lint/fail_lint_only.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+
+set -o errexit
+set -o nounset
+
+TMP="$(mktemp -d)"
+clean() { rm -rf "$TMP"; }
+trap clean EXIT
+
+cat << 'EOF' > "$TMP/schema.json"
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "string",
+  "contentMediaType": "application/json",
+  "enum": [ "foo", "bar" ]
+}
+EOF
+
+"$1" lint "$TMP/schema.json" >"$TMP/stderr.txt" 2>&1 && CODE="$?" || CODE="$?"
+test "$CODE" = "1" || exit 1
+
+cat << EOF > "$TMP/expected.txt"
+$(realpath "$TMP")/schema.json:
+  The \`contentMediaType\` keyword is meaningless without the presence of the \`contentEncoding\` keyword (content_media_type_without_encoding)
+    at schema location ""
+$(realpath "$TMP")/schema.json:
+  Setting \`type\` alongside \`enum\` is considered an anti-pattern, as the enumeration choices already imply their respective types (enum_with_type)
+    at schema location ""
+EOF
+
+diff "$TMP/stderr.txt" "$TMP/expected.txt"
+
+"$1" lint "$TMP/schema.json" --only content_media_type_without_encoding >"$TMP/stderr.txt" 2>&1 && CODE="$?" || CODE="$?"
+
+cat << EOF > "$TMP/expected.txt"
+$(realpath "$TMP")/schema.json:
+  The \`contentMediaType\` keyword is meaningless without the presence of the \`contentEncoding\` keyword (content_media_type_without_encoding)
+    at schema location ""
+EOF
+
+diff "$TMP/stderr.txt" "$TMP/expected.txt"

test/lint/fail_lint_only_unknown.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -o errexit
+set -o nounset
+
+TMP="$(mktemp -d)"
+clean() { rm -rf "$TMP"; }
+trap clean EXIT
+
+cat << 'EOF' > "$TMP/schema.json"
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "string",
+  "enum": [ "foo" ]
+}
+EOF
+
+"$1" lint "$TMP/schema.json" --only foobarbaz \
+  >"$TMP/stderr.txt" 2>&1 && CODE="$?" || CODE="$?"
+test "$CODE" = "1" || exit 1
+
+cat << EOF > "$TMP/expected.txt"
+error: The following linting rule does not exist
+  foobarbaz
+EOF
+
+diff "$TMP/stderr.txt" "$TMP/expected.txt"

test/lint/fail_lint_only_unknown_verbose.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+set -o errexit
+set -o nounset
+
+TMP="$(mktemp -d)"
+clean() { rm -rf "$TMP"; }
+trap clean EXIT
+
+cat << 'EOF' > "$TMP/schema.json"
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "string",
+  "enum": [ "foo" ]
+}
+EOF
+
+"$1" lint "$TMP/schema.json" --only foobarbaz --verbose \
+  >"$TMP/stderr.txt" 2>&1 && CODE="$?" || CODE="$?"
+test "$CODE" = "1" || exit 1
+
+cat << EOF > "$TMP/expected.txt"
+Only enabling rule: foobarbaz
+error: The following linting rule does not exist
+  foobarbaz
+EOF
+
+diff "$TMP/stderr.txt" "$TMP/expected.txt"

test/lint/fail_lint_only_with_exclude.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -o errexit
+set -o nounset
+
+TMP="$(mktemp -d)"
+clean() { rm -rf "$TMP"; }
+trap clean EXIT
+
+cat << 'EOF' > "$TMP/schema.json"
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "type": "string",
+  "enum": [ "foo" ]
+}
+EOF
+
+"$1" lint "$TMP/schema.json" \
+  --only enum_with_type --exclude const_with_type --verbose \
+  >"$TMP/stderr.txt" 2>&1 && CODE="$?" || CODE="$?"
+test "$CODE" = "1" || exit 1
+
+cat << EOF > "$TMP/expected.txt"
+error: Cannot use --only and --exclude at the same time
+EOF
+
+diff "$TMP/stderr.txt" "$TMP/expected.txt"

test/lint/pass_lint_list_only_many.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+set -o errexit
+set -o nounset
+
+TMP="$(mktemp -d)"
+clean() { rm -rf "$TMP"; }
+trap clean EXIT
+
+"$1" lint --list --only then_empty --only then_without_if > "$TMP/output.txt"
+
+cat << 'EOF' > "$TMP/expected.txt"
+then_empty
+  Setting the `then` keyword to the empty schema does not add any further constraint
+
+then_without_if
+  The `then` keyword is meaningless without the presence of the `if` keyword
+
+Number of rules: 2
+EOF
+
+diff "$TMP/output.txt" "$TMP/expected.txt"

test/lint/pass_lint_list_only_one.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -o errexit
+set -o nounset
+
+TMP="$(mktemp -d)"
+clean() { rm -rf "$TMP"; }
+trap clean EXIT
+
+"$1" lint --list --only definitions_to_defs > "$TMP/output.txt"
+
+cat << 'EOF' > "$TMP/expected.txt"
+definitions_to_defs
+  `definitions` was superseded by `$defs` in 2019-09 and later versions
+
+Number of rules: 1
+EOF
+
+diff "$TMP/output.txt" "$TMP/expected.txt"