@owenlamont/ryl 0.4.1

package/tests/config_ignore_overrides.rs

@@ -0,0 +1,83 @@
+use std::path::PathBuf;
+
+use ryl::config::{Overrides, discover_config_with};
+
+#[path = "common/mod.rs"]
+mod common;
+use common::fake_env::FakeEnv;
+
+#[test]
+fn child_ignore_patterns_replace_parent_entries() {
+    let root = PathBuf::from("/workspace");
+    let base_cfg = root.join("base.yml");
+    let child_cfg = root.join("child.yml");
+
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(base_cfg.clone(), "rules: {}\nignore: ['parent.yaml']\n")
+        .with_file(
+            child_cfg.clone(),
+            "extends: base.yml\nignore: ['child.yaml']\nrules: {}\n",
+        );
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(child_cfg),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("child config should parse");
+
+    let base_dir = ctx.base_dir.clone();
+    assert!(
+        ctx.config
+            .is_file_ignored(&base_dir.join("child.yaml"), &base_dir),
+        "child.yaml should be ignored by child config"
+    );
+    assert!(
+        !ctx.config
+            .is_file_ignored(&base_dir.join("parent.yaml"), &base_dir),
+        "parent.yaml should not use parent ignore entries"
+    );
+}
+
+#[test]
+fn child_ignore_from_file_replaces_parent_patterns() {
+    let root = PathBuf::from("/workspace");
+    let base_cfg = root.join("base.yml");
+    let child_cfg = root.join("child.yml");
+    let ignore_file = root.join("child.ignore");
+
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(base_cfg.clone(), "rules: {}\nignore: ['parent.yaml']\n")
+        .with_file(
+            child_cfg.clone(),
+            "extends: base.yml\nignore-from-file: child.ignore\nrules: {}\n",
+        )
+        .with_file(ignore_file.clone(), "child.yaml\n");
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(child_cfg),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("child config should parse");
+
+    let base_dir = ctx.base_dir.clone();
+    assert!(
+        ctx.config
+            .is_file_ignored(&base_dir.join("child.yaml"), &base_dir),
+        "child.yaml should respect child ignore-from-file entries"
+    );
+    assert!(
+        !ctx.config
+            .is_file_ignored(&base_dir.join("parent.yaml"), &base_dir),
+        "parent ignores should be replaced by child ignore-from-file"
+    );
+}

package/tests/config_indentation.rs

@@ -0,0 +1,65 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn rejects_invalid_spaces_type() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  indentation:\n    spaces: foo\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"spaces\" of \"indentation\" should be in (<class 'int'>, 'consistent')"
+    );
+}
+
+#[test]
+fn rejects_invalid_indent_sequences_type() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  indentation:\n    indent-sequences: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"indent-sequences\" of \"indentation\" should be in (<class 'bool'>, 'whatever', 'consistent')"
+    );
+}
+
+#[test]
+fn rejects_invalid_multiline_flag() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  indentation:\n    check-multi-line-strings: []\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"check-multi-line-strings\" of \"indentation\" should be bool"
+    );
+}
+
+#[test]
+fn accepts_full_configuration() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  indentation:\n    spaces: 2\n    indent-sequences: consistent\n    check-multi-line-strings: true\n",
+    )
+    .expect("configuration should parse");
+    assert!(cfg.rule_names().iter().any(|name| name == "indentation"));
+}
+
+#[test]
+fn rejects_unknown_option_key() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  indentation:\n    unexpected: true\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unexpected\" for rule \"indentation\""
+    );
+}
+
+#[test]
+fn accepts_whatever_sequence_setting() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  indentation:\n    indent-sequences: whatever\n",
+    )
+    .expect("configuration should parse");
+    assert!(cfg.rule_names().iter().any(|name| name == "indentation"));
+}

package/tests/config_invalid_globs.rs

@@ -0,0 +1,16 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn invalid_ignore_and_yaml_file_patterns_error() {
+    // '[' is an invalid glob; configuration should fail to parse.
+    let cfg = "ignore: ['[']\nyaml-files: ['[']\n";
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .unwrap_err();
+    assert!(err.contains("invalid config"));
+}

package/tests/config_invalid_types.rs

@@ -0,0 +1,19 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn invalid_types_for_ignore_and_yaml_files_error() {
+    let yaml = r#"
+ignore: { bad: 1 }
+yaml-files: { bad: 2 }
+rules: {}
+"#;
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .unwrap_err();
+    assert!(err.contains("invalid config"));
+}

package/tests/config_key_duplicates.rs

@@ -0,0 +1,34 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn error_on_non_bool_for_forbid_merge_keys() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-duplicates:\n    forbid-duplicated-merge-keys: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"forbid-duplicated-merge-keys\" of \"key-duplicates\" should be bool"
+    );
+}
+
+#[test]
+fn error_on_unknown_option() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  key-duplicates:\n    foo: true\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"foo\" for rule \"key-duplicates\""
+    );
+}
+
+#[test]
+fn error_on_non_string_option_key() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  key-duplicates:\n    1: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"key-duplicates\""
+    );
+}

package/tests/config_key_ordering.rs

@@ -0,0 +1,70 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn ignored_keys_sequence_accepts_valid_entries() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    ignored-keys: [\"name\", \"^b\"]\n",
+    )
+    .expect("config should parse");
+    let resolved = ryl::rules::key_ordering::Config::resolve(&cfg);
+    let hits = ryl::rules::key_ordering::check("b: 1\na: 1\n", &resolved);
+    assert!(
+        hits.is_empty(),
+        "ignored keys should skip enforcement: {hits:?}"
+    );
+}
+
+#[test]
+fn ignored_keys_sequence_non_string_errors() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    ignored-keys: [1]\n",
+    )
+    .expect_err("non-string sequence entries should error");
+    assert!(
+        err.contains("ignored-keys"),
+        "error should mention ignored-keys: {err}"
+    );
+}
+
+#[test]
+fn ignored_keys_sequence_invalid_regex_errors() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    ignored-keys: [\"[\"]\n",
+    )
+    .expect_err("invalid regex should error");
+    assert!(err.contains("invalid regex"), "unexpected message: {err}");
+}
+
+#[test]
+fn ignored_keys_scalar_invalid_regex_errors() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    ignored-keys: \"[\"\n",
+    )
+    .expect_err("invalid scalar regex should error");
+    assert!(err.contains("invalid regex"), "unexpected message: {err}");
+}
+
+#[test]
+fn ignored_keys_invalid_type_errors() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    ignored-keys: {bad: true}\n",
+    )
+    .expect_err("non sequence/string should error");
+    assert!(err.contains("should contain regex strings"), "{err}");
+}
+
+#[test]
+fn key_ordering_unknown_option_errors() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  key-ordering:\n    unexpected: true\n",
+    )
+    .expect_err("unknown option should error");
+    assert!(err.contains("unknown option \"unexpected\""), "{err}");
+}
+
+#[test]
+fn key_ordering_non_string_key_errors() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  key-ordering:\n    1: true\n")
+        .expect_err("non-string key should error");
+    assert!(err.contains("unknown option"), "{err}");
+}

package/tests/config_line_length.rs

@@ -0,0 +1,65 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn rejects_unknown_option() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  line-length:\n    unexpected: true\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unexpected\" for rule \"line-length\""
+    );
+}
+
+#[test]
+fn rejects_non_integer_max() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  line-length:\n    max: []\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max\" of \"line-length\" should be int"
+    );
+}
+
+#[test]
+fn rejects_non_boolean_allow_words() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  line-length:\n    allow-non-breakable-words: []\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"allow-non-breakable-words\" of \"line-length\" should be bool"
+    );
+}
+
+#[test]
+fn rejects_non_boolean_allow_inline() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  line-length:\n    allow-non-breakable-inline-mappings: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"allow-non-breakable-inline-mappings\" of \"line-length\" should be bool"
+    );
+}
+
+#[test]
+fn accepts_valid_configuration() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  line-length:\n    max: 100\n    allow-non-breakable-words: false\n    allow-non-breakable-inline-mappings: true\n",
+    )
+    .expect("configuration should parse");
+    assert!(cfg.rule_names().iter().any(|name| name == "line-length"));
+}
+
+#[test]
+fn rejects_non_string_option_key() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  line-length:\n    1: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"line-length\""
+    );
+}

package/tests/config_locale.rs

@@ -0,0 +1,111 @@
+use std::path::PathBuf;
+
+use ryl::config::{Overrides, discover_config, discover_config_with};
+
+#[path = "common/mod.rs"]
+mod common;
+use common::fake_env::FakeEnv;
+
+#[test]
+fn locale_value_is_parsed() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some("locale: en_US.UTF-8\nrules: {}\n".into()),
+        },
+    )
+    .expect("locale should parse");
+    assert_eq!(ctx.config.locale(), Some("en_US.UTF-8"));
+}
+
+#[test]
+fn locale_from_child_overrides_base() {
+    let root = PathBuf::from("/workspace");
+    let child = root.join("child.yml");
+    let base = root.join("base.yml");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(child.clone(), "locale: fr_FR.UTF-8\nextends: base.yml\n")
+        .with_exists(child.clone())
+        .with_file(base.clone(), "locale: en_US.UTF-8\n")
+        .with_exists(base.clone());
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(child),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("child locale should win");
+    assert_eq!(ctx.config.locale(), Some("fr_FR.UTF-8"));
+}
+
+#[test]
+fn locale_falls_back_to_base_when_missing() {
+    let root = PathBuf::from("/workspace");
+    let child = root.join("child.yml");
+    let base = root.join("base.yml");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(child.clone(), "extends: base.yml\n")
+        .with_exists(child.clone())
+        .with_file(base.clone(), "locale: en_US.UTF-8\n")
+        .with_exists(base.clone());
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(child),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("locale should bubble from base");
+    assert_eq!(ctx.config.locale(), Some("en_US.UTF-8"));
+}
+
+#[test]
+fn locale_non_string_errors() {
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some("locale: [1]\n".into()),
+        },
+    )
+    .expect_err("non-string locale should error");
+    assert!(err.contains("locale should be a string"));
+}
+
+#[test]
+fn locale_survives_additional_extends() {
+    let root = PathBuf::from("/workspace");
+    let cfg = root.join("config.yml");
+    let first = root.join("first.yml");
+    let second = root.join("second.yml");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(first.clone(), "locale: en_US.UTF-8\n")
+        .with_exists(first.clone())
+        .with_file(second.clone(), "rules: { extra: enable }\n")
+        .with_exists(second.clone())
+        .with_file(
+            cfg.clone(),
+            format!("extends: ['{}', '{}']\n", first.display(), second.display()),
+        )
+        .with_exists(cfg.clone());
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(cfg),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("multiple extends should parse");
+    assert_eq!(ctx.config.locale(), Some("en_US.UTF-8"));
+}

package/tests/config_merge.rs

@@ -0,0 +1,26 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn rules_merge_deep_and_replace_scalars() {
+    // Start from default (anchors: enable [scalar], comments: { level: warning } [map])
+    // Then replace anchors with a mapping and extend comments with an extra key.
+    let cfg = r#"
+extends: default
+rules:
+  anchors:
+    forbid-duplicated-anchors: true
+  comments:
+    min-spaces-from-content: 1
+    level: error
+"#;
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("parse");
+    assert!(ctx.config.rule_names().contains(&"anchors".to_string()));
+    assert!(ctx.config.rule_names().contains(&"comments".to_string()));
+}

package/tests/config_new_lines.rs

@@ -0,0 +1,89 @@
+use ryl::config::{Overrides, discover_config};
+
+fn discover_with_yaml(yaml: &str) -> Result<(), String> {
+    discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.to_string()),
+        },
+    )
+    .map(|_| ())
+}
+
+#[test]
+fn unknown_option_errors() {
+    let err = discover_with_yaml("rules:\n  new-lines:\n    foo: bar\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"foo\" for rule \"new-lines\""
+    );
+}
+
+#[test]
+fn invalid_type_value_errors() {
+    let err =
+        discover_with_yaml("rules:\n  new-lines:\n    type: invalid\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"type\" of \"new-lines\" should be in ('unix', 'dos', 'platform')"
+    );
+}
+
+#[test]
+fn invalid_type_kind_errors_on_non_string() {
+    let err =
+        discover_with_yaml("rules:\n  new-lines:\n    type: [unix]\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"type\" of \"new-lines\" should be in ('unix', 'dos', 'platform')"
+    );
+}
+
+#[test]
+fn unknown_option_reports_numeric_key() {
+    let err = discover_with_yaml("rules:\n  new-lines:\n    1: value\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"new-lines\""
+    );
+}
+
+#[test]
+fn unknown_option_reports_boolean_key() {
+    let err =
+        discover_with_yaml("rules:\n  new-lines:\n    true: value\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"true\" for rule \"new-lines\""
+    );
+}
+
+#[test]
+fn unknown_option_reports_float_key() {
+    let err = discover_with_yaml("rules:\n  new-lines:\n    1.5: value\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1.5\" for rule \"new-lines\""
+    );
+}
+
+#[test]
+fn unknown_option_reports_tagged_key() {
+    let err =
+        discover_with_yaml("rules:\n  new-lines:\n    !foo bar: value\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"Tagged(Tag { handle: \"!\", suffix: \"foo\" }, Value(String(\"bar\")))\" for rule \"new-lines\""
+    );
+}
+
+#[test]
+fn unknown_option_reports_null_key() {
+    let err =
+        discover_with_yaml("rules:\n  new-lines:\n    null: value\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"None\" for rule \"new-lines\""
+    );
+}

package/tests/config_octal_values.rs

@@ -0,0 +1,33 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn error_on_non_bool_for_forbid_implicit() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  octal-values:\n    forbid-implicit-octal: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"forbid-implicit-octal\" of \"octal-values\" should be bool"
+    );
+}
+
+#[test]
+fn error_on_unknown_option() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  octal-values:\n    foo: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"foo\" for rule \"octal-values\""
+    );
+}
+
+#[test]
+fn error_on_non_string_option_key() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  octal-values:\n    1: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"octal-values\""
+    );
+}