Add support for type in json schema to be a list

src/json_schema/mod.rs

@@ -1,9 +1,8 @@
 mod parsing;
 mod types;
 
-pub use types::*;
-
 use serde_json::Value;
+pub use types::*;
 
 use crate::JsonSchemaParserError;
 
@@ -24,9 +23,10 @@ pub fn to_regex(json: &Value, whitespace_pattern: Option<&str>) -> Result<String
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use regex::Regex;
 
+    use super::*;
+
     fn should_match(re: &Regex, value: &str) {
         // Asserts that value is fully matched.
         match re.find(value) {
@@ -918,8 +918,26 @@ mod tests {
                     "username@example..com",          // double dot in domain name
                     "username@.example..com",         // multiple errors in domain
                 ]
-            )
+            ),
 
+            // ==========================================================
+            //                      Multiple types
+            // ==========================================================
+            (
+                r#"{
+                    "title": "Foo",
+                    "type": ["string", "number", "boolean"]
+                }"#,
+                format!(r#"((?:"{STRING_INNER}*")|(?:{NUMBER})|(?:{BOOLEAN}))"#).as_str(),
+                vec!["12.3", "true", r#""a""#],
+                vec![
+                    "null",
+                    "",
+                    "12true",
+                    r#"1.3"a""#,
+                    r#"12.3true"a""#,
+                ],
+            )
         ] {
             let json: Value = serde_json::from_str(schema).expect("Can't parse json");
             let result = to_regex(&json, None).expect("To regex failed");

src/json_schema/parsing.rs

@@ -315,10 +315,21 @@ impl<'a> Parser<'a> {
     }
 
     fn parse_type(&mut self, obj: &serde_json::Map<String, Value>) -> Result<String> {
-        let instance_type = obj["type"]
-            .as_str()
-            .ok_or_else(|| JsonSchemaParserError::TypeMustBeAString)?;
-        match instance_type {
+        let instance_types = if let Some(instance_type) = obj["type"].as_str() {
+            vec![instance_type]
+        } else if let Some(instance_types) = obj["type"].as_array() {
+            instance_types
+                .iter()
+                .map(|instance_type| match instance_type.as_str() {
+                    Some(instance_type) => Ok(instance_type),
+                    None => Err(JsonSchemaParserError::TypeMustBeAString),
+                })
+                .collect::<Result<Vec<&str>>>()?
+        } else {
+            return Err(JsonSchemaParserError::TypeMustBeAString);
+        };
+
+        let mut parse_instance_type = |instance_type: &str| match instance_type {
             "string" => self.parse_string_type(obj),
             "number" => self.parse_number_type(obj),
             "integer" => self.parse_integer_type(obj),
@@ -329,6 +340,21 @@ impl<'a> Parser<'a> {
             _ => Err(JsonSchemaParserError::UnsupportedType(Box::from(
                 instance_type,
             ))),
+        };
+
+        if instance_types.len() == 1 {
+            parse_instance_type(instance_types[0])
+        } else {
+            let xor_patterns = instance_types
+                .into_iter()
+                .map(|instance_type| {
+                    let sub_regex = parse_instance_type(instance_type)?;
+
+                    Ok(format!(r"(?:{})", sub_regex))
+                })
+                .collect::<Result<Vec<String>>>()?;
+
+            Ok(format!(r"({})", xor_patterns.join("|")))
         }
     }