Extend SchemaFrame::references_to to support dynamic references (#1563

)

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

src/core/jsonschema/frame.cc

@@ -937,19 +937,36 @@ auto SchemaFrame::instance_locations(const Location &location) const -> const
   return match->second;
 }
 
-// TODO: This is currently very slow, as we need to loop on every reference
-// to brute force whether it points to the desired entry or not
 auto SchemaFrame::references_to(const Pointer &pointer) const -> std::vector<
     std::reference_wrapper<const typename References::value_type>> {
   std::vector<std::reference_wrapper<const typename References::value_type>>
       result;
+
+  // TODO: This is currently very slow, as we need to loop on every reference
+  // to brute force whether it points to the desired entry or not
   for (const auto &reference : this->references_) {
-    // TODO: Handle dynamic references by attempting to find all possible
-    // targets
-    const auto match{this->locations_.find(
-        {SchemaReferenceType::Static, reference.second.destination})};
-    if (match != this->locations_.cend() && match->second.pointer == pointer) {
-      result.emplace_back(reference);
+    assert(!reference.first.second.empty());
+    assert(reference.first.second.back().is_property());
+
+    if (reference.first.first == SchemaReferenceType::Static) {
+      const auto match{this->locations_.find(
+          {reference.first.first, reference.second.destination})};
+      if (match != this->locations_.cend() &&
+          match->second.pointer == pointer) {
+        result.emplace_back(reference);
+      }
+    } else {
+      for (const auto &location : this->locations_) {
+        if (location.second.type == LocationType::Anchor &&
+            location.first.first == SchemaReferenceType::Dynamic &&
+            location.second.pointer == pointer) {
+          if (!reference.second.fragment.has_value() ||
+              URI{location.first.second}.fragment().value_or("") ==
+                  reference.second.fragment.value()) {
+            result.emplace_back(reference);
+          }
+        }
+      }
     }
   }
 

test/jsonschema/jsonschema_frame_2019_09_test.cc

@@ -1589,8 +1589,7 @@ TEST(JSONSchema_frame_2019_09, recursive_ref_nested_recursive_anchor_true) {
   EXPECT_FRAME_STATIC_2019_09_RESOURCE(
       frame, "https://www.sourcemeta.com/schema",
       "https://www.sourcemeta.com/schema", "",
-      "https://www.sourcemeta.com/schema", "", POINTER_TEMPLATES("", "/~I~"),
-      std::nullopt);
+      "https://www.sourcemeta.com/schema", "", {""}, std::nullopt);
 
   EXPECT_FRAME_STATIC_2019_09_POINTER(
       frame, "https://www.sourcemeta.com/schema#/$id",
@@ -1657,7 +1656,8 @@ TEST(JSONSchema_frame_2019_09, recursive_ref_multiple_recursive_anchor_true) {
   EXPECT_FRAME_STATIC_2019_09_RESOURCE(
       frame, "https://www.sourcemeta.com/schema",
       "https://www.sourcemeta.com/schema", "",
-      "https://www.sourcemeta.com/schema", "", {""}, std::nullopt);
+      "https://www.sourcemeta.com/schema", "", POINTER_TEMPLATES("", "/~I~"),
+      std::nullopt);
   EXPECT_FRAME_STATIC_2019_09_RESOURCE(
       frame, "https://www.sourcemeta.com/nested",
       "https://www.sourcemeta.com/schema", "/additionalItems",
@@ -1715,7 +1715,8 @@ TEST(JSONSchema_frame_2019_09, recursive_ref_multiple_recursive_anchor_true) {
   EXPECT_FRAME_DYNAMIC_2019_09_ANCHOR(
       frame, "https://www.sourcemeta.com/schema",
       "https://www.sourcemeta.com/schema", "",
-      "https://www.sourcemeta.com/schema", "", {""}, std::nullopt);
+      "https://www.sourcemeta.com/schema", "", POINTER_TEMPLATES("", "/~I~"),
+      std::nullopt);
   EXPECT_FRAME_DYNAMIC_2019_09_ANCHOR(
       frame, "https://www.sourcemeta.com/nested",
       "https://www.sourcemeta.com/schema", "/additionalItems",

test/jsonschema/jsonschema_frame_test.cc

@@ -795,3 +795,119 @@ TEST(JSONSchema_frame, mode_locations) {
 
   EXPECT_EQ(frame.references().size(), 0);
 }
+
+TEST(JSONSchema_frame, references_to_1) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$id": "https://example.com",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "properties": {
+      "foo": {
+        "$id": "foo",
+        "$dynamicAnchor": "test"
+      },
+      "bar": {
+        "$id": "bar",
+        "$dynamicAnchor": "test"
+      },
+      "baz": {
+        "$id": "baz",
+        "$anchor": "test"
+      }
+    },
+    "$defs": {
+      "bookending": {
+        "$dynamicAnchor": "test"
+      },
+      "static": {
+        "$ref": "#test"
+      },
+      "dynamic": {
+        "$dynamicRef": "#test"
+      },
+      "dynamic-non-anchor": {
+        "$dynamicRef": "baz"
+      }
+    }
+  })JSON");
+
+  sourcemeta::core::SchemaFrame frame{
+      sourcemeta::core::SchemaFrame::Mode::References};
+  frame.analyse(document, sourcemeta::core::schema_official_walker,
+                sourcemeta::core::schema_official_resolver);
+
+  const auto foo{frame.references_to({"properties", "foo"})};
+  EXPECT_EQ(foo.size(), 1);
+  EXPECT_REFERENCE_TO(foo, 0, Dynamic, "/$defs/dynamic/$dynamicRef");
+
+  const auto bar{frame.references_to({"properties", "bar"})};
+  EXPECT_EQ(bar.size(), 1);
+  EXPECT_REFERENCE_TO(bar, 0, Dynamic, "/$defs/dynamic/$dynamicRef");
+
+  const auto baz{frame.references_to({"properties", "baz"})};
+  EXPECT_EQ(baz.size(), 1);
+  EXPECT_REFERENCE_TO(baz, 0, Static, "/$defs/dynamic-non-anchor/$dynamicRef");
+
+  const auto bookending{frame.references_to({"$defs", "bookending"})};
+  EXPECT_EQ(bookending.size(), 2);
+  EXPECT_REFERENCE_TO(bookending, 0, Static, "/$defs/static/$ref");
+  EXPECT_REFERENCE_TO(bookending, 1, Dynamic, "/$defs/dynamic/$dynamicRef");
+}
+
+TEST(JSONSchema_frame, references_to_2) {
+  const sourcemeta::core::JSON document = sourcemeta::core::parse_json(R"JSON({
+    "$id": "https://example.com",
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "properties": {
+      "foo": {
+        "$id": "foo",
+        "$recursiveAnchor": true
+      },
+      "bar": {
+        "$id": "bar",
+        "$recursiveAnchor": true
+      },
+      "baz": {
+        "$id": "baz",
+        "$anchor": "test"
+      },
+      "qux": {
+        "$id": "qux",
+        "$recursiveAnchor": false
+      }
+    },
+    "$defs": {
+      "bookending": {
+        "$recursiveAnchor": true
+      },
+      "static": {
+        "$ref": "#test"
+      },
+      "dynamic": {
+        "$recursiveRef": "#"
+      }
+    }
+  })JSON");
+
+  sourcemeta::core::SchemaFrame frame{
+      sourcemeta::core::SchemaFrame::Mode::References};
+  frame.analyse(document, sourcemeta::core::schema_official_walker,
+                sourcemeta::core::schema_official_resolver);
+
+  const auto foo{frame.references_to({"properties", "foo"})};
+  EXPECT_EQ(foo.size(), 1);
+  EXPECT_REFERENCE_TO(foo, 0, Dynamic, "/$defs/dynamic/$recursiveRef");
+
+  const auto bar{frame.references_to({"properties", "bar"})};
+  EXPECT_EQ(bar.size(), 1);
+  EXPECT_REFERENCE_TO(bar, 0, Dynamic, "/$defs/dynamic/$recursiveRef");
+
+  const auto baz{frame.references_to({"properties", "baz"})};
+  EXPECT_EQ(baz.size(), 0);
+
+  const auto qux{frame.references_to({"properties", "qux"})};
+  EXPECT_EQ(qux.size(), 0);
+
+  const auto bookending{frame.references_to({"$defs", "bookending"})};
+  EXPECT_EQ(bookending.size(), 1);
+  EXPECT_REFERENCE_TO(bookending, 0, Dynamic, "/$defs/dynamic/$recursiveRef");
+}

test/jsonschema/jsonschema_test_utils.h

@@ -521,4 +521,11 @@
       expected_instance_location, expected_relative_instance_location);        \
   EXPECT_TRUE(entries.at(index).orphan);
 
+#define EXPECT_REFERENCE_TO(result, index, type, origin)                       \
+  EXPECT_EQ((result).at((index)).get().first.first,                            \
+            sourcemeta::core::SchemaReferenceType::type);                      \
+  EXPECT_EQ(                                                                   \
+      sourcemeta::core::to_string((result).at((index)).get().first.second),    \
+      (origin));
+
 #endif