@owenlamont/ryl 0.4.1

package/tests/config_toml_discovery.rs

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

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

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

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

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

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

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