@owenlamont/ryl 0.4.1

package/tests/rule_comments_indentation.rs

@@ -0,0 +1,127 @@
+use ryl::rules::comments_indentation::{self, Config, Violation};
+
+fn run(input: &str) -> Vec<Violation> {
+    comments_indentation::check(input, &Config)
+}
+
+#[test]
+fn empty_input_returns_no_hits() {
+    let hits = run("");
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn accepts_aligned_comment_inside_mapping() {
+    let input = "obj:\n  # ok\n  value: 1\n";
+    let hits = run(input);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn rejects_comment_with_extra_indent() {
+    let input = "obj:\n # wrong\n  value: 1\n";
+    let hits = run(input);
+    assert_eq!(hits, vec![Violation { line: 2, column: 2 }]);
+}
+
+#[test]
+fn rejects_comment_after_comment_block_reset() {
+    let input = "obj1:\n  a: 1\n# heading\n  # misplaced\nobj2: no\n";
+    let hits = run(input);
+    assert_eq!(hits, vec![Violation { line: 4, column: 3 }]);
+}
+
+#[test]
+fn rejects_comment_after_inline_comment() {
+    let input = "- a  # inline\n # wrong\n";
+    let hits = run(input);
+    assert_eq!(hits, vec![Violation { line: 2, column: 2 }]);
+}
+
+#[test]
+fn blank_line_keeps_comment_alignment() {
+    let input = "# top\n\n  # wrong\nvalue: 1\n";
+    let hits = run(input);
+    assert_eq!(hits, vec![Violation { line: 3, column: 3 }]);
+}
+
+#[test]
+fn allows_comment_inside_block_scalar_body() {
+    let input = "rule:\n  - pattern: |\n      body\n    # example\n  - other: value\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "block scalar comment should be ignored: {hits:?}"
+    );
+}
+
+#[test]
+fn allows_comment_dedented_to_indicator_indent() {
+    let input = "rule:\n  - pattern: |\n      body\n  # metadata\n  - other: value\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "comment aligned with indicator should pass: {hits:?}"
+    );
+}
+
+#[test]
+fn indicator_with_trailing_comment_is_supported() {
+    let input = "job:\n  run: | # trailing comment\n    step one\n  next: value\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "inline comment on indicator should be ignored: {hits:?}"
+    );
+}
+
+#[test]
+fn block_scalar_allows_blank_line() {
+    let input = "rule:\n  - pattern: |\n      alpha\n\n      omega\n  - other: value\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "blank lines inside block scalars should pass: {hits:?}"
+    );
+}
+
+#[test]
+fn inline_quotes_and_escapes_before_comment_are_handled() {
+    let with_single = "value: 'quoted # fragment' # note\n  # aligned\n";
+    let hits = run(with_single);
+    assert_eq!(hits, vec![Violation { line: 2, column: 3 }]);
+
+    let with_escape = "path: \"dir\\#name\" # note\n  # aligned\n";
+    let hits = run(with_escape);
+    assert_eq!(hits, vec![Violation { line: 2, column: 3 }]);
+}
+
+#[test]
+fn block_scalar_followed_by_mapping_is_handled() {
+    let input = "value: |\n  text\nnext: 1\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "block scalar should reset tracker before next mapping: {hits:?}"
+    );
+}
+
+#[test]
+fn folded_block_scalar_with_chomping_is_detected() {
+    let input = "rule:\n  value: >-\n    body\n  # metadata\n  next: value\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "folded block scalar with chomping should not flag comments: {hits:?}"
+    );
+}
+
+#[test]
+fn empty_block_scalar_resets_state() {
+    let input = "value: |\nnext: item\n";
+    let hits = run(input);
+    assert!(
+        hits.is_empty(),
+        "empty block scalars should not cause diagnostics: {hits:?}"
+    );
+}

package/tests/rule_document_end.rs

@@ -0,0 +1,118 @@
+use ryl::rules::document_end::{
+    self, Config, FORBIDDEN_MESSAGE, MISSING_MESSAGE,
+    classify_document_end_marker_bytes,
+};
+
+#[test]
+fn reports_missing_marker_at_stream_end() {
+    let cfg = Config::new_for_tests(true);
+    let input = "---\nwithout:\n  document: end\n";
+    let hits = document_end::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected a violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 3);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, MISSING_MESSAGE);
+}
+
+#[test]
+fn reports_missing_marker_between_documents() {
+    let cfg = Config::new_for_tests(true);
+    let input = "---\nfirst: document\n---\nsecond: document\n";
+    let hits = document_end::check(input, &cfg);
+    assert_eq!(hits.len(), 2, "expected two violations: {hits:?}");
+    assert_eq!(hits[0].line, 3);
+    assert_eq!(hits[0].column, 1);
+    assert_eq!(hits[0].message, MISSING_MESSAGE);
+    assert_eq!(hits[1].line, 4);
+    assert_eq!(hits[1].column, 1);
+    assert_eq!(hits[1].message, MISSING_MESSAGE);
+}
+
+#[test]
+fn explicit_marker_satisfies_requirement() {
+    let cfg = Config::new_for_tests(true);
+    let input = "---\nwith:\n  document: end\n...\n";
+    let hits = document_end::check(input, &cfg);
+    assert!(hits.is_empty(), "explicit marker should pass: {hits:?}");
+}
+
+#[test]
+fn forbidding_marker_flags_explicit_marker() {
+    let cfg = Config::new_for_tests(false);
+    let input = "---\nwith:\n  document: end\n...\n";
+    let hits = document_end::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected a violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 4);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, FORBIDDEN_MESSAGE);
+}
+
+#[test]
+fn forbidding_marker_allows_absent_marker() {
+    let cfg = Config::new_for_tests(false);
+    let input = "---\nwith:\n  document: end\n";
+    let hits = document_end::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "missing marker allowed when forbidden: {hits:?}"
+    );
+}
+
+#[test]
+fn empty_stream_has_no_diagnostics() {
+    let cfg = Config::new_for_tests(true);
+    let hits = document_end::check("", &cfg);
+    assert!(hits.is_empty(), "empty stream should not warn: {hits:?}");
+}
+
+#[test]
+fn explicit_marker_with_trailing_spaces_is_still_detected() {
+    let cfg = Config::new_for_tests(false);
+    let input = "---\nwith:\n  document: end\n...   \n";
+    let hits = document_end::check(input, &cfg);
+    assert_eq!(
+        hits.len(),
+        1,
+        "expected forbidden marker violation: {hits:?}"
+    );
+    let hit = &hits[0];
+    assert_eq!(hit.line, 4);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, FORBIDDEN_MESSAGE);
+}
+
+#[test]
+fn marker_with_leading_indent_is_allowed() {
+    let cfg = Config::new_for_tests(true);
+    let input = "---\nwith:\n  document: end\n  ...\n";
+    let hits = document_end::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "indented marker should satisfy requirement: {hits:?}"
+    );
+}
+
+#[test]
+fn marker_with_inline_comment_is_allowed() {
+    let cfg = Config::new_for_tests(true);
+    let input = "---\nwith:\n  document: end\n... # done\n";
+    let hits = document_end::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "marker followed by comment should satisfy requirement: {hits:?}"
+    );
+}
+
+#[test]
+fn classify_marker_bytes_trims_whitespace() {
+    assert_eq!(classify_document_end_marker_bytes(b"  ...   "), Some("..."));
+    assert_eq!(classify_document_end_marker_bytes(b"\t---\r"), Some("---"));
+}
+
+#[test]
+fn classify_marker_bytes_rejects_comments_and_empty() {
+    assert!(classify_document_end_marker_bytes(b"... # done").is_none());
+    assert!(classify_document_end_marker_bytes(b"").is_none());
+}

package/tests/rule_document_start.rs

@@ -0,0 +1,60 @@
+use ryl::rules::document_start::{self, Config, FORBIDDEN_MESSAGE, MISSING_MESSAGE};
+
+#[test]
+fn reports_missing_marker_at_start_of_file() {
+    let cfg = Config::new_for_tests(true);
+    let input = "foo: bar\n";
+    let hits = document_start::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected a violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 1);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, MISSING_MESSAGE);
+}
+
+#[test]
+fn reports_missing_marker_after_comment_block() {
+    let cfg = Config::new_for_tests(true);
+    let input = "# header\nfoo: bar\n";
+    let hits = document_start::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected a violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 2);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, MISSING_MESSAGE);
+}
+
+#[test]
+fn explicit_marker_satisfies_requirement() {
+    let cfg = Config::new_for_tests(true);
+    let input = "---\nfoo: bar\n";
+    let hits = document_start::check(input, &cfg);
+    assert!(hits.is_empty(), "explicit marker should pass: {hits:?}");
+}
+
+#[test]
+fn forbidding_marker_flags_explicit_documents() {
+    let cfg = Config::new_for_tests(false);
+    let input = "---\nfoo: bar\n";
+    let hits = document_start::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected a violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 1);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, FORBIDDEN_MESSAGE);
+}
+
+#[test]
+fn implicit_documents_respected_when_forbidden() {
+    let cfg = Config::new_for_tests(false);
+    let input = "foo: bar\n";
+    let hits = document_start::check(input, &cfg);
+    assert!(hits.is_empty(), "implicit document start allowed: {hits:?}");
+}
+
+#[test]
+fn empty_stream_has_no_diagnostics() {
+    let cfg = Config::new_for_tests(true);
+    let hits = document_start::check("", &cfg);
+    assert!(hits.is_empty(), "empty stream should not warn: {hits:?}");
+}

package/tests/rule_empty_lines.rs

@@ -0,0 +1,96 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::empty_lines::{self, Config};
+
+fn resolve(contents: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(contents).expect("config parses");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn default_allows_two_blank_lines() {
+    let cfg = resolve("rules:\n  empty-lines: enable\n");
+    let ok = "key: value\n\n\nnext: item\n";
+    let violations = empty_lines::check(ok, &cfg);
+    assert!(
+        violations.is_empty(),
+        "unexpected diagnostics: {violations:?}"
+    );
+
+    let bad = "key: value\n\n\n\nnext: item\n";
+    let hits = empty_lines::check(bad, &cfg);
+    assert_eq!(hits.len(), 1);
+    let hit = &hits[0];
+    assert_eq!(hit.line, 4);
+    assert_eq!(hit.column, 1);
+    assert_eq!(hit.message, "too many blank lines (3 > 2)");
+}
+
+#[test]
+fn exceeds_max_reports_violation() {
+    let cfg = resolve(
+        "rules:\n  empty-lines:\n    max: 0\n    max-start: 0\n    max-end: 0\n",
+    );
+    let input = "---\nvalue: 1\n\nother: 2\n";
+    let hits = empty_lines::check(input, &cfg);
+    assert_eq!(hits.len(), 1);
+    let hit = &hits[0];
+    assert_eq!(hit.line, 3);
+    assert_eq!(hit.message, "too many blank lines (1 > 0)");
+}
+
+#[test]
+fn start_limit_applied_before_general_max() {
+    let cfg = resolve(
+        "rules:\n  empty-lines:\n    max: 5\n    max-start: 1\n    max-end: 0\n",
+    );
+    let input = "\n\nkey: value\n";
+    let hits = empty_lines::check(input, &cfg);
+    assert_eq!(hits.len(), 1);
+    let hit = &hits[0];
+    assert_eq!(hit.line, 2);
+    assert_eq!(hit.message, "too many blank lines (2 > 1)");
+}
+
+#[test]
+fn end_limit_overrides_general_max() {
+    let cfg = resolve(
+        "rules:\n  empty-lines:\n    max: 5\n    max-start: 0\n    max-end: 1\n",
+    );
+    let input = "key: value\n\n\n";
+    let hits = empty_lines::check(input, &cfg);
+    assert_eq!(hits.len(), 1);
+    let hit = &hits[0];
+    assert_eq!(hit.line, 3);
+    assert_eq!(hit.message, "too many blank lines (2 > 1)");
+}
+
+#[test]
+fn single_newline_file_is_ignored() {
+    let cfg = resolve(
+        "rules:\n  empty-lines:\n    max: 0\n    max-start: 0\n    max-end: 0\n",
+    );
+    let hits = empty_lines::check("\n", &cfg);
+    assert!(
+        hits.is_empty(),
+        "single newline should not produce violations"
+    );
+
+    let crlf_hits = empty_lines::check("\r\n", &cfg);
+    assert!(
+        crlf_hits.is_empty(),
+        "single CRLF newline should not produce violations"
+    );
+}
+
+#[test]
+fn space_only_lines_are_not_blank() {
+    let cfg = resolve(
+        "rules:\n  empty-lines:\n    max: 0\n    max-start: 0\n    max-end: 0\n",
+    );
+    let input = "---\nintro\n \nend\n";
+    let hits = empty_lines::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "space-only lines should not be treated as blank"
+    );
+}

package/tests/rule_empty_values.rs

@@ -0,0 +1,102 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::empty_values::{self, Config, Violation};
+
+fn resolve_config(data: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(data).unwrap();
+    empty_values::Config::resolve(&cfg)
+}
+
+#[test]
+fn reports_block_mapping_empty_value() {
+    let yaml = "block:\n  missing:\n";
+    let cfg = resolve_config("rules:\n  empty-values: enable\n");
+    let hits = empty_values::check(yaml, &cfg);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 2,
+            column: 11,
+            message: "empty value in block mapping".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn reports_flow_mapping_empty_value() {
+    let yaml = "root: { key: }\n";
+    let cfg = resolve_config("rules:\n  empty-values: enable\n");
+    let hits = empty_values::check(yaml, &cfg);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 13,
+            message: "empty value in flow mapping".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn reports_block_sequence_empty_value() {
+    let yaml = "-\n";
+    let cfg = resolve_config("rules:\n  empty-values: enable\n");
+    let hits = empty_values::check(yaml, &cfg);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 2,
+            message: "empty value in block sequence".to_string(),
+        }]
+    );
+}
+
+#[test]
+fn respects_block_sequence_flag() {
+    let yaml = "-\n";
+    let cfg = resolve_config(
+        "rules:\n  empty-values:\n    forbid-in-block-sequences: false\n",
+    );
+    let hits = empty_values::check(yaml, &cfg);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn respects_flow_mapping_flag() {
+    let yaml = "root: { key: }\n";
+    let cfg =
+        resolve_config("rules:\n  empty-values:\n    forbid-in-flow-mappings: false\n");
+    let hits = empty_values::check(yaml, &cfg);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn respects_block_mapping_flag() {
+    let yaml = "key:\n";
+    let cfg = resolve_config(
+        "rules:\n  empty-values:\n    forbid-in-block-mappings: false\n",
+    );
+    let hits = empty_values::check(yaml, &cfg);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn ignores_flow_sequences() {
+    let yaml = "seq: [ value ]\n";
+    let cfg = resolve_config("rules:\n  empty-values: enable\n");
+    let hits = empty_values::check(yaml, &cfg);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn handles_alias_nodes() {
+    let yaml = "anchors:\n  value: &id 1\nusage:\n  alias: *id\n";
+    let cfg = resolve_config("rules:\n  empty-values: enable\n");
+    let hits = empty_values::check(yaml, &cfg);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn covers_nothing_event_branch() {
+    empty_values::coverage_touch_nothing_branch();
+}

package/tests/rule_float_values.rs

@@ -0,0 +1,109 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::float_values::{self, Config};
+
+fn build_config(yaml: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(yaml).expect("config parses");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn flags_forbidden_float_variants() {
+    let resolved = build_config(
+        "rules:\n  float-values:\n    require-numeral-before-decimal: true\n    forbid-scientific-notation: true\n    forbid-nan: true\n    forbid-inf: true\n",
+    );
+
+    let hits = float_values::check("a: .5\nb: 1e2\nc: .nan\nd: .inf\n", &resolved);
+
+    assert_eq!(hits.len(), 4, "all variants should be flagged");
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 4);
+    assert_eq!(hits[0].message, "forbidden decimal missing 0 prefix \".5\"");
+
+    assert_eq!(hits[1].line, 2);
+    assert_eq!(hits[1].column, 4);
+    assert_eq!(hits[1].message, "forbidden scientific notation \"1e2\"");
+
+    assert_eq!(hits[2].line, 3);
+    assert_eq!(hits[2].column, 4);
+    assert_eq!(hits[2].message, "forbidden not a number value \".nan\"");
+
+    assert_eq!(hits[3].line, 4);
+    assert_eq!(hits[3].column, 4);
+    assert_eq!(hits[3].message, "forbidden infinite value \".inf\"");
+}
+
+#[test]
+fn skips_quoted_and_tagged_values() {
+    let resolved = build_config(
+        "rules:\n  float-values:\n    require-numeral-before-decimal: true\n",
+    );
+    let hits =
+        float_values::check("quoted: '.5'\ntagged: !!float .5\nplain: .5\n", &resolved);
+
+    assert_eq!(
+        hits.len(),
+        1,
+        "only plain scalar without tag should be flagged"
+    );
+    assert_eq!(hits[0].line, 3);
+    assert_eq!(hits[0].column, 8);
+    assert_eq!(hits[0].message, "forbidden decimal missing 0 prefix \".5\"");
+}
+
+#[test]
+fn scientific_notation_edge_cases() {
+    let resolved = build_config(
+        "rules:\n  float-values:\n    forbid-scientific-notation: true\n    require-numeral-before-decimal: true\n",
+    );
+
+    let buffer = "\
+scientific_lower: .5e+2
+scientific_upper: -.5E-2
+missing_mantissa: e3
+invalid_mantissa: a.e2
+invalid_fraction: 1.ae2
+missing_digits_after_dot: .e2
+bare_decimal: .
+missing_exponent: .5e
+signed_without_digits: .5e+
+invalid_exponent_chars: 1e+Q
+";
+    let hits = float_values::check(buffer, &resolved);
+    let messages: Vec<_> = hits.iter().map(|d| d.message.as_str()).collect();
+
+    assert_eq!(
+        hits.len(),
+        4,
+        "expected two diagnostics per scientific value"
+    );
+    assert!(
+        messages.contains(&"forbidden scientific notation \".5e+2\""),
+        "messages: {messages:?}"
+    );
+    assert!(
+        messages.contains(&"forbidden decimal missing 0 prefix \".5e+2\""),
+        "messages: {messages:?}"
+    );
+    assert!(
+        messages.contains(&"forbidden scientific notation \"-.5E-2\""),
+        "messages: {messages:?}"
+    );
+    assert!(
+        messages.contains(&"forbidden decimal missing 0 prefix \"-.5E-2\""),
+        "messages: {messages:?}"
+    );
+    let forbidden = [
+        "\"a.e2\"",
+        "\"1.ae2\"",
+        "\".e2\"",
+        "\".5e\"",
+        "\".5e+\"",
+        "\"1e+Q\"",
+    ];
+    assert!(
+        messages
+            .iter()
+            .all(|m| forbidden.iter().all(|value| !m.contains(value))),
+        "unexpected diagnostics: {messages:?}"
+    );
+}

package/tests/rule_hyphens.rs

@@ -0,0 +1,65 @@
+use ryl::rules::hyphens::{self, Config, Violation};
+
+#[test]
+fn allows_single_space_after_hyphen() {
+    let cfg = Config::new_for_tests(1);
+    let diagnostics = hyphens::check("- item\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn reports_too_many_spaces_in_root_sequence() {
+    let cfg = Config::new_for_tests(1);
+    let diagnostics = hyphens::check("-  item\n", &cfg);
+    assert_eq!(diagnostics, vec![Violation { line: 1, column: 3 }]);
+}
+
+#[test]
+fn reports_too_many_spaces_with_indentation() {
+    let cfg = Config::new_for_tests(1);
+    let diagnostics = hyphens::check("  -  item\n", &cfg);
+    assert_eq!(diagnostics, vec![Violation { line: 1, column: 5 }]);
+}
+
+#[test]
+fn respects_configured_max_spaces() {
+    let cfg = Config::new_for_tests(3);
+    let diagnostics = hyphens::check("-    item\n", &cfg);
+    assert_eq!(diagnostics, vec![Violation { line: 1, column: 5 }]);
+
+    let ok = hyphens::check("-   item\n", &cfg);
+    assert!(ok.is_empty(), "unexpected diagnostics: {ok:?}");
+}
+
+#[test]
+fn ignores_entries_with_comments_only() {
+    let cfg = Config::new_for_tests(1);
+    let diagnostics = hyphens::check("-  # comment\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn ignores_blank_lines() {
+    let cfg = Config::new_for_tests(1);
+    let diagnostics = hyphens::check("\n- item\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}
+
+#[test]
+fn ignores_entries_without_inline_values() {
+    let cfg = Config::new_for_tests(1);
+    let diagnostics = hyphens::check("-\n  key: value\n", &cfg);
+    assert!(
+        diagnostics.is_empty(),
+        "unexpected diagnostics: {diagnostics:?}"
+    );
+}