Tag handling: simplify core checks, normalize tags, add binary/timestamp tests

Author: t-kalinowski

src/lib.rs

@@ -435,10 +435,7 @@ fn resolve_representation(node: &mut Yaml, _simplify: bool) {
 
     let parsed = match tag {
         Some(tag) => {
-            let is_core_schema = tag.is_yaml_core_schema();
-            let normalized_suffix = normalized_suffix(tag.suffix.as_str());
-
-            if is_core_schema {
+            if tag.is_yaml_core_schema() {
                 match tag.suffix.as_str() {
                     "str" => Yaml::value_from_cow_and_metadata(value, style, Some(&tag)),
                     "null" => {
@@ -466,8 +463,6 @@ fn resolve_representation(node: &mut Yaml, _simplify: bool) {
                         }
                     }
                 }
-            } else if is_effective_core_null(&tag, is_core_schema, normalized_suffix) {
-                Yaml::Value(Scalar::Null)
             } else {
                 Yaml::Tagged(tag, Box::new(Yaml::Value(Scalar::String(value))))
             }
@@ -586,17 +581,11 @@ fn convert_tagged(
         }
     }
 
-    let is_core_schema = tag.is_yaml_core_schema();
-    let normalized_suffix = normalized_suffix(tag.suffix.as_str());
-
-    if is_effective_core_null(tag, is_core_schema, normalized_suffix) {
-        return Ok(py.None());
-    }
-
     let value = yaml_to_py(py, node, is_key, handlers)?;
 
-    if is_core_schema {
-        return match tag.suffix.as_str() {
+    let normalized_suffix = normalized_suffix(tag.suffix.as_str());
+    if is_core_tag(tag) {
+        return match normalized_suffix {
             "str" | "null" | "bool" | "int" | "float" | "seq" | "map" => Ok(value),
             "timestamp" | "set" | "omap" | "pairs" | "binary" => {
                 let rendered = render_tag(tag);
@@ -633,25 +622,24 @@ fn is_core_null_tag(tag: &Tag) -> bool {
 }
 
 fn is_core_scalar_tag(tag: &Tag) -> bool {
-    tag.is_yaml_core_schema()
-        && matches!(
-            tag.suffix.as_str(),
-            "str" | "null" | "bool" | "int" | "float" | "seq" | "map"
-        )
+    if !is_core_tag(tag) {
+        return false;
+    }
+    matches!(
+        normalized_suffix(tag.suffix.as_str()),
+        "str" | "null" | "bool" | "int" | "float" | "seq" | "map"
+    )
 }
 
 fn normalized_suffix(suffix: &str) -> &str {
     let suffix = suffix.trim_start_matches('!');
     suffix.strip_prefix("tag:yaml.org,2002:").unwrap_or(suffix)
 }
 
-fn is_effective_core_null(tag: &Tag, is_core_schema: bool, normalized_suffix: &str) -> bool {
-    (is_core_schema && tag.suffix.as_str() == "null")
-        || (tag.handle.as_str() == "!!" && tag.suffix.as_str() == "null")
-        || (tag.handle.is_empty()
-            && normalized_suffix == "null"
-            && (tag.suffix.as_str().starts_with('!')
-                || tag.suffix.as_str().starts_with("tag:yaml.org,2002:")))
+fn is_core_tag(tag: &Tag) -> bool {
+    tag.is_yaml_core_schema()
+        || (tag.handle.as_str() == "!" && tag.suffix.as_str().starts_with('!'))
+        || (tag.handle.is_empty() && tag.suffix.as_str().starts_with("tag:yaml.org,2002:"))
 }
 
 fn render_tag(tag: &Tag) -> String {
@@ -790,38 +778,66 @@ fn py_to_yaml(py: Python<'_>, obj: &Bound<'_, PyAny>, is_key: bool) -> Result<Ya
 }
 
 fn parse_tag_string(tag: &str) -> Result<Tag> {
-    const YAML_CORE_HANDLE: &str = "tag:yaml.org,2002:";
-
     let trimmed = tag.trim();
     if trimmed.is_empty() {
         return Err(PyValueError::new_err("tag must not be empty"));
     }
 
-    let Some((mut handle, mut suffix)) = split_tag_name(trimmed) else {
-        return Err(PyValueError::new_err(format!(
-            "invalid YAML tag `{trimmed}`"
-        )));
-    };
+    let invalid_tag_error = || PyValueError::new_err(format!("invalid YAML tag `{trimmed}`"));
 
-    if handle == "!!" {
-        handle = YAML_CORE_HANDLE;
-    } else if handle.is_empty() && suffix.starts_with(YAML_CORE_HANDLE) {
-        suffix = &suffix[YAML_CORE_HANDLE.len()..];
-        handle = YAML_CORE_HANDLE;
+    if !trimmed.contains('!') && !trimmed.contains(':') {
+        return Err(invalid_tag_error());
     }
 
-    // saphyr cannot emit a bare tag represented as handle="" / suffix="!".
-    // Normalize to handle="!" / suffix="" so round-tripping `!` works.
-    let (handle, suffix) = if handle.is_empty() && suffix == "!" {
-        ("!", "")
+    let tag = if trimmed == "!" {
+        Tag {
+            handle: String::new(),
+            suffix: "!".to_string(),
+        }
+    } else if let Some(rest) = trimmed.strip_prefix("!!") {
+        if rest.is_empty() {
+            return Err(invalid_tag_error());
+        }
+        let mut suffix = String::with_capacity(rest.len() + 1);
+        suffix.push('!');
+        suffix.push_str(rest);
+        Tag {
+            handle: "!".to_string(),
+            suffix,
+        }
+    } else if let Some(rest) = trimmed.strip_prefix('!') {
+        if rest.is_empty() {
+            return Err(invalid_tag_error());
+        }
+        Tag {
+            handle: "!".to_string(),
+            suffix: rest.to_string(),
+        }
+    } else if let Some((handle, suffix)) = trimmed.rsplit_once('!') {
+        if suffix.is_empty() {
+            return Err(invalid_tag_error());
+        }
+        Tag {
+            handle: handle.to_string(),
+            suffix: suffix.to_string(),
+        }
     } else {
-        (handle, suffix)
+        Tag {
+            handle: String::new(),
+            suffix: trimmed.to_string(),
+        }
     };
 
-    Ok(Tag {
-        handle: handle.to_string(),
-        suffix: suffix.to_string(),
-    })
+    // saphyr cannot emit a bare tag represented as handle="" / suffix="!".
+    // Normalize to handle="!" / suffix="" so round-tripping `!` works.
+    if tag.handle.is_empty() && tag.suffix.as_str() == "!" {
+        Ok(Tag {
+            handle: "!".to_string(),
+            suffix: String::new(),
+        })
+    } else {
+        Ok(tag)
+    }
 }
 
 fn is_tagged(py: Python<'_>, obj: &Bound<'_, PyAny>) -> Result<bool> {

tests_py/test_format_parse.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import math
 import textwrap
 from typing import Callable
@@ -8,6 +9,7 @@
 
 import yaml12
 from yaml12 import Tagged
+import base64
 
 
 def test_format_yaml_round_trip_nested_structures():
@@ -43,6 +45,20 @@ def test_format_yaml_preserves_tagged_values():
     assert reparsed.value["seq"].tag == "!seq"
 
 
+def test_format_yaml_preserves_binary_tags():
+    payload = base64.b64encode(b"hello world").decode("ascii")
+    tagged = Tagged(payload, "!!binary")
+
+    out = yaml12.format_yaml(tagged)
+
+    assert out.startswith("!!binary ")
+
+    reparsed = yaml12.parse_yaml(out)
+    assert isinstance(reparsed, Tagged)
+    assert reparsed.tag == "tag:yaml.org,2002:binary"
+    assert reparsed.value == payload
+
+
 def test_format_yaml_ignores_core_schema_handles():
     obj = Tagged(
         {
@@ -292,6 +308,24 @@ def test_parse_yaml_preserves_custom_tags():
     assert nested["values"].value == [1, 2]
 
 
+def test_parse_yaml_preserves_timestamp_tags():
+    yaml = textwrap.dedent(
+        """\
+        - !!timestamp 2025-01-01
+        - !!timestamp 2025-01-01 21:59:43.10 -5
+        """
+    )
+    parsed = yaml12.parse_yaml(yaml)
+
+    assert isinstance(parsed, list)
+    assert len(parsed) == 2
+    expected_values = ["2025-01-01", "2025-01-01 21:59:43.10 -5"]
+    for item, expected in zip(parsed, expected_values):
+        assert isinstance(item, Tagged)
+        assert item.tag == "tag:yaml.org,2002:timestamp"
+        assert item.value == expected
+
+
 def test_parse_yaml_applies_handlers_to_tagged_nodes():
     handlers: dict[str, Callable[[object], object]] = {
         "!expr": lambda value: eval(str(value)),
@@ -374,18 +408,22 @@ def test_parse_yaml_validates_handlers_argument():
 def test_parse_yaml_resolves_canonical_null_tags():
     canonical_cases = [
         "!!null ~",
-        "!<!!null> ~",
         "!<tag:yaml.org,2002:null> ~",
-        "!<!null> ~",
     ]
     for yaml in canonical_cases:
         parsed = yaml12.parse_yaml(yaml)
         assert parsed is None
 
-    custom = yaml12.parse_yaml("!null ~")
-    assert isinstance(custom, Tagged)
-    assert custom.tag == "!null"
-    assert custom.value == "~"
+    informative_cases = {
+        "!<!!null> ~": "!!null",
+        "!<!null> ~": "!null",
+        "!null ~": "!null",
+    }
+    for yaml, expected_tag in informative_cases.items():
+        parsed = yaml12.parse_yaml(yaml)
+        assert isinstance(parsed, Tagged)
+        assert parsed.tag == expected_tag
+        assert parsed.value == "~"
 
 
 def test_parse_yaml_errors_on_invalid_canonical_tags():