From 4fd779f2538942d4059b60f8c8a6402f2a9ff4ff Mon Sep 17 00:00:00 2001 From: Juan Cruz Viotti Date: Fri, 4 Oct 2024 18:28:05 -0400 Subject: [PATCH] Upgrade AlterSchema to `358df64771979da64e043a416cf340d83a5382ca` (#171) Signed-off-by: Juan Cruz Viotti --- DEPENDENCIES | 2 +- .../sourcemeta/alterschema/engine_bundle.h | 32 ++++++++++--------- .../sourcemeta/alterschema/engine_rule.h | 22 +++++++------ .../src/linter/antipattern/const_with_type.h | 9 +++--- .../antipattern/duplicate_enum_values.h | 9 +++--- .../antipattern/duplicate_required_values.h | 9 +++--- .../src/linter/antipattern/enum_with_type.h | 9 +++--- .../exclusive_maximum_number_and_maximum.h | 9 +++--- .../exclusive_minimum_number_and_minimum.h | 9 +++--- .../src/linter/desugar/boolean_true.h | 9 +++--- .../src/linter/desugar/const_as_enum.h | 9 +++--- .../exclusive_maximum_integer_to_maximum.h | 9 +++--- .../exclusive_minimum_integer_to_minimum.h | 9 +++--- .../desugar/type_array_to_any_of_2020_12.h | 9 +++--- .../src/linter/desugar/type_boolean_as_enum.h | 9 +++--- .../src/linter/desugar/type_null_as_enum.h | 9 +++--- .../max_contains_covered_by_max_items.h | 9 +++--- .../implicit/min_items_given_min_contains.h | 9 +++--- .../src/linter/implicit/min_items_implicit.h | 9 +++--- .../src/linter/implicit/min_length_implicit.h | 9 +++--- .../min_properties_covered_by_required.h | 9 +++--- .../linter/implicit/min_properties_implicit.h | 9 +++--- .../linter/implicit/multiple_of_implicit.h | 9 +++--- .../src/linter/implicit/properties_implicit.h | 9 +++--- .../src/linter/implicit/type_union_implicit.h | 9 +++--- .../redundant/additional_properties_default.h | 9 +++--- .../linter/redundant/content_schema_default.h | 9 +++--- .../linter/redundant/dependencies_default.h | 9 +++--- .../redundant/dependent_required_default.h | 9 +++--- .../linter/redundant/items_array_default.h | 9 +++--- .../linter/redundant/items_schema_default.h | 9 +++--- .../redundant/pattern_properties_default.h | 9 +++--- .../src/linter/redundant/properties_default.h | 9 +++--- .../redundant/unevaluated_items_default.h | 9 +++--- .../unevaluated_properties_default.h | 9 +++--- .../redundant/unsatisfiable_max_contains.h | 9 +++--- .../redundant/unsatisfiable_min_properties.h | 9 +++--- .../dependencies_property_tautology.h | 9 +++--- .../simplify/dependent_required_tautology.h | 9 +++--- .../simplify/equal_numeric_bounds_to_enum.h | 9 +++--- .../simplify/maximum_real_for_integer.h | 9 +++--- .../simplify/minimum_real_for_integer.h | 9 +++--- .../src/linter/simplify/single_type_array.h | 9 +++--- .../content_media_type_without_encoding.h | 9 +++--- .../content_schema_without_media_type.h | 9 +++--- ...op_non_array_keywords_applicator_2019_09.h | 9 +++--- ...op_non_array_keywords_applicator_2020_12.h | 9 +++--- .../drop_non_array_keywords_content_2019_09.h | 9 +++--- .../drop_non_array_keywords_content_2020_12.h | 9 +++--- .../drop_non_array_keywords_draft0.h | 9 +++--- .../drop_non_array_keywords_draft1.h | 9 +++--- .../drop_non_array_keywords_draft2.h | 9 +++--- .../drop_non_array_keywords_draft3.h | 9 +++--- .../drop_non_array_keywords_draft4.h | 9 +++--- .../drop_non_array_keywords_draft6.h | 9 +++--- .../drop_non_array_keywords_draft7.h | 9 +++--- .../drop_non_array_keywords_format_2019_09.h | 9 +++--- .../drop_non_array_keywords_format_2020_12.h | 9 +++--- ...p_non_array_keywords_unevaluated_2020_12.h | 9 +++--- ...op_non_array_keywords_validation_2019_09.h | 9 +++--- ...op_non_array_keywords_validation_2020_12.h | 9 +++--- ..._non_boolean_keywords_applicator_2019_09.h | 9 +++--- ..._non_boolean_keywords_applicator_2020_12.h | 9 +++--- ...rop_non_boolean_keywords_content_2019_09.h | 9 +++--- ...rop_non_boolean_keywords_content_2020_12.h | 9 +++--- .../drop_non_boolean_keywords_draft0.h | 9 +++--- .../drop_non_boolean_keywords_draft1.h | 9 +++--- .../drop_non_boolean_keywords_draft2.h | 9 +++--- .../drop_non_boolean_keywords_draft3.h | 9 +++--- .../drop_non_boolean_keywords_draft4.h | 9 +++--- .../drop_non_boolean_keywords_draft6.h | 9 +++--- .../drop_non_boolean_keywords_draft7.h | 9 +++--- ...drop_non_boolean_keywords_format_2019_09.h | 9 +++--- ...drop_non_boolean_keywords_format_2020_12.h | 9 +++--- ...non_boolean_keywords_unevaluated_2020_12.h | 9 +++--- ..._non_boolean_keywords_validation_2019_09.h | 9 +++--- ..._non_boolean_keywords_validation_2020_12.h | 9 +++--- ...rop_non_null_keywords_applicator_2019_09.h | 9 +++--- ...rop_non_null_keywords_applicator_2020_12.h | 9 +++--- .../drop_non_null_keywords_content_2019_09.h | 9 +++--- .../drop_non_null_keywords_content_2020_12.h | 9 +++--- .../drop_non_null_keywords_draft0.h | 9 +++--- .../drop_non_null_keywords_draft1.h | 9 +++--- .../drop_non_null_keywords_draft2.h | 9 +++--- .../drop_non_null_keywords_draft3.h | 9 +++--- .../drop_non_null_keywords_draft4.h | 9 +++--- .../drop_non_null_keywords_draft6.h | 9 +++--- .../drop_non_null_keywords_draft7.h | 9 +++--- .../drop_non_null_keywords_format_2019_09.h | 9 +++--- .../drop_non_null_keywords_format_2020_12.h | 9 +++--- ...op_non_null_keywords_unevaluated_2020_12.h | 9 +++--- ...rop_non_null_keywords_validation_2019_09.h | 9 +++--- ...rop_non_null_keywords_validation_2020_12.h | 9 +++--- ..._non_numeric_keywords_applicator_2019_09.h | 9 +++--- ..._non_numeric_keywords_applicator_2020_12.h | 9 +++--- ...rop_non_numeric_keywords_content_2019_09.h | 9 +++--- ...rop_non_numeric_keywords_content_2020_12.h | 9 +++--- .../drop_non_numeric_keywords_draft0.h | 9 +++--- .../drop_non_numeric_keywords_draft1.h | 9 +++--- .../drop_non_numeric_keywords_draft2.h | 9 +++--- .../drop_non_numeric_keywords_draft3.h | 9 +++--- .../drop_non_numeric_keywords_draft4.h | 9 +++--- .../drop_non_numeric_keywords_draft6.h | 9 +++--- .../drop_non_numeric_keywords_draft7.h | 9 +++--- ...drop_non_numeric_keywords_format_2019_09.h | 9 +++--- ...drop_non_numeric_keywords_format_2020_12.h | 9 +++--- ...non_numeric_keywords_unevaluated_2020_12.h | 9 +++--- ..._non_numeric_keywords_validation_2019_09.h | 9 +++--- ..._non_numeric_keywords_validation_2020_12.h | 9 +++--- ...p_non_object_keywords_applicator_2019_09.h | 9 +++--- ...p_non_object_keywords_applicator_2020_12.h | 9 +++--- ...drop_non_object_keywords_content_2019_09.h | 9 +++--- ...drop_non_object_keywords_content_2020_12.h | 9 +++--- .../drop_non_object_keywords_draft0.h | 9 +++--- .../drop_non_object_keywords_draft1.h | 9 +++--- .../drop_non_object_keywords_draft2.h | 9 +++--- .../drop_non_object_keywords_draft3.h | 9 +++--- .../drop_non_object_keywords_draft4.h | 9 +++--- .../drop_non_object_keywords_draft6.h | 9 +++--- .../drop_non_object_keywords_draft7.h | 9 +++--- .../drop_non_object_keywords_format_2019_09.h | 9 +++--- .../drop_non_object_keywords_format_2020_12.h | 9 +++--- ..._non_object_keywords_unevaluated_2020_12.h | 9 +++--- ...p_non_object_keywords_validation_2019_09.h | 9 +++--- ...p_non_object_keywords_validation_2020_12.h | 9 +++--- ...p_non_string_keywords_applicator_2019_09.h | 9 +++--- ...p_non_string_keywords_applicator_2020_12.h | 9 +++--- .../drop_non_string_keywords_draft0.h | 9 +++--- .../drop_non_string_keywords_draft1.h | 9 +++--- .../drop_non_string_keywords_draft2.h | 9 +++--- .../drop_non_string_keywords_draft3.h | 9 +++--- .../drop_non_string_keywords_draft4.h | 9 +++--- .../drop_non_string_keywords_draft6.h | 9 +++--- .../drop_non_string_keywords_draft7.h | 9 +++--- ..._non_string_keywords_unevaluated_2020_12.h | 9 +++--- ...p_non_string_keywords_validation_2019_09.h | 9 +++--- ...p_non_string_keywords_validation_2020_12.h | 9 +++--- .../superfluous/duplicate_allof_branches.h | 9 +++--- .../superfluous/duplicate_anyof_branches.h | 9 +++--- .../src/linter/superfluous/else_without_if.h | 9 +++--- .../linter/superfluous/if_without_then_else.h | 9 +++--- .../max_contains_without_contains.h | 9 +++--- .../min_contains_without_contains.h | 9 +++--- .../src/linter/superfluous/then_without_if.h | 9 +++--- .../src/linter/syntax_sugar/enum_to_const.h | 9 +++--- .../noa/cmake/noa/compiler/options.cmake | 16 +++++++++- .../vendor/noa/cmake/noa/library.cmake | 7 ++-- 147 files changed, 759 insertions(+), 598 deletions(-) diff --git a/DEPENDENCIES b/DEPENDENCIES index 26a7e50..ac5804c 100644 --- a/DEPENDENCIES +++ b/DEPENDENCIES @@ -2,5 +2,5 @@ vendorpull https://github.com/sourcemeta/vendorpull dea311b5bfb53b6926a414026795 noa https://github.com/sourcemeta/noa 517e88aef5981b88ac6bb8caff15d17dffcb4320 jsontoolkit https://github.com/sourcemeta/jsontoolkit b5c8f63fbc4b4b7a9cd4bdd71774d89db6ee2a99 hydra https://github.com/sourcemeta/hydra 3c53d3fdef79e9ba603d48470a508cc45472a0dc -alterschema https://github.com/sourcemeta/alterschema 744cf03a950b681a61f1f4cf6a7bb55bc52836c9 +alterschema https://github.com/sourcemeta/alterschema 358df64771979da64e043a416cf340d83a5382ca jsonbinpack https://github.com/sourcemeta/jsonbinpack 43d53dd32c432333deb1aea147095ed8707b5f11 diff --git a/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_bundle.h b/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_bundle.h index 39a5e56..f0fa2a1 100644 --- a/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_bundle.h +++ b/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_bundle.h @@ -103,13 +103,14 @@ class SOURCEMETA_ALTERSCHEMA_ENGINE_EXPORT Bundle { } /// Apply the bundle of rules to a schema - auto apply(sourcemeta::jsontoolkit::JSON &schema, - const sourcemeta::jsontoolkit::SchemaWalker &walker, - const sourcemeta::jsontoolkit::SchemaResolver &resolver, - const sourcemeta::jsontoolkit::Pointer &pointer = - sourcemeta::jsontoolkit::empty_pointer, - const std::optional &default_dialect = - std::nullopt) const -> void; + auto + apply(sourcemeta::jsontoolkit::JSON &schema, + const sourcemeta::jsontoolkit::SchemaWalker &walker, + const sourcemeta::jsontoolkit::SchemaResolver &resolver, + const sourcemeta::jsontoolkit::Pointer &pointer = + sourcemeta::jsontoolkit::empty_pointer, + const std::optional &default_dialect = std::nullopt) const + -> void; /// The callback that is called whenever the "check" functionality reports a /// rule whose condition holds true. The arguments are as follows: @@ -122,14 +123,15 @@ class SOURCEMETA_ALTERSCHEMA_ENGINE_EXPORT Bundle { const std::string_view, const std::string_view)>; /// Report back the rules from the bundle that need to be applied to a schema - auto check(const sourcemeta::jsontoolkit::JSON &schema, - const sourcemeta::jsontoolkit::SchemaWalker &walker, - const sourcemeta::jsontoolkit::SchemaResolver &resolver, - const CheckCallback &callback, - const sourcemeta::jsontoolkit::Pointer &pointer = - sourcemeta::jsontoolkit::empty_pointer, - const std::optional &default_dialect = - std::nullopt) const -> bool; + auto + check(const sourcemeta::jsontoolkit::JSON &schema, + const sourcemeta::jsontoolkit::SchemaWalker &walker, + const sourcemeta::jsontoolkit::SchemaResolver &resolver, + const CheckCallback &callback, + const sourcemeta::jsontoolkit::Pointer &pointer = + sourcemeta::jsontoolkit::empty_pointer, + const std::optional &default_dialect = std::nullopt) const + -> bool; private: // Exporting symbols that depends on the standard C++ library is considered diff --git a/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_rule.h b/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_rule.h index 0de7aef..35e79f1 100644 --- a/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_rule.h +++ b/vendor/alterschema/src/engine/include/sourcemeta/alterschema/engine_rule.h @@ -71,18 +71,20 @@ class SOURCEMETA_ALTERSCHEMA_ENGINE_EXPORT Rule { [[nodiscard]] auto message() const -> const std::string &; /// Apply the rule to a schema - auto apply(sourcemeta::jsontoolkit::JSON &schema, - const sourcemeta::jsontoolkit::Pointer &pointer, - const sourcemeta::jsontoolkit::SchemaResolver &resolver, - const std::optional &default_dialect = - std::nullopt) const -> std::vector; + auto + apply(sourcemeta::jsontoolkit::JSON &schema, + const sourcemeta::jsontoolkit::Pointer &pointer, + const sourcemeta::jsontoolkit::SchemaResolver &resolver, + const std::optional &default_dialect = std::nullopt) const + -> std::vector; /// Check if the rule applies to a schema - auto check(const sourcemeta::jsontoolkit::JSON &schema, - const sourcemeta::jsontoolkit::Pointer &pointer, - const sourcemeta::jsontoolkit::SchemaResolver &resolver, - const std::optional &default_dialect = - std::nullopt) const -> bool; + auto + check(const sourcemeta::jsontoolkit::JSON &schema, + const sourcemeta::jsontoolkit::Pointer &pointer, + const sourcemeta::jsontoolkit::SchemaResolver &resolver, + const std::optional &default_dialect = std::nullopt) const + -> bool; private: /// The rule condition diff --git a/vendor/alterschema/src/linter/antipattern/const_with_type.h b/vendor/alterschema/src/linter/antipattern/const_with_type.h index 51fe69d..a583d47 100644 --- a/vendor/alterschema/src/linter/antipattern/const_with_type.h +++ b/vendor/alterschema/src/linter/antipattern/const_with_type.h @@ -5,10 +5,11 @@ class ConstWithType final : public Rule { "Setting `type` alongside `const` is considered an anti-pattern, " "as the constant already implies its respective type"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/antipattern/duplicate_enum_values.h b/vendor/alterschema/src/linter/antipattern/duplicate_enum_values.h index 4030ea2..d3675c6 100644 --- a/vendor/alterschema/src/linter/antipattern/duplicate_enum_values.h +++ b/vendor/alterschema/src/linter/antipattern/duplicate_enum_values.h @@ -4,10 +4,11 @@ class DuplicateEnumValues final : public Rule { : Rule{"duplicate_enum_values", "Setting duplicate values in `enum` is " "considered an anti-pattern"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/antipattern/duplicate_required_values.h b/vendor/alterschema/src/linter/antipattern/duplicate_required_values.h index 358612d..2519bad 100644 --- a/vendor/alterschema/src/linter/antipattern/duplicate_required_values.h +++ b/vendor/alterschema/src/linter/antipattern/duplicate_required_values.h @@ -5,10 +5,11 @@ class DuplicateRequiredValues final : public Rule { "Setting duplicate values in `required` is considered an " "anti-pattern"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/antipattern/enum_with_type.h b/vendor/alterschema/src/linter/antipattern/enum_with_type.h index 2745301..dde564a 100644 --- a/vendor/alterschema/src/linter/antipattern/enum_with_type.h +++ b/vendor/alterschema/src/linter/antipattern/enum_with_type.h @@ -6,10 +6,11 @@ class EnumWithType final : public Rule { "Setting `type` alongside `enum` is considered an anti-pattern, as " "the enumeration choices already imply their respective types"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/antipattern/exclusive_maximum_number_and_maximum.h b/vendor/alterschema/src/linter/antipattern/exclusive_maximum_number_and_maximum.h index 972af98..691560c 100644 --- a/vendor/alterschema/src/linter/antipattern/exclusive_maximum_number_and_maximum.h +++ b/vendor/alterschema/src/linter/antipattern/exclusive_maximum_number_and_maximum.h @@ -5,10 +5,11 @@ class ExclusiveMaximumNumberAndMaximum final : public Rule { "Setting both `exclusiveMaximum` and `maximum` at the same time " "is considered an anti-pattern. You should choose one"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/antipattern/exclusive_minimum_number_and_minimum.h b/vendor/alterschema/src/linter/antipattern/exclusive_minimum_number_and_minimum.h index 440b24f..519537f 100644 --- a/vendor/alterschema/src/linter/antipattern/exclusive_minimum_number_and_minimum.h +++ b/vendor/alterschema/src/linter/antipattern/exclusive_minimum_number_and_minimum.h @@ -5,10 +5,11 @@ class ExclusiveMinimumNumberAndMinimum final : public Rule { "Setting both `exclusiveMinimum` and `minimum` at the same time " "is considered an anti-pattern. You should choose one"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/desugar/boolean_true.h b/vendor/alterschema/src/linter/desugar/boolean_true.h index b78ca0a..791635b 100644 --- a/vendor/alterschema/src/linter/desugar/boolean_true.h +++ b/vendor/alterschema/src/linter/desugar/boolean_true.h @@ -5,10 +5,11 @@ class BooleanTrue final : public Rule { "The boolean schema `true` is syntax sugar for the empty schema"} { }; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return schema.is_boolean() && schema.to_boolean(); } diff --git a/vendor/alterschema/src/linter/desugar/const_as_enum.h b/vendor/alterschema/src/linter/desugar/const_as_enum.h index 2545eca..534d19c 100644 --- a/vendor/alterschema/src/linter/desugar/const_as_enum.h +++ b/vendor/alterschema/src/linter/desugar/const_as_enum.h @@ -4,10 +4,11 @@ class ConstAsEnum final : public Rule { : Rule{"const_as_enum", "Setting `const` is syntax sugar for an " "enumeration of a single value"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/desugar/exclusive_maximum_integer_to_maximum.h b/vendor/alterschema/src/linter/desugar/exclusive_maximum_integer_to_maximum.h index c2d139b..13f27e8 100644 --- a/vendor/alterschema/src/linter/desugar/exclusive_maximum_integer_to_maximum.h +++ b/vendor/alterschema/src/linter/desugar/exclusive_maximum_integer_to_maximum.h @@ -5,10 +5,11 @@ class ExclusiveMaximumIntegerToMaximum final : public Rule { "Setting `exclusiveMaximum` when `type` is `integer` is syntax " "sugar for `maximum`") {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/desugar/exclusive_minimum_integer_to_minimum.h b/vendor/alterschema/src/linter/desugar/exclusive_minimum_integer_to_minimum.h index d1b37f0..4ba9a6c 100644 --- a/vendor/alterschema/src/linter/desugar/exclusive_minimum_integer_to_minimum.h +++ b/vendor/alterschema/src/linter/desugar/exclusive_minimum_integer_to_minimum.h @@ -5,10 +5,11 @@ class ExclusiveMinimumIntegerToMinimum final : public Rule { "Setting `exclusiveMinimum` when `type` is `integer` is syntax " "sugar for `minimum`") {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/desugar/type_array_to_any_of_2020_12.h b/vendor/alterschema/src/linter/desugar/type_array_to_any_of_2020_12.h index f59891c..4c0fc5a 100644 --- a/vendor/alterschema/src/linter/desugar/type_array_to_any_of_2020_12.h +++ b/vendor/alterschema/src/linter/desugar/type_array_to_any_of_2020_12.h @@ -5,10 +5,11 @@ class TypeArrayToAnyOf_2020_12 final : public Rule { "Setting `type` to more than one choice is syntax sugar to " "`anyOf` over the corresponding types"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/desugar/type_boolean_as_enum.h b/vendor/alterschema/src/linter/desugar/type_boolean_as_enum.h index d3693c6..fe694a6 100644 --- a/vendor/alterschema/src/linter/desugar/type_boolean_as_enum.h +++ b/vendor/alterschema/src/linter/desugar/type_boolean_as_enum.h @@ -5,10 +5,11 @@ class TypeBooleanAsEnum final : public Rule { "Setting `type` to `boolean` is syntax sugar for an enumeration " "of two values: `false` and `true`"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/desugar/type_null_as_enum.h b/vendor/alterschema/src/linter/desugar/type_null_as_enum.h index e2c6aa3..9bc6c23 100644 --- a/vendor/alterschema/src/linter/desugar/type_null_as_enum.h +++ b/vendor/alterschema/src/linter/desugar/type_null_as_enum.h @@ -5,10 +5,11 @@ class TypeNullAsEnum final : public Rule { "Setting `type` to `null` is syntax sugar for an enumeration " "of a single value: `null`"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/max_contains_covered_by_max_items.h b/vendor/alterschema/src/linter/implicit/max_contains_covered_by_max_items.h index 40ccef7..348772f 100644 --- a/vendor/alterschema/src/linter/implicit/max_contains_covered_by_max_items.h +++ b/vendor/alterschema/src/linter/implicit/max_contains_covered_by_max_items.h @@ -6,10 +6,11 @@ class MaxContainsCoveredByMaxItems final : public Rule { "equal to the array upper bound does not add any further " "constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/min_items_given_min_contains.h b/vendor/alterschema/src/linter/implicit/min_items_given_min_contains.h index 9e9ad51..a8ae861 100644 --- a/vendor/alterschema/src/linter/implicit/min_items_given_min_contains.h +++ b/vendor/alterschema/src/linter/implicit/min_items_given_min_contains.h @@ -5,10 +5,11 @@ class MinItemsGivenMinContains final : public sourcemeta::alterschema::Rule { "Every array has a minimum size of zero items but may be affected " "by `minContains`"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/min_items_implicit.h b/vendor/alterschema/src/linter/implicit/min_items_implicit.h index 6eebbde..a997cdf 100644 --- a/vendor/alterschema/src/linter/implicit/min_items_implicit.h +++ b/vendor/alterschema/src/linter/implicit/min_items_implicit.h @@ -4,10 +4,11 @@ class MinItemsImplicit final : public Rule { : Rule{"min_items_implicit", "Every array has a minimum size of zero items"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any(vocabularies, {"http://json-schema.org/draft-07/schema#", "http://json-schema.org/draft-06/schema#", diff --git a/vendor/alterschema/src/linter/implicit/min_length_implicit.h b/vendor/alterschema/src/linter/implicit/min_length_implicit.h index 4744f34..e69f3d5 100644 --- a/vendor/alterschema/src/linter/implicit/min_length_implicit.h +++ b/vendor/alterschema/src/linter/implicit/min_length_implicit.h @@ -4,10 +4,11 @@ class MinLengthImplicit final : public sourcemeta::alterschema::Rule { : Rule{"min_length_implicit", "Every string has a minimum length of zero characters"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/min_properties_covered_by_required.h b/vendor/alterschema/src/linter/implicit/min_properties_covered_by_required.h index c9e138f..036bc09 100644 --- a/vendor/alterschema/src/linter/implicit/min_properties_covered_by_required.h +++ b/vendor/alterschema/src/linter/implicit/min_properties_covered_by_required.h @@ -5,10 +5,11 @@ class MinPropertiesCoveredByRequired final : public Rule { "Setting `minProperties` to a number less than `required` does " "not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/min_properties_implicit.h b/vendor/alterschema/src/linter/implicit/min_properties_implicit.h index 776ba6e..7c81bd5 100644 --- a/vendor/alterschema/src/linter/implicit/min_properties_implicit.h +++ b/vendor/alterschema/src/linter/implicit/min_properties_implicit.h @@ -5,10 +5,11 @@ class MinPropertiesImplicit final : public Rule { "The `minProperties` keyword has a logical default of 0 or the " "size of `required`"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/multiple_of_implicit.h b/vendor/alterschema/src/linter/implicit/multiple_of_implicit.h index 9b36253..c12b12c 100644 --- a/vendor/alterschema/src/linter/implicit/multiple_of_implicit.h +++ b/vendor/alterschema/src/linter/implicit/multiple_of_implicit.h @@ -4,10 +4,11 @@ class MultipleOfImplicit final : public Rule { : Rule{"multiple_of_implicit", "The unit of `multipleOf` is the integer 1"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/implicit/properties_implicit.h b/vendor/alterschema/src/linter/implicit/properties_implicit.h index 4980cfe..b5945b8 100644 --- a/vendor/alterschema/src/linter/implicit/properties_implicit.h +++ b/vendor/alterschema/src/linter/implicit/properties_implicit.h @@ -4,10 +4,11 @@ class PropertiesImplicit final : public sourcemeta::alterschema::Rule { : Rule{"properties_implicit", "Every object has an implicit `properties` " "that consists of the empty object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return ((vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && vocabularies.contains( diff --git a/vendor/alterschema/src/linter/implicit/type_union_implicit.h b/vendor/alterschema/src/linter/implicit/type_union_implicit.h index d9c16d4..99e3157 100644 --- a/vendor/alterschema/src/linter/implicit/type_union_implicit.h +++ b/vendor/alterschema/src/linter/implicit/type_union_implicit.h @@ -4,10 +4,11 @@ class TypeUnionImplicit final : public sourcemeta::alterschema::Rule { : Rule{"type_union_implicit", "Not setting `type` is equivalent to accepting any type"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { if (!schema.is_object()) { return false; } diff --git a/vendor/alterschema/src/linter/redundant/additional_properties_default.h b/vendor/alterschema/src/linter/redundant/additional_properties_default.h index 9443eb2..ddcb561 100644 --- a/vendor/alterschema/src/linter/redundant/additional_properties_default.h +++ b/vendor/alterschema/src/linter/redundant/additional_properties_default.h @@ -5,10 +5,11 @@ class AdditionalPropertiesDefault final : public Rule { "Setting the `additionalProperties` keyword to the true schema " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/redundant/content_schema_default.h b/vendor/alterschema/src/linter/redundant/content_schema_default.h index 1228b23..4be61c2 100644 --- a/vendor/alterschema/src/linter/redundant/content_schema_default.h +++ b/vendor/alterschema/src/linter/redundant/content_schema_default.h @@ -5,10 +5,11 @@ class ContentSchemaDefault final : public Rule { "Setting the `contentSchema` keyword to the true schema " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/content", diff --git a/vendor/alterschema/src/linter/redundant/dependencies_default.h b/vendor/alterschema/src/linter/redundant/dependencies_default.h index 426cab0..b9bd21e 100644 --- a/vendor/alterschema/src/linter/redundant/dependencies_default.h +++ b/vendor/alterschema/src/linter/redundant/dependencies_default.h @@ -5,10 +5,11 @@ class DependenciesDefault final : public Rule { "Setting the `dependencies` keyword to an empty object " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any(vocabularies, {"http://json-schema.org/draft-07/schema#", "http://json-schema.org/draft-06/schema#", diff --git a/vendor/alterschema/src/linter/redundant/dependent_required_default.h b/vendor/alterschema/src/linter/redundant/dependent_required_default.h index bd9fe37..181d3ee 100644 --- a/vendor/alterschema/src/linter/redundant/dependent_required_default.h +++ b/vendor/alterschema/src/linter/redundant/dependent_required_default.h @@ -5,10 +5,11 @@ class DependentRequiredDefault final : public Rule { "Setting the `dependentRequired` keyword to an empty object " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/redundant/items_array_default.h b/vendor/alterschema/src/linter/redundant/items_array_default.h index b903c51..f28e2cc 100644 --- a/vendor/alterschema/src/linter/redundant/items_array_default.h +++ b/vendor/alterschema/src/linter/redundant/items_array_default.h @@ -5,10 +5,11 @@ class ItemsArrayDefault final : public Rule { "Setting the `items` keyword to the empty array " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2019-09/vocab/applicator", diff --git a/vendor/alterschema/src/linter/redundant/items_schema_default.h b/vendor/alterschema/src/linter/redundant/items_schema_default.h index abc716b..d861f9a 100644 --- a/vendor/alterschema/src/linter/redundant/items_schema_default.h +++ b/vendor/alterschema/src/linter/redundant/items_schema_default.h @@ -5,10 +5,11 @@ class ItemsSchemaDefault final : public Rule { "Setting the `items` keyword to the true schema " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/redundant/pattern_properties_default.h b/vendor/alterschema/src/linter/redundant/pattern_properties_default.h index 71ae322..eed8cf8 100644 --- a/vendor/alterschema/src/linter/redundant/pattern_properties_default.h +++ b/vendor/alterschema/src/linter/redundant/pattern_properties_default.h @@ -5,10 +5,11 @@ class PatternPropertiesDefault final : public Rule { "Setting the `patternProperties` keyword to the empty object " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/redundant/properties_default.h b/vendor/alterschema/src/linter/redundant/properties_default.h index 99b7015..ad76c01 100644 --- a/vendor/alterschema/src/linter/redundant/properties_default.h +++ b/vendor/alterschema/src/linter/redundant/properties_default.h @@ -5,10 +5,11 @@ class PropertiesDefault final : public Rule { "Setting the `properties` keyword to the empty object " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/redundant/unevaluated_items_default.h b/vendor/alterschema/src/linter/redundant/unevaluated_items_default.h index 548ba45..2da0cf5 100644 --- a/vendor/alterschema/src/linter/redundant/unevaluated_items_default.h +++ b/vendor/alterschema/src/linter/redundant/unevaluated_items_default.h @@ -5,10 +5,11 @@ class UnevaluatedItemsDefault final : public Rule { "Setting the `unevaluatedItems` keyword to the true schema " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/unevaluated", diff --git a/vendor/alterschema/src/linter/redundant/unevaluated_properties_default.h b/vendor/alterschema/src/linter/redundant/unevaluated_properties_default.h index ca5da92..8986361 100644 --- a/vendor/alterschema/src/linter/redundant/unevaluated_properties_default.h +++ b/vendor/alterschema/src/linter/redundant/unevaluated_properties_default.h @@ -5,10 +5,11 @@ class UnevaluatedPropertiesDefault final : public Rule { "Setting the `unevaluatedProperties` keyword to the true schema " "does not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/unevaluated", diff --git a/vendor/alterschema/src/linter/redundant/unsatisfiable_max_contains.h b/vendor/alterschema/src/linter/redundant/unsatisfiable_max_contains.h index 9987784..b097d9c 100644 --- a/vendor/alterschema/src/linter/redundant/unsatisfiable_max_contains.h +++ b/vendor/alterschema/src/linter/redundant/unsatisfiable_max_contains.h @@ -6,10 +6,11 @@ class UnsatisfiableMaxContains final : public Rule { "equal to the array upper bound does not add any further " "constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/redundant/unsatisfiable_min_properties.h b/vendor/alterschema/src/linter/redundant/unsatisfiable_min_properties.h index a4460d0..30db681 100644 --- a/vendor/alterschema/src/linter/redundant/unsatisfiable_min_properties.h +++ b/vendor/alterschema/src/linter/redundant/unsatisfiable_min_properties.h @@ -5,10 +5,11 @@ class UnsatisfiableMinProperties final : public Rule { "Setting `minProperties` to a number less than `required` does " "not add any further constraint"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/simplify/dependencies_property_tautology.h b/vendor/alterschema/src/linter/simplify/dependencies_property_tautology.h index 0a46c0d..52d51b0 100644 --- a/vendor/alterschema/src/linter/simplify/dependencies_property_tautology.h +++ b/vendor/alterschema/src/linter/simplify/dependencies_property_tautology.h @@ -6,10 +6,11 @@ class DependenciesPropertyTautology final : public Rule { "that is already marked as required is an unnecessarily complex " "use of `dependencies`"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any(vocabularies, {"http://json-schema.org/draft-07/schema#", "http://json-schema.org/draft-06/schema#", diff --git a/vendor/alterschema/src/linter/simplify/dependent_required_tautology.h b/vendor/alterschema/src/linter/simplify/dependent_required_tautology.h index a1d9307..d533654 100644 --- a/vendor/alterschema/src/linter/simplify/dependent_required_tautology.h +++ b/vendor/alterschema/src/linter/simplify/dependent_required_tautology.h @@ -6,10 +6,11 @@ class DependentRequiredTautology final : public Rule { "that is already marked as required is an unnecessarily complex " "use of `dependentRequired`"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/simplify/equal_numeric_bounds_to_enum.h b/vendor/alterschema/src/linter/simplify/equal_numeric_bounds_to_enum.h index f1f0a78..e6d9eef 100644 --- a/vendor/alterschema/src/linter/simplify/equal_numeric_bounds_to_enum.h +++ b/vendor/alterschema/src/linter/simplify/equal_numeric_bounds_to_enum.h @@ -5,10 +5,11 @@ class EqualNumericBoundsToEnum final : public Rule { "Setting `minimum` and `maximum` to the same number only leaves " "one possible value"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/simplify/maximum_real_for_integer.h b/vendor/alterschema/src/linter/simplify/maximum_real_for_integer.h index 1c8cf32..fe6144e 100644 --- a/vendor/alterschema/src/linter/simplify/maximum_real_for_integer.h +++ b/vendor/alterschema/src/linter/simplify/maximum_real_for_integer.h @@ -6,10 +6,11 @@ class MaximumRealForInteger final : public Rule { "number upper bound is the same as a floor of that upper bound"} { }; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/simplify/minimum_real_for_integer.h b/vendor/alterschema/src/linter/simplify/minimum_real_for_integer.h index 0c7c33d..1cec27b 100644 --- a/vendor/alterschema/src/linter/simplify/minimum_real_for_integer.h +++ b/vendor/alterschema/src/linter/simplify/minimum_real_for_integer.h @@ -5,10 +5,11 @@ class MinimumRealForInteger final : public Rule { "If an instance is guaranteed to be an integer, setting a real " "number lower bound is the same as a ceil of that lower bound"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/simplify/single_type_array.h b/vendor/alterschema/src/linter/simplify/single_type_array.h index 01a3399..0e81bd4 100644 --- a/vendor/alterschema/src/linter/simplify/single_type_array.h +++ b/vendor/alterschema/src/linter/simplify/single_type_array.h @@ -5,10 +5,11 @@ class SingleTypeArray final : public Rule { "Setting `type` to an array of a single type is " "the same as directly declaring such type"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/superfluous/content_media_type_without_encoding.h b/vendor/alterschema/src/linter/superfluous/content_media_type_without_encoding.h index 8a9f47d..6ea1196 100644 --- a/vendor/alterschema/src/linter/superfluous/content_media_type_without_encoding.h +++ b/vendor/alterschema/src/linter/superfluous/content_media_type_without_encoding.h @@ -5,10 +5,11 @@ class ContentMediaTypeWithoutEncoding final : public Rule { "The `contentMediaType` keyword is meaningless " "without the presence of the `contentEncoding` keyword"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any(vocabularies, {"https://json-schema.org/draft/2020-12/vocab/content", "https://json-schema.org/draft/2019-09/vocab/content", diff --git a/vendor/alterschema/src/linter/superfluous/content_schema_without_media_type.h b/vendor/alterschema/src/linter/superfluous/content_schema_without_media_type.h index f39d6d2..c6c0f03 100644 --- a/vendor/alterschema/src/linter/superfluous/content_schema_without_media_type.h +++ b/vendor/alterschema/src/linter/superfluous/content_schema_without_media_type.h @@ -5,10 +5,11 @@ class ContentSchemaWithoutMediaType final : public Rule { "The `contentSchema` keyword is meaningless without the presence " "of the `contentMediaType` keyword"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/content", diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2019_09.h index b243195..9077ee4 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2019_09.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsApplicator_2019_09 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2020_12.h index 05b0802..657dd98 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_applicator_2020_12.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsApplicator_2020_12 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2019_09.h index 75fc7a2..cc67175 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2019_09.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsContent_2019_09 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2020_12.h index a2f8263..520a092 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_content_2020_12.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsContent_2020_12 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft0.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft0.h index 98c7460..0d7259a 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft0.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft0.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft0 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-00/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft1.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft1.h index a44e710..1ac6a5a 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft1.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft1.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft1 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-01/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft2.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft2.h index 425b9f0..678f742 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft2.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft2.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft2 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-02/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft3.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft3.h index 7599fe8..772f74d 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft3.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft3.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft3 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-03/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft4.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft4.h index 913a945..70e9a6e 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft4.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft4.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft4 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-04/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft6.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft6.h index 5fc0ae4..ec7c978 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft6.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft6.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft6 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-06/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft7.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft7.h index 58c9dbd..e39358e 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft7.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_draft7.h @@ -5,10 +5,11 @@ class DropNonArrayKeywords_Draft7 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-07/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2019_09.h index 92d34bb..d385efc 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2019_09.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsFormat_2019_09 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2020_12.h index 4aea095..aeb8cc1 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_format_2020_12.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsFormat_2020_12 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_unevaluated_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_unevaluated_2020_12.h index e3ae17a..30692e1 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_unevaluated_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_unevaluated_2020_12.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsUnevaluated_2020_12 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2019_09.h index dcdcab1..2935606 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2019_09.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsValidation_2019_09 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2020_12.h index 58ecce5..4a4bb42 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_array_keywords_validation_2020_12.h @@ -5,10 +5,11 @@ class DropNonArrayKeywordsValidation_2020_12 final : public Rule { "Keywords that don't apply to arrays will never match if the " "instance is guaranteed to be an array"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2019_09.h index d26cb0f..598ee77 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2019_09.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsApplicator_2019_09 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2020_12.h index ae03d39..05c6332 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_applicator_2020_12.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsApplicator_2020_12 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2019_09.h index 33fe367..e86d962 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2019_09.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsContent_2019_09 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2020_12.h index bf1b98f..70e9956 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_content_2020_12.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsContent_2020_12 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft0.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft0.h index 91323dd..6c9ca8b 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft0.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft0.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft0 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-00/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft1.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft1.h index e9a8848..f6939fe 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft1.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft1.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft1 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-01/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft2.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft2.h index 09f1a27..e00dbb6 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft2.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft2.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft2 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-02/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft3.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft3.h index 97a7877..bf6b5c3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft3.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft3.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft3 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-03/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft4.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft4.h index 6840ec5..8d217ce 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft4.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft4.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft4 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-04/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft6.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft6.h index 94de111..976c12b 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft6.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft6.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft6 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-06/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft7.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft7.h index c66f550..72c5501 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft7.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_draft7.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywords_Draft7 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-07/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2019_09.h index 3e1d681..00b0148 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2019_09.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsFormat_2019_09 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2020_12.h index fc93814..2173162 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_format_2020_12.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsFormat_2020_12 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_unevaluated_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_unevaluated_2020_12.h index a2e2b3a..7b19e77 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_unevaluated_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_unevaluated_2020_12.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsUnevaluated_2020_12 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2019_09.h index 072b8e8..1c98da3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2019_09.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsValidation_2019_09 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2020_12.h index e3d5b81..4354ad2 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_boolean_keywords_validation_2020_12.h @@ -5,10 +5,11 @@ class DropNonBooleanKeywordsValidation_2020_12 final : public Rule { "Keywords that don't apply to booleans will never match if the " "instance is guaranteed to be a boolean"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2019_09.h index b6279f4..aa504a3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2019_09.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsApplicator_2019_09 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2020_12.h index f6958e0..739c956 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_applicator_2020_12.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsApplicator_2020_12 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2019_09.h index 9343c03..64bd596 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2019_09.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsContent_2019_09 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2020_12.h index 61538b1..00ce274 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_content_2020_12.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsContent_2020_12 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft0.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft0.h index 366d193..c14b247 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft0.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft0.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft0 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-00/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft1.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft1.h index 8b2a85d..4c97fe4 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft1.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft1.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft1 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-01/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft2.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft2.h index f06acf8..24a5138 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft2.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft2.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft2 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-02/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft3.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft3.h index ffb36cf..42944dd 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft3.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft3.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft3 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-03/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft4.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft4.h index 8aed21e..b8b3884 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft4.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft4.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft4 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-04/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft6.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft6.h index 2be83a8..e9d6f6b 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft6.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft6.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft6 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-06/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft7.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft7.h index a025d45..54fade5 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft7.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_draft7.h @@ -5,10 +5,11 @@ class DropNonNullKeywords_Draft7 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-07/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2019_09.h index 28592fc..07cc569 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2019_09.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsFormat_2019_09 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2020_12.h index de26f8d..2c9fca1 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_format_2020_12.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsFormat_2020_12 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_unevaluated_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_unevaluated_2020_12.h index de42538..b2b6154 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_unevaluated_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_unevaluated_2020_12.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsUnevaluated_2020_12 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2019_09.h index b35331f..2519108 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2019_09.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsValidation_2019_09 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2020_12.h index be528a4..d582185 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_null_keywords_validation_2020_12.h @@ -5,10 +5,11 @@ class DropNonNullKeywordsValidation_2020_12 final : public Rule { "Keywords that don't apply to null values will never match if the " "instance is guaranteed to be null"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2019_09.h index 6827d61..244eda1 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2019_09.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsApplicator_2019_09 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2020_12.h index e475d11..1dc03a7 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_applicator_2020_12.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsApplicator_2020_12 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2019_09.h index db6bac2..e03f530 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2019_09.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsContent_2019_09 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2020_12.h index 40f0194..5a5e3fc 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_content_2020_12.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsContent_2020_12 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft0.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft0.h index b8ac546..f975989 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft0.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft0.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft0 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-00/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft1.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft1.h index f27f584..160b258 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft1.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft1.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft1 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-01/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft2.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft2.h index 4b14b7b..6c17556 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft2.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft2.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft2 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-02/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft3.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft3.h index 82e02ca..5016397 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft3.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft3.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft3 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-03/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft4.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft4.h index 10b0bfd..fe3660b 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft4.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft4.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft4 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-04/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft6.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft6.h index 6fc5029..fcc8e9d 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft6.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft6.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft6 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-06/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft7.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft7.h index befe174..f9a5e64 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft7.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_draft7.h @@ -5,10 +5,11 @@ class DropNonNumericKeywords_Draft7 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-07/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2019_09.h index 1dc8145..fc624a3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2019_09.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsFormat_2019_09 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2020_12.h index 1fbe343..494f89d 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_format_2020_12.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsFormat_2020_12 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_unevaluated_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_unevaluated_2020_12.h index 919ff86..785ff10 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_unevaluated_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_unevaluated_2020_12.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsUnevaluated_2020_12 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2019_09.h index 7d6f186..74a7e7d 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2019_09.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsValidation_2019_09 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2020_12.h index c74e72b..df1de43 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_numeric_keywords_validation_2020_12.h @@ -5,10 +5,11 @@ class DropNonNumericKeywordsValidation_2020_12 final : public Rule { "Keywords that don't apply to numbers will never match if the " "instance is guaranteed to be a number"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2019_09.h index 59e255e..ee025b8 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2019_09.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsApplicator_2019_09 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2020_12.h index 212d009..65dbc84 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_applicator_2020_12.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsApplicator_2020_12 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2019_09.h index eb73b34..b82a1a3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2019_09.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsContent_2019_09 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2020_12.h index 70d2485..8202d24 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_content_2020_12.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsContent_2020_12 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft0.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft0.h index 67f4e46..6157e06 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft0.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft0.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft0 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-00/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft1.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft1.h index 56e84ca..8fea029 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft1.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft1.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft1 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-01/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft2.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft2.h index 0c21be2..7e56a29 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft2.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft2.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft2 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-02/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft3.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft3.h index d33ecb3..0112fc5 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft3.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft3.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft3 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-03/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft4.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft4.h index 55ecaea..eb9884b 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft4.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft4.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft4 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-04/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft6.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft6.h index 22942ef..13f0316 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft6.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft6.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft6 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-06/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft7.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft7.h index 3e0db71..52d7da5 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft7.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_draft7.h @@ -5,10 +5,11 @@ class DropNonObjectKeywords_Draft7 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-07/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2019_09.h index 3ac6973..51d9c15 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2019_09.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsFormat_2019_09 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2020_12.h index 8ab84ed..17a4406 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_format_2020_12.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsFormat_2020_12 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_unevaluated_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_unevaluated_2020_12.h index a486125..1ee11a1 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_unevaluated_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_unevaluated_2020_12.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsUnevaluated_2020_12 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2019_09.h index d41cff0..ef534c3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2019_09.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsValidation_2019_09 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2020_12.h index 90dc496..c2deb91 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_object_keywords_validation_2020_12.h @@ -5,10 +5,11 @@ class DropNonObjectKeywordsValidation_2020_12 final : public Rule { "Keywords that don't apply to objects will never match if the " "instance is guaranteed to be an object"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2019_09.h index 7133783..2d85479 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2019_09.h @@ -5,10 +5,11 @@ class DropNonStringKeywordsApplicator_2019_09 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2020_12.h index 0f6c4e7..3be2184 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_applicator_2020_12.h @@ -5,10 +5,11 @@ class DropNonStringKeywordsApplicator_2020_12 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft0.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft0.h index db7309e..1801751 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft0.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft0.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft0 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-00/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft1.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft1.h index d8099ee..a21f03e 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft1.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft1.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft1 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-01/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft2.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft2.h index 7b85ec2..2dfbc3c 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft2.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft2.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft2 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "http://json-schema.org/draft-02/hyper-schema#") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft3.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft3.h index 16b3376..0608aea 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft3.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft3.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft3 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-03/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft4.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft4.h index aacd47b..cf2a052 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft4.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft4.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft4 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-04/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft6.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft6.h index e3e9f03..99f5cf0 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft6.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft6.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft6 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-06/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft7.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft7.h index 5eff1fc..eefd2a3 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft7.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_draft7.h @@ -5,10 +5,11 @@ class DropNonStringKeywords_Draft7 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains("http://json-schema.org/draft-07/schema#") && schema.is_object() && schema.defines("type") && schema.at("type").is_string() && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_unevaluated_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_unevaluated_2020_12.h index 2d7495f..712960b 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_unevaluated_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_unevaluated_2020_12.h @@ -5,10 +5,11 @@ class DropNonStringKeywordsUnevaluated_2020_12 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2019_09.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2019_09.h index 0d69e75..12743af 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2019_09.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2019_09.h @@ -5,10 +5,11 @@ class DropNonStringKeywordsValidation_2019_09 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2019-09/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2020_12.h b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2020_12.h index 1caa459..da2b783 100644 --- a/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2020_12.h +++ b/vendor/alterschema/src/linter/superfluous/drop_non_string_keywords_validation_2020_12.h @@ -5,10 +5,11 @@ class DropNonStringKeywordsValidation_2020_12 final : public Rule { "Keywords that don't apply to strings will never match if the " "instance is guaranteed to be a string"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return vocabularies.contains( "https://json-schema.org/draft/2020-12/vocab/validation") && schema.is_object() && schema.defines("type") && diff --git a/vendor/alterschema/src/linter/superfluous/duplicate_allof_branches.h b/vendor/alterschema/src/linter/superfluous/duplicate_allof_branches.h index 66a82a8..1ed3f15 100644 --- a/vendor/alterschema/src/linter/superfluous/duplicate_allof_branches.h +++ b/vendor/alterschema/src/linter/superfluous/duplicate_allof_branches.h @@ -7,10 +7,11 @@ class DuplicateAllOfBranches final : public Rule { "unnecessary additional validation that is guaranteed to not " "affect the validation result"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/superfluous/duplicate_anyof_branches.h b/vendor/alterschema/src/linter/superfluous/duplicate_anyof_branches.h index c9b9a54..e309714 100644 --- a/vendor/alterschema/src/linter/superfluous/duplicate_anyof_branches.h +++ b/vendor/alterschema/src/linter/superfluous/duplicate_anyof_branches.h @@ -7,10 +7,11 @@ class DuplicateAnyOfBranches final : public Rule { "unnecessary additional validation that is guaranteed to not " "affect the validation result"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/superfluous/else_without_if.h b/vendor/alterschema/src/linter/superfluous/else_without_if.h index 83f2526..19d5838 100644 --- a/vendor/alterschema/src/linter/superfluous/else_without_if.h +++ b/vendor/alterschema/src/linter/superfluous/else_without_if.h @@ -4,10 +4,11 @@ class ElseWithoutIf final : public Rule { : Rule{"else_without_if", "The `else` keyword is meaningless " "without the presence of the `if` keyword"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/superfluous/if_without_then_else.h b/vendor/alterschema/src/linter/superfluous/if_without_then_else.h index 5a9735a..c81c577 100644 --- a/vendor/alterschema/src/linter/superfluous/if_without_then_else.h +++ b/vendor/alterschema/src/linter/superfluous/if_without_then_else.h @@ -5,10 +5,11 @@ class IfWithoutThenElse final : public Rule { "The `if` keyword is meaningless " "without the presence of the `then` or `else` keywords"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/superfluous/max_contains_without_contains.h b/vendor/alterschema/src/linter/superfluous/max_contains_without_contains.h index 3cc9249..6358df3 100644 --- a/vendor/alterschema/src/linter/superfluous/max_contains_without_contains.h +++ b/vendor/alterschema/src/linter/superfluous/max_contains_without_contains.h @@ -5,10 +5,11 @@ class MaxContainsWithoutContains final : public Rule { "The `maxContains` keyword is meaningless " "without the presence of the `contains` keyword"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/superfluous/min_contains_without_contains.h b/vendor/alterschema/src/linter/superfluous/min_contains_without_contains.h index 73246c6..7321e54 100644 --- a/vendor/alterschema/src/linter/superfluous/min_contains_without_contains.h +++ b/vendor/alterschema/src/linter/superfluous/min_contains_without_contains.h @@ -5,10 +5,11 @@ class MinContainsWithoutContains final : public Rule { "The `minContains` keyword is meaningless " "without the presence of the `contains` keyword"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/src/linter/superfluous/then_without_if.h b/vendor/alterschema/src/linter/superfluous/then_without_if.h index f952f59..9f1ad2c 100644 --- a/vendor/alterschema/src/linter/superfluous/then_without_if.h +++ b/vendor/alterschema/src/linter/superfluous/then_without_if.h @@ -4,10 +4,11 @@ class ThenWithoutIf final : public Rule { : Rule{"then_without_if", "The `then` keyword is meaningless " "without the presence of the `if` keyword"} {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/applicator", diff --git a/vendor/alterschema/src/linter/syntax_sugar/enum_to_const.h b/vendor/alterschema/src/linter/syntax_sugar/enum_to_const.h index d7c5694..69aa67e 100644 --- a/vendor/alterschema/src/linter/syntax_sugar/enum_to_const.h +++ b/vendor/alterschema/src/linter/syntax_sugar/enum_to_const.h @@ -4,10 +4,11 @@ class EnumToConst final : public Rule { : Rule("enum_to_const", "An `enum` of a single value can be expressed as `const`") {}; - [[nodiscard]] auto - condition(const sourcemeta::jsontoolkit::JSON &schema, const std::string &, - const std::set &vocabularies, - const sourcemeta::jsontoolkit::Pointer &) const -> bool override { + [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema, + const std::string &, + const std::set &vocabularies, + const sourcemeta::jsontoolkit::Pointer &) const + -> bool override { return contains_any( vocabularies, {"https://json-schema.org/draft/2020-12/vocab/validation", diff --git a/vendor/alterschema/vendor/noa/cmake/noa/compiler/options.cmake b/vendor/alterschema/vendor/noa/cmake/noa/compiler/options.cmake index c859781..b1fc6e5 100644 --- a/vendor/alterschema/vendor/noa/cmake/noa/compiler/options.cmake +++ b/vendor/alterschema/vendor/noa/cmake/noa/compiler/options.cmake @@ -40,6 +40,8 @@ function(noa_add_default_options visibility target) -Wnon-virtual-dtor -Woverloaded-virtual -Winvalid-offsetof + -funroll-loops + -fstrict-aliasing # Assume that signed arithmetic overflow of addition, subtraction and # multiplication wraps around using twos-complement representation @@ -68,6 +70,18 @@ function(noa_add_default_options visibility target) -Wc++11-extensions -Wcomma -Wno-exit-time-destructors - -Wrange-loop-analysis) + -Wrange-loop-analysis + + # Enable loop vectorization for performance reasons + -fvectorize + # Enable vectorization of straight-line code for performance + -fslp-vectorize) + elseif(NOA_COMPILER_GCC) + target_compile_options("${target}" ${visibility} + # Newer versions of GCC (i.e. 14) seem to print a lot of false-positives here + -Wno-dangling-reference + + # Disables runtime type information + -fno-rtti) endif() endfunction() diff --git a/vendor/alterschema/vendor/noa/cmake/noa/library.cmake b/vendor/alterschema/vendor/noa/cmake/noa/library.cmake index 56e152b..05d5774 100644 --- a/vendor/alterschema/vendor/noa/cmake/noa/library.cmake +++ b/vendor/alterschema/vendor/noa/cmake/noa/library.cmake @@ -22,13 +22,14 @@ function(noa_library) if(NOA_LIBRARY_SOURCES) set(ABSOLUTE_PRIVATE_HEADERS "${CMAKE_CURRENT_BINARY_DIR}/${NOA_LIBRARY_NAME}_export.h") - foreach(private_header IN LISTS NOA_LIBRARY_PRIVATE_HEADERS) - list(APPEND ABSOLUTE_PRIVATE_HEADERS "${INCLUDE_PREFIX}/${NOA_LIBRARY_NAME}_${private_header}") - endforeach() else() set(ABSOLUTE_PRIVATE_HEADERS) endif() + foreach(private_header IN LISTS NOA_LIBRARY_PRIVATE_HEADERS) + list(APPEND ABSOLUTE_PRIVATE_HEADERS "${INCLUDE_PREFIX}/${NOA_LIBRARY_NAME}_${private_header}") + endforeach() + if(NOA_LIBRARY_NAMESPACE) set(TARGET_NAME "${NOA_LIBRARY_NAMESPACE}_${NOA_LIBRARY_PROJECT}_${NOA_LIBRARY_NAME}") set(ALIAS_NAME "${NOA_LIBRARY_NAMESPACE}::${NOA_LIBRARY_PROJECT}::${NOA_LIBRARY_NAME}")