Support returning pointers as part of SchemaTransformRule::Result

jviotti · jviotti · commit 060bb2651952 · 2025-08-22T16:07:28.000-04:00
Signed-off-by: Juan Cruz Viotti &lt;jv@jviotti.com&gt;
diff --git a/src/core/jsonschema/include/sourcemeta/core/jsonschema_transform.h b/src/core/jsonschema/include/sourcemeta/core/jsonschema_transform.h
@@ -11,8 +11,9 @@
 #include <sourcemeta/core/jsonschema_resolver.h>
 
 #include <cassert>     // assert
-#include <concepts>    // std::derived_from
+#include <concepts>    // std::derived_from, std::same_as
 #include <functional>  // std::function
+#include <iterator>    // std::make_move_iterator, std::begin, std::end
 #include <map>         // std::map
 #include <memory>      // std::make_unique, std::unique_ptr
 #include <optional>    // std::optional, std::nullopt
@@ -88,8 +89,26 @@ class SOURCEMETA_CORE_JSONSCHEMA_EXPORT SchemaTransformRule {
         : applies{true}, description{std::move(description_)} {}
     Result(const char *description_)
         : applies{true}, description{description_} {}
+    Result(Pointer pointer)
+        : applies{true}, description{""}, locations{std::move(pointer)} {
+      assert(this->locations.size() == 1);
+    }
+
+    template <typename T>
+      requires std::same_as<typename T::value_type, Pointer>
+    Result(T &&container) : applies{true}, description{""} {
+      auto &&input = std::forward<T>(container);
+      if constexpr (requires { input.size(); }) {
+        locations.reserve(input.size());
+      }
+
+      locations.assign(std::make_move_iterator(std::begin(input)),
+                       std::make_move_iterator(std::end(input)));
+    }
+
     bool applies;
     std::string description{""};
+    std::vector<Pointer> locations;
   };
 
   /// Apply the rule to a schema
diff --git a/src/extension/alterschema/alterschema.cc b/src/extension/alterschema/alterschema.cc
@@ -1,5 +1,7 @@
 #include <sourcemeta/core/alterschema.h>
 
+#include <initializer_list> // std::initializer_list
+
 // For built-in rules
 #include <algorithm>
 #include <cmath>
@@ -14,6 +16,29 @@ contains_any(const Vocabularies &container,
   });
 }
 
+static auto keyword(const Pointer::Token::Property &keyword,
+                    const bool condition) -> SchemaTransformRule::Result {
+  if (condition) {
+    return Pointer{keyword};
+  } else {
+    return false;
+  }
+}
+
+static auto keywords(std::initializer_list<Pointer::Token::Property> keywords,
+                     const bool condition) -> SchemaTransformRule::Result {
+  if (condition) {
+    std::vector<Pointer> result;
+    result.reserve(keywords.size());
+    for (auto &&keyword : keywords) {
+      result.push_back(Pointer{keyword});
+    }
+    return result;
+  } else {
+    return false;
+  }
+}
+
 // Canonicalizer
 #include "canonicalizer/boolean_true.h"
 #include "canonicalizer/const_as_enum.h"
diff --git a/src/extension/alterschema/canonicalizer/const_as_enum.h b/src/extension/alterschema/canonicalizer/const_as_enum.h
@@ -14,14 +14,15 @@ class ConstAsEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation",
-                "http://json-schema.org/draft-07/schema#",
-                "http://json-schema.org/draft-06/schema#"}) &&
-           schema.is_object() && schema.defines("const") &&
-           !schema.defines("enum");
+    return keyword(
+        "const",
+        contains_any(vocabularies,
+                     {"https://json-schema.org/draft/2020-12/vocab/validation",
+                      "https://json-schema.org/draft/2019-09/vocab/validation",
+                      "http://json-schema.org/draft-07/schema#",
+                      "http://json-schema.org/draft-06/schema#"}) &&
+            schema.is_object() && schema.defines("const") &&
+            !schema.defines("enum"));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/exclusive_maximum_integer_to_maximum.h b/src/extension/alterschema/canonicalizer/exclusive_maximum_integer_to_maximum.h
@@ -15,18 +15,19 @@ class ExclusiveMaximumIntegerToMaximum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation",
-                "http://json-schema.org/draft-07/schema#",
-                "http://json-schema.org/draft-06/schema#"}) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").is_string() &&
-           schema.at("type").to_string() == "integer" &&
-           schema.defines("exclusiveMaximum") &&
-           schema.at("exclusiveMaximum").is_number() &&
-           !schema.defines("maximum");
+    return keywords(
+        {"exclusiveMaximum", "type"},
+        contains_any(vocabularies,
+                     {"https://json-schema.org/draft/2020-12/vocab/validation",
+                      "https://json-schema.org/draft/2019-09/vocab/validation",
+                      "http://json-schema.org/draft-07/schema#",
+                      "http://json-schema.org/draft-06/schema#"}) &&
+            schema.is_object() && schema.defines("type") &&
+            schema.at("type").is_string() &&
+            schema.at("type").to_string() == "integer" &&
+            schema.defines("exclusiveMaximum") &&
+            schema.at("exclusiveMaximum").is_number() &&
+            !schema.defines("maximum"));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/exclusive_minimum_integer_to_minimum.h b/src/extension/alterschema/canonicalizer/exclusive_minimum_integer_to_minimum.h
@@ -15,18 +15,19 @@ class ExclusiveMinimumIntegerToMinimum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation",
-                "http://json-schema.org/draft-07/schema#",
-                "http://json-schema.org/draft-06/schema#"}) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").is_string() &&
-           schema.at("type").to_string() == "integer" &&
-           schema.defines("exclusiveMinimum") &&
-           schema.at("exclusiveMinimum").is_number() &&
-           !schema.defines("minimum");
+    return keywords(
+        {"exclusiveMinimum", "type"},
+        contains_any(vocabularies,
+                     {"https://json-schema.org/draft/2020-12/vocab/validation",
+                      "https://json-schema.org/draft/2019-09/vocab/validation",
+                      "http://json-schema.org/draft-07/schema#",
+                      "http://json-schema.org/draft-06/schema#"}) &&
+            schema.is_object() && schema.defines("type") &&
+            schema.at("type").is_string() &&
+            schema.at("type").to_string() == "integer" &&
+            schema.defines("exclusiveMinimum") &&
+            schema.at("exclusiveMinimum").is_number() &&
+            !schema.defines("minimum"));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/max_contains_covered_by_max_items.h b/src/extension/alterschema/canonicalizer/max_contains_covered_by_max_items.h
@@ -16,15 +16,17 @@ class MaxContainsCoveredByMaxItems final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation"}) &&
-           schema.is_object() && schema.defines("maxContains") &&
-           schema.at("maxContains").is_integer() &&
-           schema.defines("maxItems") && schema.at("maxItems").is_integer() &&
-           schema.at("maxContains").to_integer() >
-               schema.at("maxItems").to_integer();
+    return keywords(
+        {"maxContains", "maxItems"},
+        contains_any(
+            vocabularies,
+            {"https://json-schema.org/draft/2020-12/vocab/validation",
+             "https://json-schema.org/draft/2019-09/vocab/validation"}) &&
+            schema.is_object() && schema.defines("maxContains") &&
+            schema.at("maxContains").is_integer() &&
+            schema.defines("maxItems") && schema.at("maxItems").is_integer() &&
+            schema.at("maxContains").to_integer() >
+                schema.at("maxItems").to_integer());
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/min_properties_covered_by_required.h b/src/extension/alterschema/canonicalizer/min_properties_covered_by_required.h
@@ -15,20 +15,21 @@ class MinPropertiesCoveredByRequired final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation",
-                "http://json-schema.org/draft-07/schema#",
-                "http://json-schema.org/draft-06/schema#",
-                "http://json-schema.org/draft-04/schema#"}) &&
-           schema.is_object() && schema.defines("minProperties") &&
-           schema.at("minProperties").is_integer() &&
-           schema.defines("required") && schema.at("required").is_array() &&
-           schema.at("required").unique() &&
-           std::cmp_greater(schema.at("required").size(),
-                            static_cast<std::uint64_t>(
-                                schema.at("minProperties").to_integer()));
+    return keywords(
+        {"minProperties", "required"},
+        contains_any(vocabularies,
+                     {"https://json-schema.org/draft/2020-12/vocab/validation",
+                      "https://json-schema.org/draft/2019-09/vocab/validation",
+                      "http://json-schema.org/draft-07/schema#",
+                      "http://json-schema.org/draft-06/schema#",
+                      "http://json-schema.org/draft-04/schema#"}) &&
+            schema.is_object() && schema.defines("minProperties") &&
+            schema.at("minProperties").is_integer() &&
+            schema.defines("required") && schema.at("required").is_array() &&
+            schema.at("required").unique() &&
+            std::cmp_greater(schema.at("required").size(),
+                             static_cast<std::uint64_t>(
+                                 schema.at("minProperties").to_integer())));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/type_array_to_any_of_2020_12.h b/src/extension/alterschema/canonicalizer/type_array_to_any_of_2020_12.h
@@ -31,17 +31,19 @@ class TypeArrayToAnyOf_2020_12 final : public SchemaTransformRule {
                      sourcemeta::core::SchemaFrame::LocationType::Anchor;
         })};
 
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2020-12/vocab/applicator"}) &&
-           !has_identifiers && schema.is_object() && schema.defines("type") &&
-           schema.at("type").is_array() &&
-           // Non type-specific applicators can leads to invalid schemas
-           !schema.defines("$defs") && !schema.defines("$ref") &&
-           !schema.defines("if") && !schema.defines("then") &&
-           !schema.defines("else") && !schema.defines("allOf") &&
-           !schema.defines("oneOf") && !schema.defines("anyOf");
+    return keyword(
+        "type",
+        contains_any(
+            vocabularies,
+            {"https://json-schema.org/draft/2020-12/vocab/validation",
+             "https://json-schema.org/draft/2020-12/vocab/applicator"}) &&
+            !has_identifiers && schema.is_object() && schema.defines("type") &&
+            schema.at("type").is_array() &&
+            // Non type-specific applicators can leads to invalid schemas
+            !schema.defines("$defs") && !schema.defines("$ref") &&
+            !schema.defines("if") && !schema.defines("then") &&
+            !schema.defines("else") && !schema.defines("allOf") &&
+            !schema.defines("oneOf") && !schema.defines("anyOf"));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/type_boolean_as_enum.h b/src/extension/alterschema/canonicalizer/type_boolean_as_enum.h
@@ -15,20 +15,21 @@ class TypeBooleanAsEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation",
-                "http://json-schema.org/draft-07/schema#",
-                "http://json-schema.org/draft-06/schema#",
-                "http://json-schema.org/draft-04/schema#",
-                "http://json-schema.org/draft-03/schema#",
-                "http://json-schema.org/draft-02/schema#",
-                "http://json-schema.org/draft-01/schema#"}) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").is_string() &&
-           schema.at("type").to_string() == "boolean" &&
-           !schema.defines("enum") && !schema.defines("const");
+    return keyword(
+        "type",
+        contains_any(vocabularies,
+                     {"https://json-schema.org/draft/2020-12/vocab/validation",
+                      "https://json-schema.org/draft/2019-09/vocab/validation",
+                      "http://json-schema.org/draft-07/schema#",
+                      "http://json-schema.org/draft-06/schema#",
+                      "http://json-schema.org/draft-04/schema#",
+                      "http://json-schema.org/draft-03/schema#",
+                      "http://json-schema.org/draft-02/schema#",
+                      "http://json-schema.org/draft-01/schema#"}) &&
+            schema.is_object() && schema.defines("type") &&
+            schema.at("type").is_string() &&
+            schema.at("type").to_string() == "boolean" &&
+            !schema.defines("enum") && !schema.defines("const"));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/src/extension/alterschema/canonicalizer/type_null_as_enum.h b/src/extension/alterschema/canonicalizer/type_null_as_enum.h
@@ -15,20 +15,21 @@ class TypeNullAsEnum final : public SchemaTransformRule {
             const sourcemeta::core::SchemaWalker &,
             const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
-    return contains_any(
-               vocabularies,
-               {"https://json-schema.org/draft/2020-12/vocab/validation",
-                "https://json-schema.org/draft/2019-09/vocab/validation",
-                "http://json-schema.org/draft-07/schema#",
-                "http://json-schema.org/draft-06/schema#",
-                "http://json-schema.org/draft-04/schema#",
-                "http://json-schema.org/draft-03/schema#",
-                "http://json-schema.org/draft-02/schema#",
-                "http://json-schema.org/draft-01/schema#"}) &&
-           schema.is_object() && schema.defines("type") &&
-           schema.at("type").is_string() &&
-           schema.at("type").to_string() == "null" && !schema.defines("enum") &&
-           !schema.defines("const");
+    return keyword(
+        "type",
+        contains_any(vocabularies,
+                     {"https://json-schema.org/draft/2020-12/vocab/validation",
+                      "https://json-schema.org/draft/2019-09/vocab/validation",
+                      "http://json-schema.org/draft-07/schema#",
+                      "http://json-schema.org/draft-06/schema#",
+                      "http://json-schema.org/draft-04/schema#",
+                      "http://json-schema.org/draft-03/schema#",
+                      "http://json-schema.org/draft-02/schema#",
+                      "http://json-schema.org/draft-01/schema#"}) &&
+            schema.is_object() && schema.defines("type") &&
+            schema.at("type").is_string() &&
+            schema.at("type").to_string() == "null" &&
+            !schema.defines("enum") && !schema.defines("const"));
   }
 
   auto transform(JSON &schema) const -> void override {
diff --git a/test/jsonschema/jsonschema_transform_rules.h b/test/jsonschema/jsonschema_transform_rules.h
@@ -25,10 +25,10 @@ class ExampleRule1 final : public sourcemeta::core::SchemaTransformRule {
   }
 };
 
-class ExampleRule1WithDescription final
+class ExampleRule1WithPointer final
     : public sourcemeta::core::SchemaTransformRule {
 public:
-  ExampleRule1WithDescription()
+  ExampleRule1WithPointer()
       : sourcemeta::core::SchemaTransformRule(
             "example_rule_1", "Keyword foo is not permitted") {};
 
@@ -41,7 +41,37 @@ class ExampleRule1WithDescription final
                                const sourcemeta::core::SchemaResolver &) const
       -> sourcemeta::core::SchemaTransformRule::Result override {
     if (schema.defines("foo")) {
-      return "This is a message from the rule";
+      return sourcemeta::core::Pointer{"foo"};
+    } else {
+      return false;
+    }
+  }
+
+  auto transform(sourcemeta::core::JSON &schema) const -> void override {
+    schema.erase("foo");
+  }
+};
+
+class ExampleRuleWithManyPointers final
+    : public sourcemeta::core::SchemaTransformRule {
+public:
+  ExampleRuleWithManyPointers()
+      : sourcemeta::core::SchemaTransformRule("example_rule_with_many_pointers",
+                                              "Foo Bar") {};
+
+  [[nodiscard]] auto condition(const sourcemeta::core::JSON &schema,
+                               const sourcemeta::core::JSON &,
+                               const sourcemeta::core::Vocabularies &,
+                               const sourcemeta::core::SchemaFrame &,
+                               const sourcemeta::core::SchemaFrame::Location &,
+                               const sourcemeta::core::SchemaWalker &,
+                               const sourcemeta::core::SchemaResolver &) const
+      -> sourcemeta::core::SchemaTransformRule::Result override {
+    if (schema.defines("foo") && schema.defines("bar")) {
+      std::vector<sourcemeta::core::Pointer> locations;
+      locations.emplace_back(sourcemeta::core::Pointer{"foo"});
+      locations.emplace_back(sourcemeta::core::Pointer{"bar"});
+      return locations;
     } else {
       return false;
     }
diff --git a/test/jsonschema/jsonschema_transformer_test.cc b/test/jsonschema/jsonschema_transformer_test.cc
