validator refactor progress

src/validator/rules/string.rs

@@ -0,0 +1,53 @@
+use crate::validator::context::ValidationContext;
+use crate::validator::error::ValidationError;
+use crate::validator::result::ValidationResult;
+use regex::Regex;
+
+impl<'a> ValidationContext<'a> {
+  pub(crate) fn validate_string(
+    &self,
+    result: &mut ValidationResult,
+  ) -> Result<bool, ValidationError> {
+    let current = self.instance;
+    if let Some(s) = current.as_str() {
+      if let Some(min) = self.schema.min_length {
+        if (s.chars().count() as f64) < min {
+          result.errors.push(ValidationError {
+            code: "MIN_LENGTH_VIOLATED".to_string(),
+            message: format!("Length < min {}", min),
+            path: self.path.to_string(),
+          });
+        }
+      }
+      if let Some(max) = self.schema.max_length {
+        if (s.chars().count() as f64) > max {
+          result.errors.push(ValidationError {
+            code: "MAX_LENGTH_VIOLATED".to_string(),
+            message: format!("Length > max {}", max),
+            path: self.path.to_string(),
+          });
+        }
+      }
+      if let Some(ref compiled_re) = self.schema.compiled_pattern {
+        if !compiled_re.0.is_match(s) {
+          result.errors.push(ValidationError {
+            code: "PATTERN_VIOLATED".to_string(),
+            message: format!("Pattern mismatch {:?}", self.schema.pattern),
+            path: self.path.to_string(),
+          });
+        }
+      } else if let Some(ref pattern) = self.schema.pattern {
+        if let Ok(re) = Regex::new(pattern) {
+          if !re.is_match(s) {
+            result.errors.push(ValidationError {
+              code: "PATTERN_VIOLATED".to_string(),
+              message: format!("Pattern mismatch {}", pattern),
+              path: self.path.to_string(),
+            });
+          }
+        }
+      }
+    }
+    Ok(true)
+  }
+}