@owenlamont/ryl 0.4.1

package/tests/rule_brackets.rs

@@ -0,0 +1,217 @@
+use ryl::rules::brackets::{self, Config, Forbid, Violation};
+
+fn defaults() -> Config {
+    Config::new_for_tests(Forbid::None, 0, 0, -1, -1)
+}
+
+#[test]
+fn empty_input_returns_no_diagnostics() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn accepts_compact_flow_sequence() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("object: [1, 2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn reports_space_after_open_bracket() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("object: [ 1, 2]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 10,
+            message: "too many spaces inside brackets".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn reports_space_before_closing_bracket() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("object: [1, 2 ]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 14,
+            message: "too many spaces inside brackets".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn forbid_true_rejects_flow_sequence() {
+    let cfg = Config::new_for_tests(Forbid::All, 0, 0, -1, -1);
+    let diagnostics = brackets::check("object: [1, 2]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 10,
+            message: "forbidden flow sequence".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn forbid_non_empty_allows_empty_sequence() {
+    let cfg = Config::new_for_tests(Forbid::NonEmpty, 0, 0, -1, -1);
+    let diagnostics = brackets::check("object: []\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn forbid_non_empty_rejects_non_empty_sequence() {
+    let cfg = Config::new_for_tests(Forbid::NonEmpty, 0, 0, -1, -1);
+    let diagnostics = brackets::check("object: [1]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 10,
+            message: "forbidden flow sequence".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn min_spaces_inside_enforced_on_both_sides() {
+    let cfg = Config::new_for_tests(Forbid::None, 1, -1, -1, -1);
+    let diagnostics = brackets::check("object: [1, 2]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![
+            Violation {
+                line: 1,
+                column: 10,
+                message: "too few spaces inside brackets".to_string(),
+            },
+            Violation {
+                line: 1,
+                column: 14,
+                message: "too few spaces inside brackets".to_string(),
+            },
+        ]
+    );
+}
+
+#[test]
+fn max_spaces_inside_limits_padding() {
+    let cfg = Config::new_for_tests(Forbid::None, 0, 1, -1, -1);
+    let diagnostics = brackets::check("object: [  1, 2   ]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![
+            Violation {
+                line: 1,
+                column: 11,
+                message: "too many spaces inside brackets".to_string(),
+            },
+            Violation {
+                line: 1,
+                column: 18,
+                message: "too many spaces inside brackets".to_string(),
+            },
+        ]
+    );
+}
+
+#[test]
+fn empty_sequence_spacing_overrides_defaults() {
+    let cfg = Config::new_for_tests(Forbid::None, 0, 0, 1, 2);
+    let diagnostics = brackets::check("object: []\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 10,
+            message: "too few spaces inside empty brackets".to_string(),
+        }]
+    );
+
+    let diagnostics = brackets::check("object: [    ]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 13,
+            message: "too many spaces inside empty brackets".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn multiline_sequences_skip_spacing_checks() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("seq: [\n  1,\n  2\n]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn brackets_inside_scalars_are_ignored() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("value: \"[ not a sequence ]\"\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn comments_inside_flow_sequences_are_ignored() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("object: [1, # comment\n  2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn carriage_returns_inside_flow_are_ignored() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("object: [1,\r\n  2]\r\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn nested_sequences_mark_outer_non_empty() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("outer: [[1]]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn unmatched_closing_bracket_is_ignored() {
+    let cfg = defaults();
+    let diagnostics = brackets::check("]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}

package/tests/rule_commas.rs

@@ -0,0 +1,205 @@
+use ryl::rules::commas::{self, Config, Violation};
+
+fn defaults() -> Config {
+    Config::new_for_tests(0, 1, 1)
+}
+
+#[test]
+fn empty_input_returns_no_diagnostics() {
+    let cfg = defaults();
+    let diagnostics = commas::check("", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn accepts_well_spaced_flow_sequence() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1, 2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn reports_space_before_comma() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1 ,2]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![
+            Violation {
+                line: 1,
+                column: 3,
+                message: "too many spaces before comma".to_string(),
+            },
+            Violation {
+                line: 1,
+                column: 5,
+                message: "too few spaces after comma".to_string(),
+            },
+        ]
+    );
+}
+
+#[test]
+fn reports_missing_space_after_comma() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1,2]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 4,
+            message: "too few spaces after comma".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn reports_excess_space_after_comma() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1,  2]\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![Violation {
+            line: 1,
+            column: 5,
+            message: "too many spaces after comma".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn ignores_newline_after_comma() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1,\n  2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn ignores_comma_at_line_start() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[\n  1\n, 2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn newline_before_comma_is_ignored() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1\n, 2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn ignores_commas_inside_scalars() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[\"café, menu\", 3]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn respects_relaxed_spacing_config() {
+    let cfg = Config::new_for_tests(-1, 0, -1);
+    let diagnostics = commas::check("[1   ,2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn handles_flow_mapping_entries() {
+    let cfg = defaults();
+    let diagnostics = commas::check("{foo: 1 ,bar: 2}\n", &cfg);
+    assert_eq!(
+        diagnostics,
+        vec![
+            Violation {
+                line: 1,
+                column: 8,
+                message: "too many spaces before comma".to_string(),
+            },
+            Violation {
+                line: 1,
+                column: 10,
+                message: "too few spaces after comma".to_string(),
+            },
+        ]
+    );
+}
+
+#[test]
+fn allows_comment_after_comma_on_same_line() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1, # comment\n  2]\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn allows_comment_after_comma_with_crlf() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1, # comment\r\n  2]\r\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn carriage_return_after_comma_is_ignored() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1,\r\n  2]\r\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn trailing_spaces_without_next_token_do_not_panic() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1,  ", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn bare_carriage_return_is_treated_as_line_break() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1, 2]\r", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn bare_carriage_return_before_comma_is_ignored() {
+    let cfg = defaults();
+    let diagnostics = commas::check("[1\r, 2]\r", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}

package/tests/rule_comments.rs

@@ -0,0 +1,197 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::comments::{self, Config, Violation};
+
+fn build_config(yaml: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(yaml).expect("config parses");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn missing_space_reports_violation() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("#comment\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 2,
+            message: "missing starting space in comment".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn allows_hash_art_lines() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("########################\n", &resolved);
+    assert!(hits.is_empty(), "hash art should be allowed: {hits:?}");
+}
+
+#[test]
+fn enforces_min_spacing_for_inline_comments() {
+    let resolved = build_config(
+        "rules:\n  comments:\n    require-starting-space: true\n    min-spaces-from-content: 2\n",
+    );
+    let hits = comments::check("key: value # comment\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 12,
+            message: "too few spaces before comment: expected 2".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn disables_min_spacing_with_negative_one() {
+    let resolved = build_config(
+        "rules:\n  comments:\n    require-starting-space: true\n    min-spaces-from-content: -1\n",
+    );
+    let hits = comments::check("key: value # comment\n", &resolved);
+    assert!(
+        hits.is_empty(),
+        "min spacing of -1 should disable the check: {hits:?}"
+    );
+}
+
+#[test]
+fn shebang_respected_when_ignored() {
+    let resolved = build_config(
+        "rules:\n  comments:\n    require-starting-space: true\n    ignore-shebangs: true\n",
+    );
+    let hits = comments::check("#!/usr/bin/env foo\n", &resolved);
+    assert!(hits.is_empty(), "shebang should be ignored: {hits:?}");
+}
+
+#[test]
+fn shebang_flagged_when_not_ignored() {
+    let resolved = build_config(
+        "rules:\n  comments:\n    require-starting-space: true\n    ignore-shebangs: false\n",
+    );
+    let hits = comments::check("#!/usr/bin/env foo\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 2,
+            message: "missing starting space in comment".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn inline_comment_reports_both_issues() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("value: foo #bar\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![
+            Violation {
+                line: 1,
+                column: 12,
+                message: "too few spaces before comment: expected 2".to_string(),
+            },
+            Violation {
+                line: 1,
+                column: 13,
+                message: "missing starting space in comment".to_string(),
+            },
+        ]
+    );
+}
+
+#[test]
+fn url_fragment_does_not_count_as_comment() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("link: https://example.com/#anchor\n", &resolved);
+    assert!(
+        hits.is_empty(),
+        "URL fragments should not be treated as comments: {hits:?}"
+    );
+}
+
+#[test]
+fn ignores_hash_characters_inside_quotes() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("string: \"value #not comment\" # comment\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 30,
+            message: "too few spaces before comment: expected 2".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn ignores_hash_inside_single_quotes() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("string: 'value #not comment' # comment\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 30,
+            message: "too few spaces before comment: expected 2".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn handles_escaped_hash_inside_double_quotes() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("string: \"path\\#not comment\" # comment\n", &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 29,
+            message: "too few spaces before comment: expected 2".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn handles_crlf_newlines() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let hits = comments::check("key: value # comment\r\n#comment\r\n", &resolved);
+    assert_eq!(hits.len(), 2, "expected two violations: {hits:?}");
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[1].line, 2);
+}
+
+#[test]
+fn multiline_quoted_scalars_ignore_hashes() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let input = "value: \"first line\\n  second # still scalar\\n  third\"\n";
+    let hits = comments::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "quoted scalar hash should not be comment: {hits:?}"
+    );
+}
+
+#[test]
+fn block_scalar_lines_do_not_trigger_comment_checks() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let input =
+        "job:\n  run: |\n    line one\n   line two\n    line three\n  next: value\n";
+    let hits = comments::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "block scalar content must be ignored: {hits:?}"
+    );
+}
+
+#[test]
+fn empty_block_scalar_is_ignored() {
+    let resolved = build_config("rules:\n  comments: {}\n");
+    let input = "job:\n  run: |\n  next: value\n";
+    let hits = comments::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "empty block scalar should reset tracker: {hits:?}"
+    );
+}