@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/yamllint_compat_colors.rs

@@ -1,80 +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,
-};
-
-struct Case {
-    label: &'static str,
-    config_path: Option<std::path::PathBuf>,
-    expected_exit: i32,
-}
-
-#[test]
-fn colored_diagnostics_match_yamllint_across_formats() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-    let file = dir.path().join("layout.yaml");
-    fs::write(&file, "list: [1,2]\n").unwrap();
-
-    let warning_cfg = dir.path().join("layout-warning.yml");
-    fs::write(&warning_cfg, "rules:\n  commas:\n    level: warning\n").unwrap();
-
-    let cases = [
-        Case {
-            label: "default-config",
-            config_path: None,
-            expected_exit: 1,
-        },
-        Case {
-            label: "commas-warning",
-            config_path: Some(warning_cfg.clone()),
-            expected_exit: 0,
-        },
-    ];
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-
-    for scenario in SCENARIOS {
-        for case in &cases {
-            let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
-            if let Some(cfg) = &case.config_path {
-                ryl_cmd.arg("-c").arg(cfg);
-            }
-            ryl_cmd.current_dir(dir.path());
-            ryl_cmd.arg(&file);
-            let (ryl_code, ryl_output) = capture_with_env(ryl_cmd, scenario.envs);
-
-            let mut yam_cmd = build_yamllint_command(scenario.yam_format);
-            if let Some(cfg) = &case.config_path {
-                yam_cmd.arg("-c").arg(cfg);
-            }
-            yam_cmd.current_dir(dir.path());
-            yam_cmd.arg(&file);
-            let (yam_code, yam_output) = capture_with_env(yam_cmd, scenario.envs);
-
-            assert_eq!(
-                ryl_code, case.expected_exit,
-                "ryl exit code mismatch (scenario: {}, case: {})",
-                scenario.label, case.label
-            );
-            assert_eq!(
-                yam_code, case.expected_exit,
-                "yamllint exit code mismatch (scenario: {}, case: {})",
-                scenario.label, case.label
-            );
-            assert_eq!(
-                ryl_output, yam_output,
-                "diagnostic mismatch (scenario: {}, case: {})",
-                scenario.label, case.label
-            );
-        }
-    }
-}

package/tests/yamllint_compat_commas.rs

@@ -1,375 +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 commas_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("commas-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  commas: enable\n",
-    )
-    .unwrap();
-
-    let warning_cfg = dir.path().join("commas-warning.yml");
-    fs::write(
-        &warning_cfg,
-        "rules:\n  document-start: disable\n  commas:\n    level: warning\n",
-    )
-    .unwrap();
-
-    let before_cfg = dir.path().join("commas-before.yml");
-    fs::write(
-        &before_cfg,
-        "rules:\n  document-start: disable\n  commas:\n    max-spaces-before: 2\n",
-    )
-    .unwrap();
-
-    let after_cfg = dir.path().join("commas-after.yml");
-    fs::write(
-        &after_cfg,
-        "rules:\n  document-start: disable\n  commas:\n    max-spaces-after: 3\n",
-    )
-    .unwrap();
-
-    let min_cfg = dir.path().join("commas-min.yml");
-    fs::write(
-        &min_cfg,
-        "rules:\n  document-start: disable\n  commas:\n    min-spaces-after: 2\n    max-spaces-after: -1\n",
-    )
-    .unwrap();
-
-    let ignore_cfg = dir.path().join("commas-ignore.yml");
-    fs::write(
-        &ignore_cfg,
-        "rules:\n  document-start: disable\n  commas:\n    ignore:\n      - ignored.yaml\n",
-    )
-    .unwrap();
-
-    let ignore_list = dir.path().join("commas-ignore.txt");
-    fs::write(&ignore_list, "ignored-from-file.yaml\n").unwrap();
-
-    let ignore_from_file_cfg = dir.path().join("commas-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  commas:\n    ignore-from-file: '{}'\n",
-            ignore_path
-        ),
-    )
-    .unwrap();
-
-    let default_violation = dir.path().join("default.yaml");
-    fs::write(&default_violation, "---\n[1,2]\n").unwrap();
-
-    let before_violation = dir.path().join("before-bad.yaml");
-    fs::write(&before_violation, "---\n[1   , 2]\n").unwrap();
-
-    let before_ok = dir.path().join("before-ok.yaml");
-    fs::write(&before_ok, "---\n[1  , 2]\n").unwrap();
-
-    let after_violation = dir.path().join("after-bad.yaml");
-    fs::write(&after_violation, "---\n[1,    2]\n").unwrap();
-
-    let after_ok = dir.path().join("after-ok.yaml");
-    fs::write(&after_ok, "---\n[1,   2]\n").unwrap();
-
-    let min_violation = dir.path().join("min-bad.yaml");
-    fs::write(&min_violation, "---\n[1, 2]\n").unwrap();
-
-    let min_ok = dir.path().join("min-ok.yaml");
-    fs::write(&min_ok, "---\n[1,  2]\n").unwrap();
-
-    let ignored_file = dir.path().join("ignored.yaml");
-    fs::write(&ignored_file, "---\n[1,2]\n").unwrap();
-
-    let ignored_from_file = dir.path().join("ignored-from-file.yaml");
-    fs::write(&ignored_from_file, "---\n[1,2]\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(&default_violation);
-        let (ryl_default_code, ryl_default_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(&default_violation);
-        let (yam_default_code, yam_default_output) =
-            capture_with_env(yam_default, scenario.envs);
-
-        assert_eq!(ryl_default_code, 1, "ryl default exit ({})", scenario.label);
-        assert_eq!(
-            yam_default_code, 1,
-            "yamllint default exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_default_output, yam_default_output,
-            "default diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_warning = build_ryl_command(exe, scenario.ryl_format);
-        ryl_warning
-            .arg("-c")
-            .arg(&warning_cfg)
-            .arg(&default_violation);
-        let (ryl_warning_code, ryl_warning_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(&default_violation);
-        let (yam_warning_code, yam_warning_output) =
-            capture_with_env(yam_warning, scenario.envs);
-
-        assert_eq!(ryl_warning_code, 0, "ryl warning exit ({})", scenario.label);
-        assert_eq!(
-            yam_warning_code, 0,
-            "yamllint warning exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_warning_output, yam_warning_output,
-            "warning diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_before_bad = build_ryl_command(exe, scenario.ryl_format);
-        ryl_before_bad
-            .arg("-c")
-            .arg(&before_cfg)
-            .arg(&before_violation);
-        let (ryl_before_bad_code, ryl_before_bad_output) =
-            capture_with_env(ryl_before_bad, scenario.envs);
-
-        let mut yam_before_bad = build_yamllint_command(scenario.yam_format);
-        yam_before_bad
-            .arg("-c")
-            .arg(&before_cfg)
-            .arg(&before_violation);
-        let (yam_before_bad_code, yam_before_bad_output) =
-            capture_with_env(yam_before_bad, scenario.envs);
-
-        assert_eq!(
-            ryl_before_bad_code, 1,
-            "ryl before-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_before_bad_code, 1,
-            "yamllint before-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_before_bad_output, yam_before_bad_output,
-            "before-bad diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_before_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_before_ok.arg("-c").arg(&before_cfg).arg(&before_ok);
-        let (ryl_before_ok_code, ryl_before_ok_output) =
-            capture_with_env(ryl_before_ok, scenario.envs);
-
-        let mut yam_before_ok = build_yamllint_command(scenario.yam_format);
-        yam_before_ok.arg("-c").arg(&before_cfg).arg(&before_ok);
-        let (yam_before_ok_code, yam_before_ok_output) =
-            capture_with_env(yam_before_ok, scenario.envs);
-
-        assert_eq!(
-            ryl_before_ok_code, 0,
-            "ryl before-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_before_ok_code, 0,
-            "yamllint before-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_before_ok_output, yam_before_ok_output,
-            "before-ok diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_after_bad = build_ryl_command(exe, scenario.ryl_format);
-        ryl_after_bad
-            .arg("-c")
-            .arg(&after_cfg)
-            .arg(&after_violation);
-        let (ryl_after_bad_code, ryl_after_bad_output) =
-            capture_with_env(ryl_after_bad, scenario.envs);
-
-        let mut yam_after_bad = build_yamllint_command(scenario.yam_format);
-        yam_after_bad
-            .arg("-c")
-            .arg(&after_cfg)
-            .arg(&after_violation);
-        let (yam_after_bad_code, yam_after_bad_output) =
-            capture_with_env(yam_after_bad, scenario.envs);
-
-        assert_eq!(
-            ryl_after_bad_code, 1,
-            "ryl after-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_after_bad_code, 1,
-            "yamllint after-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_after_bad_output, yam_after_bad_output,
-            "after-bad diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_after_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_after_ok.arg("-c").arg(&after_cfg).arg(&after_ok);
-        let (ryl_after_ok_code, ryl_after_ok_output) =
-            capture_with_env(ryl_after_ok, scenario.envs);
-
-        let mut yam_after_ok = build_yamllint_command(scenario.yam_format);
-        yam_after_ok.arg("-c").arg(&after_cfg).arg(&after_ok);
-        let (yam_after_ok_code, yam_after_ok_output) =
-            capture_with_env(yam_after_ok, scenario.envs);
-
-        assert_eq!(
-            ryl_after_ok_code, 0,
-            "ryl after-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_after_ok_code, 0,
-            "yamllint after-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_after_ok_output, yam_after_ok_output,
-            "after-ok diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_min_bad = build_ryl_command(exe, scenario.ryl_format);
-        ryl_min_bad.arg("-c").arg(&min_cfg).arg(&min_violation);
-        let (ryl_min_bad_code, ryl_min_bad_output) =
-            capture_with_env(ryl_min_bad, scenario.envs);
-
-        let mut yam_min_bad = build_yamllint_command(scenario.yam_format);
-        yam_min_bad.arg("-c").arg(&min_cfg).arg(&min_violation);
-        let (yam_min_bad_code, yam_min_bad_output) =
-            capture_with_env(yam_min_bad, scenario.envs);
-
-        assert_eq!(ryl_min_bad_code, 1, "ryl min-bad exit ({})", scenario.label);
-        assert_eq!(
-            yam_min_bad_code, 1,
-            "yamllint min-bad exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_min_bad_output, yam_min_bad_output,
-            "min-bad diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_min_ok = build_ryl_command(exe, scenario.ryl_format);
-        ryl_min_ok.arg("-c").arg(&min_cfg).arg(&min_ok);
-        let (ryl_min_ok_code, ryl_min_ok_output) =
-            capture_with_env(ryl_min_ok, scenario.envs);
-
-        let mut yam_min_ok = build_yamllint_command(scenario.yam_format);
-        yam_min_ok.arg("-c").arg(&min_cfg).arg(&min_ok);
-        let (yam_min_ok_code, yam_min_ok_output) =
-            capture_with_env(yam_min_ok, scenario.envs);
-
-        assert_eq!(ryl_min_ok_code, 0, "ryl min-ok exit ({})", scenario.label);
-        assert_eq!(
-            yam_min_ok_code, 0,
-            "yamllint min-ok exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_min_ok_output, yam_min_ok_output,
-            "min-ok 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_ignore_file_code, ryl_ignore_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_ignore_file_code, yam_ignore_file_output) =
-            capture_with_env(yam_ignore_file, scenario.envs);
-
-        assert_eq!(
-            ryl_ignore_file_code, 0,
-            "ryl ignore-from-file exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            yam_ignore_file_code, 0,
-            "yamllint ignore-from-file exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_ignore_file_output, yam_ignore_file_output,
-            "ignore-from-file diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}

package/tests/yamllint_compat_comments.rs

@@ -1,167 +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 comments_rule_matches_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let default_cfg = dir.path().join("comments-default.yml");
-    fs::write(
-        &default_cfg,
-        "rules:\n  document-start: disable\n  comments:\n    require-starting-space: true\n    ignore-shebangs: true\n    min-spaces-from-content: 2\n",
-    )
-    .unwrap();
-
-    let no_require_cfg = dir.path().join("comments-no-require.yml");
-    fs::write(
-        &no_require_cfg,
-        "rules:\n  document-start: disable\n  comments:\n    require-starting-space: false\n    ignore-shebangs: true\n    min-spaces-from-content: 2\n",
-    )
-    .unwrap();
-
-    let shebang_cfg = dir.path().join("comments-shebang.yml");
-    fs::write(
-        &shebang_cfg,
-        "rules:\n  document-start: disable\n  comments:\n    require-starting-space: true\n    ignore-shebangs: false\n",
-    )
-    .unwrap();
-
-    let bad_file = dir.path().join("bad.yaml");
-    fs::write(
-        &bad_file,
-        "#comment\nkey: value # comment\nvalue: foo #bar\n",
-    )
-    .unwrap();
-
-    let inline_file = dir.path().join("inline.yaml");
-    fs::write(&inline_file, "key: value # comment\n").unwrap();
-
-    let shebang_file = dir.path().join("shebang.yaml");
-    fs::write(&shebang_file, "#!/usr/bin/env foo\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_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
-        );
-
-        let mut ryl_no_require = build_ryl_command(exe, scenario.ryl_format);
-        ryl_no_require
-            .arg("-c")
-            .arg(&no_require_cfg)
-            .arg(&inline_file);
-        let (ryl_nr_code, ryl_nr_output) =
-            capture_with_env(ryl_no_require, scenario.envs);
-
-        let mut yam_no_require = build_yamllint_command(scenario.yam_format);
-        yam_no_require
-            .arg("-c")
-            .arg(&no_require_cfg)
-            .arg(&inline_file);
-        let (yam_nr_code, yam_nr_output) =
-            capture_with_env(yam_no_require, scenario.envs);
-
-        assert_eq!(ryl_nr_code, 1, "ryl no-require exit ({})", scenario.label);
-        assert_eq!(
-            yam_nr_code, 1,
-            "yamllint no-require exit ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_nr_output, yam_nr_output,
-            "no-require diagnostics mismatch ({})",
-            scenario.label
-        );
-
-        let mut ryl_shebang = build_ryl_command(exe, scenario.ryl_format);
-        ryl_shebang.arg("-c").arg(&shebang_cfg).arg(&shebang_file);
-        let (ryl_sh_code, ryl_sh_output) = capture_with_env(ryl_shebang, scenario.envs);
-
-        let mut yam_shebang = build_yamllint_command(scenario.yam_format);
-        yam_shebang.arg("-c").arg(&shebang_cfg).arg(&shebang_file);
-        let (yam_sh_code, yam_sh_output) = capture_with_env(yam_shebang, scenario.envs);
-
-        assert_eq!(ryl_sh_code, 1, "ryl shebang exit ({})", scenario.label);
-        assert_eq!(yam_sh_code, 1, "yamllint shebang exit ({})", scenario.label);
-        assert_eq!(
-            ryl_sh_output, yam_sh_output,
-            "shebang diagnostics mismatch ({})",
-            scenario.label
-        );
-    }
-}
-
-#[test]
-fn block_scalar_comments_match_yamllint() {
-    ensure_yamllint_installed();
-
-    let dir = tempdir().unwrap();
-
-    let cfg_path = dir.path().join("comments.yaml");
-    fs::write(
-        &cfg_path,
-        "rules:\n  document-start: disable\n  comments:\n    min-spaces-from-content: 1\n",
-    )
-    .unwrap();
-
-    let yaml_path = dir.path().join("script.yaml");
-    fs::write(
-        &yaml_path,
-        r#"job:
-  run: |
-    PREV_VERSION="${{ github.event.inputs.previous_version }}"
-
-    # Remove 'v' prefix if present
-    PREV_VERSION=${PREV_VERSION#v}
-"#,
-    )
-    .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, 0, "ryl emitted diagnostics ({})", scenario.label);
-        assert_eq!(
-            yam_code, 0,
-            "yamllint emitted diagnostics ({})",
-            scenario.label
-        );
-        assert_eq!(
-            ryl_output, yam_output,
-            "output mismatch ({})",
-            scenario.label
-        );
-    }
-}