all jspg tests now passing

src/validator/rules/combinators.rs

@@ -15,52 +15,61 @@ impl<'a> ValidationContext<'a> {
       }
     }
 
-    if let Some(ref any_of) = self.schema.any_of {
-      let mut valid = false;
-
-      for sub in any_of {
-        let derived = self.derive_for_schema(sub, true);
-        let sub_res = derived.validate()?;
-        if sub_res.is_valid() {
-          valid = true;
-          result.merge(sub_res);
-        }
-      }
-
-      if !valid {
-        result.errors.push(ValidationError {
-          code: "ANY_OF_VIOLATED".to_string(),
-          message: "Matches none of anyOf schemas".to_string(),
-          path: self.path.to_string(),
-        });
-      }
-    }
-
     if let Some(ref one_of) = self.schema.one_of {
-      let mut valid_count = 0;
-      let mut valid_res = ValidationResult::new();
+      let mut passed_candidates: Vec<(Option<String>, usize, ValidationResult)> = Vec::new();
 
       for sub in one_of {
         let derived = self.derive_for_schema(sub, true);
         let sub_res = derived.validate()?;
         if sub_res.is_valid() {
-          valid_count += 1;
-          valid_res = sub_res;
+          let child_id = sub.id.clone();
+          let depth = child_id
+            .as_ref()
+            .and_then(|id| self.db.depths.get(id).copied())
+            .unwrap_or(0);
+          passed_candidates.push((child_id, depth, sub_res));
         }
       }
 
-      if valid_count == 1 {
-        result.merge(valid_res);
-      } else if valid_count == 0 {
+      if passed_candidates.len() == 1 {
+        result.merge(passed_candidates.pop().unwrap().2);
+      } else if passed_candidates.is_empty() {
         result.errors.push(ValidationError {
-          code: "ONE_OF_VIOLATED".to_string(),
+          code: "NO_ONEOF_MATCH".to_string(),
           message: "Matches none of oneOf schemas".to_string(),
           path: self.path.to_string(),
         });
       } else {
+        // Apply depth heuristic tie-breaker
+        let mut best_depth: Option<usize> = None;
+        let mut ambiguous = false;
+        let mut best_res = None;
+
+        for (_, depth, res) in passed_candidates.into_iter() {
+          if let Some(current_best) = best_depth {
+            if depth > current_best {
+              best_depth = Some(depth);
+              best_res = Some(res);
+              ambiguous = false;
+            } else if depth == current_best {
+              ambiguous = true;
+            }
+          } else {
+            best_depth = Some(depth);
+            best_res = Some(res);
+          }
+        }
+
+        if !ambiguous {
+          if let Some(res) = best_res {
+            result.merge(res);
+            return Ok(true);
+          }
+        }
+
         result.errors.push(ValidationError {
-          code: "ONE_OF_VIOLATED".to_string(),
-          message: format!("Matches {} of oneOf schemas (expected 1)", valid_count),
+          code: "AMBIGUOUS_ONEOF_MATCH".to_string(),
+          message: "Matches multiple oneOf schemas without a clear depth winner".to_string(),
           path: self.path.to_string(),
         });
       }