Error on duplicate keys (#294)

I can't see a reason that you'd want to allow these in maps, but let me know if you think this needs an extension to the schema to optionally allow.

Author: hadley

crates/quarto-yaml-validation/src/error.rs

@@ -149,6 +149,9 @@ pub enum ValidationErrorKind {
     /// Unresolved schema reference
     UnresolvedReference { ref_id: String },
 
+    /// A mapping key appears more than once
+    DuplicateKey { key: String },
+
     /// Other validation error
     ///
     /// **WARNING**: This is a last-resort variant for errors that don't fit any other category.
@@ -176,6 +179,7 @@ impl ValidationErrorKind {
             ValidationErrorKind::ObjectPropertyCountInvalid { .. } => "Q-1-16",
             ValidationErrorKind::UnresolvedReference { .. } => "Q-1-17",
             ValidationErrorKind::UnknownProperty { .. } => "Q-1-18",
+            ValidationErrorKind::DuplicateKey { .. } => "Q-1-20",
             ValidationErrorKind::ArrayItemsNotUnique => "Q-1-19",
             ValidationErrorKind::StringLengthInvalid { .. } => "Q-1-29",
             ValidationErrorKind::Other { .. } => "Q-1-99",
@@ -286,6 +290,9 @@ impl ValidationErrorKind {
             ValidationErrorKind::UnresolvedReference { ref_id } => {
                 format!("Unresolved schema reference: {}", ref_id)
             }
+            ValidationErrorKind::DuplicateKey { key } => {
+                format!("Duplicate key '{}'", key)
+            }
             ValidationErrorKind::Other { message } => message.clone(),
         }
     }
@@ -757,6 +764,22 @@ mod tests {
         assert_eq!(kind.error_code(), "Q-1-18");
     }
 
+    #[test]
+    fn test_error_code_duplicate_key() {
+        let kind = ValidationErrorKind::DuplicateKey {
+            key: "examples".to_string(),
+        };
+        assert_eq!(kind.error_code(), "Q-1-20");
+    }
+
+    #[test]
+    fn test_message_duplicate_key() {
+        let kind = ValidationErrorKind::DuplicateKey {
+            key: "examples".to_string(),
+        };
+        assert_eq!(kind.message(), "Duplicate key 'examples'");
+    }
+
     #[test]
     fn test_error_code_array_items_not_unique() {
         let kind = ValidationErrorKind::ArrayItemsNotUnique;

crates/quarto-yaml-validation/src/validator.rs

@@ -588,11 +588,20 @@ fn validate_object(
         }
     };
 
-    // Extract keys
+    // Extract keys, rejecting duplicates. The source-tracked hash view
+    // preserves every entry (the collapsed `Yaml::Hash` would not), so a
+    // repeated key is detectable here. Report it on the second occurrence,
+    // pointing at that key's span.
     let mut keys = HashSet::new();
     for entry in entries {
-        if let Yaml::String(ref key) = entry.key.yaml {
-            keys.insert(key.clone());
+        if let Yaml::String(ref key) = entry.key.yaml
+            && !keys.insert(key.clone())
+        {
+            context.add_error(
+                ValidationErrorKind::DuplicateKey { key: key.clone() },
+                &entry.key,
+            );
+            return Err(context.errors[0].clone());
         }
     }
 
@@ -1800,6 +1809,40 @@ mod tests {
         assert!(validate(&yaml, &schema, &registry, &source_ctx).is_err());
     }
 
+    #[test]
+    fn test_validate_object_duplicate_keys() {
+        let registry = SchemaRegistry::new();
+        let source_ctx = SourceContext::new();
+        let schema = Schema::Object(ObjectSchema {
+            annotations: SchemaAnnotations::default(),
+            properties: HashMap::new(),
+            pattern_properties: HashMap::new(),
+            additional_properties: None,
+            required: vec![],
+            min_properties: None,
+            max_properties: None,
+            closed: false,
+            property_names: None,
+            naming_convention: None,
+            base_schema: None,
+        });
+
+        // A mapping with a repeated key must be rejected, not silently deduped.
+        let yaml = yaml_object(vec![
+            ("examples", Yaml::String("a".to_string())),
+            ("examples", Yaml::String("c".to_string())),
+        ]);
+        let result = validate(&yaml, &schema, &registry, &source_ctx);
+        let err = result.expect_err("duplicate key should fail validation");
+        assert_eq!(
+            err.kind,
+            ValidationErrorKind::DuplicateKey {
+                key: "examples".to_string(),
+            }
+        );
+        assert_eq!(err.error_code(), "Q-1-20");
+    }
+
     // ==================== AnyOf Tests ====================
 
     #[test]