@owenlamont/ryl 0.4.1

package/tests/yamllint_compat_key_duplicates.rs

@@ -0,0 +1,139 @@
+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 key_duplicates_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("key-duplicates-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  key-duplicates: enable\n",
+    )
+    .unwrap();
+
+    let forbid_cfg = dir.path().join("key-duplicates-forbid.yml");
+    fs::write(
+        &forbid_cfg,
+        "rules:\n  document-start: disable\n  key-duplicates:\n    forbid-duplicated-merge-keys: true\n",
+    )
+    .unwrap();
+
+    let dup_bad = dir.path().join("dup-bad.yaml");
+    fs::write(&dup_bad, "foo: 1\nbar: 2\nfoo: 3\n").unwrap();
+
+    let dup_ok = dir.path().join("dup-ok.yaml");
+    fs::write(&dup_ok, "foo: 1\nbar: 2\n").unwrap();
+
+    let merge_dup = dir.path().join("merge-dup.yaml");
+    fs::write(
+        &merge_dup,
+        "anchor: &a\n  value: 1\nmerged:\n  <<: *a\n  <<: *a\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        let mut ryl_bad = build_ryl_command(exe, scenario.ryl_format);
+        ryl_bad.arg("-c").arg(&default_cfg).arg(&dup_bad);
+        let (ryl_bad_code, ryl_bad_msg) = capture_with_env(ryl_bad, scenario.envs);
+
+        let mut yam_bad = build_yamllint_command(scenario.yam_format);
+        yam_bad.arg("-c").arg(&default_cfg).arg(&dup_bad);
+        let (yam_bad_code, yam_bad_msg) = capture_with_env(yam_bad, scenario.envs);
+
+        assert_eq!(ryl_bad_code, 1, "ryl dup exit ({})", scenario.label);
+        assert_eq!(yam_bad_code, 1, "yamllint dup exit ({})", scenario.label);
+        assert_eq!(
+            ryl_bad_msg, yam_bad_msg,
+            "duplicate diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ok.arg("-c").arg(&default_cfg).arg(&dup_ok);
+        let (ryl_ok_code, ryl_ok_msg) = capture_with_env(ryl_ok, scenario.envs);
+
+        let mut yam_ok = build_yamllint_command(scenario.yam_format);
+        yam_ok.arg("-c").arg(&default_cfg).arg(&dup_ok);
+        let (yam_ok_code, yam_ok_msg) = capture_with_env(yam_ok, scenario.envs);
+
+        assert_eq!(ryl_ok_code, 0, "ryl ok exit ({})", scenario.label);
+        assert_eq!(yam_ok_code, 0, "yamllint ok exit ({})", scenario.label);
+        assert_eq!(
+            ryl_ok_msg, yam_ok_msg,
+            "ok diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_merge_default = build_ryl_command(exe, scenario.ryl_format);
+        ryl_merge_default
+            .arg("-c")
+            .arg(&default_cfg)
+            .arg(&merge_dup);
+        let (ryl_merge_def_code, ryl_merge_def_msg) =
+            capture_with_env(ryl_merge_default, scenario.envs);
+
+        let mut yam_merge_default = build_yamllint_command(scenario.yam_format);
+        yam_merge_default
+            .arg("-c")
+            .arg(&default_cfg)
+            .arg(&merge_dup);
+        let (yam_merge_def_code, yam_merge_def_msg) =
+            capture_with_env(yam_merge_default, scenario.envs);
+
+        assert_eq!(
+            ryl_merge_def_code, 0,
+            "ryl merge default exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_merge_def_code, 0,
+            "yamllint merge default exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_merge_def_msg, yam_merge_def_msg,
+            "merge default diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_merge_forbid = build_ryl_command(exe, scenario.ryl_format);
+        ryl_merge_forbid.arg("-c").arg(&forbid_cfg).arg(&merge_dup);
+        let (ryl_merge_forbid_code, ryl_merge_forbid_msg) =
+            capture_with_env(ryl_merge_forbid, scenario.envs);
+
+        let mut yam_merge_forbid = build_yamllint_command(scenario.yam_format);
+        yam_merge_forbid.arg("-c").arg(&forbid_cfg).arg(&merge_dup);
+        let (yam_merge_forbid_code, yam_merge_forbid_msg) =
+            capture_with_env(yam_merge_forbid, scenario.envs);
+
+        assert_eq!(
+            ryl_merge_forbid_code, 1,
+            "ryl merge forbid exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_merge_forbid_code, 1,
+            "yamllint merge forbid exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_merge_forbid_msg, yam_merge_forbid_msg,
+            "merge forbid diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_key_ordering.rs

@@ -0,0 +1,170 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+#[path = "common/compat.rs"]
+mod compat;
+
+use compat::{
+    SCENARIOS, STANDARD_ENV, build_ryl_command, build_yamllint_command,
+    capture_with_env, ensure_yamllint_installed,
+};
+
+#[test]
+fn key_ordering_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("key-ordering-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  key-ordering: enable\n",
+    )
+    .unwrap();
+
+    let ignored_cfg = dir.path().join("key-ordering-ignored.yml");
+    fs::write(
+        &ignored_cfg,
+        "rules:\n  document-start: disable\n  key-ordering:\n    ignored-keys: [\"n(a|o)me\", \"^b\"]\n",
+    )
+    .unwrap();
+
+    let locale_cfg = dir.path().join("key-ordering-locale.yml");
+    fs::write(
+        &locale_cfg,
+        "locale: en_US.UTF-8\nrules:\n  document-start: disable\n  key-ordering: enable\n",
+    )
+    .unwrap();
+
+    let bad_block = dir.path().join("bad-block.yaml");
+    fs::write(
+        &bad_block,
+        "block mapping:\n  second: value\n  first: value\n",
+    )
+    .unwrap();
+
+    let good_block = dir.path().join("good-block.yaml");
+    fs::write(
+        &good_block,
+        "block mapping:\n  first: value\n  second: value\n  third: v\n",
+    )
+    .unwrap();
+
+    let ignored_file = dir.path().join("ignored.yaml");
+    fs::write(
+        &ignored_file,
+        "a:\nb:\nc:\nname: ignored\nfirst-name: ignored\nnome: ignored\ngnomes: ignored\nd:\ne:\nboat: ignored\n.boat: ERROR\ncall: ERROR\nf:\ng:\n",
+    )
+    .unwrap();
+
+    let locale_file = dir.path().join("locale.yaml");
+    fs::write(
+        &locale_file,
+        "- t-shirt: 1\n  T-shirt: 2\n  t-shirts: 3\n  T-shirts: 4\n- hair: true\n  haïr: true\n  hais: true\n  haïssable: true\n",
+    )
+    .unwrap();
+
+    // Probe locale availability before running the full matrix. Skip locale comparison when
+    // yamllint cannot set the configured locale.
+    let mut locale_probe = Command::new("yamllint");
+    locale_probe.arg("-c").arg(&locale_cfg).arg(&locale_file);
+    let (probe_code, probe_output) = capture_with_env(locale_probe, STANDARD_ENV);
+    let skip_locale = if probe_code != 0
+        && (probe_output.contains("unsupported locale")
+            || probe_output.contains("unknown locale"))
+    {
+        eprintln!("skipping locale comparison: {probe_output}");
+        true
+    } else {
+        false
+    };
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        // default configuration, expect violations on bad block
+        let mut ryl_bad = build_ryl_command(exe, scenario.ryl_format);
+        ryl_bad.arg("-c").arg(&default_cfg).arg(&bad_block);
+        let (ryl_bad_code, ryl_bad_msg) = capture_with_env(ryl_bad, scenario.envs);
+
+        let mut yam_bad = build_yamllint_command(scenario.yam_format);
+        yam_bad.arg("-c").arg(&default_cfg).arg(&bad_block);
+        let (yam_bad_code, yam_bad_msg) = capture_with_env(yam_bad, scenario.envs);
+
+        assert_eq!(ryl_bad_code, 1, "ryl bad exit ({})", scenario.label);
+        assert_eq!(yam_bad_code, 1, "yamllint bad exit ({})", scenario.label);
+        assert_eq!(
+            ryl_bad_msg, yam_bad_msg,
+            "bad block diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // good block should be clean
+        let mut ryl_good = build_ryl_command(exe, scenario.ryl_format);
+        ryl_good.arg("-c").arg(&default_cfg).arg(&good_block);
+        let (ryl_good_code, ryl_good_msg) = capture_with_env(ryl_good, scenario.envs);
+
+        let mut yam_good = build_yamllint_command(scenario.yam_format);
+        yam_good.arg("-c").arg(&default_cfg).arg(&good_block);
+        let (yam_good_code, yam_good_msg) = capture_with_env(yam_good, scenario.envs);
+
+        assert_eq!(ryl_good_code, 0, "ryl good exit ({})", scenario.label);
+        assert_eq!(yam_good_code, 0, "yamllint good exit ({})", scenario.label);
+        assert_eq!(
+            ryl_good_msg, yam_good_msg,
+            "good block diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // ignored-keys configuration should allow ignored patterns and flag others equally
+        let mut ryl_ignored = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ignored.arg("-c").arg(&ignored_cfg).arg(&ignored_file);
+        let (ryl_ignored_code, ryl_ignored_msg) =
+            capture_with_env(ryl_ignored, scenario.envs);
+
+        let mut yam_ignored = build_yamllint_command(scenario.yam_format);
+        yam_ignored.arg("-c").arg(&ignored_cfg).arg(&ignored_file);
+        let (yam_ignored_code, yam_ignored_msg) =
+            capture_with_env(yam_ignored, scenario.envs);
+
+        assert_eq!(ryl_ignored_code, 1, "ryl ignored exit ({})", scenario.label);
+        assert_eq!(
+            yam_ignored_code, 1,
+            "yamllint ignored exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_ignored_msg, yam_ignored_msg,
+            "ignored diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        if skip_locale {
+            continue;
+        }
+
+        let mut ryl_locale = build_ryl_command(exe, scenario.ryl_format);
+        ryl_locale.arg("-c").arg(&locale_cfg).arg(&locale_file);
+        let (ryl_locale_code, ryl_locale_msg) =
+            capture_with_env(ryl_locale, scenario.envs);
+
+        let mut yam_locale = build_yamllint_command(scenario.yam_format);
+        yam_locale.arg("-c").arg(&locale_cfg).arg(&locale_file);
+        let (yam_locale_code, yam_locale_msg) =
+            capture_with_env(yam_locale, scenario.envs);
+
+        assert_eq!(ryl_locale_code, 0, "ryl locale exit ({})", scenario.label);
+        assert_eq!(
+            yam_locale_code, 0,
+            "yamllint locale exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_locale_msg, yam_locale_msg,
+            "locale diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_line_length.rs

@@ -0,0 +1,375 @@
+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 line_length_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("line-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  empty-lines: disable\n  new-line-at-end-of-file: disable\n  line-length:\n    max: 80\n",
+    )
+    .unwrap();
+
+    let warning_cfg = dir.path().join("line-warning.yml");
+    fs::write(
+        &warning_cfg,
+        "rules:\n  document-start: disable\n  empty-lines: disable\n  new-line-at-end-of-file: disable\n  line-length:\n    max: 80\n    level: warning\n",
+    )
+    .unwrap();
+
+    let strict_cfg = dir.path().join("line-strict.yml");
+    fs::write(
+        &strict_cfg,
+        "rules:\n  document-start: disable\n  line-length:\n    max: 20\n    allow-non-breakable-words: false\n",
+    )
+    .unwrap();
+
+    let inline_cfg = dir.path().join("line-inline.yml");
+    fs::write(
+        &inline_cfg,
+        "rules:\n  document-start: disable\n  line-length:\n    max: 20\n    allow-non-breakable-inline-mappings: true\n",
+    )
+    .unwrap();
+
+    let bad_file = dir.path().join("bad.yaml");
+    fs::write(
+        &bad_file,
+        "key: this line is definitely longer than eighty characters so yamllint and ryl should both flag it\n",
+    )
+    .unwrap();
+
+    let long_word_file = dir.path().join("long_word.yaml");
+    fs::write(&long_word_file, format!("{}\n", "A".repeat(50))).unwrap();
+
+    let inline_ok_file = dir.path().join("inline_ok.yaml");
+    fs::write(
+        &inline_ok_file,
+        "url: http://example.com/very/very/very/very/very/very/long/path\n",
+    )
+    .unwrap();
+
+    let inline_bad_file = dir.path().join("inline_bad.yaml");
+    fs::write(
+        &inline_bad_file,
+        "url: http://example.com/short + extra words to trigger the rule\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        // default configuration should produce an error for spaced text
+        let mut ryl_default = build_ryl_command(exe, scenario.ryl_format);
+        ryl_default.arg("-c").arg(&default_cfg).arg(&bad_file);
+        let (ryl_code, ryl_output) = capture_with_env(ryl_default, scenario.envs);
+
+        let mut yam_default = build_yamllint_command(scenario.yam_format);
+        yam_default.arg("-c").arg(&default_cfg).arg(&bad_file);
+        let (yam_code, yam_output) = capture_with_env(yam_default, scenario.envs);
+
+        assert_eq!(ryl_code, 1, "ryl default exit ({})", scenario.label);
+        assert_eq!(yam_code, 1, "yamllint default exit ({})", scenario.label);
+        assert_eq!(
+            ryl_output, yam_output,
+            "default diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // warning configuration should keep diagnostics but exit 0
+        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
+        );
+
+        // strict configuration should flag long non-breakable words
+        let mut ryl_strict = build_ryl_command(exe, scenario.ryl_format);
+        ryl_strict.arg("-c").arg(&strict_cfg).arg(&long_word_file);
+        let (ryl_strict_code, ryl_strict_output) =
+            capture_with_env(ryl_strict, scenario.envs);
+
+        let mut yam_strict = build_yamllint_command(scenario.yam_format);
+        yam_strict.arg("-c").arg(&strict_cfg).arg(&long_word_file);
+        let (yam_strict_code, yam_strict_output) =
+            capture_with_env(yam_strict, scenario.envs);
+
+        assert_eq!(ryl_strict_code, 1, "ryl strict exit ({})", scenario.label);
+        assert_eq!(
+            yam_strict_code, 1,
+            "yamllint strict exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_strict_output, yam_strict_output,
+            "strict diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // inline mapping allowance should let long URLs through
+        let mut ryl_inline_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_inline_ok
+            .arg("-c")
+            .arg(&inline_cfg)
+            .arg(&inline_ok_file);
+        let (ryl_inline_code, ryl_inline_output) =
+            capture_with_env(ryl_inline_ok, scenario.envs);
+
+        let mut yam_inline_ok = build_yamllint_command(scenario.yam_format);
+        yam_inline_ok
+            .arg("-c")
+            .arg(&inline_cfg)
+            .arg(&inline_ok_file);
+        let (yam_inline_code, yam_inline_output) =
+            capture_with_env(yam_inline_ok, scenario.envs);
+
+        assert_eq!(
+            ryl_inline_code, 0,
+            "ryl inline-ok exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_inline_code, 0,
+            "yamllint inline-ok exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_inline_output, yam_inline_output,
+            "inline ok diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        // inline mapping option should still flag when spaces remain
+        let mut ryl_inline_bad = build_ryl_command(exe, scenario.ryl_format);
+        ryl_inline_bad
+            .arg("-c")
+            .arg(&inline_cfg)
+            .arg(&inline_bad_file);
+        let (ryl_inline_bad_code, ryl_inline_bad_output) =
+            capture_with_env(ryl_inline_bad, scenario.envs);
+
+        let mut yam_inline_bad = build_yamllint_command(scenario.yam_format);
+        yam_inline_bad
+            .arg("-c")
+            .arg(&inline_cfg)
+            .arg(&inline_bad_file);
+        let (yam_inline_bad_code, yam_inline_bad_output) =
+            capture_with_env(yam_inline_bad, scenario.envs);
+
+        assert_eq!(
+            ryl_inline_bad_code, 1,
+            "ryl inline-bad exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_inline_bad_code, 1,
+            "yamllint inline-bad exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_inline_bad_output, yam_inline_bad_output,
+            "inline bad diagnostics mismatch ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn line_length_disable_enable_comments_match_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("line-110.yml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 110\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("line-disable-comments.yaml");
+    fs::write(
+        &input,
+        "# yamllint disable rule:line-length\nmsg: \"This is a very very very very very very very very very very very very very very very long line that should be ignored\"\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 line-length disable comments ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for line-length disable comments ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn line_length_disable_line_applies_to_one_line_only() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("line-40.yml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 40\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("line-disable-line.yaml");
+    fs::write(
+        &input,
+        "---\n# yamllint disable-line rule:line-length\nlong: \"01234567890123456789012345678901234567890123456789\"\nlong2: \"01234567890123456789012345678901234567890123456789\"\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 line-length disable-line semantics ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for line-length disable-line semantics ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn line_length_disable_line_is_consumed_by_next_directive_line() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("line-40.yml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 40\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("line-disable-line-directive.yaml");
+    fs::write(
+        &input,
+        "---\n# yamllint disable-line rule:line-length\n# yamllint enable rule:line-length\nlong: \"01234567890123456789012345678901234567890123456789\"\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 disable-line consumed by directive line ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for disable-line consumed by directive line ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn line_length_disable_line_is_consumed_by_blank_line() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("line-40.yml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 40\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("line-disable-line-blank.yaml");
+    fs::write(
+        &input,
+        "---\n# yamllint disable-line rule:line-length\n\nlong: \"01234567890123456789012345678901234567890123456789\"\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 disable-line consumed by blank line ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for disable-line consumed by blank line ({})",
+            scenario.label
+        );
+    }
+}