Implement TransformRule in the JSON Schema module (#1482)

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

src/core/jsonschema/CMakeLists.txt

@@ -5,10 +5,12 @@ include(./official_resolver.cmake)
 noa_library(NAMESPACE sourcemeta PROJECT jsontoolkit NAME jsonschema
   FOLDER "JSON Toolkit/JSON Schema"
   PRIVATE_HEADERS anchor.h bundle.h resolver.h
-    walker.h reference.h frame.h error.h unevaluated.h keywords.h
+    walker.h reference.h frame.h error.h unevaluated.h
+    keywords.h transform.h
   SOURCES jsonschema.cc default_walker.cc frame.cc
     anchor.cc resolver.cc walker.cc bundle.cc
     unevaluated.cc relativize.cc unidentify.cc
+    transform_rule.cc
     "${CMAKE_CURRENT_BINARY_DIR}/official_resolver.cc")
 
 if(JSONTOOLKIT_INSTALL)

src/core/jsonschema/include/sourcemeta/jsontoolkit/jsonschema.h

@@ -13,6 +13,7 @@
 #include <sourcemeta/jsontoolkit/jsonschema_keywords.h>
 #include <sourcemeta/jsontoolkit/jsonschema_reference.h>
 #include <sourcemeta/jsontoolkit/jsonschema_resolver.h>
+#include <sourcemeta/jsontoolkit/jsonschema_transform.h>
 #include <sourcemeta/jsontoolkit/jsonschema_unevaluated.h>
 #include <sourcemeta/jsontoolkit/jsonschema_walker.h>
 

src/core/jsonschema/include/sourcemeta/jsontoolkit/jsonschema_transform.h

@@ -0,0 +1,111 @@
+#ifndef SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_RULE_H_
+#define SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_RULE_H_
+
+#ifndef SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT
+#include <sourcemeta/jsontoolkit/jsonschema_export.h>
+#endif
+
+#include <sourcemeta/jsontoolkit/json.h>
+#include <sourcemeta/jsontoolkit/jsonpointer.h>
+#include <sourcemeta/jsontoolkit/jsonschema_resolver.h>
+
+#include <optional> // std::optional, std::nullopt
+#include <set>      // std::set
+#include <string>   // std::string
+#include <vector>   // std::vector
+
+namespace sourcemeta::jsontoolkit {
+/// @ingroup jsonschema
+///
+/// A class that represents a transformation rule. Clients of this class
+/// are expected to subclass and implement their own condition and
+/// transformation methods.
+///
+/// For example, this is a rule that deletes any property called `foo` in every
+/// subschema:
+///
+/// ```cpp
+/// #include <sourcemeta/jsontoolkit/jsonschema.h>
+///
+/// class MyTransformRule final
+///   : public sourcemeta::jsontoolkit::TransformRule {
+/// public:
+///   MyTransformRule() : sourcemeta::jsontoolkit::TransformRule("my_rule", "My
+///   rule") {};
+///
+///   [[nodiscard]] auto condition(const sourcemeta::jsontoolkit::JSON &schema,
+///                                const std::string &dialect,
+///                                const std::set<std::string> &vocabularies,
+///                                const sourcemeta::jsontoolkit::Pointer
+///                                  &pointer) const
+///       -> bool override
+///     return schema.defines("foo");
+///   }
+///
+///   auto transform(sourcemeta::jsontoolkit::PointerProxy &transformer)
+///       const -> void override {
+///     transformer.erase("foo");
+///   }
+/// };
+/// ```
+class SOURCEMETA_JSONTOOLKIT_JSONSCHEMA_EXPORT TransformRule {
+public:
+  /// Create a transformation rule. Each rule must have a unique name.
+  TransformRule(std::string &&name, std::string &&message);
+
+  // Necessary to wrap rules on smart pointers
+  virtual ~TransformRule() = default;
+
+  // We don't need any of these
+  TransformRule(const TransformRule &) = delete;
+  TransformRule(TransformRule &&) = delete;
+  auto operator=(const TransformRule &) -> TransformRule & = delete;
+  auto operator=(TransformRule &&) -> TransformRule & = delete;
+
+  /// Compare a rule against another rule.
+  auto operator==(const TransformRule &other) const -> bool;
+
+  /// Fetch the name of a rule
+  [[nodiscard]] auto name() const -> const std::string &;
+
+  /// Fetch the message of a rule
+  [[nodiscard]] auto message() const -> const std::string &;
+
+  /// Apply the rule to a schema
+  auto
+  apply(JSON &schema, const Pointer &pointer, const SchemaResolver &resolver,
+        const std::optional<std::string> &default_dialect = std::nullopt) const
+      -> std::vector<PointerProxy::Operation>;
+
+  /// Check if the rule applies to a schema
+  auto
+  check(const JSON &schema, const Pointer &pointer,
+        const SchemaResolver &resolver,
+        const std::optional<std::string> &default_dialect = std::nullopt) const
+      -> bool;
+
+private:
+  /// The rule condition
+  [[nodiscard]] virtual auto
+  condition(const JSON &schema, const std::string &dialect,
+            const std::set<std::string> &vocabularies,
+            const Pointer &pointer) const -> bool = 0;
+
+  /// The rule transformation
+  virtual auto transform(PointerProxy &transformer) const -> void = 0;
+
+// Exporting symbols that depends on the standard C++ library is considered
+// safe.
+// https://learn.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-2-c4275?view=msvc-170&redirectedfrom=MSDN
+#if defined(_MSC_VER)
+#pragma warning(disable : 4251)
+#endif
+  const std::string name_;
+  const std::string message_;
+#if defined(_MSC_VER)
+#pragma warning(default : 4251)
+#endif
+};
+} // namespace sourcemeta::jsontoolkit
+
+#endif

src/core/jsonschema/transform_rule.cc

@@ -0,0 +1,86 @@
+#include <sourcemeta/jsontoolkit/jsonschema.h>
+
+#include <cassert>   // assert
+#include <sstream>   // std::ostringstream
+#include <stdexcept> // std::runtime_error
+#include <utility>   // std::move
+
+namespace {
+
+auto vocabularies_to_set(const std::map<std::string, bool> &vocabularies)
+    -> std::set<std::string> {
+  std::set<std::string> result;
+  for (const auto &pair : vocabularies) {
+    result.insert(pair.first);
+  }
+
+  return result;
+}
+
+} // namespace
+
+namespace sourcemeta::jsontoolkit {
+
+TransformRule::TransformRule(std::string &&name, std::string &&message)
+    : name_{std::move(name)}, message_{std::move(message)} {}
+
+auto TransformRule::operator==(const TransformRule &other) const -> bool {
+  return this->name() == other.name();
+}
+
+auto TransformRule::name() const -> const std::string & { return this->name_; }
+
+auto TransformRule::message() const -> const std::string & {
+  return this->message_;
+}
+
+auto TransformRule::apply(
+    JSON &schema, const Pointer &pointer, const SchemaResolver &resolver,
+    const std::optional<std::string> &default_dialect) const
+    -> std::vector<PointerProxy::Operation> {
+  const std::optional<std::string> effective_dialect{
+      dialect(schema, default_dialect)};
+  if (!effective_dialect.has_value()) {
+    throw SchemaError("Could not determine the schema dialect");
+  }
+
+  const auto current_vocabularies{
+      vocabularies_to_set(vocabularies(schema, resolver, default_dialect))};
+  if (!this->condition(schema, effective_dialect.value(), current_vocabularies,
+                       pointer)) {
+    return {};
+  }
+
+  PointerProxy transformer{schema};
+  this->transform(transformer);
+  // Otherwise the transformation didn't do anything
+  assert(!transformer.traces().empty());
+
+  // The condition must always be false after applying the
+  // transformation in order to avoid infinite loops
+  if (this->condition(schema, effective_dialect.value(), current_vocabularies,
+                      pointer)) {
+    std::ostringstream error;
+    error << "Rule condition holds after application: " << this->name();
+    throw std::runtime_error(error.str());
+  }
+
+  return transformer.traces();
+}
+
+auto TransformRule::check(
+    const JSON &schema, const Pointer &pointer, const SchemaResolver &resolver,
+    const std::optional<std::string> &default_dialect) const -> bool {
+  const std::optional<std::string> effective_dialect{
+      dialect(schema, default_dialect)};
+  if (!effective_dialect.has_value()) {
+    throw SchemaError("Could not determine the schema dialect");
+  }
+
+  return this->condition(
+      schema, effective_dialect.value(),
+      vocabularies_to_set(vocabularies(schema, resolver, default_dialect)),
+      pointer);
+}
+
+} // namespace sourcemeta::jsontoolkit

test/jsonschema/CMakeLists.txt

@@ -42,6 +42,8 @@ noa_googletest(NAMESPACE sourcemeta PROJECT jsontoolkit NAME jsonschema
     jsonschema_bundle_test.cc
     jsonschema_unidentify_test.cc
     jsonschema_metaschema_test.cc
+    jsonschema_transform_rules.h
+    jsonschema_transform_rule_test.cc
     jsonschema_dialect_test.cc
     jsonschema_dialect_2020_12_test.cc
     jsonschema_dialect_2019_09_test.cc

test/jsonschema/jsonschema_transform_rule_test.cc

@@ -0,0 +1,32 @@
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include <sourcemeta/jsontoolkit/json.h>
+#include <sourcemeta/jsontoolkit/jsonschema.h>
+
+#include "jsonschema_transform_rules.h"
+
+TEST(JSONSchema_transform_rule, instances_of_same_rule_are_equal) {
+  const ExampleRule1 foo{};
+  const ExampleRule1 bar{};
+  EXPECT_EQ(foo, bar);
+}
+
+TEST(JSONSchema_transform_rule,
+     instances_of_same_rule_are_equal_with_unique_ptr) {
+  const std::unique_ptr<ExampleRule1> foo{};
+  const std::unique_ptr<ExampleRule1> bar{};
+  EXPECT_EQ(foo, bar);
+}
+
+TEST(JSONSchema_transform_rule, instances_of_different_rules_are_different) {
+  const ExampleRule1 foo{};
+  const ExampleRule2 bar{};
+  EXPECT_NE(foo, bar);
+}
+
+TEST(JSONSchema_transform_rule, rule_message) {
+  const ExampleRule7 rule{};
+  EXPECT_EQ(rule.message(), "My custom message");
+}