Need to preserve backwards compat for RefResolvers without the new methods.

Author: Julian

jsonschema/_validators.py

@@ -190,14 +190,20 @@ def enum(validator, enums, instance, schema):
 
 
 def ref(validator, ref, instance, schema):
-    scope, resolved = validator.resolver.resolve(ref)
-    validator.resolver.push_scope(scope)
+    resolve = getattr(validator.resolver, "resolve", None)
+    if resolve is None:
+        with validator.resolver.resolving(ref) as resolved:
+            for error in validator.descend(instance, resolved):
+                yield error
+    else:
+        scope, resolved = validator.resolver.resolve(ref)
+        validator.resolver.push_scope(scope)
 
-    try:
-        for error in validator.descend(instance, resolved):
-            yield error
-    finally:
-        validator.resolver.pop_scope()
+        try:
+            for error in validator.descend(instance, resolved):
+                yield error
+        finally:
+            validator.resolver.pop_scope()
 
 
 def type_draft3(validator, types, instance, schema):

jsonschema/tests/test_validators.py

@@ -1,4 +1,5 @@
 from collections import deque
+from contextlib import contextmanager
 import json
 
 from jsonschema import FormatChecker, ValidationError
@@ -639,6 +640,25 @@ def test_it_delegates_to_a_ref_resolver(self):
 
         resolve.assert_called_once_with(schema["$ref"])
 
+    def test_it_delegates_to_a_legacy_ref_resolver(self):
+        """
+        Legacy RefResolvers support only the context manager form of
+        resolution.
+
+        """
+
+        class LegacyRefResolver(object):
+            @contextmanager
+            def resolving(this, ref):
+                self.assertEqual(ref, "the ref")
+                yield {"type" : "integer"}
+
+        resolver = LegacyRefResolver()
+        schema = {"$ref" : "the ref"}
+
+        with self.assertRaises(ValidationError):
+            self.validator_class(schema, resolver=resolver).validate(None)
+
     def test_is_type_is_true_for_valid_type(self):
         self.assertTrue(self.validator.is_type("foo", "string"))