Revamp RefResolver.

Now properly should resolve both local and remote uris and fragments within
them.

Author: Julian

jsonschema.py

@@ -21,19 +21,36 @@
 
 __version__ = "0.8dev"
 
-FLOAT_TOLERANCE = 10 ** -15
 PY3 = sys.version_info[0] >= 3
 
 if PY3:
     basestring = unicode = str
     iteritems = operator.methodcaller("items")
+    from urllib import parse as urlparse
     from urllib.parse import unquote
     from urllib.request import urlopen
 else:
     from itertools import izip as zip
     iteritems = operator.methodcaller("iteritems")
     from urllib import unquote
     from urllib2 import urlopen
+    import urlparse
+
+
+FLOAT_TOLERANCE = 10 ** -15
+validators = {}
+
+
+def validator(version):
+    """
+    Register a validator for a ``version`` of the specification.
+
+    """
+
+    def _validator(cls):
+        validators[version] = cls
+        return cls
+    return _validator
 
 
 class UnknownType(Exception):
@@ -86,6 +103,7 @@ def __init__(self, message, validator=None, path=()):
         self.validator = validator
 
 
+@validator("draft3")
 class Draft3Validator(object):
     """
     A validator for JSON Schema draft 3.
@@ -123,7 +141,7 @@ def __init__(self, schema, types=(), resolver=None):
         self._types["any"] = tuple(self._types.values())
 
         if resolver is None:
-            resolver = RefResolver()
+            resolver = RefResolver.from_schema(schema)
 
         self.resolver = resolver
         self.schema = schema
@@ -412,7 +430,7 @@ def validate_extends(self, extends, instance, schema):
                 yield error
 
     def validate_ref(self, ref, instance, schema):
-        resolved = self.resolver.resolve(self.schema, ref)
+        resolved = self.resolver.resolve(ref)
         for error in self.iter_errors(instance, resolved):
             yield error
 
@@ -503,50 +521,69 @@ def validate_ref(self, ref, instance, schema):
 
 class RefResolver(object):
     """
-    Resolve JSON Schema refs.
+    Resolve JSON References.
 
     """
 
-    def __init__(self, store=None, get_page=urlopen):
-        if store is None:
-            store = {}
+    def __init__(self, base_uri, referrer, store=()):
+        self.base_uri = base_uri
+        self.referrer = referrer
+        self.store = collections.defaultdict(dict, store, **_meta_schemas())
+
+    @classmethod
+    def from_schema(cls, schema, *args, **kwargs):
+        """
+        Construct a resolver from a JSON schema object.
+
+        """
 
-        self.get_page = get_page
-        self.store = store
+        return cls(schema.get("id", ""), schema, *args, **kwargs)
 
-    def resolve(self, root_schema, ref):
+    def resolve(self, ref):
         """
-        Resolve a ``ref`` within the context of the ``root_schema``.
+        Resolve a JSON ``ref``.
 
         """
 
-        if ref in self.store:
-            return self.store[ref]
-        elif ref.startswith("#"):
-            return self.resolve_relative(root_schema, ref)
+        base_uri = self.base_uri
+        uri, fragment = urlparse.urldefrag(urlparse.urljoin(base_uri, ref))
+
+        if uri in self.store:
+            document = self.store[uri]
+        elif not uri or uri == self.base_uri:
+            document = self.referrer
         else:
-            return json.load(self.get_page(ref))
+            document = self.resolve_remote(uri)
+
+        return self.resolve_fragment(document, fragment.lstrip("/"))
 
-    def resolve_relative(self, schema, ref):
+    def resolve_fragment(self, document, fragment):
         """
-        Resolve a relative ``ref`` within the given ``schema``.
+        Resolve a ``fragment`` within the referenced ``document``.
 
         """
 
-        if ref == "#":
-            return schema
+        parts = unquote(fragment).split("/") if fragment else []
 
-        parts = ref.lstrip("#/").split("/")
-        parts = map(unquote, parts)
-        parts = [part.replace('~1', '/').replace('~0', '~') for part in parts]
+        for part in parts:
+            part = part.replace("~1", "/").replace("~0", "~")
 
-        try:
-            for part in parts:
-                schema = schema[part]
-        except KeyError:
-            raise InvalidRef("Unresolvable json-pointer %r" % ref)
-        else:
-            return schema
+            if part not in document:
+                raise InvalidRef("Unresolvable JSON pointer: %r" % fragment)
+
+            document = document[part]
+
+        return document
+
+    def resolve_remote(self, uri):
+        """
+        Resolve a remote ``uri``.
+
+        Does not check the store first.
+
+        """
+
+        return json.load(urlopen(uri))
 
 
 class ErrorTree(object):
@@ -599,6 +636,16 @@ def total_errors(self):
         return len(self.errors) + child_errors
 
 
+def _meta_schemas():
+    """
+    Collect the urls and meta schemas from each known validator.
+
+    """
+
+    meta_schemas = (v.META_SCHEMA for v in validators.values())
+    return dict((urlparse.urldefrag(m["id"])[0], m) for m in meta_schemas)
+
+
 def _find_additional_properties(instance, schema):
     """
     Return the set of additional properties for the given ``instance``.

tests.py

@@ -1,12 +1,10 @@
 from __future__ import unicode_literals
 from decimal import Decimal
-from functools import wraps
-from io import StringIO
+from io import BytesIO
 import glob
 import os
 import re
 import sys
-import warnings
 import json
 
 if sys.version_info[:2] < (2, 7):  # pragma: no cover
@@ -21,7 +19,7 @@
 
 from jsonschema import (
     PY3, SchemaError, UnknownType, ValidationError, ErrorTree,
-    Draft3Validator, RefResolver, urlopen, validate
+    Draft3Validator, RefResolver, validate
 )
 
 
@@ -349,7 +347,7 @@ def test_it_delegates_to_a_ref_resolver(self):
         with self.assertRaises(ValidationError):
             Draft3Validator(schema, resolver=resolver).validate(None)
 
-        resolver.resolve.assert_called_once_with(schema, schema["$ref"])
+        resolver.resolve.assert_called_once_with(schema["$ref"])
 
     def test_is_type_is_true_for_valid_type(self):
         self.assertTrue(self.validator.is_type("foo", "string"))
@@ -372,36 +370,52 @@ def test_is_type_raises_exception_for_unknown_type(self):
 
 class TestRefResolver(TestCase):
     def setUp(self):
-        self.resolver = RefResolver()
-        self.schema = mock.MagicMock()
+        self.base_uri = ""
+        self.referrer = {}
+        self.store = {}
+        self.resolver = RefResolver(self.base_uri, self.referrer, self.store)
 
-    def test_it_resolves_local_refs(self):
-        ref = "#/properties/foo"
-        resolved = self.resolver.resolve(self.schema, ref)
-        self.assertEqual(resolved, self.schema["properties"]["foo"])
-
-    def test_it_retrieves_non_local_refs(self):
-        schema = '{"type" : "integer"}'
-        get_page = mock.Mock(return_value=StringIO(schema))
-        resolver = RefResolver(get_page=get_page)
-
-        url = "http://example.com/schema"
-        resolved = resolver.resolve(mock.Mock(), url)
+    def test_it_does_not_retrieve_schema_urls_from_the_network(self):
+        ref = Draft3Validator.META_SCHEMA["id"]
+        with mock.patch.object(self.resolver, "resolve_remote") as remote:
+            resolved = self.resolver.resolve(ref)
 
-        self.assertEqual(resolved, json.loads(schema))
-        get_page.assert_called_once_with(url)
+        self.assertEqual(resolved, Draft3Validator.META_SCHEMA)
+        self.assertFalse(remote.called)
 
-    def test_it_uses_urlopen_by_default_for_nonlocal_refs(self):
-        self.assertEqual(self.resolver.get_page, urlopen)
-
-    def test_it_accepts_a_ref_store(self):
-        store = mock.Mock()
-        self.assertEqual(RefResolver(store).store, store)
+    def test_it_resolves_local_refs(self):
+        ref = "#/properties/foo"
+        self.referrer["properties"] = {"foo" : object()}
+        resolved = self.resolver.resolve(ref)
+        self.assertEqual(resolved, self.referrer["properties"]["foo"])
 
     def test_it_retrieves_stored_refs(self):
-        ref = self.resolver.store["cached_ref"] = mock.Mock()
-        resolved = self.resolver.resolve(self.schema, "cached_ref")
-        self.assertEqual(resolved, ref)
+        ref = self.resolver.store["cached_ref"] = {"foo" : 12}
+        resolved = self.resolver.resolve("cached_ref#/foo")
+        self.assertEqual(resolved, 12)
+
+    def test_it_retrieves_unstored_refs_via_urlopen(self):
+        ref = "http://bar#baz"
+        schema = {"baz" : 12}
+
+        with mock.patch("jsonschema.urlopen") as urlopen:
+            urlopen.return_value.read.return_value = json.dumps(schema)
+            resolved = self.resolver.resolve(ref)
+
+        self.assertEqual(resolved, 12)
+        urlopen.assert_called_once_with("http://bar")
+
+    def test_it_can_construct_a_base_uri_from_a_schema(self):
+        schema = {"id" : "foo"}
+        resolver = RefResolver.from_schema(schema)
+        self.assertEqual(resolver.base_uri, "foo")
+        self.assertEqual(resolver.referrer, schema)
+
+    def test_it_can_construct_a_base_uri_from_a_schema_without_id(self):
+        schema = {}
+        resolver = RefResolver.from_schema(schema)
+        self.assertEqual(resolver.base_uri, "")
+        self.assertEqual(resolver.referrer, schema)
 
 
 def sorted_errors(errors):