@owenlamont/ryl 0.4.1

package/tests/rule_quoted_strings.rs

@@ -0,0 +1,290 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::quoted_strings::{self, Config};
+
+fn build_config(yaml: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(yaml).expect("config should parse");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn required_true_flags_plain_values() {
+    let cfg =
+        build_config("rules:\n  document-start: disable\n  quoted-strings: enable\n");
+    let hits = quoted_strings::check("foo: bar\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 6);
+    assert_eq!(
+        hits[0].message,
+        "string value is not quoted with any quotes"
+    );
+}
+
+#[test]
+fn quote_type_single_requires_single_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    quote-type: single\n",
+    );
+    let hits = quoted_strings::check("foo: \"bar\"\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(
+        hits[0].message,
+        "string value is not quoted with single quotes"
+    );
+}
+
+#[test]
+fn non_string_plain_values_are_ignored() {
+    let cfg =
+        build_config("rules:\n  document-start: disable\n  quoted-strings: enable\n");
+    let hits = quoted_strings::check("foo: 123\n", &cfg);
+    assert!(hits.is_empty(), "numeric scalars should be skipped");
+}
+
+#[test]
+fn required_false_respects_extra_required() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: false\n    extra-required: ['^http']\n",
+    );
+    let hits = quoted_strings::check("- http://example.com\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(hits[0].message, "string value is not quoted");
+}
+
+#[test]
+fn only_when_needed_flags_redundant_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let hits = quoted_strings::check("foo: \"bar\"\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(
+        hits[0].message,
+        "string value is redundantly quoted with any quotes"
+    );
+}
+
+#[test]
+fn only_when_needed_respects_extra_allowed() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    extra-allowed: ['^http']\n",
+    );
+    let hits = quoted_strings::check("foo: \"http://example\"\n", &cfg);
+    assert!(hits.is_empty(), "quoted URL should be allowed");
+}
+
+#[test]
+fn required_false_flags_mismatched_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: false\n    quote-type: single\n",
+    );
+    let hits = quoted_strings::check("foo: \"bar\"\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert!(hits[0].message.contains("single quotes"));
+}
+
+#[test]
+fn only_when_needed_extra_required_enforces_quoting() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    extra-required: ['^foo']\n",
+    );
+    let hits = quoted_strings::check("foo: foo\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert!(hits[0].message.contains("not quoted"));
+}
+
+#[test]
+fn only_when_needed_flags_mismatched_quote_type() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    quote-type: single\n",
+    );
+    let hits = quoted_strings::check("foo: \"bar\"\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert!(hits[0].message.contains("single quotes"));
+}
+
+#[test]
+fn only_when_needed_mismatched_quote_type_when_quotes_required() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    quote-type: single\n",
+    );
+    let hits = quoted_strings::check("foo: \"!bar\"\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(
+        hits[0].message,
+        "string value is not quoted with single quotes"
+    );
+}
+
+#[test]
+fn tagged_scalars_are_skipped() {
+    let cfg =
+        build_config("rules:\n  document-start: disable\n  quoted-strings: enable\n");
+    let hits = quoted_strings::check("foo: !!str yes\n", &cfg);
+    assert!(
+        hits.is_empty(),
+        "explicitly tagged scalars should be ignored"
+    );
+}
+
+#[test]
+fn literal_block_is_ignored() {
+    let cfg =
+        build_config("rules:\n  document-start: disable\n  quoted-strings: enable\n");
+    let hits = quoted_strings::check("foo: |\n  line\n", &cfg);
+    assert!(hits.is_empty(), "literal blocks are outside rule scope");
+}
+
+#[test]
+fn double_quoted_non_printable_is_considered_needed() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "foo: \"\u{0007}\"\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(hits.is_empty(), "non-printable characters require quotes");
+}
+
+#[test]
+fn quoted_value_starting_with_bang_keeps_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let hits = quoted_strings::check("foo: \"!foo\"\n", &cfg);
+    assert!(hits.is_empty(), "values starting with bang need quotes");
+}
+
+#[test]
+fn required_false_allows_plain_strings_without_extras() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: false\n",
+    );
+    let hits = quoted_strings::check("foo: bar\n", &cfg);
+    assert!(hits.is_empty(), "plain values should be allowed");
+}
+
+#[test]
+fn required_false_respects_matching_quote_type() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: false\n    quote-type: double\n",
+    );
+    let hits = quoted_strings::check("foo: \"bar\"\n", &cfg);
+    assert!(hits.is_empty(), "matching quotes should be permitted");
+}
+
+#[test]
+fn complex_keys_do_not_suppress_value_diagnostics() {
+    let cfg =
+        build_config("rules:\n  document-start: disable\n  quoted-strings: enable\n");
+    let yaml = "? { key: value }\n: data\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert_eq!(hits.len(), 1, "expected value diagnostic, got: {:?}", hits);
+    assert_eq!(hits[0].line, 2);
+    assert_eq!(hits[0].column, 3);
+    assert_eq!(
+        hits[0].message,
+        "string value is not quoted with any quotes"
+    );
+}
+
+#[test]
+fn allow_quoted_quotes_permits_mismatched_quotes_with_inner_quote() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    quote-type: double\n    allow-quoted-quotes: true\n",
+    );
+    let hits = quoted_strings::check("foo: 'bar\"baz'\n", &cfg);
+    assert!(hits.is_empty(), "mismatched quoting should be permitted");
+}
+
+#[test]
+fn check_keys_true_flags_keys() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n    check-keys: true\n    extra-required: ['[:]']\n",
+    );
+    let hits = quoted_strings::check("foo:bar: baz\n", &cfg);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 1);
+    assert_eq!(hits[0].message, "string key is not quoted");
+}
+
+#[test]
+fn flow_context_retain_quotes_when_needed() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let hits = quoted_strings::check("items: [\"a,b\"]\n", &cfg);
+    assert!(
+        hits.is_empty(),
+        "quotes are required in flow contexts containing commas"
+    );
+}
+
+#[test]
+fn flow_context_after_multibyte_key_retain_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "\u{00E9}: [\"a,b\"]\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(
+        hits.is_empty(),
+        "flow context after multibyte key should keep quotes"
+    );
+}
+
+#[test]
+fn multiline_backslash_requires_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "foo: \"line1\\\n  line2\"\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(
+        hits.is_empty(),
+        "backslash line continuations should require quotes"
+    );
+}
+
+#[test]
+fn multiline_flow_tokens_require_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "foo: \"{ missing\"\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(hits.is_empty(), "unbalanced flow tokens should keep quotes");
+}
+
+#[test]
+fn multiline_backslash_with_crlf_requires_quotes() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "foo: \"line1\\\r\n  line2\"\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(
+        hits.is_empty(),
+        "CRLF backslash continuations should require quotes"
+    );
+}
+
+#[test]
+fn multiline_empty_double_quoted_value_is_handled() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "foo: \"\n\"\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(hits.is_empty(), "blank multi-line content should not panic");
+}
+
+#[test]
+fn inner_double_quotes_are_preserved() {
+    let cfg = build_config(
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    );
+    let yaml = "foo: \"\\\"bar\\\"\"\n";
+    let hits = quoted_strings::check(yaml, &cfg);
+    assert!(hits.is_empty(), "embedded quotes should keep outer quoting");
+}

package/tests/rule_trailing_spaces.rs

@@ -0,0 +1,41 @@
+use ryl::rules::trailing_spaces::{self, Violation};
+
+#[test]
+fn reports_trailing_space() {
+    let input = "---\nsome: text \n";
+    let hits = trailing_spaces::check(input);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 2,
+            column: 11,
+        }]
+    );
+}
+
+#[test]
+fn reports_trailing_tab() {
+    let input = "key:\t\n";
+    let hits = trailing_spaces::check(input);
+    assert_eq!(hits, vec![Violation { line: 1, column: 5 }]);
+}
+
+#[test]
+fn ignores_clean_lines() {
+    let input = "foo: bar\n";
+    let hits = trailing_spaces::check(input);
+    assert!(hits.is_empty());
+}
+
+#[test]
+fn handles_crlf_lines() {
+    let input = "---\r\nsome: text \r\n";
+    let hits = trailing_spaces::check(input);
+    assert_eq!(
+        hits,
+        vec![Violation {
+            line: 2,
+            column: 11,
+        }]
+    );
+}

package/tests/rule_truthy.rs

@@ -0,0 +1,236 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::truthy::{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_truthy_values_in_values() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let hits = truthy::check("key: True\nother: yes\n", &resolved);
+    assert_eq!(hits.len(), 2, "expected to flag both values");
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 6);
+    assert_eq!(
+        hits[0].message,
+        "truthy value should be one of [false, true]"
+    );
+    assert_eq!(hits[1].line, 2);
+    assert_eq!(hits[1].column, 8);
+}
+
+#[test]
+fn skips_quoted_or_explicitly_tagged_values() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let hits = truthy::check(
+        "---\nstring: \"True\"\nexplicit: !!str yes\nboolean: !!bool True\n",
+        &resolved,
+    );
+    assert!(hits.is_empty(), "quoted/tagged values should be ignored");
+}
+
+#[test]
+fn respects_allowed_values_override() {
+    let resolved =
+        build_config("rules:\n  truthy:\n    allowed-values: [\"yes\", \"no\"]\n");
+    let hits = truthy::check("key: yes\nkey2: true\n", &resolved);
+    assert_eq!(hits.len(), 1);
+    assert_eq!(hits[0].line, 2);
+    assert_eq!(hits[0].column, 7);
+    assert_eq!(hits[0].message, "truthy value should be one of [no, yes]");
+}
+
+#[test]
+fn respects_yaml_version_directive() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "yes: 1\n...\n%YAML 1.2\n---\nyes: 2\n...\n%YAML 1.1\n---\nyes: 3\n";
+    let hits = truthy::check(input, &resolved);
+    assert_eq!(hits.len(), 2, "only YAML 1.1 documents should flag 'yes'");
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 1);
+    assert_eq!(hits[1].line, 9);
+    assert_eq!(hits[1].column, 1);
+}
+
+#[test]
+fn skips_keys_when_disabled() {
+    let resolved = build_config(
+        "rules:\n  truthy:\n    allowed-values: []\n    check-keys: false\n",
+    );
+    let hits = truthy::check("True: yes\nvalue: True\n", &resolved);
+    assert_eq!(hits.len(), 2, "keys should be skipped but values flagged");
+    assert!(
+        hits.iter().all(|hit| !(hit.line == 1 && hit.column == 1)),
+        "key diagnostics should be suppressed: {hits:?}"
+    );
+}
+
+#[test]
+fn flags_keys_when_enabled() {
+    let resolved = build_config("rules:\n  truthy:\n    allowed-values: []\n");
+    let hits = truthy::check("True: yes\n", &resolved);
+    assert_eq!(hits.len(), 2);
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 1);
+    assert_eq!(hits[1].line, 1);
+    assert_eq!(hits[1].column, 7);
+}
+
+#[test]
+fn handles_complex_keys_without_leaking_key_depth() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "? { mixed: True }\n: value\n";
+    let hits = truthy::check(input, &resolved);
+    assert_eq!(hits.len(), 1, "should flag nested truthy value once");
+    assert_eq!(hits[0].line, 1);
+    assert_eq!(hits[0].column, 12);
+}
+
+#[test]
+fn ignores_malformed_yaml_directive_without_version() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "%YAML\n---\nfoo: True\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "malformed directive should be skipped: {hits:?}"
+    );
+}
+
+#[test]
+fn ignores_yaml_directive_with_non_numeric_version() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "%YAML 1.x\n---\nfoo: True\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "invalid directives should be ignored: {hits:?}"
+    );
+}
+
+#[test]
+fn ignores_yaml_directive_missing_minor_version() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "%YAML 1\n---\nfoo: True\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "directive without minor version should be ignored"
+    );
+}
+
+#[test]
+fn ignores_yaml_directive_with_non_numeric_major() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "%YAML x.1\n---\nfoo: True\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "directive with invalid major should be ignored"
+    );
+}
+
+#[test]
+fn disable_line_inline_comment_suppresses_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "value: yes  # yamllint disable-line rule:truthy\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "inline disable-line should suppress diagnostics: {hits:?}"
+    );
+}
+
+#[test]
+fn disable_line_without_rule_applies_to_next_line() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "# yamllint disable-line\nvalue: on\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "global disable-line should apply to the next line: {hits:?}"
+    );
+}
+
+#[test]
+fn disable_line_with_other_rule_does_not_affect_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "value: on  # yamllint disable-line rule:comments\n";
+    let hits = truthy::check(input, &resolved);
+    assert_eq!(hits.len(), 1, "truthy diagnostics should remain: {hits:?}");
+}
+
+#[test]
+fn disable_line_without_rule_list_still_matches_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "#   yamllint disable-line   \nvalue: off\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "implicit disable-line should apply to truthy rule: {hits:?}"
+    );
+}
+
+#[test]
+fn disable_line_with_multiple_rules_including_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "value: on  # yamllint disable-line rule:comments rule:truthy\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "listing truthy rule should suppress diagnostics: {hits:?}"
+    );
+}
+
+#[test]
+fn disable_line_without_rule_prefix_disables_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "value: on  # yamllint disable-line truthy\n";
+    let hits = truthy::check(input, &resolved);
+    assert!(
+        hits.is_empty(),
+        "directive without rule: prefix should disable all rules: {hits:?}"
+    );
+}
+
+#[test]
+fn disable_line_parsing_handles_quotes_and_escapes() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let double_quoted =
+        "value: \"hash # fragment\"  # yamllint disable-line rule:truthy\n";
+    assert!(truthy::check(double_quoted, &resolved).is_empty());
+
+    let single_quoted =
+        "value: 'path\\#fragment'  # yamllint disable-line rule:truthy\n";
+    assert!(truthy::check(single_quoted, &resolved).is_empty());
+
+    let escaped_hash = "value: foo \\# not comment\n";
+    assert!(truthy::check(escaped_hash, &resolved).is_empty());
+}
+
+#[test]
+fn regular_comment_does_not_disable_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "value: yes  # regular comment\n";
+    let hits = truthy::check(input, &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "non-directive comment should not disable rule"
+    );
+}
+
+#[test]
+fn disable_line_block_comment_with_truthy() {
+    let resolved = build_config("rules:\n  truthy: enable\n");
+    let input = "# yamllint disable-line rule:truthy\nvalue: yes\nnext: On\n";
+    let hits = truthy::check(input, &resolved);
+    assert_eq!(
+        hits.len(),
+        1,
+        "only the immediately following line should be disabled"
+    );
+    assert_eq!(hits[0].line, 3);
+}

package/tests/user_global_invalid_yaml.rs

@@ -0,0 +1,32 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("failed to run ryl");
+    let code = out.status.code().unwrap_or(-1);
+    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
+    let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
+    (code, stdout, stderr)
+}
+
+#[test]
+fn user_global_config_with_invalid_yaml_errors() {
+    let td = tempdir().unwrap();
+    let xdg = td.path().join("xdg").join("yamllint");
+    fs::create_dir_all(&xdg).unwrap();
+    fs::write(xdg.join("config"), "rules: {\n").unwrap();
+
+    let proj = td.path().join("proj");
+    fs::create_dir_all(&proj).unwrap();
+    fs::write(proj.join("a.yaml"), "a: 1\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(Command::new(exe)
+        .env("XDG_CONFIG_HOME", td.path().join("xdg"))
+        .arg("--list-files")
+        .arg(&proj));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to parse config data"));
+}