@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/config_extends_inline.rs

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

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

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

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

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

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

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

@@ -1,243 +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 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/**"));
-}