@owenlamont/ryl 0.4.1

package/tests/yamllint_compat_comments_indentation.rs

@@ -0,0 +1,281 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
+    ensure_yamllint_installed,
+};
+
+#[test]
+fn comments_indentation_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let enable_cfg = dir.path().join("comments-enable.yml");
+    fs::write(
+        &enable_cfg,
+        "rules:\n  document-start: disable\n  comments-indentation: enable\n",
+    )
+    .unwrap();
+
+    let warning_cfg = dir.path().join("comments-warning.yml");
+    fs::write(
+        &warning_cfg,
+        "rules:\n  document-start: disable\n  comments-indentation:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let ignore_cfg = dir.path().join("comments-ignore.yml");
+    fs::write(
+        &ignore_cfg,
+        "rules:\n  document-start: disable\n  comments-indentation:\n    ignore:\n      - ignored.yaml\n",
+    )
+    .unwrap();
+
+    let ignore_list = dir.path().join("comments-ignore.txt");
+    fs::write(&ignore_list, "ignored-from-file.yaml\n").unwrap();
+
+    let ignore_from_file_cfg = dir.path().join("comments-ignore-from-file.yml");
+    let ignore_path = ignore_list.display().to_string().replace('\'', "''");
+    fs::write(
+        &ignore_from_file_cfg,
+        format!(
+            "rules:\n  document-start: disable\n  comments-indentation:\n    ignore-from-file: '{}'\n",
+            ignore_path
+        ),
+    )
+    .unwrap();
+
+    let bad_file = dir.path().join("bad.yaml");
+    fs::write(&bad_file, "obj:\n # wrong\n  value: 1\n").unwrap();
+
+    let ignored_file = dir.path().join("ignored.yaml");
+    fs::write(&ignored_file, "obj:\n # wrong\n  value: 1\n").unwrap();
+
+    let ignored_from_file = dir.path().join("ignored-from-file.yaml");
+    fs::write(&ignored_from_file, "obj:\n # wrong\n  value: 1\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_enable = build_ryl_command(exe, scenario.ryl_format);
+        ryl_enable.arg("-c").arg(&enable_cfg).arg(&bad_file);
+        let (ryl_code, ryl_output) = capture_with_env(ryl_enable, scenario.envs);
+
+        let mut yam_enable = build_yamllint_command(scenario.yam_format);
+        yam_enable.arg("-c").arg(&enable_cfg).arg(&bad_file);
+        let (yam_code, yam_output) = capture_with_env(yam_enable, scenario.envs);
+
+        assert_eq!(ryl_code, 1, "ryl enable exit ({})", scenario.label);
+        assert_eq!(yam_code, 1, "yamllint enable exit ({})", scenario.label);
+        assert_eq!(
+            ryl_output, yam_output,
+            "enable diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_warning = build_ryl_command(exe, scenario.ryl_format);
+        ryl_warning.arg("-c").arg(&warning_cfg).arg(&bad_file);
+        let (ryl_warn_code, ryl_warn_output) =
+            capture_with_env(ryl_warning, scenario.envs);
+
+        let mut yam_warning = build_yamllint_command(scenario.yam_format);
+        yam_warning.arg("-c").arg(&warning_cfg).arg(&bad_file);
+        let (yam_warn_code, yam_warn_output) =
+            capture_with_env(yam_warning, scenario.envs);
+
+        assert_eq!(ryl_warn_code, 0, "ryl warning exit ({})", scenario.label);
+        assert_eq!(
+            yam_warn_code, 0,
+            "yamllint warning exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_warn_output, yam_warn_output,
+            "warning diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_ignore = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ignore.arg("-c").arg(&ignore_cfg).arg(&ignored_file);
+        let (ryl_ignore_code, ryl_ignore_output) =
+            capture_with_env(ryl_ignore, scenario.envs);
+
+        let mut yam_ignore = build_yamllint_command(scenario.yam_format);
+        yam_ignore.arg("-c").arg(&ignore_cfg).arg(&ignored_file);
+        let (yam_ignore_code, yam_ignore_output) =
+            capture_with_env(yam_ignore, scenario.envs);
+
+        assert_eq!(ryl_ignore_code, 0, "ryl ignore exit ({})", scenario.label);
+        assert_eq!(
+            yam_ignore_code, 0,
+            "yamllint ignore exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_ignore_output, yam_ignore_output,
+            "ignore diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_ignore_file = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ignore_file
+            .arg("-c")
+            .arg(&ignore_from_file_cfg)
+            .arg(&ignored_from_file);
+        let (ryl_file_code, ryl_file_output) =
+            capture_with_env(ryl_ignore_file, scenario.envs);
+
+        let mut yam_ignore_file = build_yamllint_command(scenario.yam_format);
+        yam_ignore_file
+            .arg("-c")
+            .arg(&ignore_from_file_cfg)
+            .arg(&ignored_from_file);
+        let (yam_file_code, yam_file_output) =
+            capture_with_env(yam_ignore_file, scenario.envs);
+
+        assert_eq!(
+            ryl_file_code, 0,
+            "ryl ignore-from-file exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_file_code, 0,
+            "yamllint ignore-from-file exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_file_output, yam_file_output,
+            "ignore-from-file diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn comments_around_line_length_toggle_match_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("cfg.yml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 110\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("input.yml");
+    fs::write(
+        &input,
+        "body:\n  - type: markdown\n    attributes:\n      # yamllint disable rule:line-length\n      value: |\n        hello\n      # yamllint enable rule:line-length\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_cmd.arg("-c").arg(&cfg).arg(&input);
+        let (ryl_code, ryl_msg) = capture_with_env(ryl_cmd, scenario.envs);
+
+        let mut yam_cmd = build_yamllint_command(scenario.yam_format);
+        yam_cmd.arg("-c").arg(&cfg).arg(&input);
+        let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_code, yam_code,
+            "exit mismatch for comments around line-length toggle ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for comments around line-length toggle ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn comment_after_block_scalar_pattern_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("cfg.yml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 110\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("input.yml");
+    fs::write(
+        &input,
+        "---\nhooks:\n  - id: x\n    files: >\n      (?x)\n      ^a$|\n      ^b$\n    ## ONLY ADD PREK HOOKS HERE THAT REQUIRE CI IMAGE\n  - id: y\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    for scenario in SCENARIOS {
+        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_cmd.arg("-c").arg(&cfg).arg("--strict").arg(&input);
+        let (ryl_code, ryl_msg) = capture_with_env(ryl_cmd, scenario.envs);
+
+        let mut yam_cmd = build_yamllint_command(scenario.yam_format);
+        yam_cmd.arg("-c").arg(&cfg).arg("--strict").arg(&input);
+        let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_code, yam_code,
+            "exit mismatch for comment after block scalar pattern ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for comment after block scalar pattern ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn explicit_key_block_scalar_comment_content_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("cfg.yml");
+    fs::write(
+        &cfg,
+        "rules:\n  document-start: disable\n  comments-indentation: enable\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("input.yml");
+    fs::write(&input, "? |\n  # block scalar content\n: value\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    for scenario in SCENARIOS {
+        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_cmd.arg("-c").arg(&cfg).arg(&input);
+        let (ryl_code, ryl_msg) = capture_with_env(ryl_cmd, scenario.envs);
+
+        let mut yam_cmd = build_yamllint_command(scenario.yam_format);
+        yam_cmd.arg("-c").arg(&cfg).arg(&input);
+        let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_code, yam_code,
+            "exit mismatch for explicit-key block scalar comment content ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for explicit-key block scalar comment content ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_config.rs

@@ -0,0 +1,170 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn ensure_yamllint_installed() {
+    let ok = Command::new("yamllint")
+        .arg("--version")
+        .output()
+        .map(|o| o.status.success())
+        .unwrap_or(false);
+    assert!(
+        ok,
+        "yamllint must be installed and in PATH for parity tests"
+    );
+}
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("failed to run command");
+    let code = out.status.code().unwrap_or(-1);
+    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+    let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
+    (code, stdout, stderr)
+}
+
+#[test]
+fn yamllint_and_ryl_honor_ignore_from_file() {
+    ensure_yamllint_installed();
+
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join(".yamllint"),
+        "ignore-from-file: patterns.ignore\nrules: {}\n",
+    )
+    .unwrap();
+    fs::write(root.join("patterns.ignore"), "*.skip.yaml\n").unwrap();
+    fs::write(root.join("keep.yaml"), "ok: 1\n").unwrap();
+    fs::write(root.join("skip.yaml"), "bad: [1\n").unwrap();
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
+        .current_dir(root)
+        .arg("--list-files")
+        .arg("."));
+    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
+    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
+    ryl_list.sort();
+
+    let (_yc, y_out, y_err) = run(Command::new("yamllint")
+        .current_dir(root)
+        .arg("--list-files")
+        .arg("."));
+    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
+    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
+    y_list.sort();
+
+    assert_eq!(ryl_list, y_list, "file lists should match");
+}
+
+#[test]
+fn project_config_precedence_over_env_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join(".yamllint"),
+        "ignore: ['ignored.yaml']\nrules: {}\n",
+    )
+    .unwrap();
+    let env_cfg = root.join("env.yaml");
+    fs::write(&env_cfg, "rules: {}\n").unwrap();
+    fs::write(root.join("ignored.yaml"), "ok: 1\n").unwrap();
+    fs::write(root.join("keep.yaml"), "ok: 1\n").unwrap();
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
+        .current_dir(root)
+        .env("YAMLLINT_CONFIG_FILE", env_cfg.display().to_string())
+        .arg("--list-files")
+        .arg("."));
+    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
+    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
+    ryl_list.sort();
+
+    let (_yc, y_out, y_err) = run(Command::new("yamllint")
+        .current_dir(root)
+        .env("YAMLLINT_CONFIG_FILE", env_cfg.display().to_string())
+        .arg("--list-files")
+        .arg("."));
+    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
+    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
+    y_list.sort();
+
+    assert_eq!(ryl_list, y_list, "project config should take precedence");
+}
+
+#[test]
+fn ignore_can_reinclude_file_from_excluded_directory_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join(".yamllint"),
+        "ignore: |\n  build/\n  !build/keep.yaml\nrules: {}\n",
+    )
+    .unwrap();
+    fs::create_dir_all(root.join("build")).unwrap();
+    fs::write(root.join("build/keep.yaml"), "ok: 1\n").unwrap();
+    fs::write(root.join("build/drop.yaml"), "ok: 1\n").unwrap();
+    fs::write(root.join("top.yaml"), "ok: 1\n").unwrap();
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
+        .current_dir(root)
+        .arg("--list-files")
+        .arg("."));
+    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
+    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
+    ryl_list.sort();
+
+    let (_yc, y_out, y_err) = run(Command::new("yamllint")
+        .current_dir(root)
+        .arg("--list-files")
+        .arg("."));
+    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
+    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
+    y_list.sort();
+
+    assert_eq!(ryl_list, y_list, "file lists should match");
+}
+
+#[test]
+fn ignore_from_file_can_reinclude_file_from_excluded_directory_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join(".yamllint"),
+        "ignore-from-file: patterns.ignore\nrules: {}\n",
+    )
+    .unwrap();
+    fs::write(root.join("patterns.ignore"), "build/\n!build/keep.yaml\n").unwrap();
+    fs::create_dir_all(root.join("build")).unwrap();
+    fs::write(root.join("build/keep.yaml"), "ok: 1\n").unwrap();
+    fs::write(root.join("build/drop.yaml"), "ok: 1\n").unwrap();
+    fs::write(root.join("top.yaml"), "ok: 1\n").unwrap();
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+    let (_code, ryl_out, ryl_err) = run(Command::new(ryl)
+        .current_dir(root)
+        .arg("--list-files")
+        .arg("."));
+    assert!(ryl_err.is_empty(), "unexpected stderr from ryl: {ryl_err}");
+    let mut ryl_list: Vec<_> = ryl_out.lines().map(|s| s.to_string()).collect();
+    ryl_list.sort();
+
+    let (_yc, y_out, y_err) = run(Command::new("yamllint")
+        .current_dir(root)
+        .arg("--list-files")
+        .arg("."));
+    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
+    let mut y_list: Vec<_> = y_out.lines().map(|s| s.to_string()).collect();
+    y_list.sort();
+
+    assert_eq!(ryl_list, y_list, "file lists should match");
+}

package/tests/yamllint_compat_document_end.rs

@@ -0,0 +1,243 @@
+use std::fs;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, build_ryl_command, build_yamllint_command, capture_with_env,
+    ensure_yamllint_installed,
+};
+
+#[test]
+fn document_end_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let missing = dir.path().join("missing.yaml");
+    fs::write(&missing, "---\nfoo: bar\n").unwrap();
+
+    let explicit = dir.path().join("explicit.yaml");
+    fs::write(&explicit, "---\nfoo: bar\n...\n").unwrap();
+
+    let explicit_with_comment = dir.path().join("explicit_with_comment.yaml");
+    fs::write(&explicit_with_comment, "---\nfoo: bar\n... # done\n").unwrap();
+
+    let require_cfg = dir.path().join("require.yml");
+    fs::write(
+        &require_cfg,
+        "rules:\n  document-end:\n    level: error\n    present: true\n",
+    )
+    .unwrap();
+
+    let forbid_cfg = dir.path().join("forbid.yml");
+    fs::write(
+        &forbid_cfg,
+        "rules:\n  document-end:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_require = build_ryl_command(exe, scenario.ryl_format);
+        ryl_require.arg("-c").arg(&require_cfg).arg(&missing);
+        let (ryl_req_code, ryl_req_msg) = capture_with_env(ryl_require, scenario.envs);
+
+        let mut yam_require = build_yamllint_command(scenario.yam_format);
+        yam_require.arg("-c").arg(&require_cfg).arg(&missing);
+        let (yam_req_code, yam_req_msg) = capture_with_env(yam_require, scenario.envs);
+
+        assert_eq!(ryl_req_code, 1, "ryl require exit ({})", scenario.label);
+        assert_eq!(
+            yam_req_code, 1,
+            "yamllint require exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_req_msg, yam_req_msg,
+            "missing marker diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_require_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_require_ok.arg("-c").arg(&require_cfg).arg(&explicit);
+        let (ryl_req_ok_code, ryl_req_ok_msg) =
+            capture_with_env(ryl_require_ok, scenario.envs);
+
+        let mut yam_require_ok = build_yamllint_command(scenario.yam_format);
+        yam_require_ok.arg("-c").arg(&require_cfg).arg(&explicit);
+        let (yam_req_ok_code, yam_req_ok_msg) =
+            capture_with_env(yam_require_ok, scenario.envs);
+
+        assert_eq!(
+            ryl_req_ok_code, 0,
+            "ryl require pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_req_ok_code, 0,
+            "yamllint require pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_req_ok_msg, yam_req_ok_msg,
+            "require pass diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_require_comment = build_ryl_command(exe, scenario.ryl_format);
+        ryl_require_comment
+            .arg("-c")
+            .arg(&require_cfg)
+            .arg(&explicit_with_comment);
+        let (ryl_req_comment_code, ryl_req_comment_msg) =
+            capture_with_env(ryl_require_comment, scenario.envs);
+
+        let mut yam_require_comment = build_yamllint_command(scenario.yam_format);
+        yam_require_comment
+            .arg("-c")
+            .arg(&require_cfg)
+            .arg(&explicit_with_comment);
+        let (yam_req_comment_code, yam_req_comment_msg) =
+            capture_with_env(yam_require_comment, scenario.envs);
+
+        assert_eq!(
+            ryl_req_comment_code, 0,
+            "ryl require pass (with comment) exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_req_comment_code, 0,
+            "yamllint require pass (with comment) exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_req_comment_msg, yam_req_comment_msg,
+            "require comment diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_forbid = build_ryl_command(exe, scenario.ryl_format);
+        ryl_forbid.arg("-c").arg(&forbid_cfg).arg(&explicit);
+        let (ryl_forbid_code, ryl_forbid_msg) =
+            capture_with_env(ryl_forbid, scenario.envs);
+
+        let mut yam_forbid = build_yamllint_command(scenario.yam_format);
+        yam_forbid.arg("-c").arg(&forbid_cfg).arg(&explicit);
+        let (yam_forbid_code, yam_forbid_msg) =
+            capture_with_env(yam_forbid, scenario.envs);
+
+        assert_eq!(ryl_forbid_code, 1, "ryl forbid exit ({})", scenario.label);
+        assert_eq!(
+            yam_forbid_code, 1,
+            "yamllint forbid exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_forbid_msg, yam_forbid_msg,
+            "forbid diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_forbid_comment = build_ryl_command(exe, scenario.ryl_format);
+        ryl_forbid_comment
+            .arg("-c")
+            .arg(&forbid_cfg)
+            .arg(&explicit_with_comment);
+        let (ryl_forbid_comment_code, ryl_forbid_comment_msg) =
+            capture_with_env(ryl_forbid_comment, scenario.envs);
+
+        let mut yam_forbid_comment = build_yamllint_command(scenario.yam_format);
+        yam_forbid_comment
+            .arg("-c")
+            .arg(&forbid_cfg)
+            .arg(&explicit_with_comment);
+        let (yam_forbid_comment_code, yam_forbid_comment_msg) =
+            capture_with_env(yam_forbid_comment, scenario.envs);
+
+        assert_eq!(
+            ryl_forbid_comment_code, 1,
+            "ryl forbid comment exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_forbid_comment_code, 1,
+            "yamllint forbid comment exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_forbid_comment_msg, yam_forbid_comment_msg,
+            "forbid comment diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_forbid_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_forbid_ok.arg("-c").arg(&forbid_cfg).arg(&missing);
+        let (ryl_forbid_ok_code, ryl_forbid_ok_msg) =
+            capture_with_env(ryl_forbid_ok, scenario.envs);
+
+        let mut yam_forbid_ok = build_yamllint_command(scenario.yam_format);
+        yam_forbid_ok.arg("-c").arg(&forbid_cfg).arg(&missing);
+        let (yam_forbid_ok_code, yam_forbid_ok_msg) =
+            capture_with_env(yam_forbid_ok, scenario.envs);
+
+        assert_eq!(
+            ryl_forbid_ok_code, 0,
+            "ryl forbid pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_forbid_ok_code, 0,
+            "yamllint forbid pass exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_forbid_ok_msg, yam_forbid_ok_msg,
+            "forbid pass diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn document_end_handles_unicode_scalars() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let cfg_path = dir.path().join("config.yaml");
+    fs::write(
+        &cfg_path,
+        "rules:\n  document-start: disable\n  document-end:\n    level: error\n    present: false\n",
+    )
+    .unwrap();
+
+    let yaml_path = dir.path().join("unicode.yaml");
+    fs::write(
+        &yaml_path,
+        "set_room_temperature:\n  fields:\n    comfort_temp:\n      selector:\n        number:\n          min: 0\n          max: 100\n          unit_of_measurement: \"°\"\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_cmd.arg("-c").arg(&cfg_path).arg(&yaml_path);
+        let (ryl_code, ryl_output) = capture_with_env(ryl_cmd, scenario.envs);
+
+        let mut yam_cmd = build_yamllint_command(scenario.yam_format);
+        yam_cmd.arg("-c").arg(&cfg_path).arg(&yaml_path);
+        let (yam_code, yam_output) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(ryl_code, yam_code, "exit mismatch ({})", scenario.label);
+        assert_eq!(
+            ryl_output, yam_output,
+            "diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}