@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/config_ignore_overrides.rs

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

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

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

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

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

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

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

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

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

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

@@ -1,33 +0,0 @@
-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\""
-    );
-}