validator refactor progress

src/validator/rules/core.rs

@@ -0,0 +1,84 @@
+use crate::validator::Validator;
+use crate::validator::context::ValidationContext;
+use crate::validator::error::ValidationError;
+use crate::validator::result::ValidationResult;
+
+impl<'a> ValidationContext<'a> {
+  pub(crate) fn validate_core(
+    &self,
+    result: &mut ValidationResult,
+  ) -> Result<bool, ValidationError> {
+    let current = self.instance;
+
+    if let Some(ref type_) = self.schema.type_ {
+      match type_ {
+        crate::database::schema::SchemaTypeOrArray::Single(t) => {
+          if !Validator::check_type(t, current) {
+            result.errors.push(ValidationError {
+              code: "INVALID_TYPE".to_string(),
+              message: format!("Expected type '{}'", t),
+              path: self.path.to_string(),
+            });
+          }
+        }
+        crate::database::schema::SchemaTypeOrArray::Multiple(types) => {
+          let mut valid = false;
+          for t in types {
+            if Validator::check_type(t, current) {
+              valid = true;
+              break;
+            }
+          }
+          if !valid {
+            result.errors.push(ValidationError {
+              code: "INVALID_TYPE".to_string(),
+              message: format!("Expected one of types {:?}", types),
+              path: self.path.to_string(),
+            });
+          }
+        }
+      }
+    }
+
+    if let Some(ref const_val) = self.schema.const_ {
+      if !crate::validator::util::equals(current, const_val) {
+        result.errors.push(ValidationError {
+          code: "CONST_VIOLATED".to_string(),
+          message: "Value does not match const".to_string(),
+          path: self.path.to_string(),
+        });
+      } else {
+        if let Some(obj) = current.as_object() {
+          result.evaluated_keys.extend(obj.keys().cloned());
+        } else if let Some(arr) = current.as_array() {
+          result.evaluated_indices.extend(0..arr.len());
+        }
+      }
+    }
+
+    if let Some(ref enum_vals) = self.schema.enum_ {
+      let mut found = false;
+      for val in enum_vals {
+        if crate::validator::util::equals(current, val) {
+          found = true;
+          break;
+        }
+      }
+      if !found {
+        result.errors.push(ValidationError {
+          code: "ENUM_MISMATCH".to_string(),
+          message: "Value is not in enum".to_string(),
+          path: self.path.to_string(),
+        });
+      } else {
+        if let Some(obj) = current.as_object() {
+          result.evaluated_keys.extend(obj.keys().cloned());
+        } else if let Some(arr) = current.as_array() {
+          result.evaluated_indices.extend(0..arr.len());
+        }
+      }
+    }
+
+    Ok(true)
+  }
+}