@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/config_toml_discovery.rs

@@ -1,304 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use ryl::config::{Overrides, discover_config_with, discover_per_file};
-use tempfile::tempdir;
-
-#[path = "common/mod.rs"]
-mod common;
-use common::fake_env::FakeEnv;
-
-#[test]
-fn project_toml_takes_precedence_over_yaml_and_adds_notice() {
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(
-            PathBuf::from("/repo/.ryl.toml"),
-            "locale = 'fr_FR.UTF-8'\n[rules]\nanchors = 'disable'\n",
-        )
-        .with_file(
-            PathBuf::from("/repo/.yamllint"),
-            "locale: en_US.UTF-8\nrules: {}\n",
-        )
-        .with_exists(PathBuf::from("/repo/file.yaml"));
-    let ctx = discover_config_with(
-        &[PathBuf::from("/repo/file.yaml")],
-        &Overrides::default(),
-        &env,
-    )
-    .expect("project TOML should load");
-    assert_eq!(ctx.source.as_deref(), Some(Path::new("/repo/.ryl.toml")));
-    assert_eq!(ctx.config.locale(), Some("fr_FR.UTF-8"));
-    assert_eq!(ctx.notices.len(), 1);
-    assert!(ctx.notices[0].contains("ignoring legacy YAML config discovery"));
-}
-
-#[test]
-fn explicit_pyproject_with_tool_ryl_section_loads() {
-    let pyproject = PathBuf::from("/repo/pyproject.toml");
-    let env = FakeEnv::new().with_cwd(PathBuf::from("/repo")).with_file(
-        pyproject.clone(),
-        "[project]\nname = 'demo'\nversion = '0.1.0'\n[tool.ryl]\nlocale = 'en_GB.UTF-8'\n",
-    );
-    let ctx = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(pyproject),
-            config_data: None,
-        },
-        &env,
-    )
-    .expect("explicit pyproject [tool.ryl] should load");
-    assert_eq!(ctx.config.locale(), Some("en_GB.UTF-8"));
-}
-
-#[test]
-fn project_pyproject_without_tool_ryl_falls_back_to_yaml() {
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(
-            PathBuf::from("/repo/pyproject.toml"),
-            "[project]\nname = 'demo'\nversion = '0.1.0'\n",
-        )
-        .with_file(
-            PathBuf::from("/repo/.yamllint"),
-            "locale: en_US.UTF-8\nrules: {}\n",
-        )
-        .with_exists(PathBuf::from("/repo/file.yaml"));
-    let ctx = discover_config_with(
-        &[PathBuf::from("/repo/file.yaml")],
-        &Overrides::default(),
-        &env,
-    )
-    .expect("yaml fallback should load");
-    assert_eq!(ctx.source.as_deref(), Some(Path::new("/repo/.yamllint")));
-    assert_eq!(ctx.config.locale(), Some("en_US.UTF-8"));
-    assert!(ctx.notices.is_empty());
-}
-
-#[test]
-fn discover_per_file_finds_project_toml() {
-    let td = tempdir().unwrap();
-    let root = td.path();
-    std::fs::write(root.join(".ryl.toml"), "[rules]\nanchors = 'disable'\n").unwrap();
-    std::fs::write(root.join("file.yaml"), "a: 1\n").unwrap();
-    let ctx = discover_per_file(&root.join("file.yaml")).expect("per-file discovery");
-    assert_eq!(
-        ctx.source.as_deref(),
-        Some(root.join(".ryl.toml").as_path())
-    );
-}
-
-#[test]
-fn project_skips_non_ryl_pyproject_and_uses_parent_toml() {
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(
-            PathBuf::from("/repo/sub/pyproject.toml"),
-            "[project]\nname = 'sub'\nversion = '0.1.0'\n",
-        )
-        .with_file(
-            PathBuf::from("/repo/.ryl.toml"),
-            "locale = 'fr_FR.UTF-8'\n[rules]\nanchors = 'disable'\n",
-        )
-        .with_exists(PathBuf::from("/repo/sub/file.yaml"));
-    let ctx = discover_config_with(
-        &[PathBuf::from("/repo/sub/file.yaml")],
-        &Overrides::default(),
-        &env,
-    )
-    .expect("ancestor TOML should load");
-    assert_eq!(ctx.source.as_deref(), Some(Path::new("/repo/.ryl.toml")));
-    assert_eq!(ctx.config.locale(), Some("fr_FR.UTF-8"));
-}
-
-#[test]
-fn project_pyproject_with_tool_ryl_is_used() {
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(
-            PathBuf::from("/repo/pyproject.toml"),
-            "[project]\nname = 'demo'\nversion = '0.1.0'\n[tool.ryl]\nlocale = 'de_DE.UTF-8'\n",
-        )
-        .with_exists(PathBuf::from("/repo/file.yaml"));
-    let ctx = discover_config_with(
-        &[PathBuf::from("/repo/file.yaml")],
-        &Overrides::default(),
-        &env,
-    )
-    .expect("pyproject [tool.ryl] should load");
-    assert_eq!(
-        ctx.source.as_deref(),
-        Some(Path::new("/repo/pyproject.toml"))
-    );
-    assert_eq!(ctx.config.locale(), Some("de_DE.UTF-8"));
-}
-
-#[test]
-fn explicit_pyproject_requires_tool_ryl_section() {
-    let pyproject = PathBuf::from("/repo/pyproject.toml");
-    let env = FakeEnv::new().with_cwd(PathBuf::from("/repo")).with_file(
-        pyproject.clone(),
-        "[project]\nname = 'demo'\nversion = '0.1.0'\n",
-    );
-    let err = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(pyproject),
-            config_data: None,
-        },
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("missing [tool.ryl] section"));
-}
-
-#[test]
-fn toml_config_rejects_extends_key() {
-    let cfg = PathBuf::from("/repo/.ryl.toml");
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(cfg.clone(), "extends = 'relaxed'\n");
-    let err = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(cfg),
-            config_data: None,
-        },
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("extends is not supported in TOML configuration"));
-}
-
-#[test]
-fn explicit_toml_parse_error_is_reported() {
-    let cfg = PathBuf::from("/repo/.ryl.toml");
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(cfg.clone(), "rules = [\n");
-    let err = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(cfg),
-            config_data: None,
-        },
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("failed to parse config data"));
-}
-
-#[test]
-fn toml_scalar_types_are_accepted_for_unknown_keys() {
-    let cfg = PathBuf::from("/repo/.ryl.toml");
-    let env = FakeEnv::new().with_cwd(PathBuf::from("/repo")).with_file(
-        cfg.clone(),
-        "flag = true\nratio = 1.5\nstamp = 1979-05-27T07:32:00Z\n[rules]\nanchors = 'disable'\n",
-    );
-    discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(cfg),
-            config_data: None,
-        },
-        &env,
-    )
-    .expect("scalar conversion should parse");
-}
-
-#[test]
-fn toml_integer_scalar_is_accepted_for_unknown_keys() {
-    let cfg = PathBuf::from("/repo/.ryl.toml");
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(cfg.clone(), "answer = 42\n[rules]\nanchors = 'disable'\n");
-    discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(cfg),
-            config_data: None,
-        },
-        &env,
-    )
-    .expect("integer conversion should parse");
-}
-
-#[test]
-fn toml_float_value_for_locale_reports_string_error() {
-    let cfg = PathBuf::from("/repo/.ryl.toml");
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(cfg.clone(), "locale = 1.25\n");
-    let err = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(cfg),
-            config_data: None,
-        },
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("invalid config: locale should be a string"));
-}
-
-#[test]
-fn invalid_project_pyproject_toml_errors_in_discover_config() {
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(PathBuf::from("/repo/pyproject.toml"), "[tool.ryl\n")
-        .with_exists(PathBuf::from("/repo/file.yaml"));
-    let err = discover_config_with(
-        &[PathBuf::from("/repo/file.yaml")],
-        &Overrides::default(),
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("failed to parse config data"));
-}
-
-#[test]
-fn invalid_project_pyproject_toml_errors_in_discover_per_file() {
-    let td = tempdir().unwrap();
-    let root = td.path();
-    std::fs::write(root.join("pyproject.toml"), "[tool.ryl\n").unwrap();
-    std::fs::write(root.join("file.yaml"), "a: 1\n").unwrap();
-    let err = discover_per_file(&root.join("file.yaml")).unwrap_err();
-    assert!(err.contains("failed to parse config data"));
-}
-
-#[test]
-fn explicit_invalid_pyproject_toml_reports_parse_error() {
-    let pyproject = PathBuf::from("/repo/pyproject.toml");
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(pyproject.clone(), "[tool.ryl\n");
-    let err = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(pyproject),
-            config_data: None,
-        },
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("failed to parse config data"));
-}
-
-#[test]
-fn yaml_extends_toml_is_rejected() {
-    let cfg = PathBuf::from("/repo/.yamllint");
-    let env = FakeEnv::new()
-        .with_cwd(PathBuf::from("/repo"))
-        .with_file(cfg.clone(), "extends: .ryl.toml\n")
-        .with_file(PathBuf::from("/repo/.ryl.toml"), "locale = 'en_US.UTF-8'\n");
-    let err = discover_config_with(
-        &[],
-        &Overrides {
-            config_file: Some(cfg),
-            config_data: None,
-        },
-        &env,
-    )
-    .unwrap_err();
-    assert!(err.contains("extends cannot reference TOML configuration"));
-}

package/tests/config_trailing_spaces.rs

@@ -1,152 +0,0 @@
-use std::fs;
-
-use ryl::config::{Overrides, YamlLintConfig, discover_config};
-use tempfile::tempdir;
-
-#[test]
-fn error_on_unknown_option() {
-    let err =
-        YamlLintConfig::from_yaml_str("rules:\n  trailing-spaces:\n    foo: true\n")
-            .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: unknown option \"foo\" for rule \"trailing-spaces\""
-    );
-}
-
-#[test]
-fn error_on_invalid_ignore_type() {
-    let err =
-        YamlLintConfig::from_yaml_str("rules:\n  trailing-spaces:\n    ignore: 1\n")
-            .unwrap_err();
-    assert_eq!(err, "invalid config: ignore should contain file patterns");
-}
-
-#[test]
-fn error_on_invalid_ignore_from_file_type() {
-    let err = YamlLintConfig::from_yaml_str(
-        "rules:\n  trailing-spaces:\n    ignore-from-file: 1\n",
-    )
-    .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: ignore-from-file should contain filename(s), either as a list or string"
-    );
-}
-
-#[test]
-fn error_on_invalid_rule_ignore_pattern() {
-    let cfg = "rules:\n  trailing-spaces:\n    ignore: ['[']\n";
-    let err = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some(cfg.into()),
-        },
-    )
-    .unwrap_err();
-    assert!(
-        err.contains("invalid config: ignore pattern '["),
-        "unexpected error message: {err}"
-    );
-}
-
-#[test]
-fn error_on_missing_rule_ignore_from_file() {
-    let cfg = "rules:\n  trailing-spaces:\n    ignore-from-file: missing.txt\n";
-    let err = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some(cfg.into()),
-        },
-    )
-    .unwrap_err();
-    assert!(
-        err.contains("failed to read ignore-from-file"),
-        "unexpected error message: {err}"
-    );
-}
-
-#[test]
-fn error_on_invalid_rule_ignore_from_file_pattern() {
-    let dir = tempdir().unwrap();
-    let patterns = dir.path().join("patterns.txt");
-    fs::write(&patterns, "[\n").unwrap();
-    let config = dir.path().join("config.yml");
-    let config_body = format!(
-        "rules:\n  trailing-spaces:\n    ignore-from-file: '{}'\n",
-        patterns.display().to_string().replace('\'', "''")
-    );
-    fs::write(&config, config_body).unwrap();
-
-    let err = discover_config(
-        &[],
-        &Overrides {
-            config_file: Some(config),
-            config_data: None,
-        },
-    )
-    .unwrap_err();
-    assert!(
-        err.contains("invalid config: ignore-from-file pattern"),
-        "unexpected error message: {err}"
-    );
-}
-
-#[test]
-fn rule_ignore_from_file_skips_blank_lines() {
-    let dir = tempdir().unwrap();
-    let patterns = dir.path().join("patterns.txt");
-    fs::write(&patterns, "\nignored.yaml\n").unwrap();
-    let config = dir.path().join("config.yml");
-    let config_body = format!(
-        "rules:\n  trailing-spaces:\n    ignore-from-file: '{}'\n",
-        patterns.display().to_string().replace('\'', "''")
-    );
-    fs::write(&config, config_body).unwrap();
-
-    discover_config(
-        &[],
-        &Overrides {
-            config_file: Some(config),
-            config_data: None,
-        },
-    )
-    .expect("config with blank lines in ignore-from-file should parse");
-}
-
-#[test]
-fn rule_ignore_with_empty_list_produces_no_matcher() {
-    let cfg = "rules:\n  trailing-spaces:\n    ignore: []\n";
-    discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some(cfg.into()),
-        },
-    )
-    .expect("empty ignore list should be accepted");
-}
-
-#[test]
-fn rule_ignore_from_file_with_only_blank_lines_produces_no_matcher() {
-    let dir = tempdir().unwrap();
-    let patterns = dir.path().join("patterns.txt");
-    fs::write(&patterns, "\n\n").unwrap();
-    let config = dir.path().join("config.yml");
-    let config_body = format!(
-        "rules:\n  trailing-spaces:\n    ignore-from-file: '{}'\n",
-        patterns.display().to_string().replace('\'', "''")
-    );
-    fs::write(&config, config_body).unwrap();
-
-    discover_config(
-        &[],
-        &Overrides {
-            config_file: Some(config),
-            config_data: None,
-        },
-    )
-    .expect("blank ignore-from-file should be accepted");
-}

package/tests/config_truthy.rs

@@ -1,77 +0,0 @@
-use ryl::config::YamlLintConfig;
-
-#[test]
-fn error_when_allowed_values_not_sequence() {
-    let err =
-        YamlLintConfig::from_yaml_str("rules:\n  truthy:\n    allowed-values: foo\n")
-            .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: option \"allowed-values\" of \"truthy\" should only contain values in ['YES', 'Yes', 'yes', 'NO', 'No', 'no', 'TRUE', 'True', 'true', 'FALSE', 'False', 'false', 'ON', 'On', 'on', 'OFF', 'Off', 'off']"
-    );
-}
-
-#[test]
-fn error_when_allowed_values_has_invalid_entry() {
-    let err =
-        YamlLintConfig::from_yaml_str("rules:\n  truthy:\n    allowed-values: [foo]\n")
-            .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: option \"allowed-values\" of \"truthy\" should only contain values in ['YES', 'Yes', 'yes', 'NO', 'No', 'no', 'TRUE', 'True', 'true', 'FALSE', 'False', 'false', 'ON', 'On', 'on', 'OFF', 'Off', 'off']"
-    );
-}
-
-#[test]
-fn error_when_allowed_values_contains_non_string() {
-    let err =
-        YamlLintConfig::from_yaml_str("rules:\n  truthy:\n    allowed-values: [1]\n")
-            .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: option \"allowed-values\" of \"truthy\" should only contain values in ['YES', 'Yes', 'yes', 'NO', 'No', 'no', 'TRUE', 'True', 'true', 'FALSE', 'False', 'false', 'ON', 'On', 'on', 'OFF', 'Off', 'off']"
-    );
-}
-
-#[test]
-fn error_when_check_keys_not_bool() {
-    let err = YamlLintConfig::from_yaml_str("rules:\n  truthy:\n    check-keys: 1\n")
-        .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: option \"check-keys\" of \"truthy\" should be bool"
-    );
-}
-
-#[test]
-fn error_on_unknown_truthy_option() {
-    let err = YamlLintConfig::from_yaml_str("rules:\n  truthy:\n    unknown: true\n")
-        .unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: unknown option \"unknown\" for rule \"truthy\""
-    );
-}
-
-#[test]
-fn error_on_non_string_truthy_option_key() {
-    let err =
-        YamlLintConfig::from_yaml_str("rules:\n  truthy:\n    1: true\n").unwrap_err();
-    assert_eq!(
-        err,
-        "invalid config: unknown option \"1\" for rule \"truthy\""
-    );
-}
-
-#[test]
-fn rule_option_returns_none_for_scalar_rule_value() {
-    let cfg = YamlLintConfig::from_yaml_str("rules:\n  truthy: enable\n")
-        .expect("config parses");
-    assert!(cfg.rule_option("truthy", "allowed-values").is_none());
-}
-
-#[test]
-fn rule_option_returns_none_when_rule_missing() {
-    let cfg = YamlLintConfig::from_yaml_str("rules: {}\n").expect("config parses");
-    assert!(cfg.rule_option("truthy", "allowed-values").is_none());
-}

package/tests/config_yaml_files.rs

@@ -1,62 +0,0 @@
-use ryl::config::{Overrides, discover_config};
-
-#[test]
-fn invalid_yaml_data_errors() {
-    let err = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some("[1]".into()),
-        },
-    )
-    .expect_err("top-level sequence should error");
-    assert!(err.contains("not a mapping"));
-}
-
-#[test]
-fn yaml_files_non_sequence_errors() {
-    let err = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some("yaml-files: 5\n".into()),
-        },
-    )
-    .expect_err("non-list yaml-files should error");
-    assert!(err.contains("yaml-files should be a list"));
-}
-
-#[test]
-fn yaml_files_invalid_pattern_is_skipped() {
-    let ctx = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some("yaml-files: ['[']\n".into()),
-        },
-    )
-    .expect("invalid glob should be ignored");
-    let base = ctx.base_dir.clone();
-    assert!(!ctx.config.is_yaml_candidate(&base.join("file.yaml"), &base));
-}
-
-#[test]
-fn yaml_files_negation_excludes_matches() {
-    let ctx = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some("yaml-files: ['*.yaml', '!skip.yaml']\n".into()),
-        },
-    )
-    .expect("yaml-files with negation should parse");
-    let base = ctx.base_dir.clone();
-    assert!(
-        ctx.config.is_yaml_candidate(&base.join("keep.yaml"), &base),
-        "positive pattern should include keep.yaml"
-    );
-    assert!(
-        !ctx.config.is_yaml_candidate(&base.join("skip.yaml"), &base),
-        "negated pattern should exclude skip.yaml"
-    );
-}

package/tests/config_yaml_files_all_non_string.rs

@@ -1,15 +0,0 @@
-use ryl::config::{Overrides, discover_config};
-
-#[test]
-fn yaml_files_sequence_all_non_strings_error() {
-    let yaml = "yaml-files: [1, 2]\nrules: {}\n";
-    let err = discover_config(
-        &[],
-        &Overrides {
-            config_file: None,
-            config_data: Some(yaml.into()),
-        },
-    )
-    .unwrap_err();
-    assert!(err.contains("invalid config"));
-}

package/tests/config_yaml_files_empty.rs

@@ -1,30 +0,0 @@
-use std::fs;
-use std::process::Command;
-
-use tempfile::tempdir;
-
-fn run(cmd: &mut Command) -> (i32, String, String) {
-    let out = cmd.output().expect("failed to run ryl");
-    let code = out.status.code().unwrap_or(-1);
-    let stdout = String::from_utf8_lossy(&out.stdout).into_owned();
-    let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
-    (code, stdout, stderr)
-}
-
-#[test]
-fn empty_yaml_files_falls_back_to_extension_filtering() {
-    let td = tempdir().unwrap();
-    let root = td.path();
-    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
-    fs::write(root.join("b.txt"), "text\n").unwrap();
-
-    let exe = env!("CARGO_BIN_EXE_ryl");
-    let (code, out, err) = run(Command::new(exe)
-        .arg("--list-files")
-        .arg("-d")
-        .arg("yaml-files: []\n")
-        .arg(root));
-    assert_eq!(code, 0, "expected success: {err}");
-    assert!(out.contains("a.yaml"));
-    assert!(!out.contains("b.txt"));
-}

package/tests/coverage_commas.rs

@@ -1,46 +0,0 @@
-use ryl::rules::commas::{
-    Config, check, coverage_compute_spaces_before, coverage_skip_comment_crlf,
-    coverage_skip_zero_length_span,
-};
-
-#[test]
-fn leading_comma_reports_zero_spaces() {
-    assert_eq!(coverage_compute_spaces_before(",", 0), Some(0));
-}
-
-#[test]
-fn leading_space_before_comma_counts_correctly() {
-    assert_eq!(coverage_compute_spaces_before(" ,", 1), Some(1));
-}
-
-#[test]
-fn newline_before_comma_is_ignored() {
-    assert_eq!(coverage_compute_spaces_before("\n,", 1), None);
-}
-
-#[test]
-fn zero_length_scalar_span_is_ignored() {
-    assert_eq!(coverage_skip_zero_length_span(), 0);
-}
-
-#[test]
-fn skip_comment_handles_crlf_lines() {
-    assert_eq!(coverage_skip_comment_crlf(), (2, 1));
-}
-
-#[test]
-fn stray_comma_outside_flow_is_ignored() {
-    let cfg = Config::new_for_tests(0, 1, 1);
-    assert!(check(",", &cfg).is_empty());
-}
-
-#[test]
-fn commas_after_multibyte_scalars_are_checked() {
-    let cfg = Config::new_for_tests(0, 1, 1);
-    let violations = check("[\"å\",\"b\"]", &cfg);
-    assert!(
-        violations
-            .iter()
-            .any(|v| v.message == "too few spaces after comma")
-    );
-}