@owenlamont/ryl 0.4.1

package/tests/yamllint_compat_hyphens.rs

@@ -0,0 +1,223 @@
+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 hyphens_rule_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let default_cfg = dir.path().join("hyphens-default.yml");
+    fs::write(
+        &default_cfg,
+        "rules:\n  document-start: disable\n  hyphens: enable\n",
+    )
+    .unwrap();
+
+    let warning_cfg = dir.path().join("hyphens-warning.yml");
+    fs::write(
+        &warning_cfg,
+        "rules:\n  document-start: disable\n  hyphens:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let max_cfg = dir.path().join("hyphens-max.yml");
+    fs::write(
+        &max_cfg,
+        "rules:\n  document-start: disable\n  hyphens:\n    max-spaces-after: 3\n",
+    )
+    .unwrap();
+
+    let ignore_cfg = dir.path().join("hyphens-ignore.yml");
+    fs::write(
+        &ignore_cfg,
+        "rules:\n  document-start: disable\n  hyphens:\n    ignore:\n      - ignored.yaml\n",
+    )
+    .unwrap();
+
+    let ignore_list = dir.path().join("hyphens-ignore.txt");
+    fs::write(&ignore_list, "ignored-from-file.yaml\n").unwrap();
+
+    let ignore_from_file_cfg = dir.path().join("hyphens-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  hyphens:\n    ignore-from-file: '{}'\n",
+            ignore_path
+        ),
+    )
+    .unwrap();
+
+    let default_file = dir.path().join("bad.yaml");
+    fs::write(&default_file, "---\n-  item\n").unwrap();
+
+    let max_violation_file = dir.path().join("bad-max.yaml");
+    fs::write(&max_violation_file, "---\n-    item\n").unwrap();
+
+    let max_ok_file = dir.path().join("ok-max.yaml");
+    fs::write(&max_ok_file, "---\n-   item\n").unwrap();
+
+    let ignored_file = dir.path().join("ignored.yaml");
+    fs::write(&ignored_file, "---\n-  item\n").unwrap();
+
+    let ignored_from_file = dir.path().join("ignored-from-file.yaml");
+    fs::write(&ignored_from_file, "---\n-  item\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_file);
+        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_file);
+        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_file);
+        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_file);
+        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_max_violation = build_ryl_command(exe, scenario.ryl_format);
+        ryl_max_violation
+            .arg("-c")
+            .arg(&max_cfg)
+            .arg(&max_violation_file);
+        let (ryl_max_code, ryl_max_output) =
+            capture_with_env(ryl_max_violation, scenario.envs);
+
+        let mut yam_max_violation = build_yamllint_command(scenario.yam_format);
+        yam_max_violation
+            .arg("-c")
+            .arg(&max_cfg)
+            .arg(&max_violation_file);
+        let (yam_max_code, yam_max_output) =
+            capture_with_env(yam_max_violation, scenario.envs);
+
+        assert_eq!(ryl_max_code, 1, "ryl max exit ({})", scenario.label);
+        assert_eq!(yam_max_code, 1, "yamllint max exit ({})", scenario.label);
+        assert_eq!(
+            ryl_max_output, yam_max_output,
+            "max diagnostics mismatch ({})",
+            scenario.label
+        );
+
+        let mut ryl_max_ok = build_ryl_command(exe, scenario.ryl_format);
+        ryl_max_ok.arg("-c").arg(&max_cfg).arg(&max_ok_file);
+        let (ryl_max_ok_code, ryl_max_ok_output) =
+            capture_with_env(ryl_max_ok, scenario.envs);
+
+        let mut yam_max_ok = build_yamllint_command(scenario.yam_format);
+        yam_max_ok.arg("-c").arg(&max_cfg).arg(&max_ok_file);
+        let (yam_max_ok_code, yam_max_ok_output) =
+            capture_with_env(yam_max_ok, scenario.envs);
+
+        assert_eq!(ryl_max_ok_code, 0, "ryl max-ok exit ({})", scenario.label);
+        assert_eq!(
+            yam_max_ok_code, 0,
+            "yamllint max-ok exit ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_max_ok_output, yam_max_ok_output,
+            "max-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_indentation.rs

@@ -0,0 +1,398 @@
+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<'a> {
+    label: &'a str,
+    config: &'a std::path::Path,
+    file: &'a std::path::Path,
+    exit: i32,
+}
+
+#[test]
+fn indentation_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let base_cfg = dir.path().join("base.yaml");
+    fs::write(
+        &base_cfg,
+        "rules:\n  document-start: disable\n  indentation:\n    spaces: 2\n",
+    )
+    .unwrap();
+
+    let seq_cfg = dir.path().join("seq.yaml");
+    fs::write(
+        &seq_cfg,
+        "rules:\n  document-start: disable\n  indentation:\n    spaces: 2\n    indent-sequences: true\n",
+    )
+    .unwrap();
+
+    let seq_off_cfg = dir.path().join("seq-off.yaml");
+    fs::write(
+        &seq_off_cfg,
+        "rules:\n  document-start: disable\n  indentation:\n    indent-sequences: false\n",
+    )
+    .unwrap();
+
+    let multi_cfg = dir.path().join("multi.yaml");
+    fs::write(
+        &multi_cfg,
+        "rules:\n  document-start: disable\n  indentation:\n    spaces: 4\n    check-multi-line-strings: true\n",
+    )
+    .unwrap();
+
+    let map_file = dir.path().join("map.yaml");
+    fs::write(&map_file, "root:\n   child: value\n").unwrap();
+
+    let seq_bad_file = dir.path().join("seq-bad.yaml");
+    fs::write(&seq_bad_file, "root:\n- item\n").unwrap();
+
+    let seq_ok_file = dir.path().join("seq-ok.yaml");
+    fs::write(&seq_ok_file, "root:\n  - item\n").unwrap();
+
+    let seq_over_file = dir.path().join("seq-over.yaml");
+    fs::write(&seq_over_file, "root:\n      - item\n").unwrap();
+
+    let multi_bad_file = dir.path().join("multi-bad.yaml");
+    fs::write(&multi_bad_file, "quote: |\n    good\n     bad\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+
+    let cases = [
+        Case {
+            label: "mapping-indent",
+            config: &base_cfg,
+            file: &map_file,
+            exit: 1,
+        },
+        Case {
+            label: "sequence-indent-required",
+            config: &seq_cfg,
+            file: &seq_bad_file,
+            exit: 1,
+        },
+        Case {
+            label: "sequence-indent-disabled",
+            config: &seq_off_cfg,
+            file: &seq_bad_file,
+            exit: 0,
+        },
+        Case {
+            label: "sequence-ok",
+            config: &seq_cfg,
+            file: &seq_ok_file,
+            exit: 0,
+        },
+        Case {
+            label: "sequence-over-indented",
+            config: &seq_cfg,
+            file: &seq_over_file,
+            exit: 1,
+        },
+        Case {
+            label: "multi-line",
+            config: &multi_cfg,
+            file: &multi_bad_file,
+            exit: 1,
+        },
+    ];
+
+    for scenario in SCENARIOS {
+        for case in &cases {
+            let mut ryl_cmd = build_ryl_command(exe, scenario.ryl_format);
+            ryl_cmd.arg("-c").arg(case.config).arg(case.file);
+            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(case.config).arg(case.file);
+            let (yam_code, yam_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+            assert_eq!(
+                ryl_code, case.exit,
+                "ryl exit mismatch {} ({})",
+                case.label, scenario.label
+            );
+            assert_eq!(
+                yam_code, case.exit,
+                "yamllint exit mismatch {} ({})",
+                case.label, scenario.label
+            );
+            assert_eq!(
+                ryl_msg, yam_msg,
+                "diagnostics mismatch {} ({})",
+                case.label, scenario.label
+            );
+        }
+    }
+}
+
+#[test]
+fn nested_sequence_indentation_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let cfg_path = dir.path().join("cfg.yaml");
+    fs::write(
+        &cfg_path,
+        "rules:\n  document-start: disable\n  indentation:\n    spaces: 2\n    indent-sequences: consistent\n",
+    )
+    .unwrap();
+
+    let yaml_path = dir.path().join("input.yaml");
+    fs::write(
+        &yaml_path,
+        "root:\n  - any:\n      - changed-files:\n          - any-glob-to-any-file:\n              - foo\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_msg) = 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_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(
+            ryl_code, 0,
+            "ryl exited with diagnostics ({})",
+            scenario.label
+        );
+        assert_eq!(
+            yam_code, 0,
+            "yamllint reported unexpected diagnostics ({})",
+            scenario.label
+        );
+        assert_eq!(ryl_msg, yam_msg, "output mismatch ({})", scenario.label);
+    }
+}
+
+#[test]
+fn sequence_after_comments_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let cfg_path = dir.path().join("cfg.yaml");
+    fs::write(
+        &cfg_path,
+        "rules:\n  document-start: disable\n  line-length: disable\n  indentation:\n    spaces: 2\n",
+    )
+    .unwrap();
+
+    let yaml_path = dir.path().join("input.yaml");
+    fs::write(
+        &yaml_path,
+        "bug:\n  # Bug Issue Template:\n  #   [Bug]:\n  # General:\n  #   panic:\n  # Terraform Plugin SDK:\n  #   doesn't support update\n  #   Invalid address to set\n  - \"(\\\\[Bug\\\\]:|doesn't support update|Invalid address to set|panic:)\"\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_msg) = 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_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(
+            yam_code, 0,
+            "yamllint should accept input ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_code, 0,
+            "ryl should accept input ({})\n{}",
+            scenario.label, ryl_msg
+        );
+        assert_eq!(ryl_msg, yam_msg, "output mismatch ({})", scenario.label);
+    }
+}
+
+#[test]
+fn compact_nested_sequence_indentation_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+
+    let cfg_path = dir.path().join("cfg.yaml");
+    fs::write(
+        &cfg_path,
+        "rules:\n  document-start: disable\n  line-length: disable\n  indentation:\n    spaces: 2\n    indent-sequences: consistent\n",
+    )
+    .unwrap();
+
+    let yaml_path = dir.path().join("input.yaml");
+    fs::write(
+        &yaml_path,
+        "- name: Test nerdctl\n  tasks:\n    - name: Test nerdctl commands\n      loop:\n        - - pull\n          - \"{{ image }}\"\n        - - save\n          - -o\n          - /tmp/hello-world.tar\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_msg) = 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_msg) = capture_with_env(yam_cmd, scenario.envs);
+
+        assert_eq!(
+            yam_code, 0,
+            "yamllint should accept compact nested sequence input ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_code, 0,
+            "ryl should accept compact nested sequence input ({})\n{}",
+            scenario.label, ryl_msg
+        );
+        assert_eq!(ryl_msg, yam_msg, "output mismatch ({})", scenario.label);
+    }
+}
+
+#[test]
+fn readthedocs_style_indentation_matches_yamllint() {
+    ensure_yamllint_installed();
+
+    let dir = tempdir().unwrap();
+    let cfg = dir.path().join("cfg.yaml");
+    fs::write(
+        &cfg,
+        "extends: default\nrules:\n  line-length:\n    max: 110\n",
+    )
+    .unwrap();
+
+    let input = dir.path().join("readthedocs.yaml");
+    fs::write(
+        &input,
+        "---\nversion: 2\nformats: []\nsphinx:\n    configuration: devel-common/src/docs/rtd-deprecation/conf.py\npython:\n    version: \"3.10\"\n    install:\n        - method: pip\n          path: .\n          extra_requirements:\n              - doc\n    system_packages: true\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 readthedocs-style indentation ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for readthedocs-style indentation ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn flow_mapping_continuation_indentation_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,
+        "---\nserializers:\n  - {className: org.example.Serializer,\n     config: {includeTypes: true}}\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 flow mapping continuation indentation ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for flow mapping continuation indentation ({})",
+            scenario.label
+        );
+    }
+}
+
+#[test]
+fn multiline_double_quoted_template_indentation_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,
+        "---\nlogging:\n  log_filename_template:\n    default: \"dag_id={{ ti.dag_id }}/run_id={{ ti.run_id }}/task_id={{ ti.task_id }}/\\\n             {%% if ti.map_index >= 0 %%}map_index={{ ti.map_index }}/{%% endif %%}\\\n             attempt={{ try_number|default(ti.try_number) }}.log\"\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 multiline quoted template indentation ({})",
+            scenario.label
+        );
+        assert_eq!(
+            ryl_msg, yam_msg,
+            "diagnostics mismatch for multiline quoted template indentation ({})",
+            scenario.label
+        );
+    }
+}