Get these out of the way.

3 files changed, 180 insertions, 171 deletions

diff --git a/jsonschema/_legacy_validators.py b/jsonschema/_legacy_validators.py
new file mode 100644
index 0000000..4e01727
--- /dev/null
+++ b/jsonschema/_legacy_validators.py
@@ -0,0 +1,160 @@
+from jsonschema import _utils
+from jsonschema.compat import iteritems
+from jsonschema.exceptions import ValidationError
+
+
+def allOf_draft4(validator, allOf, instance, schema):
+    for index, subschema in enumerate(allOf):
+        for error in validator.descend(instance, subschema, schema_path=index):
+            yield error
+
+
+def anyOf_draft4(validator, anyOf, instance, schema):
+    all_errors = []
+    for index, subschema in enumerate(anyOf):
+        errs = list(validator.descend(instance, subschema, schema_path=index))
+        if not errs:
+            break
+        all_errors.extend(errs)
+    else:
+        yield ValidationError(
+            "%r is not valid under any of the given schemas" % (instance,),
+            context=all_errors,
+        )
+
+
+def oneOf_draft4(validator, oneOf, instance, schema):
+    subschemas = enumerate(oneOf)
+    all_errors = []
+    for index, subschema in subschemas:
+        errs = list(validator.descend(instance, subschema, schema_path=index))
+        if not errs:
+            first_valid = subschema
+            break
+        all_errors.extend(errs)
+    else:
+        yield ValidationError(
+            "%r is not valid under any of the given schemas" % (instance,),
+            context=all_errors,
+        )
+
+    more_valid = [s for i, s in subschemas if validator.is_valid(instance, s)]
+    if more_valid:
+        more_valid.append(first_valid)
+        reprs = ", ".join(repr(schema) for schema in more_valid)
+        yield ValidationError(
+            "%r is valid under each of %s" % (instance, reprs)
+        )
+
+
+def disallow_draft3(validator, disallow, instance, schema):
+    for disallowed in _utils.ensure_list(disallow):
+        if validator.is_valid(instance, {"type": [disallowed]}):
+            yield ValidationError(
+                "%r is disallowed for %r" % (disallowed, instance)
+            )
+
+
+def extends_draft3(validator, extends, instance, schema):
+    if validator.is_type(extends, "object"):
+        for error in validator.descend(instance, extends):
+            yield error
+        return
+    for index, subschema in enumerate(extends):
+        for error in validator.descend(instance, subschema, schema_path=index):
+            yield error
+
+
+def items_draft3_draft4(validator, items, instance, schema):
+    if not validator.is_type(instance, "array"):
+        return
+
+    if validator.is_type(items, "object"):
+        for index, item in enumerate(instance):
+            for error in validator.descend(item, items, path=index):
+                yield error
+    else:
+        for (index, item), subschema in zip(enumerate(instance), items):
+            for error in validator.descend(
+                item, subschema, path=index, schema_path=index,
+            ):
+                yield error
+
+
+def minimum_draft3_draft4(validator, minimum, instance, schema):
+    if not validator.is_type(instance, "number"):
+        return
+
+    if schema.get("exclusiveMinimum", False):
+        failed = instance <= minimum
+        cmp = "less than or equal to"
+    else:
+        failed = instance < minimum
+        cmp = "less than"
+
+    if failed:
+        yield ValidationError(
+            "%r is %s the minimum of %r" % (instance, cmp, minimum)
+        )
+
+
+def maximum_draft3_draft4(validator, maximum, instance, schema):
+    if not validator.is_type(instance, "number"):
+        return
+
+    if schema.get("exclusiveMaximum", False):
+        failed = instance >= maximum
+        cmp = "greater than or equal to"
+    else:
+        failed = instance > maximum
+        cmp = "greater than"
+
+    if failed:
+        yield ValidationError(
+            "%r is %s the maximum of %r" % (instance, cmp, maximum)
+        )
+
+
+def properties_draft3(validator, properties, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+
+    for property, subschema in iteritems(properties):
+        if property in instance:
+            for error in validator.descend(
+                instance[property],
+                subschema,
+                path=property,
+                schema_path=property,
+            ):
+                yield error
+        elif subschema.get("required", False):
+            error = ValidationError("%r is a required property" % property)
+            error._set(
+                validator="required",
+                validator_value=subschema["required"],
+                instance=instance,
+                schema=schema,
+            )
+            error.path.appendleft(property)
+            error.schema_path.extend([property, "required"])
+            yield error
+
+
+def type_draft3(validator, types, instance, schema):
+    types = _utils.ensure_list(types)
+
+    all_errors = []
+    for index, type in enumerate(types):
+        if validator.is_type(type, "object"):
+            errors = list(validator.descend(instance, type, schema_path=index))
+            if not errors:
+                return
+            all_errors.extend(errors)
+        else:
+            if validator.is_type(instance, type):
+                return
+    else:
+        yield ValidationError(
+            _utils.types_msg(instance, types), context=all_errors,
+        )
diff --git a/jsonschema/_validators.py b/jsonschema/_validators.py
index 5b1c468..507305e 100644
--- a/jsonschema/_validators.py
+++ b/jsonschema/_validators.py
@@ -59,22 +59,6 @@ def additionalProperties(validator, aP, instance, schema):
             yield ValidationError(error % _utils.extras_msg(extras))
 
 
-def items_draft3_draft4(validator, items, instance, schema):
-    if not validator.is_type(instance, "array"):
-        return
-
-    if validator.is_type(items, "object"):
-        for index, item in enumerate(instance):
-            for error in validator.descend(item, items, path=index):
-                yield error
-    else:
-        for (index, item), subschema in zip(enumerate(instance), items):
-            for error in validator.descend(
-                item, subschema, path=index, schema_path=index,
-            ):
-                yield error
-
-
 def items(validator, items, instance, schema):
     if not validator.is_type(instance, "array"):
         return
@@ -132,40 +116,6 @@ def contains(validator, contains, instance, schema):
         )
 
 
-def minimum_draft3_draft4(validator, minimum, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if schema.get("exclusiveMinimum", False):
-        failed = instance <= minimum
-        cmp = "less than or equal to"
-    else:
-        failed = instance < minimum
-        cmp = "less than"
-
-    if failed:
-        yield ValidationError(
-            "%r is %s the minimum of %r" % (instance, cmp, minimum)
-        )
-
-
-def maximum_draft3_draft4(validator, maximum, instance, schema):
-    if not validator.is_type(instance, "number"):
-        return
-
-    if schema.get("exclusiveMaximum", False):
-        failed = instance >= maximum
-        cmp = "greater than or equal to"
-    else:
-        failed = instance > maximum
-        cmp = "greater than"
-
-    if failed:
-        yield ValidationError(
-            "%r is %s the maximum of %r" % (instance, cmp, maximum)
-        )
-
-
 def exclusiveMinimum(validator, minimum, instance, schema):
     if not validator.is_type(instance, "number"):
         return
@@ -319,69 +269,6 @@ def ref(validator, ref, instance, schema):
             validator.resolver.pop_scope()
 
 
-def type_draft3(validator, types, instance, schema):
-    types = _utils.ensure_list(types)
-
-    all_errors = []
-    for index, type in enumerate(types):
-        if validator.is_type(type, "object"):
-            errors = list(validator.descend(instance, type, schema_path=index))
-            if not errors:
-                return
-            all_errors.extend(errors)
-        else:
-            if validator.is_type(instance, type):
-                return
-    else:
-        yield ValidationError(
-            _utils.types_msg(instance, types), context=all_errors,
-        )
-
-
-def properties_draft3(validator, properties, instance, schema):
-    if not validator.is_type(instance, "object"):
-        return
-
-    for property, subschema in iteritems(properties):
-        if property in instance:
-            for error in validator.descend(
-                instance[property],
-                subschema,
-                path=property,
-                schema_path=property,
-            ):
-                yield error
-        elif subschema.get("required", False):
-            error = ValidationError("%r is a required property" % property)
-            error._set(
-                validator="required",
-                validator_value=subschema["required"],
-                instance=instance,
-                schema=schema,
-            )
-            error.path.appendleft(property)
-            error.schema_path.extend([property, "required"])
-            yield error
-
-
-def disallow_draft3(validator, disallow, instance, schema):
-    for disallowed in _utils.ensure_list(disallow):
-        if validator.is_valid(instance, {"type": [disallowed]}):
-            yield ValidationError(
-                "%r is disallowed for %r" % (disallowed, instance)
-            )
-
-
-def extends_draft3(validator, extends, instance, schema):
-    if validator.is_type(extends, "object"):
-        for error in validator.descend(instance, extends):
-            yield error
-        return
-    for index, subschema in enumerate(extends):
-        for error in validator.descend(instance, subschema, schema_path=index):
-            yield error
-
-
 def type(validator, types, instance, schema):
     types = _utils.ensure_list(types)
 
@@ -426,56 +313,12 @@ def maxProperties(validator, mP, instance, schema):
         yield ValidationError("%r has too many properties" % (instance,))
 
 
-def allOf_draft4(validator, allOf, instance, schema):
-    for index, subschema in enumerate(allOf):
-        for error in validator.descend(instance, subschema, schema_path=index):
-            yield error
-
-
 def allOf(validator, allOf, instance, schema):
     for index, subschema in enumerate(allOf):
         for error in validator.descend(instance, subschema, schema_path=index):
             yield error
 
 
-def oneOf_draft4(validator, oneOf, instance, schema):
-    subschemas = enumerate(oneOf)
-    all_errors = []
-    for index, subschema in subschemas:
-        errs = list(validator.descend(instance, subschema, schema_path=index))
-        if not errs:
-            first_valid = subschema
-            break
-        all_errors.extend(errs)
-    else:
-        yield ValidationError(
-            "%r is not valid under any of the given schemas" % (instance,),
-            context=all_errors,
-        )
-
-    more_valid = [s for i, s in subschemas if validator.is_valid(instance, s)]
-    if more_valid:
-        more_valid.append(first_valid)
-        reprs = ", ".join(repr(schema) for schema in more_valid)
-        yield ValidationError(
-            "%r is valid under each of %s" % (instance, reprs)
-        )
-
-
-def anyOf_draft4(validator, anyOf, instance, schema):
-    all_errors = []
-    for index, subschema in enumerate(anyOf):
-        errs = list(validator.descend(instance, subschema, schema_path=index))
-        if not errs:
-            break
-        all_errors.extend(errs)
-    else:
-        yield ValidationError(
-            "%r is not valid under any of the given schemas" % (instance,),
-            context=all_errors,
-        )
-
-
 def anyOf(validator, anyOf, instance, schema):
     all_errors = []
     for index, subschema in enumerate(anyOf):
diff --git a/jsonschema/validators.py b/jsonschema/validators.py
index 612a3ab..d0a2da9 100644
--- a/jsonschema/validators.py
+++ b/jsonschema/validators.py
@@ -7,7 +7,13 @@ import numbers
 
 from six import add_metaclass
 
-from jsonschema import _utils, _validators, _types, exceptions
+from jsonschema import (
+    _legacy_validators,
+    _types,
+    _utils,
+    _validators,
+    exceptions,
+)
 from jsonschema.compat import (
     Sequence,
     int_types,
@@ -404,22 +410,22 @@ Draft3Validator = create(
         u"additionalItems": _validators.additionalItems,
         u"additionalProperties": _validators.additionalProperties,
         u"dependencies": _validators.dependencies,
-        u"disallow": _validators.disallow_draft3,
+        u"disallow": _legacy_validators.disallow_draft3,
         u"divisibleBy": _validators.multipleOf,
         u"enum": _validators.enum,
-        u"extends": _validators.extends_draft3,
+        u"extends": _legacy_validators.extends_draft3,
         u"format": _validators.format,
-        u"items": _validators.items_draft3_draft4,
+        u"items": _legacy_validators.items_draft3_draft4,
         u"maxItems": _validators.maxItems,
         u"maxLength": _validators.maxLength,
-        u"maximum": _validators.maximum_draft3_draft4,
+        u"maximum": _legacy_validators.maximum_draft3_draft4,
         u"minItems": _validators.minItems,
         u"minLength": _validators.minLength,
-        u"minimum": _validators.minimum_draft3_draft4,
+        u"minimum": _legacy_validators.minimum_draft3_draft4,
         u"pattern": _validators.pattern,
         u"patternProperties": _validators.patternProperties,
-        u"properties": _validators.properties_draft3,
-        u"type": _validators.type_draft3,
+        u"properties": _legacy_validators.properties_draft3,
+        u"type": _legacy_validators.type_draft3,
         u"uniqueItems": _validators.uniqueItems,
     },
     type_checker=_types.draft3_type_checker,
@@ -433,23 +439,23 @@ Draft4Validator = create(
         u"$ref": _validators.ref,
         u"additionalItems": _validators.additionalItems,
         u"additionalProperties": _validators.additionalProperties,
-        u"allOf": _validators.allOf_draft4,
-        u"anyOf": _validators.anyOf_draft4,
+        u"allOf": _legacy_validators.allOf_draft4,
+        u"anyOf": _legacy_validators.anyOf_draft4,
         u"dependencies": _validators.dependencies,
         u"enum": _validators.enum,
         u"format": _validators.format,
-        u"items": _validators.items_draft3_draft4,
+        u"items": _legacy_validators.items_draft3_draft4,
         u"maxItems": _validators.maxItems,
         u"maxLength": _validators.maxLength,
         u"maxProperties": _validators.maxProperties,
-        u"maximum": _validators.maximum_draft3_draft4,
+        u"maximum": _legacy_validators.maximum_draft3_draft4,
         u"minItems": _validators.minItems,
         u"minLength": _validators.minLength,
         u"minProperties": _validators.minProperties,
-        u"minimum": _validators.minimum_draft3_draft4,
+        u"minimum": _legacy_validators.minimum_draft3_draft4,
         u"multipleOf": _validators.multipleOf,
         u"not": _validators.not_,
-        u"oneOf": _validators.oneOf_draft4,
+        u"oneOf": _legacy_validators.oneOf_draft4,
         u"pattern": _validators.pattern,
         u"patternProperties": _validators.patternProperties,
         u"properties": _validators.properties,