use crate::{
compilation::context::CompilationContext,
error::{error, no_error, ErrorIterator, ValidationError},
keywords::CompilationResult,
primitive_type::{PrimitiveType, PrimitiveTypesBitMap},
validator::Validate,
};
use serde_json::{json, Map, Number, Value};
use std::convert::TryFrom;
use crate::paths::{InstancePath, JSONPointer};
pub(crate) struct MultipleTypesValidator {
types: PrimitiveTypesBitMap,
schema_path: JSONPointer,
}
impl MultipleTypesValidator {
#[inline]
pub(crate) fn compile(items: &[Value], schema_path: JSONPointer) -> CompilationResult {
let mut types = PrimitiveTypesBitMap::new();
for item in items {
match item {
Value::String(string) => {
if let Ok(primitive_type) = PrimitiveType::try_from(string.as_str()) {
types |= primitive_type;
} else {
return Err(ValidationError::enumeration(
JSONPointer::default(),
schema_path,
item,
&json!([
"array", "boolean", "integer", "null", "number", "object", "string"
]),
));
}
}
_ => {
return Err(ValidationError::single_type_error(
schema_path,
JSONPointer::default(),
item,
PrimitiveType::String,
))
}
}
}
Ok(Box::new(MultipleTypesValidator { types, schema_path }))
}
}
impl Validate for MultipleTypesValidator {
fn is_valid(&self, instance: &Value) -> bool {
match instance {
Value::Array(_) => self.types.contains_type(PrimitiveType::Array),
Value::Bool(_) => self.types.contains_type(PrimitiveType::Boolean),
Value::Null => self.types.contains_type(PrimitiveType::Null),
Value::Number(num) => {
self.types.contains_type(PrimitiveType::Number)
|| (self.types.contains_type(PrimitiveType::Integer) && is_integer(num))
}
Value::Object(_) => self.types.contains_type(PrimitiveType::Object),
Value::String(_) => self.types.contains_type(PrimitiveType::String),
}
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::multiple_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
self.types,
))
}
}
}
impl core::fmt::Display for MultipleTypesValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"type: [{}]",
self.types
.into_iter()
.map(|type_| format!("{}", type_))
.collect::<Vec<String>>()
.join(", ")
)
}
}
pub(crate) struct NullTypeValidator {
schema_path: JSONPointer,
}
impl NullTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(NullTypeValidator { schema_path }))
}
}
impl Validate for NullTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
instance.is_null()
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::Null,
))
}
}
}
impl core::fmt::Display for NullTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: null".fmt(f)
}
}
pub(crate) struct BooleanTypeValidator {
schema_path: JSONPointer,
}
impl BooleanTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(BooleanTypeValidator { schema_path }))
}
}
impl Validate for BooleanTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
instance.is_boolean()
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::Boolean,
))
}
}
}
impl core::fmt::Display for BooleanTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: boolean".fmt(f)
}
}
pub(crate) struct StringTypeValidator {
schema_path: JSONPointer,
}
impl StringTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(StringTypeValidator { schema_path }))
}
}
impl Validate for StringTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
instance.is_string()
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::String,
))
}
}
}
impl core::fmt::Display for StringTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: string".fmt(f)
}
}
pub(crate) struct ArrayTypeValidator {
schema_path: JSONPointer,
}
impl ArrayTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(ArrayTypeValidator { schema_path }))
}
}
impl Validate for ArrayTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
instance.is_array()
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::Array,
))
}
}
}
impl core::fmt::Display for ArrayTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: array".fmt(f)
}
}
pub(crate) struct ObjectTypeValidator {
schema_path: JSONPointer,
}
impl ObjectTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(ObjectTypeValidator { schema_path }))
}
}
impl Validate for ObjectTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
instance.is_object()
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::Object,
))
}
}
}
impl core::fmt::Display for ObjectTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: object".fmt(f)
}
}
pub(crate) struct NumberTypeValidator {
schema_path: JSONPointer,
}
impl NumberTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(NumberTypeValidator { schema_path }))
}
}
impl Validate for NumberTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
instance.is_number()
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::Number,
))
}
}
}
impl core::fmt::Display for NumberTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: number".fmt(f)
}
}
pub(crate) struct IntegerTypeValidator {
schema_path: JSONPointer,
}
impl IntegerTypeValidator {
#[inline]
pub(crate) fn compile<'a>(schema_path: JSONPointer) -> CompilationResult<'a> {
Ok(Box::new(IntegerTypeValidator { schema_path }))
}
}
impl Validate for IntegerTypeValidator {
fn is_valid(&self, instance: &Value) -> bool {
if let Value::Number(num) = instance {
is_integer(num)
} else {
false
}
}
fn validate<'instance>(
&self,
instance: &'instance Value,
instance_path: &InstancePath,
) -> ErrorIterator<'instance> {
if self.is_valid(instance) {
no_error()
} else {
error(ValidationError::single_type_error(
self.schema_path.clone(),
instance_path.into(),
instance,
PrimitiveType::Integer,
))
}
}
}
impl core::fmt::Display for IntegerTypeValidator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
"type: integer".fmt(f)
}
}
fn is_integer(num: &Number) -> bool {
num.is_u64() || num.is_i64() || num.as_f64().expect("Always valid").fract() == 0.
}
#[inline]
pub(crate) fn compile<'a>(
_: &'a Map<String, Value>,
schema: &'a Value,
context: &CompilationContext,
) -> Option<CompilationResult<'a>> {
let schema_path = context.as_pointer_with("type");
match schema {
Value::String(item) => compile_single_type(item.as_str(), schema_path),
Value::Array(items) => {
if items.len() == 1 {
let item = &items[0];
if let Value::String(item) = item {
compile_single_type(item.as_str(), schema_path)
} else {
Some(Err(ValidationError::single_type_error(
JSONPointer::default(),
schema_path,
item,
PrimitiveType::String,
)))
}
} else {
Some(MultipleTypesValidator::compile(items, schema_path))
}
}
_ => Some(Err(ValidationError::multiple_type_error(
JSONPointer::default(),
context.clone().into_pointer(),
schema,
PrimitiveTypesBitMap::new()
.add_type(PrimitiveType::String)
.add_type(PrimitiveType::Array),
))),
}
}
fn compile_single_type(item: &str, schema_path: JSONPointer) -> Option<CompilationResult> {
match PrimitiveType::try_from(item) {
Ok(PrimitiveType::Array) => Some(ArrayTypeValidator::compile(schema_path)),
Ok(PrimitiveType::Boolean) => Some(BooleanTypeValidator::compile(schema_path)),
Ok(PrimitiveType::Integer) => Some(IntegerTypeValidator::compile(schema_path)),
Ok(PrimitiveType::Null) => Some(NullTypeValidator::compile(schema_path)),
Ok(PrimitiveType::Number) => Some(NumberTypeValidator::compile(schema_path)),
Ok(PrimitiveType::Object) => Some(ObjectTypeValidator::compile(schema_path)),
Ok(PrimitiveType::String) => Some(StringTypeValidator::compile(schema_path)),
Err(()) => Some(Err(ValidationError::null_schema())),
}
}
#[cfg(test)]
mod tests {
use crate::tests_util;
use serde_json::{json, Value};
use test_case::test_case;
#[test_case(&json!({"type": "array"}), &json!(1), "/type")]
#[test_case(&json!({"type": "boolean"}), &json!(1), "/type")]
#[test_case(&json!({"type": "integer"}), &json!("f"), "/type")]
#[test_case(&json!({"type": "null"}), &json!(1), "/type")]
#[test_case(&json!({"type": "number"}), &json!("f"), "/type")]
#[test_case(&json!({"type": "object"}), &json!(1), "/type")]
#[test_case(&json!({"type": "string"}), &json!(1), "/type")]
#[test_case(&json!({"type": ["string", "object"]}), &json!(1), "/type")]
fn schema_path(schema: &Value, instance: &Value, expected: &str) {
tests_util::assert_schema_path(schema, instance, expected)
}
}