Add support for dynamic / recursive references.

Haven't added dynamic-specific tests to the suite, but
this code passes all of the draft 2020 and draft2019 tests...
except for 1 2019 test :/

Will keep diagnosing what's up with that one, but this should
be very very close to correct (probably fully correct for 2020
at least, other than still needing a pass on making sure we
correctly discover schemas in all keywords).

Author: Julian

referencing/_core.py

@@ -5,8 +5,8 @@
 from urllib.parse import unquote, urldefrag, urljoin
 
 from attrs import evolve, field
-from pyrsistent import m, pmap, s
-from pyrsistent.typing import PMap, PSet
+from pyrsistent import m, plist, pmap, s
+from pyrsistent.typing import PList, PMap, PSet
 
 from referencing import exceptions
 from referencing._attrs import frozen
@@ -354,6 +354,11 @@ class Resolver(Generic[D]):
 
     _base_uri: str = field(alias="base_uri")
     _registry: Registry[D] = field(alias="registry")
+    _previous: PList[URI] = field(
+        default=plist(),  # type: ignore[reportUnknownArgumentType]
+        repr=False,
+        alias="previous",
+    )
 
     def lookup(self, ref: URI) -> Resolved[D]:
         """
@@ -378,24 +383,21 @@ def lookup(self, ref: URI) -> Resolved[D]:
             except KeyError:
                 raise exceptions.Unresolvable(ref=ref) from None
 
+        resolver = self._evolve(registry=registry, base_uri=uri)
         if fragment.startswith("/"):
-            return resource.pointer(
-                pointer=fragment,
-                resolver=evolve(self, registry=registry, base_uri=uri),
-            )
+            return resource.pointer(pointer=fragment, resolver=resolver)
 
         if fragment:
             try:
                 anchor = registry.anchor(uri, fragment)
             except LookupError:
                 registry = registry.crawl()
+                resolver = evolve(resolver, registry=registry)
                 anchor = registry.anchor(uri, fragment)
 
-            resource = anchor.resolve()
-        return Resolved(
-            contents=resource.contents,
-            resolver=evolve(self, registry=registry, base_uri=uri),
-        )
+            return anchor.resolve(resolver=resolver)
+
+        return Resolved(contents=resource.contents, resolver=resolver)
 
     def in_subresource(self, subresource: Resource[D]) -> Resolver[D]:
         """
@@ -404,7 +406,23 @@ def in_subresource(self, subresource: Resource[D]) -> Resolver[D]:
         id = subresource.id()
         if id is None:
             return self
-        return evolve(self, base_uri=urljoin(self._base_uri, id))
+        return self._evolve(base_uri=urljoin(self._base_uri, id))
+
+    def dynamic_scope(self) -> Iterable[tuple[URI, Registry[D]]]:
+        """
+        In specs with such a notion, return the URIs in the dynamic scope.
+        """
+        for uri in self._previous:
+            yield uri, self._registry
+
+    def _evolve(self, base_uri: str, **kwargs: Any):
+        """
+        Evolve, appending to the dynamic scope.
+        """
+        previous = self._previous
+        if self._base_uri and base_uri != self._base_uri:
+            previous = previous.cons(self._base_uri)
+        return evolve(self, base_uri=base_uri, previous=previous, **kwargs)
 
 
 @frozen
@@ -416,8 +434,8 @@ class Anchor(Generic[D]):
     name: str
     resource: Resource[D]
 
-    def resolve(self):
+    def resolve(self, resolver: Resolver[D]):
         """
         Return the resource for this anchor.
         """
-        return self.resource
+        return Resolved(contents=self.resource.contents, resolver=resolver)

referencing/jsonschema.py

@@ -9,7 +9,8 @@
 
 from referencing import Anchor, Registry, Resource, Specification
 from referencing._attrs import frozen
-from referencing.typing import URI, Mapping
+from referencing._core import Resolved as _Resolved, Resolver as _Resolver
+from referencing.typing import URI, Anchor as AnchorType, Mapping
 
 #: A JSON Schema which is a JSON object
 ObjectSchema = Mapping[str, Any]
@@ -51,6 +52,27 @@ def _legacy_id(contents: ObjectSchema) -> URI | None:
         return id
 
 
+def _anchor(
+    specification: Specification[Schema],
+    contents: Schema,
+) -> Iterable[AnchorType[Schema]]:
+    if isinstance(contents, bool):
+        return
+    anchor = contents.get("$anchor")
+    if anchor is not None:
+        yield Anchor(
+            name=anchor,
+            resource=specification.create_resource(contents),
+        )
+
+    dynamic_anchor = contents.get("$dynamicAnchor")
+    if dynamic_anchor is not None:
+        yield DynamicAnchor(
+            name=dynamic_anchor,
+            resource=specification.create_resource(contents),
+        )
+
+
 def _anchor_2019(
     specification: Specification[Schema],
     contents: Schema,
@@ -131,8 +153,12 @@ def subresources_of(contents: Schema) -> Iterable[ObjectSchema]:
 DRAFT202012 = Specification(
     name="draft2020-12",
     id_of=_dollar_id,
-    subresources_of=lambda contents: [],
-    anchors_in=lambda specification, contents: [],
+    subresources_of=_subresources_of(
+        in_value={"additionalProperties", "if", "then", "else", "not"},
+        in_subarray={"allOf", "anyOf", "oneOf"},
+        in_subvalues={"$defs", "properties"},
+    ),
+    anchors_in=_anchor,
 )
 DRAFT201909 = Specification(
     name="draft2019-09",
@@ -220,3 +246,52 @@ def specification_with(
     if default is None:  # type: ignore[reportUnnecessaryComparison]
         raise UnknownDialect(dialect_id)
     return default
+
+
+@frozen
+class DynamicAnchor:
+    """
+    Dynamic anchors, introduced in draft 2020.
+    """
+
+    name: str
+    resource: Resource[Schema]
+
+    def resolve(self, resolver: _Resolver[Schema]):
+        """
+        Resolve this anchor dynamically.
+        """
+        last = self.resource
+        for uri, registry in resolver.dynamic_scope():
+            try:
+                anchor = registry.anchor(uri, self.name)
+            except LookupError:
+                continue
+            if isinstance(anchor, DynamicAnchor):
+                last = anchor.resource
+        return _Resolved(
+            contents=last.contents,
+            resolver=resolver.in_subresource(last),
+        )
+
+
+def lookup_recursive_ref(resolver: _Resolver[Schema]) -> _Resolved[Schema]:
+    """
+    Recursive references (via recursive anchors), present only in draft 2019.
+
+    As per the 2019 specification (§ 8.2.4.2.1), only the ``#`` recursive
+    reference is supported (and is therefore assumed to be the relevant
+    reference).
+    """
+    resolved = resolver.lookup("#")
+    if isinstance(resolved.contents, Mapping) and resolved.contents.get(
+        "$recursiveAnchor"
+    ):
+        for uri, _ in resolver.dynamic_scope():
+            next_resolved = resolver.lookup(uri)
+            if not isinstance(
+                next_resolved.contents, Mapping
+            ) or not next_resolved.contents.get("$recursiveAnchor"):
+                break
+            resolved = next_resolved
+    return resolved

referencing/tests/test_core.py

@@ -546,6 +546,33 @@ def test_in_pointer_subresource(self):
         third = second.resolver.lookup("grandchild")
         assert third.contents == {"ID": "grandchild"}
 
+    def test_dynamic_scope(self):
+        root = ID_AND_CHILDREN.create_resource(
+            {
+                "ID": "http://example.com/",
+                "children": [
+                    {
+                        "ID": "child/",
+                        "children": [{"ID": "grandchild"}],
+                    },
+                ],
+            },
+        )
+        registry = Registry().with_resource(root.id(), root)
+
+        resolver = registry.resolver()
+        first = resolver.lookup("http://example.com/")
+        second = first.resolver.lookup("#/children/0")
+        third = second.resolver.lookup("grandchild")
+        assert list(third.resolver.dynamic_scope()) == [
+            ("http://example.com/child/", third.resolver._registry),
+            ("http://example.com/", third.resolver._registry),
+        ]
+        assert list(second.resolver.dynamic_scope()) == [
+            ("http://example.com/", second.resolver._registry),
+        ]
+        assert list(first.resolver.dynamic_scope()) == []
+
 
 class TestSpecification:
     def test_create_resource(self):

referencing/tests/test_jsonschema.py

@@ -1,6 +1,6 @@
 import pytest
 
-from referencing import Resource, Specification
+from referencing import Registry, Resource, Specification
 import referencing.jsonschema
 
 
@@ -154,3 +154,53 @@ def test_specification_with_default():
         default=Specification.OPAQUE,
     )
     assert specification is Specification.OPAQUE
+
+
+# FIXME: These two also ideally should live in the referencing suite.
+def test_lookup_recursive_ref_to_bool():
+    TRUE = referencing.jsonschema.DRAFT201909.create_resource(True)
+    registry = Registry({"http://example.com": TRUE})
+    resolved = referencing.jsonschema.lookup_recursive_ref(
+        resolver=registry.resolver(base_uri="http://example.com"),
+    )
+    assert resolved.contents == TRUE.contents
+
+
+def test_multiple_lookup_recursive_ref_to_bool():
+    TRUE = referencing.jsonschema.DRAFT201909.create_resource(True)
+    root = referencing.jsonschema.DRAFT201909.create_resource(
+        {
+            "$id": "http://example.com",
+            "$recursiveAnchor": True,
+            "$defs": {
+                "foo": {
+                    "$id": "foo",
+                    "$recursiveAnchor": True,
+                    "$defs": {
+                        "bar": True,
+                        "baz": {
+                            "$recursiveAnchor": True,
+                            "$anchor": "fooAnchor",
+                        },
+                    },
+                },
+            },
+        },
+    )
+    resolver = (
+        Registry()
+        .with_resources(
+            [
+                ("http://example.com", root),
+                ("http://example.com/foo/", TRUE),
+                ("http://example.com/foo/bar", root),
+            ],
+        )
+        .resolver()
+    )
+
+    first = resolver.lookup("http://example.com")
+    second = first.resolver.lookup("foo/")
+    resolver = second.resolver.lookup("bar").resolver
+    fourth = referencing.jsonschema.lookup_recursive_ref(resolver=resolver)
+    assert fourth.contents == root.contents

referencing/typing.py

@@ -14,7 +14,7 @@
 
 
 if TYPE_CHECKING:
-    from referencing._core import Resource
+    from referencing._core import Resolved, Resolver
 
 #: A URI which identifies a `Resource`.
 URI = str
@@ -38,7 +38,7 @@ def name(self) -> str:
         """
         ...
 
-    def resolve(self) -> Resource[D]:
+    def resolve(self, resolver: Resolver[D]) -> Resolved[D]:
         """
         Return the resource for this anchor.
         """