Resolve $ref using the referencing library.

Passes all the remaining referencing tests across all drafts, hooray!

Makes Validators take a referencing.Registry argument which users should
use to customize preloaded schemas, or to configure remote reference
retrieval.

This fully obsoletes jsonschema.RefResolver, which has already been
deprecated in a previous commit. Users should move to instead loading
schemas into referencing.Registry objects.

See the referencing documentation at https://referencing.rtfd.io/ for
details (with more jsonschema-specific information to be added shortly).

Note that the interface for resolving references on a Validator is not
yet public (and hidden behind _resolver and _validate_reference
attributes). One or both of these are likely to become public after some
period of stabilization.

Feedback is of course welcome!

Author: Julian

jsonschema/_legacy_validators.py

@@ -1,3 +1,5 @@
+from referencing.jsonschema import lookup_recursive_ref
+
 from jsonschema import _utils
 from jsonschema.exceptions import ValidationError
 
@@ -210,22 +212,12 @@ def contains_draft6_draft7(validator, contains, instance, schema):
 
 
 def recursiveRef(validator, recursiveRef, instance, schema):
-    lookup_url, target = validator.resolver.resolution_scope, validator.schema
-
-    for each in reversed(validator.resolver._scopes_stack[1:]):
-        lookup_url, next_target = validator.resolver.resolve(each)
-        if next_target.get("$recursiveAnchor"):
-            target = next_target
-        else:
-            break
-
-    fragment = recursiveRef.lstrip("#")
-    subschema = validator.resolver.resolve_fragment(target, fragment)
-    # FIXME: This is gutted (and not calling .descend) because it can trigger
-    #        recursion errors, so there's a bug here. Re-enable the tests to
-    #        see it.
-    subschema
-    return []
+    resolved = lookup_recursive_ref(validator._resolver)
+    yield from validator.descend(
+        instance,
+        resolved.contents,
+        resolver=resolved.resolver,
+    )
 
 
 def find_evaluated_item_indexes_by_schema(validator, instance, schema):
@@ -243,15 +235,17 @@ def find_evaluated_item_indexes_by_schema(validator, instance, schema):
         return list(range(0, len(instance)))
 
     if "$ref" in schema:
-        scope, resolved = validator.resolver.resolve(schema["$ref"])
-        validator.resolver.push_scope(scope)
-
-        try:
-            evaluated_indexes += find_evaluated_item_indexes_by_schema(
-                validator, instance, resolved,
-            )
-        finally:
-            validator.resolver.pop_scope()
+        resolved = validator._resolver.lookup(schema["$ref"])
+        evaluated_indexes.extend(
+            find_evaluated_item_indexes_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
 
     if "items" in schema:
         if validator.is_type(schema["items"], "object"):

jsonschema/_utils.py

@@ -201,15 +201,17 @@ def find_evaluated_item_indexes_by_schema(validator, instance, schema):
         return list(range(0, len(instance)))
 
     if "$ref" in schema:
-        scope, resolved = validator.resolver.resolve(schema["$ref"])
-        validator.resolver.push_scope(scope)
-
-        try:
-            evaluated_indexes += find_evaluated_item_indexes_by_schema(
-                validator, instance, resolved,
-            )
-        finally:
-            validator.resolver.pop_scope()
+        resolved = validator._resolver.lookup(schema["$ref"])
+        evaluated_indexes.extend(
+            find_evaluated_item_indexes_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
 
     if "prefixItems" in schema:
         evaluated_indexes += list(range(0, len(schema["prefixItems"])))
@@ -260,15 +262,17 @@ def find_evaluated_property_keys_by_schema(validator, instance, schema):
     evaluated_keys = []
 
     if "$ref" in schema:
-        scope, resolved = validator.resolver.resolve(schema["$ref"])
-        validator.resolver.push_scope(scope)
-
-        try:
-            evaluated_keys += find_evaluated_property_keys_by_schema(
-                validator, instance, resolved,
-            )
-        finally:
-            validator.resolver.pop_scope()
+        resolved = validator._resolver.lookup(schema["$ref"])
+        evaluated_keys.extend(
+            find_evaluated_property_keys_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
 
     for keyword in [
         "properties", "additionalProperties", "unevaluatedProperties",

jsonschema/protocols.py

@@ -11,6 +11,8 @@
 from typing import TYPE_CHECKING, Any, ClassVar, Iterable
 import sys
 
+from referencing.jsonschema import SchemaRegistry
+
 # doing these imports with `try ... except ImportError` doesn't pass mypy
 # checking because mypy sees `typing._SpecialForm` and
 # `typing_extensions._SpecialForm` as incompatible
@@ -60,6 +62,10 @@ class Validator(Protocol):
             an invalid schema can lead to undefined behavior. See
             `Validator.check_schema` to validate a schema first.
 
+        registry:
+
+            a schema registry that will be used for looking up JSON references
+
         resolver:
 
             a resolver that will be used to resolve :kw:`$ref`
@@ -113,6 +119,7 @@ class Validator(Protocol):
     def __init__(
         self,
         schema: Mapping | bool,
+        registry: SchemaRegistry,
         format_checker: jsonschema.FormatChecker | None = None,
     ) -> None:
         ...

jsonschema/tests/_suite.py

@@ -21,7 +21,7 @@
 if TYPE_CHECKING:
     import pyperf
 
-from jsonschema.validators import _VALIDATORS, _RefResolver
+from jsonschema.validators import _VALIDATORS
 import jsonschema
 
 _DELIMITERS = re.compile(r"[\W\- ]+")
@@ -245,20 +245,11 @@ def fn(this):
 
     def validate(self, Validator, **kwargs):
         Validator.check_schema(self.schema)
-        resolver = _RefResolver.from_schema(
+        validator = Validator(
             schema=self.schema,
-            store={k: v.contents for k, v in self._remotes.items()},
-            id_of=Validator.ID_OF,
+            registry=self._remotes,
+            **kwargs,
         )
-
-        # XXX: #693 asks to improve the public API for this, since yeah, it's
-        #      bad. Figures that since it's hard for end-users, we experience
-        #      the pain internally here too.
-        def prevent_network_access(uri):
-            raise RuntimeError(f"Tried to access the network: {uri}")
-        resolver.resolve_remote = prevent_network_access
-
-        validator = Validator(schema=self.schema, resolver=resolver, **kwargs)
         if os.environ.get("JSON_SCHEMA_DEBUG", "0") != "0":
             breakpoint()
         validator.validate(instance=self.data)