@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/config_env_missing.rs

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

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

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

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