@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/yamllint_compat_list.rs

@@ -1,127 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,185 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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
-        );
-    }
-}