@owenlamont/ryl 0.4.1

package/tests/config_env_missing.rs

@@ -0,0 +1,63 @@
+use std::fs;
+
+use ryl::config::{Env, Overrides, SystemEnv, discover_config_with_env};
+use tempfile::tempdir;
+
+#[test]
+fn env_points_to_missing_file_is_ignored() {
+    let workspace = tempdir().unwrap();
+    let inputs = vec![workspace.path().join("input.yaml")];
+    let ctx = discover_config_with_env(&inputs, &Overrides::default(), &|k| {
+        if k == "YAMLLINT_CONFIG_FILE" {
+            Some("/tmp/this/does/not/exist.yml".into())
+        } else {
+            None
+        }
+    })
+    .expect("discover should succeed");
+    // Missing env config falls back to default preset
+    assert!(ctx.source.is_none());
+    assert!(ctx.config.rule_names().iter().any(|r| r == "anchors"));
+}
+
+#[test]
+fn env_tilde_path_uses_closure_home_dir() {
+    let dir = tempdir().unwrap();
+    let config_path = dir
+        .path()
+        .join(".config")
+        .join("yamllint")
+        .join("custom.yml");
+    fs::create_dir_all(config_path.parent().unwrap()).unwrap();
+    fs::write(&config_path, "rules: {}\n").unwrap();
+
+    let project_root = dir.path().join("workspace");
+    fs::create_dir_all(&project_root).unwrap();
+    let inputs = vec![project_root.join("input.yaml")];
+    let ctx = discover_config_with_env(&inputs, &Overrides::default(), &|k| match k {
+        "YAMLLINT_CONFIG_FILE" => Some("~/.config/yamllint/custom.yml".into()),
+        "HOME" => Some(dir.path().to_str().unwrap().into()),
+        _ => None,
+    })
+    .expect("discover should succeed");
+
+    assert_eq!(ctx.source.as_deref(), Some(config_path.as_path()));
+}
+
+#[test]
+fn env_tilde_path_without_home_falls_back_to_system_home() {
+    let workspace = tempdir().unwrap();
+    let inputs = vec![workspace.path().join("input.yaml")];
+    let _ = SystemEnv.home_dir();
+    let ctx = discover_config_with_env(&inputs, &Overrides::default(), &|k| {
+        if k == "YAMLLINT_CONFIG_FILE" {
+            Some("~/.config/yamllint/missing.yml".into())
+        } else {
+            None
+        }
+    })
+    .expect("discover should succeed");
+
+    // No config file found; default preset applies.
+    assert!(ctx.source.is_none());
+}

package/tests/config_env_shim.rs

@@ -0,0 +1,301 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+use ryl::config::{
+    Env, Overrides, SystemEnv, discover_config_with, discover_per_file_with,
+};
+use tempfile::tempdir;
+
+#[derive(Default)]
+struct FakeEnv {
+    cwd: PathBuf,
+    cfg_dir: Option<PathBuf>,
+    files: HashMap<PathBuf, String>,
+    exists: HashSet<PathBuf>,
+    vars: HashMap<String, String>,
+    home: Option<PathBuf>,
+}
+
+impl FakeEnv {
+    fn with_cwd(mut self, p: impl Into<PathBuf>) -> Self {
+        self.cwd = p.into();
+        self
+    }
+    fn with_config_dir(mut self, p: impl Into<PathBuf>) -> Self {
+        self.cfg_dir = Some(p.into());
+        self
+    }
+    fn add_file(mut self, p: impl Into<PathBuf>, content: impl Into<String>) -> Self {
+        self.files.insert(p.into(), content.into());
+        self
+    }
+    fn add_exist(mut self, p: impl Into<PathBuf>) -> Self {
+        self.exists.insert(p.into());
+        self
+    }
+    fn set_var(mut self, k: impl Into<String>, v: impl Into<String>) -> Self {
+        self.vars.insert(k.into(), v.into());
+        self
+    }
+    fn with_home(mut self, p: impl Into<PathBuf>) -> Self {
+        self.home = Some(p.into());
+        self
+    }
+}
+
+impl Env for FakeEnv {
+    fn current_dir(&self) -> PathBuf {
+        self.cwd.clone()
+    }
+    fn config_dir(&self) -> Option<PathBuf> {
+        self.cfg_dir.clone()
+    }
+    fn read_to_string(&self, p: &Path) -> Result<String, String> {
+        self.files.get(p).cloned().ok_or_else(|| {
+            format!("failed to read config file {}: not found", p.display())
+        })
+    }
+    fn path_exists(&self, p: &Path) -> bool {
+        self.files.contains_key(p) || self.exists.contains(p)
+    }
+    fn env_var(&self, key: &str) -> Option<String> {
+        self.vars.get(key).cloned()
+    }
+    fn home_dir(&self) -> Option<PathBuf> {
+        self.home
+            .clone()
+            .or_else(|| self.vars.get("HOME").map(PathBuf::from))
+            .or_else(|| self.vars.get("USERPROFILE").map(PathBuf::from))
+    }
+}
+
+fn cfg_rules_empty() -> String {
+    "rules: {}\n".to_string()
+}
+
+#[test]
+fn shim_inline_config_path() {
+    let env = FakeEnv::default().with_cwd("/home/user");
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg_rules_empty()),
+        },
+        &env,
+    )
+    .unwrap();
+    assert!(ctx.config.rule_names().is_empty());
+    assert_eq!(ctx.base_dir, PathBuf::from("/home/user"));
+    assert!(ctx.source.is_none());
+}
+
+#[test]
+fn shim_file_config_path_with_parent_none_uses_cwd() {
+    let env = FakeEnv::default()
+        .with_cwd("/work")
+        .add_file("", cfg_rules_empty());
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(PathBuf::from("")),
+            config_data: None,
+        },
+        &env,
+    )
+    .unwrap();
+    assert_eq!(ctx.base_dir, PathBuf::from("/work"));
+    assert_eq!(ctx.source.unwrap(), PathBuf::from(""));
+}
+
+#[test]
+fn shim_env_var_points_to_file_base_dir_from_cwd() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .add_file("", cfg_rules_empty())
+        .set_var("YAMLLINT_CONFIG_FILE", "");
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(ctx.base_dir, PathBuf::from("/tmp/cwd"));
+    assert_eq!(ctx.source.unwrap(), PathBuf::from(""));
+}
+
+#[test]
+fn shim_env_var_with_tilde_expands_home() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .with_home("/home/tester")
+        .set_var("YAMLLINT_CONFIG_FILE", "~/.config/yamllint/custom.yml")
+        .add_file(
+            "/home/tester/.config/yamllint/custom.yml",
+            cfg_rules_empty(),
+        );
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(
+        ctx.source.unwrap(),
+        PathBuf::from("/home/tester/.config/yamllint/custom.yml")
+    );
+}
+
+#[test]
+fn shim_env_var_tilde_alone_uses_home_directory() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .with_home("/home/tester")
+        .set_var("YAMLLINT_CONFIG_FILE", "~")
+        .add_file("/home/tester", cfg_rules_empty());
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(ctx.source.unwrap(), PathBuf::from("/home/tester"));
+}
+
+#[test]
+fn shim_env_var_tilde_without_home_keeps_literal_path() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .set_var("YAMLLINT_CONFIG_FILE", "~/.config/yamllint/custom.yml")
+        .add_file("~/.config/yamllint/custom.yml", cfg_rules_empty());
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(
+        ctx.source.unwrap(),
+        PathBuf::from("~/.config/yamllint/custom.yml")
+    );
+}
+
+#[test]
+fn system_env_home_dir_accessible() {
+    let env = SystemEnv;
+    let _ = env.home_dir();
+}
+
+#[test]
+fn shim_env_var_userprofile_handles_windows_tilde_backslash() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .set_var("USERPROFILE", "/profiles/user")
+        .set_var("YAMLLINT_CONFIG_FILE", "~\\config.yml")
+        .add_file("/profiles/user/config.yml", cfg_rules_empty());
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(
+        ctx.source.unwrap(),
+        PathBuf::from("/profiles/user/config.yml")
+    );
+}
+
+#[test]
+fn shim_project_config_discovered_from_inputs() {
+    let env = FakeEnv::default()
+        .with_cwd("/wd")
+        .add_file("/proj/.yamllint", cfg_rules_empty())
+        .add_exist("/proj/.yamllint")
+        .add_exist("/proj/file.yaml");
+    let ctx = discover_config_with(
+        &[PathBuf::from("/proj/file.yaml")],
+        &Overrides::default(),
+        &env,
+    )
+    .unwrap();
+    assert_eq!(ctx.base_dir, PathBuf::from("/proj"));
+    assert!(ctx.source.unwrap().ends_with(".yamllint"));
+}
+
+#[test]
+fn shim_user_global_config_applies_when_no_project_or_env() {
+    let env = FakeEnv::default()
+        .with_cwd("/wd")
+        .with_config_dir("/xdg")
+        .add_file("/xdg/yamllint/config", cfg_rules_empty())
+        .add_exist("/xdg/yamllint/config");
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert!(ctx.source.unwrap().ends_with("yamllint/config"));
+}
+
+#[test]
+fn shim_user_global_missing_falls_back_to_default() {
+    let env = FakeEnv::default()
+        .with_cwd("/wd")
+        .with_config_dir("/xdg-none");
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert!(ctx.source.is_none());
+    // default preset filters by extension
+    assert!(
+        ctx.config
+            .is_yaml_candidate(&PathBuf::from("x.yaml"), &ctx.base_dir)
+    );
+}
+
+#[test]
+fn shim_systemenv_read_error_is_mapped() {
+    let env = SystemEnv;
+    let err = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(PathBuf::from("no_such_file.yml")),
+            config_data: None,
+        },
+        &env,
+    )
+    .unwrap_err();
+    assert!(err.contains("failed to read config file"));
+}
+
+#[test]
+fn shim_systemenv_read_success_is_used() {
+    let td = tempfile::tempdir().unwrap();
+    let cfgp = td.path().join("ok.yml");
+    std::fs::write(&cfgp, "rules: {}\n").unwrap();
+    let env = SystemEnv;
+    let ctx = discover_config_with(
+        &[],
+        &Overrides {
+            config_file: Some(cfgp.clone()),
+            config_data: None,
+        },
+        &env,
+    )
+    .unwrap();
+    assert!(ctx.source.unwrap().ends_with("ok.yml"));
+}
+
+#[test]
+fn system_env_read_invalid_encoding_reports_error() {
+    let td = tempdir().unwrap();
+    let path = td.path().join("bad.yml");
+    std::fs::write(&path, [0xFFu8, 0xFE, 0x00]).unwrap();
+    let env = SystemEnv;
+    let err = env.read_to_string(&path).unwrap_err();
+    assert!(err.contains("invalid"));
+}
+
+#[test]
+fn shim_env_var_tilde_slash_only_returns_home() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .set_var("HOME", "/home/tester")
+        .set_var("YAMLLINT_CONFIG_FILE", "~/")
+        .add_file("/home/tester", cfg_rules_empty());
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(ctx.source.unwrap(), PathBuf::from("/home/tester"));
+}
+
+#[test]
+fn shim_env_var_tilde_backslash_only_returns_home() {
+    let env = FakeEnv::default()
+        .with_cwd("/tmp/cwd")
+        .set_var("USERPROFILE", "/profiles/user")
+        .set_var("YAMLLINT_CONFIG_FILE", "~\\")
+        .add_file("/profiles/user", cfg_rules_empty());
+    let ctx = discover_config_with(&[], &Overrides::default(), &env).unwrap();
+    assert_eq!(ctx.source.unwrap(), PathBuf::from("/profiles/user"));
+}
+
+#[test]
+fn shim_discover_per_file_uses_project_else_user_global_else_default() {
+    let env = FakeEnv::default()
+        .with_cwd("/wd")
+        .with_config_dir("/xdg")
+        .add_file("/xdg/yamllint/config", cfg_rules_empty())
+        .add_exist("/xdg/yamllint/config");
+    // No project config, so user-global applies
+    let file = PathBuf::from("/proj/no_config/file.yaml");
+    let ctx = discover_per_file_with(&file, &env).unwrap();
+    assert!(ctx.source.unwrap().ends_with("yamllint/config"));
+}

package/tests/config_explicit_file_parse_error.rs

@@ -0,0 +1,55 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+struct FakeEnv {
+    exists: HashSet<PathBuf>,
+    files: HashMap<PathBuf, String>,
+}
+
+impl FakeEnv {
+    fn new() -> Self {
+        Self {
+            exists: HashSet::new(),
+            files: HashMap::new(),
+        }
+    }
+}
+
+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> {
+        self.files
+            .get(p)
+            .cloned()
+            .ok_or_else(|| format!("missing {}", p.display()))
+    }
+    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 explicit_config_file_with_invalid_yaml_errors() {
+    let mut envx = FakeEnv::new();
+    let file = PathBuf::from("cfg.yml");
+    envx.exists.insert(file.clone());
+    envx.files.insert(file.clone(), "rules: {".into());
+
+    let overrides = ryl::config::Overrides {
+        config_file: Some(file),
+        config_data: None,
+    };
+    let res = ryl::config::discover_config_with(&[], &overrides, &envx);
+    assert!(res.is_err());
+}

package/tests/config_extended_features.rs

@@ -0,0 +1,225 @@
+use ryl::config::{Overrides, discover_config};
+use std::fs;
+use tempfile::tempdir;
+
+#[test]
+fn ignore_block_supports_negation() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("conf.yaml");
+    fs::write(
+        &cfg,
+        "ignore: |\n  **/*.skip.yaml\n  !**/keep.skip.yaml\n  nested/\nyaml-files: []\nrules: {}\n",
+    )
+    .unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(cfg.clone()),
+            config_data: None,
+        },
+    )
+    .expect("config parse");
+    let base = ctx.base_dir.clone();
+
+    assert!(
+        ctx.config
+            .is_file_ignored(&td.path().join("a.skip.yaml"), &base)
+    );
+    assert!(
+        !ctx.config
+            .is_file_ignored(&td.path().join("keep.skip.yaml"), &base)
+    );
+    assert!(
+        ctx.config
+            .is_file_ignored(&td.path().join("nested/file.yaml"), &base)
+    );
+}
+
+#[test]
+fn ignore_from_file_patterns_are_loaded() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("conf.yaml");
+    let ignore = td.path().join(".yamllint-ignore");
+    fs::write(
+        &cfg,
+        "ignore-from-file: .yamllint-ignore\nyaml-files: []\nrules: {}\n",
+    )
+    .unwrap();
+    fs::write(&ignore, "*.gen.yaml\n!.keep.yaml\n").unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(cfg.clone()),
+            config_data: None,
+        },
+    )
+    .expect("config parse");
+    let base = ctx.base_dir.clone();
+
+    assert!(
+        ctx.config
+            .is_file_ignored(&td.path().join("output.gen.yaml"), &base)
+    );
+    assert!(
+        !ctx.config
+            .is_file_ignored(&td.path().join(".keep.yaml"), &base)
+    );
+    assert!(
+        ctx.config
+            .ignore_patterns()
+            .iter()
+            .any(|p| p == "*.gen.yaml")
+    );
+}
+
+#[test]
+fn ignore_directory_pattern_allows_reinclude_of_specific_file() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("conf.yaml");
+    fs::write(
+        &cfg,
+        "ignore: |\n  build/\n  !build/keep.yaml\nyaml-files: []\nrules: {}\n",
+    )
+    .unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(cfg.clone()),
+            config_data: None,
+        },
+    )
+    .expect("config parse");
+    let base = ctx.base_dir.clone();
+
+    assert!(
+        ctx.config
+            .is_file_ignored(&td.path().join("build/drop.yaml"), &base)
+    );
+    assert!(
+        !ctx.config
+            .is_file_ignored(&td.path().join("build/keep.yaml"), &base)
+    );
+}
+
+#[test]
+fn ignore_from_file_directory_pattern_allows_reinclude_of_specific_file() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("conf.yaml");
+    let ignore = td.path().join(".yamllint-ignore");
+    fs::write(
+        &cfg,
+        "ignore-from-file: .yamllint-ignore\nyaml-files: []\nrules: {}\n",
+    )
+    .unwrap();
+    fs::write(&ignore, "build/\n!build/keep.yaml\n").unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(cfg.clone()),
+            config_data: None,
+        },
+    )
+    .expect("config parse");
+    let base = ctx.base_dir.clone();
+
+    assert!(
+        ctx.config
+            .is_file_ignored(&td.path().join("build/drop.yaml"), &base)
+    );
+    assert!(
+        !ctx.config
+            .is_file_ignored(&td.path().join("build/keep.yaml"), &base)
+    );
+}
+
+#[test]
+fn rule_ignore_handles_direct_ignore_whitelist_and_parent_fallback() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("conf.yaml");
+    fs::write(
+        &cfg,
+        "yaml-files: []\nrules:\n  trailing-spaces:\n    ignore: |\n      build/\n      !build/keep.yaml\n      drop.yaml\n",
+    )
+    .unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(cfg.clone()),
+            config_data: None,
+        },
+    )
+    .expect("config parse");
+    let base = ctx.base_dir.clone();
+
+    assert!(!ctx.config.is_rule_ignored(
+        "trailing-spaces",
+        &td.path().join("build/keep.yaml"),
+        &base
+    ));
+    assert!(ctx.config.is_rule_ignored(
+        "trailing-spaces",
+        &td.path().join("drop.yaml"),
+        &base
+    ));
+    assert!(ctx.config.is_rule_ignored(
+        "trailing-spaces",
+        &td.path().join("build/sub/nested.yaml"),
+        &base,
+    ));
+}
+
+#[test]
+fn extends_resolves_relative_file_paths() {
+    let td = tempdir().unwrap();
+    let base_cfg = td.path().join("base.yaml");
+    fs::write(
+        &base_cfg,
+        "ignore: ['base/**']\nyaml-files: []\nrules: {}\n",
+    )
+    .unwrap();
+    let child_cfg = td.path().join("child.yaml");
+    fs::write(
+        &child_cfg,
+        "extends: base.yaml\nignore: ['child/**']\nyaml-files: []\nrules: {}\n",
+    )
+    .unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(child_cfg.clone()),
+            config_data: None,
+        },
+    )
+    .expect("config parse");
+    let base = ctx.base_dir.clone();
+
+    assert!(
+        !ctx.config
+            .is_file_ignored(&td.path().join("base/one.yaml"), &base),
+        "parent ignore entries should be replaced by child overrides"
+    );
+    assert!(
+        ctx.config
+            .is_file_ignored(&td.path().join("child/two.yaml"), &base)
+    );
+}
+
+#[test]
+fn config_data_builtin_name_expands() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some("extends: relaxed".to_string()),
+        },
+    )
+    .expect("config parse");
+
+    assert!(ctx.config.rule_names().iter().any(|r| r == "braces"));
+}