Add union operator, and JSONSchema field

Author: lovelydinosaur

tests/test_fields.py

@@ -346,6 +346,10 @@ def test_boolean():
     value, error = validator.validate_or_error(2)
     assert error == ValidationError(text="Must be a boolean.", code="type")
 
+    validator = Boolean()
+    value, error = validator.validate_or_error([])
+    assert error == ValidationError(text="Must be a boolean.", code="type")
+
     validator = Boolean(allow_null=True)
     value, error = validator.validate_or_error(None)
     assert value is None
@@ -747,6 +751,14 @@ def test_union():
         text="Must be less than or equal to 1000.", code="maximum"
     )
 
+    validator = Integer() | String() | Boolean()
+    value, error = validator.validate_or_error(123)
+    assert value == 123
+
+    validator = Integer() | (String() | Boolean())
+    value, error = validator.validate_or_error(123)
+    assert value == 123
+
 
 def test_const():
     validator = Const(const=None)

tests/test_json_schema.py

@@ -5,7 +5,7 @@
 import pytest
 
 import typesystem
-from typesystem.json_schema import from_json_schema, to_json_schema
+from typesystem.json_schema import from_json_schema, to_json_schema, JSONSchema
 
 filenames = [
     "additionalItems.json",
@@ -85,6 +85,14 @@ def test_json_schema(schema, data, is_valid, description):
         assert error is not None, description
 
 
+@pytest.mark.parametrize("schema,data,is_valid,description", test_cases)
+def test_json_schema_validator(schema, data, is_valid, description):
+    """
+    Use the `JSONSchema` field to validate all the test case schemas.
+    """
+    JSONSchema.validate(schema)
+
+
 @pytest.mark.parametrize("schema,data,is_valid,description", test_cases)
 def test_to_from_json_schema(schema, data, is_valid, description):
     """

typesystem/fields.py

@@ -77,24 +77,18 @@ def validation_error(self, code: str) -> ValidationError:
     def get_error_text(self, code: str) -> str:
         return self.errors[code].format(**self.__dict__)
 
+    def __or__(self, other: "Field") -> "Union":
+        if isinstance(self, Union):
+            any_of = self.any_of
+        else:
+            any_of = [self]
 
-def normalize_regex(
-    pattern: typing.Union[str, typing.Pattern] = None
-) -> typing.Tuple[typing.Optional[str], typing.Optional[typing.Pattern]]:
-    """
-    Normalise and validate a regular expression-like input.
-
-    Returns a 2-tuple with a pattern string and a compiled regular expression.
-    """
-    if pattern is None:
-        return (None, None)
+        if isinstance(other, Union):
+            any_of += other.any_of
+        else:
+            any_of += [other]
 
-    if isinstance(pattern, str):
-        pattern_regex = re.compile(pattern)
-    else:
-        pattern_regex = pattern
-
-    return pattern_regex.pattern, pattern_regex
+        return Union(any_of=any_of)
 
 
 class String(Field):
@@ -133,9 +127,18 @@ def __init__(
         self.trim_whitespace = trim_whitespace
         self.max_length = max_length
         self.min_length = min_length
-        self.pattern, self.pattern_regex = normalize_regex(pattern)
         self.format = format
 
+        if pattern is None:
+            self.pattern = None
+            self.pattern_regex = None
+        elif isinstance(pattern, str):
+            self.pattern = pattern
+            self.pattern_regex = re.compile(pattern)
+        else:
+            self.pattern = pattern.pattern
+            self.pattern_regex = pattern
+
     def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
         if value is None and self.allow_null:
             return None
@@ -343,7 +346,7 @@ def validate(self, value: typing.Any, *, strict: bool = False) -> typing.Any:
 
             try:
                 value = self.coerce_values[value]
-            except KeyError:
+            except (KeyError, TypeError):
                 raise self.validation_error("type")
 
         return value

typesystem/json_schema.py

@@ -1,3 +1,6 @@
+"""
+Provides 'typesystem.from_json_schema()' and 'typesystem.to_json_schema()'.
+"""
 import re
 import typing
 
@@ -13,6 +16,7 @@
     Field,
     Float,
     Integer,
+    Number,
     Object,
     String,
     Union,
@@ -47,6 +51,62 @@
 }
 
 
+definitions = SchemaDefinitions()
+
+JSONSchema = (
+    Object(
+        properties={
+            "$ref": String(),
+            "type": String() | Array(items=String()),
+            "enum": Array(unique_items=True, min_items=1),
+            "definitions": Object(
+                additional_properties=Reference("JSONSchema", definitions=definitions)
+            ),
+            # String
+            "minLength": Integer(minimum=0),
+            "maxLength": Integer(minimum=0),
+            "pattern": String(format="regex"),
+            "format": String(),
+            # Numeric
+            "minimum": Number(),
+            "maximum": Number(),
+            "exclusiveMinimum": Number(),
+            "exclusiveMaximum": Number(),
+            "multipleOf": Number(exclusive_minimum=0),
+            # Object
+            "properties": Object(
+                additional_properties=Reference("JSONSchema", definitions=definitions)
+            ),
+            "minProperties": Integer(minimum=0),
+            "maxProperties": Integer(minimum=0),
+            "patternProperties": Object(
+                additional_properties=Reference("JSONSchema", definitions=definitions)
+            ),
+            "additionalProperties": (
+                Reference("JSONSchema", definitions=definitions) | Boolean()
+            ),
+            "required": Array(items=String(), unique_items=True),
+            # Array
+            "items": (
+                Reference("JSONSchema", definitions=definitions)
+                | Array(
+                    items=Reference("JSONSchema", definitions=definitions), min_items=1
+                )
+            ),
+            "additionalItems": (
+                Reference("JSONSchema", definitions=definitions) | Boolean()
+            ),
+            "minItems": Integer(minimum=0),
+            "maxItems": Integer(minimum=0),
+            "uniqueItems": Boolean(),
+        }
+    )
+    | Boolean()
+)
+
+definitions["JSONSchema"] = JSONSchema
+
+
 def from_json_schema(
     data: typing.Union[bool, dict], definitions: SchemaDefinitions = None
 ) -> Field: