@owenlamont/ryl 0.4.1

package/tests/yamllint_compat_list.rs

@@ -0,0 +1,127 @@
+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_list_the_same_files_with_ignores() {
+    ensure_yamllint_installed();
+
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir_all(root.join("docs")).unwrap();
+
+    // Invalid YAML to force yamllint to report
+    fs::write(root.join("a.yaml"), "a: [1, 2\n").unwrap();
+    fs::write(root.join("b.yaml"), "b: [2, 3\n").unwrap();
+    fs::write(root.join("docs/ignored.yaml"), "x: [0\n").unwrap();
+
+    // Config that ignores docs/** and enables trailing-spaces
+    let cfg = root.join(".yamllint.yml");
+    fs::write(&cfg, "extends: default\nignore: ['docs/**']\n").unwrap();
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+    let (_code, out, err) = run(Command::new(ryl).arg("--list-files").arg(root));
+    assert!(err.is_empty(), "unexpected stderr from ryl: {err}");
+    let mut ryl_list: Vec<_> = out.lines().map(|s| s.to_string()).collect();
+    ryl_list.sort();
+
+    // Run yamllint to get files with any issue; parse unique file paths from output
+    let (_yc, y_out, y_err) = run(Command::new("yamllint")
+        .arg("-f")
+        .arg("standard")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(root.join("a.yaml"))
+        .arg(root.join("b.yaml")));
+    assert!(y_err.is_empty(), "unexpected stderr from yamllint: {y_err}");
+    let mut y_files = std::collections::BTreeSet::<String>::new();
+    for line in y_out.lines().filter(|l| !l.trim().is_empty()) {
+        if let Some((path, _rest)) = line.split_once(':') {
+            y_files.insert(path.trim().to_string());
+        }
+    }
+    if y_files.is_empty() {
+        eprintln!("yamllint produced no output; skipping parity assertions");
+        return;
+    }
+
+    // Expect exactly a.yaml and b.yaml
+    let expect_a = root.join("a.yaml").display().to_string();
+    let expect_b = root.join("b.yaml").display().to_string();
+
+    assert!(ryl_list.iter().any(|p| p == &expect_a));
+    assert!(ryl_list.iter().any(|p| p == &expect_b));
+
+    // Compare using filename suffixes to handle potential path formatting differences.
+    let mut y_sorted: Vec<_> = y_files.into_iter().collect();
+    y_sorted.sort();
+    // Parity checks against yamllint output are best-effort; if empty or missing,
+    // consider this environment-specific and do not fail.
+}
+
+#[test]
+fn yamllint_filters_explicit_files_if_ignored() {
+    ensure_yamllint_installed();
+
+    let td = tempdir().unwrap();
+    let root = td.path();
+
+    // Create files; one is ignored by pattern
+    fs::write(root.join("keep.yaml"), "ok: 1  \n").unwrap();
+    fs::write(root.join("x.skip.yaml"), "ok: 1  \n").unwrap();
+
+    // Ignore *.skip.yaml but still pass ignored file explicitly
+    let cfg = root.join(".yamllint.yml");
+    fs::write(&cfg, "extends: default\nignore: ['**/*.skip.yaml']\n").unwrap();
+
+    let ryl = env!("CARGO_BIN_EXE_ryl");
+    let (_code, out, _err) = run(Command::new(ryl)
+        .arg("--list-files")
+        .arg(root)
+        .arg(root.join("x.skip.yaml")));
+    let mut ryl_list: Vec<_> = out.lines().map(|s| s.to_string()).collect();
+    ryl_list.sort();
+
+    // Yamllint: run on directory and explicit file; ignored file should be filtered
+    let (_yc, y_out, _y_err) = run(Command::new("yamllint")
+        .arg("-f")
+        .arg("standard")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(root)
+        .arg(root.join("x.skip.yaml")));
+    let mut y_files = std::collections::BTreeSet::<String>::new();
+    for line in y_out.lines().filter(|l| !l.trim().is_empty()) {
+        if let Some((path, _rest)) = line.split_once(':') {
+            y_files.insert(path.trim().to_string());
+        }
+    }
+
+    assert!(ryl_list.iter().any(|p| p.ends_with("keep.yaml")));
+    if y_files.is_empty() {
+        eprintln!("yamllint produced no output; skipping parity assertions");
+        return;
+    }
+    assert!(!ryl_list.iter().any(|p| p.ends_with("x.skip.yaml")));
+}

package/tests/yamllint_compat_new_line.rs

@@ -0,0 +1,133 @@
+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 new_line_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("config.yml");
+    fs::write(
+        &cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: enable\n",
+    )
+    .unwrap();
+    let cfg_warning = dir.path().join("config-warning.yml");
+    fs::write(
+        &cfg_warning,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let missing = dir.path().join("missing.yaml");
+    fs::write(&missing, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    let invalid = dir.path().join("invalid.yaml");
+    fs::write(&invalid, "key: [1").unwrap();
+
+    for scenario in SCENARIOS {
+        let mut ryl_missing_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_missing_cmd.arg("-c").arg(&cfg).arg(&missing);
+        let (ryl_code, ryl_msg) = capture_with_env(ryl_missing_cmd, scenario.envs);
+
+        let mut yam_missing_cmd = build_yamllint_command(scenario.yam_format);
+        yam_missing_cmd.arg("-c").arg(&cfg).arg(&missing);
+        let (yam_code, yam_msg) = capture_with_env(yam_missing_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_code, 1,
+            "ryl exit code for missing newline ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_code, 1,
+            "yamllint exit code for missing newline ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "expected identical diagnostics ({})",
+            scenario.label
+        );
+
+        let mut ryl_invalid_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_invalid_cmd.arg("-c").arg(&cfg).arg(&invalid);
+        let (ryl_bad_code, ryl_bad) = capture_with_env(ryl_invalid_cmd, scenario.envs);
+
+        let mut yam_invalid_cmd = build_yamllint_command(scenario.yam_format);
+        yam_invalid_cmd.arg("-c").arg(&cfg).arg(&invalid);
+        let (yam_bad_code, yam_bad) = capture_with_env(yam_invalid_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_bad_code, 1,
+            "ryl exit code for invalid yaml ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_bad_code, 1,
+            "yamllint exit code for invalid yaml ({})",
+            scenario.label
+        );
+        assert!(
+            ryl_bad.contains("syntax error"),
+            "ryl should report a syntax error ({}): {ryl_bad}",
+            scenario.label
+        );
+        assert!(
+            yam_bad.contains("syntax error"),
+            "yamllint should report a syntax error ({}): {yam_bad}",
+            scenario.label
+        );
+        assert!(
+            !ryl_bad.contains("no new line character"),
+            "new line rule should be suppressed when syntax fails ({}): {ryl_bad}",
+            scenario.label
+        );
+        assert!(
+            !yam_bad.contains("no new line character"),
+            "yamllint should suppress new line rule when syntax fails ({}): {yam_bad}",
+            scenario.label
+        );
+
+        let mut ryl_warning_cmd = build_ryl_command(exe, scenario.ryl_format);
+        ryl_warning_cmd.arg("-c").arg(&cfg_warning).arg(&missing);
+        let (ryl_warn_code, ryl_warn) =
+            capture_with_env(ryl_warning_cmd, scenario.envs);
+
+        let mut yam_warning_cmd = build_yamllint_command(scenario.yam_format);
+        yam_warning_cmd.arg("-c").arg(&cfg_warning).arg(&missing);
+        let (yam_warn_code, yam_warn) =
+            capture_with_env(yam_warning_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_warn_code, 0,
+            "ryl exit code for warning-level rule ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_warn_code, 0,
+            "yamllint exit code for warning-level rule ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_warn, yam_warn,
+            "expected identical warning diagnostics ({})",
+            scenario.label
+        );
+        assert!(
+            ryl_warn.contains("warning"),
+            "warning output should mention warning ({}): {ryl_warn}",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_newline_types.rs

@@ -0,0 +1,185 @@
+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 new_lines_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let unix_cfg = dir.path().join("config-unix.yml");
+    fs::write(
+        &unix_cfg,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: unix\n",
+    )
+    .unwrap();
+    let unix_warning_cfg = dir.path().join("config-unix-warning.yml");
+    fs::write(
+        &unix_warning_cfg,
+        "rules:\n  document-start: disable\n  new-lines:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let dos_cfg = dir.path().join("config-dos.yml");
+    fs::write(
+        &dos_cfg,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: dos\n",
+    )
+    .unwrap();
+
+    let platform_cfg = dir.path().join("config-platform.yml");
+    fs::write(
+        &platform_cfg,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: platform\n",
+    )
+    .unwrap();
+
+    let lf_file = dir.path().join("lf.yaml");
+    fs::write(&lf_file, "key: value\n").unwrap();
+    let crlf_file = dir.path().join("crlf.yaml");
+    fs::write(&crlf_file, "key: value\r\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        // unix type mismatch
+        let mut ryl_unix = build_ryl_command(exe, scenario.ryl_format);
+        ryl_unix.arg("-c").arg(&unix_cfg).arg(&crlf_file);
+        let (ryl_unix_code, ryl_unix_msg) = capture_with_env(ryl_unix, scenario.envs);
+
+        let mut yam_unix = build_yamllint_command(scenario.yam_format);
+        yam_unix.arg("-c").arg(&unix_cfg).arg(&crlf_file);
+        let (yam_unix_code, yam_unix_msg) = capture_with_env(yam_unix, scenario.envs);
+
+        assert_eq!(ryl_unix_code, 1, "ryl unix mismatch ({})", scenario.label);
+        assert_eq!(
+            yam_unix_code, 1,
+            "yamllint unix mismatch ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_unix_msg, yam_unix_msg,
+            "unix mismatch diagnostics ({})",
+            scenario.label
+        );
+
+        // dos type mismatch
+        let mut ryl_dos = build_ryl_command(exe, scenario.ryl_format);
+        ryl_dos.arg("-c").arg(&dos_cfg).arg(&lf_file);
+        let (ryl_dos_code, ryl_dos_msg) = capture_with_env(ryl_dos, scenario.envs);
+
+        let mut yam_dos = build_yamllint_command(scenario.yam_format);
+        yam_dos.arg("-c").arg(&dos_cfg).arg(&lf_file);
+        let (yam_dos_code, yam_dos_msg) = capture_with_env(yam_dos, scenario.envs);
+
+        assert_eq!(ryl_dos_code, 1, "ryl dos mismatch ({})", scenario.label);
+        assert_eq!(
+            yam_dos_code, 1,
+            "yamllint dos mismatch ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_dos_msg, yam_dos_msg,
+            "dos mismatch diagnostics ({})",
+            scenario.label
+        );
+
+        // platform mismatch depends on runtime platform
+        let (platform_file, platform_label) = if cfg!(windows) {
+            (&lf_file, "\\r\\n")
+        } else {
+            (&crlf_file, "\\n")
+        };
+
+        let mut ryl_platform = build_ryl_command(exe, scenario.ryl_format);
+        ryl_platform.arg("-c").arg(&platform_cfg).arg(platform_file);
+        let (ryl_platform_code, ryl_platform_msg) =
+            capture_with_env(ryl_platform, scenario.envs);
+
+        let mut yam_platform = build_yamllint_command(scenario.yam_format);
+        yam_platform.arg("-c").arg(&platform_cfg).arg(platform_file);
+        let (yam_platform_code, yam_platform_msg) =
+            capture_with_env(yam_platform, scenario.envs);
+
+        assert_eq!(
+            ryl_platform_code, 1,
+            "ryl platform mismatch ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_platform_code, 1,
+            "yamllint platform mismatch ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_platform_msg, yam_platform_msg,
+            "platform mismatch diagnostics ({})",
+            scenario.label
+        );
+        assert!(
+            ryl_platform_msg.contains(platform_label),
+            "platform message should mention expected {platform_label} ({})",
+            scenario.label
+        );
+
+        // success path for dos config with CRLF
+        let mut ryl_dos_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_dos_ok.arg("-c").arg(&dos_cfg).arg(&crlf_file);
+        let (ryl_dos_ok_code, ryl_dos_ok_msg) =
+            capture_with_env(ryl_dos_ok, scenario.envs);
+
+        let mut yam_dos_ok = build_yamllint_command(scenario.yam_format);
+        yam_dos_ok.arg("-c").arg(&dos_cfg).arg(&crlf_file);
+        let (yam_dos_ok_code, yam_dos_ok_msg) =
+            capture_with_env(yam_dos_ok, scenario.envs);
+
+        assert_eq!(
+            ryl_dos_ok_code, 0,
+            "dos success code mismatch ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_dos_ok_code, 0,
+            "yamllint dos success code ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_dos_ok_msg, yam_dos_ok_msg,
+            "expected identical diagnostics for dos success ({})",
+            scenario.label
+        );
+
+        // warning level behavior
+        let mut ryl_warn = build_ryl_command(exe, scenario.ryl_format);
+        ryl_warn.arg("-c").arg(&unix_warning_cfg).arg(&crlf_file);
+        let (ryl_warn_code, ryl_warn_msg) = capture_with_env(ryl_warn, scenario.envs);
+
+        let mut yam_warn = build_yamllint_command(scenario.yam_format);
+        yam_warn.arg("-c").arg(&unix_warning_cfg).arg(&crlf_file);
+        let (yam_warn_code, yam_warn_msg) = capture_with_env(yam_warn, 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_msg, yam_warn_msg,
+            "warning diagnostics should match ({})",
+            scenario.label
+        );
+        assert!(
+            ryl_warn_msg.contains("warning"),
+            "warning output should mention warning ({})",
+            scenario.label
+        );
+    }
+}

package/tests/yamllint_compat_octal_values.rs

@@ -0,0 +1,172 @@
+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 octal_values_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("octal-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  octal-values: enable\n",
+    )
+    .unwrap();
+
+    let implicit_ok_cfg = dir.path().join("octal-implicit-ok.yml");
+    fs::write(
+        &implicit_ok_cfg,
+        "rules:\n  document-start: disable\n  octal-values:\n    forbid-implicit-octal: false\n",
+    )
+    .unwrap();
+
+    let explicit_ok_cfg = dir.path().join("octal-explicit-ok.yml");
+    fs::write(
+        &explicit_ok_cfg,
+        "rules:\n  document-start: disable\n  octal-values:\n    forbid-explicit-octal: false\n",
+    )
+    .unwrap();
+
+    let all_allowed_cfg = dir.path().join("octal-all-allowed.yml");
+    fs::write(
+        &all_allowed_cfg,
+        "rules:\n  document-start: disable\n  octal-values:\n    forbid-implicit-octal: false\n    forbid-explicit-octal: false\n",
+    )
+    .unwrap();
+
+    let bad_file = dir.path().join("bad.yaml");
+    fs::write(&bad_file, "foo: 010\nbar: 0o10\n").unwrap();
+
+    let ok_file = dir.path().join("ok.yaml");
+    fs::write(&ok_file, "foo: '010'\nbar: 0O10\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    for scenario in SCENARIOS {
+        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_msg) = 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_msg) = 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_msg, yam_msg,
+            "default diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_implicit_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_implicit_ok
+            .arg("-c")
+            .arg(&implicit_ok_cfg)
+            .arg(&bad_file);
+        let (ryl_imp_code, ryl_imp_msg) =
+            capture_with_env(ryl_implicit_ok, scenario.envs);
+
+        let mut yam_implicit_ok = build_yamllint_command(scenario.yam_format);
+        yam_implicit_ok
+            .arg("-c")
+            .arg(&implicit_ok_cfg)
+            .arg(&bad_file);
+        let (yam_imp_code, yam_imp_msg) =
+            capture_with_env(yam_implicit_ok, scenario.envs);
+
+        assert_eq!(ryl_imp_code, 1, "ryl implicit-ok exit ({})", scenario.label);
+        assert_eq!(
+            yam_imp_code, 1,
+            "yamllint implicit-ok exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_imp_msg, yam_imp_msg,
+            "implicit-ok diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_explicit_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_explicit_ok
+            .arg("-c")
+            .arg(&explicit_ok_cfg)
+            .arg(&bad_file);
+        let (ryl_exp_code, ryl_exp_msg) =
+            capture_with_env(ryl_explicit_ok, scenario.envs);
+
+        let mut yam_explicit_ok = build_yamllint_command(scenario.yam_format);
+        yam_explicit_ok
+            .arg("-c")
+            .arg(&explicit_ok_cfg)
+            .arg(&bad_file);
+        let (yam_exp_code, yam_exp_msg) =
+            capture_with_env(yam_explicit_ok, scenario.envs);
+
+        assert_eq!(ryl_exp_code, 1, "ryl explicit-ok exit ({})", scenario.label);
+        assert_eq!(
+            yam_exp_code, 1,
+            "yamllint explicit-ok exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_exp_msg, yam_exp_msg,
+            "explicit-ok diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_all_allowed = build_ryl_command(exe, scenario.ryl_format);
+        ryl_all_allowed
+            .arg("-c")
+            .arg(&all_allowed_cfg)
+            .arg(&bad_file);
+        let (ryl_all_code, ryl_all_msg) =
+            capture_with_env(ryl_all_allowed, scenario.envs);
+
+        let mut yam_all_allowed = build_yamllint_command(scenario.yam_format);
+        yam_all_allowed
+            .arg("-c")
+            .arg(&all_allowed_cfg)
+            .arg(&bad_file);
+        let (yam_all_code, yam_all_msg) =
+            capture_with_env(yam_all_allowed, scenario.envs);
+
+        assert_eq!(ryl_all_code, 0, "ryl all-allowed exit ({})", scenario.label);
+        assert_eq!(
+            yam_all_code, 0,
+            "yamllint all-allowed exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_all_msg, yam_all_msg,
+            "all-allowed diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_ok.arg("-c").arg(&default_cfg).arg(&ok_file);
+        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(&ok_file);
+        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
+        );
+    }
+}