massively improves the jspg validator by removing mathmatical functions like allOf, anyOf, ref, etc to effectively use discriminators and OOP with types to determine valid pathing an nno intersections, unions, or guesswork; added cases to replace the former conditionals

src/validator/rules/cases.rs

@@ -0,0 +1,45 @@
+use crate::validator::context::ValidationContext;
+use crate::validator::error::ValidationError;
+use crate::validator::result::ValidationResult;
+
+impl<'a> ValidationContext<'a> {
+  pub(crate) fn validate_cases(
+    &self,
+    result: &mut ValidationResult,
+  ) -> Result<bool, ValidationError> {
+    if let Some(cases) = &self.schema.cases {
+      for case in cases {
+        if let Some(ref when_schema) = case.when {
+          let derived_when = self.derive_for_schema(when_schema, true);
+          let when_res = derived_when.validate()?;
+
+          // Evaluates all cases independently.
+          if when_res.is_valid() {
+            result
+              .evaluated_keys
+              .extend(when_res.evaluated_keys.clone());
+            result
+              .evaluated_indices
+              .extend(when_res.evaluated_indices.clone());
+
+            if let Some(ref then_schema) = case.then {
+              let derived_then = self.derive_for_schema(then_schema, true);
+              result.merge(derived_then.validate()?);
+            }
+          } else {
+            if let Some(ref else_schema) = case.else_ {
+              let derived_else = self.derive_for_schema(else_schema, true);
+              result.merge(derived_else.validate()?);
+            }
+          }
+        } else if let Some(ref else_schema) = case.else_ {
+          // A rule with a missing `when` fires the `else` indiscriminately
+          let derived_else = self.derive_for_schema(else_schema, true);
+          result.merge(derived_else.validate()?);
+        }
+      }
+    }
+
+    Ok(true)
+  }
+}