Support yaml's FP sentinels (#295)

Author: hadley

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

@@ -230,7 +230,7 @@ fn validate_number(
 ) -> ValidationResult<()> {
     let num = match &value.yaml {
         Yaml::Integer(n) => *n as f64,
-        Yaml::Real(s) => s.parse::<f64>().unwrap_or(f64::NAN),
+        Yaml::Real(_) => value.yaml.as_f64().unwrap_or(f64::NAN),
         _ => {
             context.add_error(
                 ValidationErrorKind::TypeMismatch {
@@ -884,6 +884,48 @@ mod tests {
         assert!(validate(&yaml, &schema, &registry, &source_ctx).is_ok());
     }
 
+    #[test]
+    fn test_validate_number_yaml_infinity_and_nan() {
+        // End-to-end: parse real YAML text and validate against a `number`
+        // schema. The YAML core-schema float spellings (`.inf`, `-.inf`, …)
+        // must validate as numbers. Regression for tidyverse/data-dict#47,
+        // where `range: [-.inf, 8.3]` was rejected with "got string".
+        let registry = SchemaRegistry::new();
+        let source_ctx = SourceContext::new();
+        let number_schema = || {
+            Schema::Number(NumberSchema {
+                annotations: SchemaAnnotations::default(),
+                minimum: None,
+                maximum: None,
+                exclusive_minimum: None,
+                exclusive_maximum: None,
+                multiple_of: None,
+            })
+        };
+
+        for text in [".inf", "+.inf", "-.inf", ".Inf", ".INF", ".nan", ".NaN", ".NAN"] {
+            let yaml = quarto_yaml::parse(text).unwrap();
+            assert!(
+                validate(&yaml, &number_schema(), &registry, &source_ctx).is_ok(),
+                "{text:?} should validate as a number"
+            );
+        }
+
+        // And the data-dict shape: an array of numbers including -.inf.
+        let array_schema = Schema::Array(ArraySchema {
+            annotations: SchemaAnnotations::default(),
+            items: Some(Box::new(number_schema())),
+            min_items: None,
+            max_items: None,
+            unique_items: None,
+        });
+        let yaml = quarto_yaml::parse("[-.inf, 8.3]").unwrap();
+        assert!(
+            validate(&yaml, &array_schema, &registry, &source_ctx).is_ok(),
+            "[-.inf, 8.3] should validate as an array of numbers"
+        );
+    }
+
     #[test]
     fn test_validate_number_wrong_type() {
         let registry = SchemaRegistry::new();

crates/quarto-yaml/src/parser.rs

@@ -558,8 +558,10 @@ fn parse_scalar_value(value: &str) -> Yaml {
         return Yaml::Integer(i);
     }
 
-    // Try to parse as float
-    if let Ok(_f) = value.parse::<f64>() {
+    // Try to parse as float, including the YAML 1.2 core-schema float
+    // spellings (`.inf`, `-.inf`, `+.inf`, `.nan`, and case variants) that
+    // Rust's `f64::from_str` does not accept.
+    if is_yaml_float(value) {
         return Yaml::Real(value.to_string());
     }
 
@@ -581,6 +583,16 @@ fn parse_scalar_value(value: &str) -> Yaml {
     Yaml::String(value.to_string())
 }
 
+/// Returns `true` if `value` is a YAML 1.2 core-schema float.
+fn is_yaml_float(value: &str) -> bool {
+    match value {
+        ".inf" | ".Inf" | ".INF" | "+.inf" | "+.Inf" | "+.INF" => true,
+        "-.inf" | "-.Inf" | "-.INF" => true,
+        ".nan" | ".NaN" | ".NAN" => true,
+        _ => value.bytes().any(|b| b.is_ascii_digit()) && value.parse::<f64>().is_ok(),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -599,6 +611,57 @@ mod tests {
         assert_eq!(yaml.yaml.as_i64(), Some(42));
     }
 
+    #[test]
+    fn test_parse_yaml_float_special_forms() {
+        // YAML 1.2 core-schema float spellings must resolve to Yaml::Real,
+        // not Yaml::String. See tidyverse/data-dict#47.
+        for (text, expected) in [
+            (".inf", f64::INFINITY),
+            ("+.inf", f64::INFINITY),
+            (".Inf", f64::INFINITY),
+            (".INF", f64::INFINITY),
+            ("+.INF", f64::INFINITY),
+            ("-.inf", f64::NEG_INFINITY),
+            ("-.Inf", f64::NEG_INFINITY),
+            ("-.INF", f64::NEG_INFINITY),
+        ] {
+            let yaml = parse(text).unwrap();
+            assert!(
+                matches!(yaml.yaml, Yaml::Real(_)),
+                "{text:?} should parse as Yaml::Real, got {:?}",
+                yaml.yaml
+            );
+            assert_eq!(
+                yaml.yaml.as_f64(),
+                Some(expected),
+                "{text:?} should evaluate to {expected}"
+            );
+        }
+
+        for text in [".nan", ".NaN", ".NAN"] {
+            let yaml = parse(text).unwrap();
+            assert!(
+                matches!(yaml.yaml, Yaml::Real(_)),
+                "{text:?} should parse as Yaml::Real, got {:?}",
+                yaml.yaml
+            );
+            assert!(
+                yaml.yaml.as_f64().unwrap().is_nan(),
+                "{text:?} should evaluate to NaN"
+            );
+        }
+
+        // Bare `inf` / `nan` (no leading dot) are NOT YAML floats — they stay strings.
+        for text in ["inf", "nan", "infinity"] {
+            let yaml = parse(text).unwrap();
+            assert!(
+                matches!(yaml.yaml, Yaml::String(_)),
+                "{text:?} should stay a Yaml::String, got {:?}",
+                yaml.yaml
+            );
+        }
+    }
+
     #[test]
     fn test_parse_boolean() {
         let yaml = parse("true").unwrap();