@owenlamont/ryl 0.4.1

package/tests/config_braces.rs

@@ -0,0 +1,121 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::braces::{Config as BracesConfig, Forbid};
+
+fn parse_config(input: &str) -> YamlLintConfig {
+    YamlLintConfig::from_yaml_str(input).expect("config should parse")
+}
+
+#[test]
+fn braces_options_are_parsed() {
+    let cfg = parse_config(
+        "rules:\n  braces:\n    forbid: non-empty\n    min-spaces-inside: 1\n    max-spaces-inside: 2\n    min-spaces-inside-empty: 3\n    max-spaces-inside-empty: 4\n",
+    );
+
+    let rule_cfg = BracesConfig::resolve(&cfg);
+    assert_eq!(rule_cfg.forbid(), Forbid::NonEmpty);
+    assert_eq!(rule_cfg.min_spaces_inside(), 1);
+    assert_eq!(rule_cfg.max_spaces_inside(), 2);
+    assert_eq!(rule_cfg.effective_min_empty(), 3);
+    assert_eq!(rule_cfg.effective_max_empty(), 4);
+}
+
+#[test]
+fn braces_empty_overrides_fallback_to_main_values() {
+    let cfg = parse_config(
+        "rules:\n  braces:\n    min-spaces-inside: 2\n    max-spaces-inside: 3\n",
+    );
+
+    let rule_cfg = BracesConfig::resolve(&cfg);
+    assert_eq!(rule_cfg.effective_min_empty(), 2);
+    assert_eq!(rule_cfg.effective_max_empty(), 3);
+}
+
+#[test]
+fn braces_invalid_forbid_value_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  braces:\n    forbid: maybe\n")
+        .expect_err("config should fail");
+    assert!(
+        err.contains("option \"forbid\" of \"braces\" should be bool or \"non-empty\""),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn braces_invalid_numeric_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  braces:\n    min-spaces-inside: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains("option \"min-spaces-inside\" of \"braces\" should be int"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn braces_invalid_max_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  braces:\n    max-spaces-inside: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains("option \"max-spaces-inside\" of \"braces\" should be int"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn braces_invalid_empty_max_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  braces:\n    max-spaces-inside-empty: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains("option \"max-spaces-inside-empty\" of \"braces\" should be int"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn braces_invalid_empty_min_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  braces:\n    min-spaces-inside-empty: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains("option \"min-spaces-inside-empty\" of \"braces\" should be int"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn braces_unknown_string_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  braces:\n    unexpected-option: true\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains(
+            "invalid config: unknown option \"unexpected-option\" for rule \"braces\""
+        ),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn braces_non_string_key_reports_error() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  braces:\n    1: true\n")
+        .expect_err("config should fail");
+    assert!(
+        err.contains("invalid config: unknown option \"1\" for rule \"braces\""),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn forbid_false_maps_to_none() {
+    let cfg = parse_config("rules:\n  braces:\n    forbid: false\n");
+
+    let rule_cfg = BracesConfig::resolve(&cfg);
+    assert_eq!(rule_cfg.forbid(), Forbid::None);
+}

package/tests/config_brackets.rs

@@ -0,0 +1,127 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::brackets::{Config as BracketsConfig, Forbid};
+
+fn parse_config(input: &str) -> YamlLintConfig {
+    YamlLintConfig::from_yaml_str(input).expect("config should parse")
+}
+
+#[test]
+fn brackets_options_are_parsed() {
+    let cfg = parse_config(
+        "rules:\n  brackets:\n    forbid: non-empty\n    min-spaces-inside: 1\n    max-spaces-inside: 2\n    min-spaces-inside-empty: 3\n    max-spaces-inside-empty: 4\n",
+    );
+
+    let rule_cfg = BracketsConfig::resolve(&cfg);
+    assert_eq!(rule_cfg.forbid(), Forbid::NonEmpty);
+    assert_eq!(rule_cfg.min_spaces_inside(), 1);
+    assert_eq!(rule_cfg.max_spaces_inside(), 2);
+    assert_eq!(rule_cfg.effective_min_empty(), 3);
+    assert_eq!(rule_cfg.effective_max_empty(), 4);
+}
+
+#[test]
+fn brackets_empty_overrides_fallback_to_main_values() {
+    let cfg = parse_config(
+        "rules:\n  brackets:\n    min-spaces-inside: 2\n    max-spaces-inside: 3\n",
+    );
+
+    let rule_cfg = BracketsConfig::resolve(&cfg);
+    assert_eq!(rule_cfg.effective_min_empty(), 2);
+    assert_eq!(rule_cfg.effective_max_empty(), 3);
+}
+
+#[test]
+fn brackets_invalid_forbid_value_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  brackets:\n    forbid: maybe\n")
+        .expect_err("config should fail");
+    assert!(
+        err.contains(
+            "option \"forbid\" of \"brackets\" should be bool or \"non-empty\""
+        ),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn brackets_invalid_numeric_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  brackets:\n    min-spaces-inside: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains("option \"min-spaces-inside\" of \"brackets\" should be int"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn brackets_invalid_max_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  brackets:\n    max-spaces-inside: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains("option \"max-spaces-inside\" of \"brackets\" should be int"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn brackets_invalid_empty_max_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  brackets:\n    max-spaces-inside-empty: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains(
+            "option \"max-spaces-inside-empty\" of \"brackets\" should be int"
+        ),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn brackets_invalid_empty_min_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  brackets:\n    min-spaces-inside-empty: foo\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains(
+            "option \"min-spaces-inside-empty\" of \"brackets\" should be int"
+        ),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn brackets_unknown_string_option_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  brackets:\n    unexpected-option: true\n",
+    )
+    .expect_err("config should fail");
+    assert!(
+        err.contains(
+            "invalid config: unknown option \"unexpected-option\" for rule \"brackets\""
+        ),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn brackets_non_string_key_reports_error() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  brackets:\n    1: true\n")
+        .expect_err("config should fail");
+    assert!(
+        err.contains("invalid config: unknown option \"1\" for rule \"brackets\""),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn forbid_false_maps_to_none() {
+    let cfg = parse_config("rules:\n  brackets:\n    forbid: false\n");
+
+    let rule_cfg = BracketsConfig::resolve(&cfg);
+    assert_eq!(rule_cfg.forbid(), Forbid::None);
+}

package/tests/config_commas.rs

@@ -0,0 +1,79 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::commas::Config;
+
+#[test]
+fn rejects_unknown_option() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  commas:\n    unexpected: 1\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unexpected\" for rule \"commas\""
+    );
+}
+
+#[test]
+fn rejects_non_integer_max_spaces_before() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  commas:\n    max-spaces-before: []\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max-spaces-before\" of \"commas\" should be int"
+    );
+}
+
+#[test]
+fn rejects_non_integer_min_spaces_after() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  commas:\n    min-spaces-after: true\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"min-spaces-after\" of \"commas\" should be int"
+    );
+}
+
+#[test]
+fn rejects_non_integer_max_spaces_after() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  commas:\n    max-spaces-after: []\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max-spaces-after\" of \"commas\" should be int"
+    );
+}
+
+#[test]
+fn rejects_non_string_option_key() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  commas:\n    ? [foo, bar]\n    : 1\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"Sequence([Value(String(\"foo\")), Value(String(\"bar\"))])\" for rule \"commas\""
+    );
+}
+
+#[test]
+fn resolve_uses_default_values() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  commas: enable\n")
+        .expect("parse config");
+    let resolved = Config::resolve(&cfg);
+    assert_eq!(resolved.max_spaces_before(), 0);
+    assert_eq!(resolved.min_spaces_after(), 1);
+    assert_eq!(resolved.max_spaces_after(), 1);
+}
+
+#[test]
+fn resolve_reads_configured_values() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  commas:\n    max-spaces-before: 2\n    min-spaces-after: 0\n    max-spaces-after: -1\n",
+    )
+    .expect("parse config");
+    let resolved = Config::resolve(&cfg);
+    assert_eq!(resolved.max_spaces_before(), 2);
+    assert_eq!(resolved.min_spaces_after(), 0);
+    assert_eq!(resolved.max_spaces_after(), -1);
+}

package/tests/config_comments.rs

@@ -0,0 +1,65 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn rejects_unknown_option() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  comments:\n    unexpected: true\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unexpected\" for rule \"comments\""
+    );
+}
+
+#[test]
+fn rejects_non_bool_require_starting_space() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  comments:\n    require-starting-space: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"require-starting-space\" of \"comments\" should be bool"
+    );
+}
+
+#[test]
+fn rejects_non_bool_ignore_shebangs() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  comments:\n    ignore-shebangs: []\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"ignore-shebangs\" of \"comments\" should be bool"
+    );
+}
+
+#[test]
+fn rejects_non_integer_min_spaces() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  comments:\n    min-spaces-from-content: true\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"min-spaces-from-content\" of \"comments\" should be int"
+    );
+}
+
+#[test]
+fn accepts_valid_configuration() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  comments:\n    require-starting-space: false\n    ignore-shebangs: false\n    min-spaces-from-content: 4\n",
+    )
+    .expect("configuration should parse");
+    assert!(cfg.rule_names().iter().any(|name| name == "comments"));
+}
+
+#[test]
+fn accepts_negative_min_spaces() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  comments:\n    min-spaces-from-content: -1\n",
+    )
+    .expect("configuration should parse");
+    assert!(cfg.rule_names().iter().any(|name| name == "comments"));
+}

package/tests/config_comments_indentation.rs

@@ -0,0 +1,20 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn error_on_unknown_option() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  comments-indentation:\n    foo: true\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"foo\" for rule \"comments-indentation\""
+    );
+}
+
+#[test]
+fn accepts_boolean_toggle() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  comments-indentation: false\n")
+        .expect("config should parse");
+    assert!(cfg.rule_level("comments-indentation").is_none());
+}

package/tests/config_deep_merge_nonstring_key.rs

@@ -0,0 +1,24 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn deep_merge_skips_non_string_inner_keys() {
+    // default has `comments` as a mapping; we override with a mapping that contains
+    // a non-string key to trigger `continue` inside deep_merge_yaml_owned.
+    let cfg = r#"
+extends: default
+rules:
+  comments:
+    ? [1, 2]
+    : 9
+    level: error
+"#;
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("parse");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "comments"));
+}

package/tests/config_document_end.rs

@@ -0,0 +1,54 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::document_end::Config;
+
+#[test]
+fn resolve_defaults_to_present_true() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  document-end: enable\n")
+        .expect("config parses");
+    let rule_cfg = Config::resolve(&cfg);
+    assert!(rule_cfg.requires_marker(), "default should require marker");
+}
+
+#[test]
+fn resolve_reads_present_override() {
+    let cfg =
+        YamlLintConfig::from_yaml_str("rules:\n  document-end:\n    present: false\n")
+            .expect("config parses");
+    let rule_cfg = Config::resolve(&cfg);
+    assert!(
+        !rule_cfg.requires_marker(),
+        "override should disable marker"
+    );
+}
+
+#[test]
+fn invalid_present_value_is_rejected() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  document-end:\n    present: 1\n")
+            .expect_err("invalid bool should fail");
+    assert_eq!(
+        err,
+        "invalid config: option \"present\" of \"document-end\" should be bool"
+    );
+}
+
+#[test]
+fn unknown_option_is_rejected() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  document-end:\n    extra: true\n")
+            .expect_err("unknown option should fail");
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"extra\" for rule \"document-end\""
+    );
+}
+
+#[test]
+fn non_string_option_key_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  document-end:\n    1: true\n")
+        .expect_err("non string key should fail");
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"document-end\""
+    );
+}

package/tests/config_document_start.rs

@@ -0,0 +1,55 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::document_start::Config;
+
+#[test]
+fn resolve_defaults_to_present_true() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  document-start: enable\n")
+        .expect("config parses");
+    let rule_cfg = Config::resolve(&cfg);
+    assert!(rule_cfg.requires_marker(), "default should require marker");
+}
+
+#[test]
+fn resolve_reads_present_override() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  document-start:\n    present: false\n",
+    )
+    .expect("config parses");
+    let rule_cfg = Config::resolve(&cfg);
+    assert!(
+        !rule_cfg.requires_marker(),
+        "override should disable marker"
+    );
+}
+
+#[test]
+fn invalid_present_value_is_rejected() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  document-start:\n    present: 1\n")
+            .expect_err("invalid bool should fail");
+    assert_eq!(
+        err,
+        "invalid config: option \"present\" of \"document-start\" should be bool"
+    );
+}
+
+#[test]
+fn unknown_option_is_rejected() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  document-start:\n    extra: true\n")
+            .expect_err("unknown option should fail");
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"extra\" for rule \"document-start\""
+    );
+}
+
+#[test]
+fn non_string_option_key_is_rejected() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  document-start:\n    1: true\n")
+        .expect_err("non string key should fail");
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"document-start\""
+    );
+}

package/tests/config_empty_lines.rs

@@ -0,0 +1,48 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn error_on_non_integer_limits() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  empty-lines:\n    max: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max\" of \"empty-lines\" should be int"
+    );
+
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  empty-lines:\n    max-start: false\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max-start\" of \"empty-lines\" should be int"
+    );
+
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  empty-lines:\n    max-end: false\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max-end\" of \"empty-lines\" should be int"
+    );
+}
+
+#[test]
+fn error_on_unknown_option() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  empty-lines:\n    unexpected: 3\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unexpected\" for rule \"empty-lines\""
+    );
+}
+
+#[test]
+fn error_on_non_string_option_key() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  empty-lines:\n    1: 2\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"empty-lines\""
+    );
+}

package/tests/config_empty_values.rs

@@ -0,0 +1,35 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn error_on_non_bool_block_mapping_option() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  empty-values:\n    forbid-in-block-mappings: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"forbid-in-block-mappings\" of \"empty-values\" should be bool"
+    );
+}
+
+#[test]
+fn error_on_unknown_option() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  empty-values:\n    unsupported: true\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unsupported\" for rule \"empty-values\""
+    );
+}
+
+#[test]
+fn error_on_non_string_option_key() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  empty-values:\n    1: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"empty-values\""
+    );
+}

package/tests/config_env_errors.rs

@@ -0,0 +1,23 @@
+use std::fs;
+
+use ryl::config::{Overrides, discover_config_with_env};
+use tempfile::tempdir;
+
+#[test]
+fn env_points_to_unreadable_path_errors() {
+    let td = tempdir().unwrap();
+    let dir = td.path().join("cfgdir");
+    fs::create_dir_all(&dir).unwrap();
+    let inputs = vec![dir.join("input.yaml")];
+    let res = discover_config_with_env(&inputs, &Overrides::default(), &|k| {
+        if k == "YAMLLINT_CONFIG_FILE" {
+            Some(dir.display().to_string())
+        } else {
+            None
+        }
+    });
+    assert!(
+        res.is_err(),
+        "expected error when env points to a directory, got {res:?}"
+    );
+}

package/tests/config_env_invalid_inline.rs

@@ -0,0 +1,15 @@
+use ryl::config::{Overrides, discover_config_with_env};
+
+#[test]
+fn invalid_inline_data_errors_in_discover_config_with_env() {
+    let inputs: Vec<std::path::PathBuf> = vec![];
+    let res = discover_config_with_env(
+        &inputs,
+        &Overrides {
+            config_file: None,
+            config_data: Some("rules: {".into()),
+        },
+        &|_| None,
+    );
+    assert!(res.is_err());
+}