@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/rule_comments_indentation.rs

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

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

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

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

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

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

@@ -1,65 +0,0 @@
-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:?}"
-    );
-}