@owenlamont/ryl 0.4.1

package/tests/rule_key_ordering.rs

@@ -0,0 +1,207 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::key_ordering::{self, Config};
+
+fn build_config(yaml: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(yaml).expect("config parses");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn reports_block_mapping_out_of_order() {
+    let cfg = build_config("rules:\n  key-ordering: enable\n");
+    let input = "---\nblock mapping:\n  secondkey: a\n  firstkey: b\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected single violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 4);
+    assert_eq!(hit.column, 3);
+    assert_eq!(hit.message, "wrong ordering of key \"firstkey\" in mapping");
+}
+
+#[test]
+fn reports_flow_mapping_out_of_order() {
+    let cfg = build_config("rules:\n  key-ordering: enable\n");
+    let input = "---\nflow mapping:\n  {secondkey: a, firstkey: b}\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert_eq!(hits.len(), 1, "expected single violation: {hits:?}");
+    let hit = &hits[0];
+    assert_eq!(hit.line, 3);
+    assert_eq!(hit.column, 18);
+    assert_eq!(hit.message, "wrong ordering of key \"firstkey\" in mapping");
+}
+
+#[test]
+fn ordered_mapping_passes() {
+    let cfg = build_config("rules:\n  key-ordering: enable\n");
+    let input = "---\nfirst: 1\nsecond: 2\nthird: 3\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "ordered mapping should be accepted: {hits:?}"
+    );
+}
+
+#[test]
+fn ignored_keys_are_not_enforced() {
+    let cfg = build_config(
+        "rules:\n  key-ordering:\n    ignored-keys: [\"n(a|o)me\", \"^b\"]\n",
+    );
+    let input = "---\na:\nb:\nc:\nname: ignored\nfirst-name: ignored\nnome: ignored\ngnomes: ignored\nd:\ne:\nboat: ignored\n.boat: ERROR\ncall: ERROR\nf:\ng:\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert_eq!(
+        hits.len(),
+        2,
+        "expected violations for keys outside ignore filters"
+    );
+    assert_eq!(hits[0].line, 12);
+    assert_eq!(hits[0].column, 1);
+    assert_eq!(
+        hits[0].message,
+        "wrong ordering of key \".boat\" in mapping"
+    );
+    assert_eq!(hits[1].line, 13);
+    assert_eq!(hits[1].column, 1);
+    assert_eq!(hits[1].message, "wrong ordering of key \"call\" in mapping");
+}
+
+#[test]
+fn locale_enables_case_and_accent_friendly_ordering() {
+    let ascii_cfg = build_config("rules:\n  key-ordering: enable\n");
+    let locale_cfg =
+        build_config("locale: en_US.UTF-8\nrules:\n  key-ordering: enable\n");
+    let bare_locale_cfg =
+        build_config("locale: en_US\nrules:\n  key-ordering: enable\n");
+
+    let case_input = "---\nT-shirt: 1\nT-shirts: 2\nt-shirt: 3\nt-shirts: 4\n";
+    let case_hits = key_ordering::check(case_input, &ascii_cfg);
+    assert!(
+        case_hits.is_empty(),
+        "uppercase-first ordering should pass: {case_hits:?}"
+    );
+
+    let case_fail = "---\nt-shirt: 1\nT-shirt: 2\nt-shirts: 3\nT-shirts: 4\n";
+    let ascii_fail = key_ordering::check(case_fail, &ascii_cfg);
+    assert!(
+        !ascii_fail.is_empty(),
+        "expected ascii failure when lowercase precedes uppercase"
+    );
+    assert!(
+        ascii_fail
+            .iter()
+            .any(|hit| hit.line == 3 && hit.message.contains("T-shirt")),
+        "expected violation on uppercase key: {ascii_fail:?}"
+    );
+
+    let locale_pass = key_ordering::check(case_fail, &locale_cfg);
+    assert!(
+        locale_pass.is_empty(),
+        "locale-aware comparison should accept case-insensitive order: {locale_pass:?}"
+    );
+
+    let bare_locale_pass = key_ordering::check(case_fail, &bare_locale_cfg);
+    assert!(
+        bare_locale_pass.is_empty(),
+        "locale-aware comparison should accept bare locale strings: {bare_locale_pass:?}"
+    );
+
+    let accent_fail = "---\nhaïr: true\nhais: true\n";
+    let ascii_accent = key_ordering::check(accent_fail, &ascii_cfg);
+    assert_eq!(ascii_accent.len(), 1, "expected accent-sensitive failure");
+    assert_eq!(ascii_accent[0].line, 3);
+    assert_eq!(ascii_accent[0].column, 1);
+
+    let accent_pass = "---\nhair: true\nhaïr: true\nhais: true\nhaïssable: true\n";
+    let locale_accent = key_ordering::check(accent_pass, &locale_cfg);
+    assert!(
+        locale_accent.is_empty(),
+        "locale-aware comparison should accept accent-friendly order: {locale_accent:?}"
+    );
+
+    let mixed_input = "---\n- t-shirt: 1\n  T-shirt: 2\n  t-shirts: 3\n  T-shirts: 4\n- hair: true\n  haïr: true\n  hais: true\n  haïssable: true\n";
+    let locale_mixed = key_ordering::check(mixed_input, &locale_cfg);
+    assert!(
+        locale_mixed.is_empty(),
+        "locale-aware comparison should tolerate mixed case/accent segments: {locale_mixed:?}"
+    );
+}
+
+#[test]
+fn locale_still_enforces_order_within_single_mapping() {
+    let cfg = build_config("locale: en_US.UTF-8\nrules:\n  key-ordering: enable\n");
+    let input = "---\nt-shirt: 1\nT-shirt: 2\nt-shirts: 3\nT-shirts: 4\nhair: true\nhaïr: true\nhais: true\nhaïssable: true\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert_eq!(
+        hits.len(),
+        4,
+        "single mapping should report out-of-order keys even with locale"
+    );
+}
+
+#[test]
+fn ignored_keys_accepts_scalar_configuration() {
+    let raw = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    ignored-keys: \"name\"\n",
+    )
+    .expect("config parses");
+    let option = raw
+        .rule_option(key_ordering::ID, "ignored-keys")
+        .expect("option present");
+    assert!(option.as_str().is_some(), "ignored-keys should be scalar");
+    let cfg = key_ordering::Config::resolve(&raw);
+    let hits = key_ordering::check("name: 1\nalpha: 2\n", &cfg);
+    assert!(
+        hits.is_empty(),
+        "scalar ignored key should be skipped: {hits:?}"
+    );
+}
+
+#[test]
+fn c_locale_devolves_to_codepoint_ordering() {
+    let raw = YamlLintConfig::from_yaml_str(
+        "locale: C.UTF-8\nrules:\n  key-ordering: enable\n",
+    )
+    .expect("config parses");
+    assert_eq!(raw.locale(), Some("C.UTF-8"));
+    let cfg = key_ordering::Config::resolve(&raw);
+    let hits = key_ordering::check("t-shirt: 1\nT-shirt: 2\n", &cfg);
+    assert!(
+        hits.iter().any(|hit| hit.message.contains("T-shirt")),
+        "C locale should behave like default ordering: {hits:?}"
+    );
+}
+
+#[test]
+fn sequence_elements_are_checked_inside_lists() {
+    let cfg = build_config("rules:\n  key-ordering: enable\n");
+    let input = "---\n- second: 1\n  first: 0\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert_eq!(
+        hits.len(),
+        1,
+        "expected violation inside sequence: {hits:?}"
+    );
+    assert_eq!(hits[0].line, 3);
+    assert_eq!(hits[0].column, 3);
+}
+
+#[test]
+fn sequences_of_scalars_are_ignored() {
+    let cfg = build_config("rules:\n  key-ordering: enable\n");
+    let input = "---\n- bravo\n- alpha\n- charlie\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "scalar sequences should not be checked: {hits:?}"
+    );
+}
+
+#[test]
+fn complex_sequence_keys_do_not_break_tracking() {
+    let cfg = build_config("rules:\n  key-ordering: enable\n");
+    let input = "---\n? [b, a]\n: value\n? {c: 1, d: 2}\n: other\n";
+    let hits = key_ordering::check(input, &cfg);
+    assert!(
+        hits.is_empty(),
+        "complex keys should not produce diagnostics: {hits:?}"
+    );
+}

package/tests/rule_line_length.rs

@@ -0,0 +1,200 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::line_length::{self, Config, Violation};
+
+fn build_config(yaml: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(yaml).expect("config parses");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn flags_lines_longer_than_max() {
+    let resolved = build_config("rules:\n  line-length: {max: 10}\n");
+    let input = "key: alpha beta gamma\n";
+    let hits = line_length::check(input, &resolved);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 1,
+            column: 11,
+            message: format!(
+                "line too long ({} > {} characters)",
+                input.trim_end_matches(['\n']).chars().count(),
+                10
+            ),
+        }]
+    );
+}
+
+#[test]
+fn allows_long_single_word_by_default() {
+    let resolved = build_config("rules:\n  line-length: {max: 20}\n");
+    let input = format!("{}\n", "A".repeat(40));
+    let hits = line_length::check(&input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "non-breakable words should be allowed by default: {hits:?}"
+    );
+}
+
+#[test]
+fn respects_allow_non_breakable_words_flag() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-words: false\n",
+    );
+    let input = format!("{}\n", "B".repeat(40));
+    let hits = line_length::check(&input, &resolved);
+    assert_eq!(hits.len(), 1, "long words should be flagged when disabled");
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 21);
+    assert!(
+        hits[0].message.starts_with("line too long"),
+        "unexpected message: {}",
+        hits[0].message
+    );
+}
+
+#[test]
+fn allows_inline_mappings_when_requested() {
+    let strict = build_config(
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-words: false\n",
+    );
+    let inline_allowed = build_config(
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-inline-mappings: true\n",
+    );
+    let mapping = "url: http://localhost/very/very/long/path\n";
+
+    let strict_hits = line_length::check(mapping, &strict);
+    assert_eq!(
+        strict_hits.len(),
+        1,
+        "mapping should fail without inline support"
+    );
+
+    let inline_hits = line_length::check(mapping, &inline_allowed);
+    assert!(
+        inline_hits.is_empty(),
+        "inline mapping should pass when allowed"
+    );
+}
+
+#[test]
+fn inline_mappings_still_fail_when_value_contains_spaces() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-inline-mappings: true\n",
+    );
+    let mapping = "url: http://localhost/short + extra words\n";
+    let hits = line_length::check(mapping, &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "spaces should prevent inline mapping exemption"
+    );
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 21);
+}
+
+#[test]
+fn handles_comment_prefixes_like_yamllint() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-words: true\n",
+    );
+    let allowed = "## http://example.com/super/long/url/with/no/spaces\n";
+    let disallowed = "# # http://example.com/super/long/url/with/no/spaces\n";
+
+    let allowed_hits = line_length::check(allowed, &resolved);
+    assert!(allowed_hits.is_empty(), "double hash comments should pass");
+
+    let disallowed_hits = line_length::check(disallowed, &resolved);
+    assert_eq!(disallowed_hits.len(), 1, "spaced hash comments should fail");
+}
+
+#[test]
+fn inline_option_implies_non_breakable_words() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-inline-mappings: true\n",
+    );
+    let word = format!("{}\n", "C".repeat(40));
+    let hits = line_length::check(&word, &resolved);
+    assert!(
+        hits.is_empty(),
+        "inline flag should imply allow words: {hits:?}"
+    );
+}
+
+#[test]
+fn diagnostic_column_handles_negative_max() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: -1\n    allow-non-breakable-words: false\n",
+    );
+    let hits = line_length::check("abc\n", &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "negative max should still produce diagnostics"
+    );
+    assert_eq!(hits[0].column, 0, "column should clamp to zero");
+}
+
+#[test]
+fn crlf_lines_are_checked() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: 3\n    allow-non-breakable-words: false\n",
+    );
+    let hits = line_length::check("AAAA\r\n", &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "CRLF line should be counted with carriage return trimmed"
+    );
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 4);
+}
+
+#[test]
+fn spaces_only_lines_flagged() {
+    let resolved = build_config("rules:\n  line-length: {max: 2}\n");
+    let hits = line_length::check("     \n", &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "spaces should not qualify as non-breakable words"
+    );
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 3);
+}
+
+#[test]
+fn list_indicator_allows_long_word() {
+    let resolved = build_config("rules:\n  line-length: {max: 5}\n");
+    let input = format!("- {}\n", "a".repeat(30));
+    let hits = line_length::check(&input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "list item with non-breakable word should be allowed by default"
+    );
+}
+
+#[test]
+fn dash_without_value_still_flags() {
+    let resolved = build_config("rules:\n  line-length: {max: 1}\n");
+    let hits = line_length::check("- \n", &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "dash without content should not bypass limit"
+    );
+    assert_eq!(hits[0].column, 2);
+}
+
+#[test]
+fn inline_mapping_guard_handles_plain_text() {
+    let resolved = build_config(
+        "rules:\n  line-length:\n    max: 10\n    allow-non-breakable-inline-mappings: true\n    allow-non-breakable-words: false\n",
+    );
+    let hits = line_length::check("plain words here\n", &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "non-mapping lines should still report violations"
+    );
+}

package/tests/rule_new_lines.rs

@@ -0,0 +1,51 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::new_lines::{self, Config, LineKind};
+
+#[test]
+fn default_config_uses_unix() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  new-lines: enable\n")
+        .expect("config parses");
+    let resolved = Config::resolve(&cfg);
+    assert_eq!(resolved.kind, LineKind::Unix);
+}
+
+#[test]
+fn platform_newline_can_be_overridden_for_tests() {
+    let cfg =
+        YamlLintConfig::from_yaml_str("rules:\n  new-lines:\n    type: platform\n")
+            .expect("config parses");
+    let resolved = Config::resolve(&cfg);
+    let violation = new_lines::check("key: 1\n", resolved, "\r\n");
+    let err = violation.expect("should report mismatch");
+    assert_eq!(err.line, 1);
+    assert_eq!(err.column, 7);
+    assert_eq!(err.message, "wrong new line character: expected \\r\\n");
+}
+
+#[test]
+fn check_reports_column_in_chars() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  new-lines:\n    type: dos\n")
+        .expect("config parses");
+    let resolved = Config::resolve(&cfg);
+    let violation =
+        new_lines::check("héllo\n", resolved, new_lines::platform_newline());
+    let err = violation.expect("should report mismatch");
+    assert_eq!(err.column, 6, "unicode aware column");
+}
+
+#[test]
+fn check_returns_none_when_newlines_match() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  new-lines:\n    type: unix\n")
+        .expect("config parses");
+    let resolved = Config::resolve(&cfg);
+    let outcome =
+        new_lines::check("key: value\n", resolved, new_lines::platform_newline());
+    assert!(outcome.is_none());
+}
+
+#[test]
+fn resolve_defaults_when_rule_missing() {
+    let cfg = YamlLintConfig::from_yaml_str("rules: {}\n").expect("config parses");
+    let resolved = Config::resolve(&cfg);
+    assert_eq!(resolved.kind, LineKind::Unix);
+}

package/tests/rule_octal_values.rs

@@ -0,0 +1,53 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::octal_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_plain_implicit_and_explicit_values() {
+    let resolved = build_config("rules:\n  octal-values: enable\n");
+    let hits = octal_values::check("foo: 010\nbar: 0o10\n", &resolved);
+    assert_eq!(hits.len(), 2, "expected to flag both values");
+
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 9);
+    assert_eq!(hits[0].message, "forbidden implicit octal value \"010\"");
+
+    assert_eq!(hits[1].line, 2);
+    assert_eq!(hits[1].column, 10);
+    assert_eq!(hits[1].message, "forbidden explicit octal value \"0o10\"");
+}
+
+#[test]
+fn respects_forbid_implicit_override() {
+    let resolved =
+        build_config("rules:\n  octal-values:\n    forbid-implicit-octal: false\n");
+    let hits = octal_values::check("foo: 010\nbar: 0o10\n", &resolved);
+    assert_eq!(hits.len(), 1, "implicit octals should be allowed");
+    assert_eq!(hits[0].message, "forbidden explicit octal value \"0o10\"");
+}
+
+#[test]
+fn respects_forbid_explicit_override() {
+    let resolved =
+        build_config("rules:\n  octal-values:\n    forbid-explicit-octal: false\n");
+    let hits = octal_values::check("foo: 010\nbar: 0o10\n", &resolved);
+    assert_eq!(hits.len(), 1, "explicit octals should be allowed");
+    assert_eq!(hits[0].message, "forbidden implicit octal value \"010\"");
+}
+
+#[test]
+fn skips_quoted_and_tagged_values() {
+    let resolved = build_config("rules:\n  octal-values: enable\n");
+    let hits = octal_values::check(
+        "quoted: '010'\ntagged: !!str 0o10\nflow: [010, '010']\n",
+        &resolved,
+    );
+    assert_eq!(hits.len(), 1, "only plain implicit value should remain");
+    assert_eq!(hits[0].line, 3);
+    assert_eq!(hits[0].column, 11);
+    assert_eq!(hits[0].message, "forbidden implicit octal value \"010\"");
+}