@owenlamont/ryl 0.4.1

package/tests/config_extends_inline.rs

@@ -0,0 +1,185 @@
+use std::path::PathBuf;
+
+use ryl::config::{Overrides, YamlLintConfig, discover_config, discover_config_with};
+
+#[path = "common/mod.rs"]
+mod common;
+use common::fake_env::FakeEnv;
+
+#[test]
+fn inline_extends_mapping_is_ignored() {
+    let yaml = "extends:\n  invalid: true\nrules: {}\n";
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect("inline config should parse");
+    assert!(ctx.config.rule_names().is_empty());
+}
+
+#[test]
+fn extends_requires_env_error() {
+    let err = YamlLintConfig::from_yaml_str("extends: child.yml\n")
+        .expect_err("extends without env should error");
+    assert!(err.contains("requires filesystem access"));
+}
+
+#[test]
+fn extends_value_non_string_is_ignored() {
+    let cfg = YamlLintConfig::from_yaml_str("extends: 123\nrules: {}\n")
+        .expect("non-string extends should be ignored");
+    assert!(cfg.rule_names().is_empty());
+}
+
+#[test]
+fn inline_extends_sequence_skips_non_strings() {
+    let yaml = "extends: [default, 1]\n";
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect("extends should allow mixed types");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "anchors"));
+}
+
+#[test]
+fn extends_sequence_missing_entry_errors() {
+    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, missing.yml]\n")
+        .with_file(base.clone(), "rules: {}\n")
+        .with_exists(child.clone())
+        .with_exists(base);
+
+    let err = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(child),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect_err("missing extended file should error");
+    assert!(err.contains("failed to read extended config"));
+}
+
+#[test]
+fn extends_invalid_yaml_propagates_error() {
+    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_file(base.clone(), "- not mapping\n")
+        .with_exists(child)
+        .with_exists(base.clone());
+
+    let err = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("child.yml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect_err("invalid yaml in extended file should propagate");
+    assert!(err.contains("invalid config"));
+}
+
+#[test]
+fn extend_prefers_absolute_paths() {
+    let root = PathBuf::from("/workspace");
+    let abs = PathBuf::from("/configs/base.yml");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(abs.clone(), "rules:\n  abs_rule: enable\n")
+        .with_exists(abs.clone());
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(format!("extends: {}\n", abs.display())),
+        },
+        &env,
+    )
+    .expect("absolute extends should resolve");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "abs_rule"));
+}
+
+#[test]
+fn extend_falls_back_to_env_cwd_when_base_dir_missing_entry() {
+    let cwd = PathBuf::from("/env-cwd");
+    let project = PathBuf::from("/project");
+    let cli_cfg = project.join("child.yml");
+    let env = FakeEnv::new()
+        .with_cwd(cwd.clone())
+        .with_file(cli_cfg.clone(), "extends: config.yml\n")
+        .with_exists(cli_cfg.clone())
+        .with_file(cwd.join("config.yml"), "rules:\n  cwd_rule: enable\n")
+        .with_exists(cwd.join("config.yml"));
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(cli_cfg),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("extend should fall back to cwd");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "cwd_rule"));
+}
+
+#[test]
+fn extend_empty_entry_uses_candidate_path() {
+    let root = PathBuf::from("/workspace");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(PathBuf::from(""), "rules: {}\n");
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some("extends: ''\n".into()),
+        },
+        &env,
+    )
+    .expect("empty extends should resolve using candidate path");
+    assert!(ctx.config.rule_names().is_empty());
+}
+
+#[test]
+fn extend_relative_entry_uses_base_directory() {
+    let project = PathBuf::from("/workspace/project");
+    let child = project.join("child.yml");
+    let base = project.join("base.yml");
+    let env = FakeEnv::new()
+        .with_cwd(project.clone())
+        .with_file(child.clone(), "extends: base.yml\n")
+        .with_exists(child.clone())
+        .with_file(base.clone(), "rules: { base_rule: enable }\n")
+        .with_exists(base.clone());
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(child),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("relative extends should resolve using config directory");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "base_rule"));
+}

package/tests/config_extends_sequence.rs

@@ -0,0 +1,18 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn extends_sequence_merges_presets_in_order() {
+    let cfg = "extends: [default, relaxed]\n";
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("parse");
+    // From default
+    assert!(ctx.config.rule_names().contains(&"anchors".to_string()));
+    // From relaxed override
+    assert!(ctx.config.rule_names().contains(&"braces".to_string()));
+}

package/tests/config_find_project_home_boundary.rs

@@ -0,0 +1,54 @@
+use std::path::{Path, PathBuf};
+
+use ryl::config::{Overrides, discover_config_with};
+
+#[path = "common/mod.rs"]
+mod common;
+use common::fake_env::FakeEnv;
+
+#[test]
+fn project_search_respects_home_boundary() {
+    let env = FakeEnv::new()
+        .with_cwd(PathBuf::from("/workspace"))
+        .with_var("HOME", "/workspace/userhome".to_string())
+        .with_exists(PathBuf::from("/workspace/.yamllint"))
+        .with_file(
+            PathBuf::from("/workspace/.yamllint"),
+            "rules: { custom: enable }\n",
+        );
+
+    let ctx = discover_config_with(
+        &[PathBuf::from("/workspace/userhome/project/file.yaml")],
+        &Overrides::default(),
+        &env,
+    )
+    .expect("config discovery should succeed");
+    assert!(ctx.source.is_none(), "project config should not cross HOME");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "anchors"));
+    assert!(!ctx.config.rule_names().iter().any(|r| r == "custom"));
+}
+
+#[test]
+fn project_search_supports_relative_home() {
+    let env = FakeEnv::new()
+        .with_cwd(PathBuf::from("/workspace"))
+        .with_var("HOME", "userhome".to_string())
+        .with_file(
+            PathBuf::from("/workspace/userhome/.yamllint"),
+            "rules: { rel: enable }\n",
+        )
+        .with_exists(PathBuf::from("/workspace/userhome/.yamllint"))
+        .with_exists(PathBuf::from("/workspace/userhome/project/file.yaml"));
+
+    let ctx = discover_config_with(
+        &[PathBuf::from("/workspace/userhome/project/file.yaml")],
+        &Overrides::default(),
+        &env,
+    )
+    .expect("relative HOME should be joined with cwd");
+    assert_eq!(
+        ctx.source.as_deref(),
+        Some(Path::new("/workspace/userhome/.yamllint"))
+    );
+    assert!(ctx.config.rule_names().iter().any(|r| r == "rel"));
+}

package/tests/config_find_project_two_files_in_cwd.rs

@@ -0,0 +1,47 @@
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+
+struct FakeEnv {
+    exists: HashSet<PathBuf>,
+}
+
+impl ryl::config::Env for FakeEnv {
+    fn current_dir(&self) -> PathBuf {
+        PathBuf::from(".")
+    }
+    fn config_dir(&self) -> Option<PathBuf> {
+        None
+    }
+    fn read_to_string(&self, p: &Path) -> Result<String, String> {
+        if p == Path::new(".yamllint") {
+            Ok("rules: {}\n".into())
+        } else {
+            Err("no".into())
+        }
+    }
+    fn path_exists(&self, p: &Path) -> bool {
+        self.exists.contains(p)
+    }
+    fn home_dir(&self) -> Option<PathBuf> {
+        None
+    }
+    fn env_var(&self, _key: &str) -> Option<String> {
+        None
+    }
+}
+
+#[test]
+fn project_config_search_dedups_multiple_files_without_parent() {
+    let mut envx = FakeEnv {
+        exists: HashSet::new(),
+    };
+    envx.exists.insert(PathBuf::from(".yamllint"));
+    let inputs = vec![PathBuf::from("a.yml"), PathBuf::from("b.yml")];
+    let ctx = ryl::config::discover_config_with(
+        &inputs,
+        &ryl::config::Overrides::default(),
+        &envx,
+    )
+    .expect("ok");
+    assert_eq!(ctx.source.as_deref(), Some(Path::new(".yamllint")));
+}

package/tests/config_float_values.rs

@@ -0,0 +1,34 @@
+use ryl::config::YamlLintConfig;
+
+#[test]
+fn error_on_non_bool_require_numeral() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  float-values:\n    require-numeral-before-decimal: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"require-numeral-before-decimal\" of \"float-values\" should be bool"
+    );
+}
+
+#[test]
+fn error_on_unknown_option() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  float-values:\n    minimum: true\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"minimum\" for rule \"float-values\""
+    );
+}
+
+#[test]
+fn error_on_non_string_option_key() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  float-values:\n    1: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"float-values\""
+    );
+}

package/tests/config_from_yaml_paths.rs

@@ -0,0 +1,32 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn from_yaml_str_covers_ignore_yamlfiles_and_rules_paths() {
+    let yaml = r#"
+extends: default
+locale: en_US
+ignore:
+  - "a.yml"
+  - "b.yaml"
+yaml-files:
+  - "*.yml"
+rules:
+  new_rule: { enabled: true }
+"#;
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect("config parse");
+
+    let pats = ctx.config.ignore_patterns();
+    assert!(pats.iter().any(|p| p == "a.yml"));
+    assert!(pats.iter().any(|p| p == "b.yaml"));
+
+    assert!(ctx.config.rule_names().iter().any(|n| n == "new_rule"));
+    assert!(ctx.config.rule_names().iter().any(|n| n == "anchors"));
+    assert_eq!(ctx.config.locale(), Some("en_US"));
+}

package/tests/config_hyphens.rs

@@ -0,0 +1,51 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::hyphens::Config;
+
+#[test]
+fn rejects_unknown_option() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  hyphens:\n    unexpected: true\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unexpected\" for rule \"hyphens\""
+    );
+}
+
+#[test]
+fn rejects_non_integer_max_spaces_after() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  hyphens:\n    max-spaces-after: []\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"max-spaces-after\" of \"hyphens\" should be int"
+    );
+}
+
+#[test]
+fn resolve_uses_default_when_option_missing() {
+    let cfg = YamlLintConfig::from_yaml_str("rules:\n  hyphens: enable\n")
+        .expect("parse config");
+    let resolved = Config::resolve(&cfg);
+    assert_eq!(resolved.max_spaces_after(), 1);
+}
+
+#[test]
+fn resolve_reads_configured_value() {
+    let cfg =
+        YamlLintConfig::from_yaml_str("rules:\n  hyphens:\n    max-spaces-after: 4\n")
+            .expect("parse config");
+    let resolved = Config::resolve(&cfg);
+    assert_eq!(resolved.max_spaces_after(), 4);
+}
+
+#[test]
+fn rejects_non_string_option_key() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  hyphens:\n    1: true\n").unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"hyphens\""
+    );
+}

package/tests/config_ignore_errors.rs

@@ -0,0 +1,243 @@
+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 ignore_and_ignore_from_file_conflict_errors() {
+    let yaml = "ignore: ['a']\nignore-from-file: ['b']\n";
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect_err("conflicting ignore keys should error");
+    assert!(err.contains("cannot be used together"));
+}
+
+#[test]
+fn ignore_from_file_non_string_errors() {
+    let yaml = "ignore-from-file: [1]\n";
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect_err("non-string ignore-from-file entries should fail");
+    assert!(err.contains("ignore-from-file"));
+}
+
+#[test]
+fn ignore_from_file_invalid_mapping_errors() {
+    let yaml = "ignore-from-file: { bad: 1 }\n";
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect_err("mapping value should error");
+    assert!(err.contains("ignore-from-file should contain"));
+}
+
+#[test]
+fn ignore_patterns_non_string_errors() {
+    let yaml = "ignore: [1]\n";
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect_err("non-string ignore pattern should error");
+    assert!(err.contains("ignore should contain"));
+}
+
+#[test]
+fn ignore_from_file_patterns_are_loaded() {
+    let root = PathBuf::from("/workspace");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(root.join("cfg.yaml"), "ignore-from-file: .gitignore\n")
+        .with_exists(root.join("cfg.yaml"))
+        .with_file(root.join(".gitignore"), "vendor/**\n")
+        .with_exists(root.join(".gitignore"));
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("cfg.yaml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("ignore-from-file should hydrate patterns");
+    assert!(
+        ctx.config
+            .ignore_patterns()
+            .iter()
+            .any(|p| p == "vendor/**")
+    );
+}
+
+#[test]
+fn missing_ignore_from_file_errors() {
+    let root = PathBuf::from("/workspace");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(root.join("cfg.yaml"), "ignore-from-file: missing.txt\n")
+        .with_exists(root.join("cfg.yaml"));
+
+    let err = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("cfg.yaml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect_err("missing ignore file should error");
+    assert!(err.contains("failed to read ignore-from-file"));
+}
+
+#[test]
+fn invalid_ignore_from_file_pattern_errors() {
+    let root = PathBuf::from("/workspace");
+    let ignore = root.join("rules.ignore");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(root.join("cfg.yaml"), "ignore-from-file: rules.ignore\n")
+        .with_exists(root.join("cfg.yaml"))
+        .with_file(ignore.clone(), "[\n")
+        .with_exists(ignore);
+
+    let err = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("cfg.yaml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect_err("invalid glob should bubble up");
+    assert!(err.contains("invalid config: ignore-from-file pattern"));
+}
+
+#[test]
+fn ignore_block_scalar_skips_blank_lines() {
+    let yaml = "ignore: |\n  docs/**\n\n  build/\nrules: {}\n";
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect("block scalar ignore should parse");
+    assert!(
+        !ctx.config
+            .ignore_patterns()
+            .iter()
+            .any(|p| p.trim().is_empty())
+    );
+}
+
+#[test]
+fn ignore_blank_entries_are_removed() {
+    let yaml = "ignore: ['   ', 'tmp/**']\nrules: {}\n";
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(yaml.into()),
+        },
+    )
+    .expect("blank ignore entries should be skipped");
+    assert_eq!(ctx.config.ignore_patterns().len(), 1);
+    assert_eq!(ctx.config.ignore_patterns()[0], "tmp/**");
+}
+
+#[test]
+fn ignore_from_file_blank_lines_are_skipped() {
+    let root = PathBuf::from("/workspace");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(root.join("cfg.yaml"), "ignore-from-file: rules.ignore\n")
+        .with_exists(root.join("cfg.yaml"))
+        .with_file(root.join("rules.ignore"), "\nlogs/**\n\n")
+        .with_exists(root.join("rules.ignore"));
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("cfg.yaml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("blank lines in ignore-from-file should be ignored");
+    assert!(ctx.config.ignore_patterns().iter().any(|p| p == "logs/**"));
+}
+
+#[test]
+fn ignore_from_file_sequence_is_supported() {
+    let root = PathBuf::from("/workspace");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(
+            root.join("cfg.yaml"),
+            "ignore-from-file: ['a.ignore', 'b.ignore']\n",
+        )
+        .with_exists(root.join("cfg.yaml"))
+        .with_file(root.join("a.ignore"), "a/**\n")
+        .with_exists(root.join("a.ignore"))
+        .with_file(root.join("b.ignore"), "b/**\n")
+        .with_exists(root.join("b.ignore"));
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("cfg.yaml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("sequence of ignore-from-file entries should parse");
+    assert!(ctx.config.ignore_patterns().iter().any(|p| p == "a/**"));
+    assert!(ctx.config.ignore_patterns().iter().any(|p| p == "b/**"));
+}
+
+#[test]
+fn ignore_from_file_absolute_paths_are_supported() {
+    let root = PathBuf::from("/workspace");
+    let abs = PathBuf::from("/workspace/.abs-ignore");
+    let env = FakeEnv::new()
+        .with_cwd(root.clone())
+        .with_file(
+            root.join("cfg.yaml"),
+            format!("ignore-from-file: {}\n", abs.display()),
+        )
+        .with_exists(root.join("cfg.yaml"))
+        .with_file(abs.clone(), "abs/**\n")
+        .with_exists(abs);
+
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(root.join("cfg.yaml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .expect("absolute ignore-from-file paths should resolve");
+    assert!(ctx.config.ignore_patterns().iter().any(|p| p == "abs/**"));
+}