@owenlamont/ryl 0.4.1

package/tests/decoder_decode.rs

@@ -0,0 +1,338 @@
+use std::path::Path;
+
+use ryl::decoder;
+use tempfile::tempdir;
+
+#[test]
+fn decode_utf8_plain() {
+    assert_eq!(decoder::decode_bytes(b"hello").unwrap(), "hello");
+}
+
+#[test]
+fn decode_utf8_invalid_reports_error() {
+    let err = decoder::decode_bytes(&[0x80]).unwrap_err();
+    assert!(
+        err.contains("invalid utf-8 data"),
+        "expected utf-8 error, got: {err}"
+    );
+}
+
+#[test]
+fn decode_utf8_bom_is_stripped() {
+    let data = [0xEF, 0xBB, 0xBF, b'h', b'i'];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf8_sig_without_bom_is_identity() {
+    assert_eq!(
+        decoder::decode_bytes_with_override(b"hi", Some("utf-8-sig")).unwrap(),
+        "hi"
+    );
+}
+
+#[test]
+fn decode_utf16_big_endian_with_bom() {
+    let data = [0xFE, 0xFF, 0x00, b'h', 0x00, b'i'];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf16_little_endian_with_bom() {
+    let data = [0xFF, 0xFE, b'h', 0x00, b'i', 0x00];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf16_big_endian_without_bom() {
+    let data = [0x00, b'h', 0x00, b'i'];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf16_little_endian_without_bom() {
+    let data = [b'h', 0x00, b'i', 0x00];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf16_invalid_length_reports_error() {
+    let err = decoder::decode_bytes(&[0xFF, 0xFE, 0x00]).unwrap_err();
+    assert!(err.contains("invalid utf-16"), "unexpected error: {err}");
+}
+
+#[test]
+fn decode_utf32_big_endian_with_bom() {
+    let data = [
+        0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i',
+    ];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf32_little_endian_with_bom() {
+    let data = [
+        0xFF, 0xFE, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i', 0x00, 0x00, 0x00,
+    ];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf32_big_endian_without_bom() {
+    let data = [0x00, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i'];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf32_little_endian_without_bom() {
+    let data = [b'h', 0x00, 0x00, 0x00, b'i', 0x00, 0x00, 0x00];
+    assert_eq!(decoder::decode_bytes(&data).unwrap(), "hi");
+}
+
+#[test]
+fn decode_utf32_invalid_length_reports_error() {
+    let data = [0x00, 0x00, 0x00, b'h', 0x00];
+    let err = decoder::decode_bytes(&data).unwrap_err();
+    assert!(err.contains("invalid utf-32"), "unexpected error: {err}");
+}
+
+#[test]
+fn decode_utf32_invalid_scalar_reports_error() {
+    let data = [0x00, 0x00, 0xFE, 0xFF, 0x00, 0x11, 0x00, 0x00];
+    let err = decoder::decode_bytes(&data).unwrap_err();
+    assert!(
+        err.contains("invalid scalar value"),
+        "unexpected error: {err}"
+    );
+}
+
+#[test]
+fn decode_utf16_invalid_scalar_reports_error() {
+    let err = decoder::decode_bytes_with_override(&[0xD8, 0x00], Some("utf-16be"))
+        .unwrap_err();
+    assert!(err.contains("invalid utf-16"));
+}
+
+#[test]
+fn decode_with_override_utf16_variants() {
+    let big = [0xFE, 0xFF, 0x00, b'h', 0x00, b'i'];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&big, Some("utf-16")).unwrap(),
+        "hi"
+    );
+    let big_no_bom = [0x00, b'h', 0x00, b'i'];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&big_no_bom, Some("utf-16")).unwrap(),
+        "hi"
+    );
+    let little_bom = [0xFF, 0xFE, b'h', 0x00];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&little_bom, Some("UTF_16")).unwrap(),
+        "h"
+    );
+    let little = [b'h', 0x00, b'i', 0x00];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&little, Some("utf-16le")).unwrap(),
+        "hi"
+    );
+    let little_no_bom = [b'h', 0x00, b'i', 0x00];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&little_no_bom, Some("utf-16")).unwrap(),
+        "hi"
+    );
+}
+
+#[test]
+fn decode_with_override_utf16_fallbacks_to_little_when_ambiguous() {
+    let bytes = [0x2D, 0x4E, 0x87, 0x65]; // "中文" in little-endian without BOM or zero hints
+    assert_eq!(
+        decoder::decode_bytes_with_override(&bytes, Some("utf-16")).unwrap(),
+        "中文"
+    );
+}
+
+#[test]
+fn decode_with_override_utf32_variants() {
+    let big = [0x00, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i'];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&big, Some("utf-32")).unwrap(),
+        "hi"
+    );
+    let big_bom = [
+        0x00, 0x00, 0xFE, 0xFF, 0x00, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i',
+    ];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&big_bom, Some("utf-32")).unwrap(),
+        "hi"
+    );
+    let little = [b'h', 0x00, 0x00, 0x00, b'i', 0x00, 0x00, 0x00];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&little, Some("utf-32le")).unwrap(),
+        "hi"
+    );
+    assert_eq!(
+        decoder::decode_bytes_with_override(&little, Some("utf-32")).unwrap(),
+        "hi"
+    );
+}
+
+#[test]
+fn decode_with_override_utf32_detects_little_without_bom() {
+    let bytes = [0x2D, 0x4E, 0x00, 0x00, 0x87, 0x65, 0x00, 0x00];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&bytes, Some("utf-32")).unwrap(),
+        "中文"
+    );
+}
+
+#[test]
+fn decode_with_override_utf32_missing_hint_errors() {
+    let err =
+        decoder::decode_bytes_with_override(&[0x01, 0x02, 0x03, 0x04], Some("utf-32"))
+            .unwrap_err();
+    assert!(err.contains("utf-32"), "unexpected error: {err}");
+}
+
+#[test]
+fn decode_with_override_utf8_alias() {
+    assert_eq!(
+        decoder::decode_bytes_with_override(b"hi", Some("utf-8")).unwrap(),
+        "hi"
+    );
+}
+
+#[test]
+fn decode_with_override_utf16be_explicit() {
+    let data = [0x00, b'h', 0x00, b'i'];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&data, Some("utf-16be")).unwrap(),
+        "hi"
+    );
+}
+
+#[test]
+fn decode_with_override_utf32be_explicit() {
+    let data = [0x00, 0x00, 0x00, b'h', 0x00, 0x00, 0x00, b'i'];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&data, Some("utf-32be")).unwrap(),
+        "hi"
+    );
+}
+
+#[test]
+fn decode_with_override_latin1_variants() {
+    let bytes = [0xA1, 0x21];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&bytes, Some("latin-1")).unwrap(),
+        "¡!"
+    );
+    let alias = [0xA1];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&alias, Some("ISO_8859_1")).unwrap(),
+        "¡"
+    );
+    assert_eq!(
+        decoder::decode_bytes_with_override(&alias, Some("latin1")).unwrap(),
+        "¡"
+    );
+}
+
+#[test]
+fn decode_with_override_utf8_sig() {
+    let data = [0xEF, 0xBB, 0xBF, b'h'];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&data, Some("utf8-sig")).unwrap(),
+        "h"
+    );
+}
+
+#[test]
+fn decode_with_override_utf16_only_bom() {
+    let data = [0xFF, 0xFE];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&data, Some("utf-16")).unwrap(),
+        ""
+    );
+}
+
+#[test]
+fn decode_with_override_utf32_only_bom() {
+    let data = [0xFF, 0xFE, 0x00, 0x00];
+    assert_eq!(
+        decoder::decode_bytes_with_override(&data, Some("utf-32")).unwrap(),
+        ""
+    );
+}
+
+#[test]
+fn decode_with_override_utf16_empty_input() {
+    assert_eq!(
+        decoder::decode_bytes_with_override(&[], Some("utf-16le")).unwrap(),
+        ""
+    );
+}
+
+#[test]
+fn decode_with_override_utf32_empty_input() {
+    assert_eq!(
+        decoder::decode_bytes_with_override(&[], Some("utf-32le")).unwrap(),
+        ""
+    );
+}
+
+#[test]
+fn decode_with_override_unknown_errors() {
+    let err =
+        decoder::decode_bytes_with_override(b"data", Some("unsupported")).unwrap_err();
+    assert!(err.contains("unsupported label"));
+}
+
+#[test]
+fn decode_with_override_empty_label_errors() {
+    let err = decoder::decode_bytes_with_override(b"data", Some("  ")).unwrap_err();
+    assert!(err.contains("cannot be empty"));
+}
+
+#[test]
+fn decode_with_custom_encoding() {
+    let bytes = b"hello";
+    assert_eq!(
+        decoder::decode_bytes_with_override(bytes, Some("koi8-r")).unwrap(),
+        "hello"
+    );
+    assert_eq!(
+        decoder::decode_bytes_with_override(bytes, Some("KOI8_R")).unwrap(),
+        "hello"
+    );
+}
+
+#[test]
+fn decode_with_custom_encoding_errors() {
+    let err =
+        decoder::decode_bytes_with_override(&[0x82], Some("shift_jis")).unwrap_err();
+    assert!(err.contains("decode error"));
+}
+
+#[test]
+fn read_file_decodes_utf8() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("sample.yml");
+    std::fs::write(&path, "key: value\n").unwrap();
+    let content = decoder::read_file(&path).unwrap();
+    assert!(content.contains("key: value"));
+}
+
+#[test]
+fn read_file_invalid_utf8_errors() {
+    let dir = tempdir().unwrap();
+    let path = dir.path().join("invalid.yml");
+    std::fs::write(&path, [0xFF]).unwrap();
+    let err = decoder::read_file(&path).unwrap_err();
+    assert!(err.contains("invalid utf-8 data"));
+}
+
+#[test]
+fn read_file_missing_file_errors() {
+    let err = decoder::read_file(Path::new("no_such_decoder_file.yml")).unwrap_err();
+    assert!(err.contains("failed to read"));
+}

package/tests/discover_config_bin_all.rs

@@ -0,0 +1,66 @@
+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 helper");
+    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 dc_ok_prints_empty_when_no_configs() {
+    let td = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, out, err) = run(Command::new(exe).arg(td.path()));
+    assert_eq!(code, 0, "expected success: {err}");
+    assert_eq!(out.trim(), "");
+}
+
+#[test]
+fn dc_ok_prints_env_config_path() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("envcfg.yml");
+    fs::write(&cfg, "ignore: ['**/skip/**']\n").unwrap();
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, out, err) = run(Command::new(exe)
+        .env("YAMLLINT_CONFIG_FILE", &cfg)
+        .arg(td.path()));
+    assert_eq!(code, 0, "expected success: {err}");
+    assert!(out.trim_end().ends_with(cfg.to_string_lossy().as_ref()));
+}
+
+#[test]
+fn dc_error_on_project_config_dir() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir(root.join(".yamllint")).unwrap();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, _out, err) = run(Command::new(exe).arg(root));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to read"));
+}
+
+#[test]
+fn dc_ok_prints_user_global_path_when_present() {
+    let td = tempdir().unwrap();
+    let xdg = td.path().join("xdg").join("yamllint");
+    fs::create_dir_all(&xdg).unwrap();
+    let global_cfg = xdg.join("config");
+    fs::write(&global_cfg, "ignore: ['**/a.yaml']\n").unwrap();
+    let proj = td.path().join("proj");
+    fs::create_dir_all(&proj).unwrap();
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, out, err) = run(Command::new(exe)
+        .env("XDG_CONFIG_HOME", td.path().join("xdg"))
+        .arg(&proj));
+    assert_eq!(code, 0, "expected success: {err}");
+    assert!(
+        out.trim_end()
+            .ends_with(global_cfg.to_string_lossy().as_ref())
+    );
+}

package/tests/discover_config_bin_env_invalid_yaml.rs

@@ -0,0 +1,26 @@
+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 helper");
+    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 dc_error_on_env_config_parse_error() {
+    let td = tempdir().unwrap();
+    let cfg = td.path().join("envcfg.yml");
+    fs::write(&cfg, "rules: {\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, _out, err) = run(Command::new(exe)
+        .env("YAMLLINT_CONFIG_FILE", &cfg)
+        .arg(td.path()));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to parse config data"));
+}

package/tests/discover_config_bin_project_config_parse_error.rs

@@ -0,0 +1,24 @@
+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 helper");
+    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 dc_error_on_project_config_parse_error() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join(".yamllint"), "rules: {\n").unwrap();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, _out, err) = run(Command::new(exe).arg(root));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to parse config data"));
+}

package/tests/discover_config_bin_user_global_error.rs

@@ -0,0 +1,26 @@
+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 helper");
+    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 dc_error_on_user_global_config_dir() {
+    let td = tempdir().unwrap();
+    let xdg = td.path().join("xdg").join("yamllint");
+    fs::create_dir_all(xdg.join("config")).unwrap(); // create directory where file is expected
+
+    let exe = env!("CARGO_BIN_EXE_discover_config_bin");
+    let (code, _out, err) = run(Command::new(exe)
+        .env("XDG_CONFIG_HOME", td.path().join("xdg"))
+        .current_dir(td.path()));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to read"));
+}

package/tests/discover_module.rs

@@ -0,0 +1,30 @@
+use std::fs;
+use std::path::PathBuf;
+
+use ryl::discover::{gather_yaml_from_dir, is_yaml_path};
+use tempfile::tempdir;
+
+#[test]
+fn is_yaml_path_matches_common_extensions_case_insensitive() {
+    assert!(is_yaml_path(&PathBuf::from("foo.yaml")));
+    assert!(is_yaml_path(&PathBuf::from("bar.yml")));
+    assert!(is_yaml_path(&PathBuf::from("BAZ.YAML")));
+    assert!(!is_yaml_path(&PathBuf::from("nope.txt")));
+}
+
+#[test]
+fn gather_yaml_from_dir_finds_yaml_files_only() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join("b.yml"), "b: 1\n").unwrap();
+    fs::write(root.join("not.yaml.txt"), "noop\n").unwrap();
+
+    let files = gather_yaml_from_dir(root);
+    let mut names: Vec<_> = files
+        .into_iter()
+        .map(|p| p.file_name().unwrap().to_string_lossy().into_owned())
+        .collect();
+    names.sort();
+    assert_eq!(names, vec!["a.yaml", "b.yml"]);
+}

package/tests/discover_per_file_dir.rs

@@ -0,0 +1,10 @@
+use ryl::config::discover_per_file;
+use tempfile::tempdir;
+
+#[test]
+fn discover_per_file_handles_directory_input() {
+    let td = tempdir().unwrap();
+    // No project or user config; falls back to built-in default.
+    let ctx = discover_per_file(td.path()).expect("discover default for dir");
+    assert!(ctx.config.rule_names().iter().any(|r| r == "anchors"));
+}

package/tests/discover_per_file_project_config_error.rs

@@ -0,0 +1,21 @@
+use std::fs;
+
+use ryl::config::discover_per_file;
+use tempfile::tempdir;
+
+#[test]
+fn discover_per_file_errors_on_invalid_project_config() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join(".yamllint"), "rules: {\n").unwrap();
+    let file = root.join("a.yaml");
+    fs::write(&file, "a: 1\n").unwrap();
+
+    let res = discover_per_file(&file);
+    assert!(
+        res.is_err(),
+        "expected parse error from invalid project config"
+    );
+    let err = res.err().unwrap();
+    assert!(err.contains("failed to parse config data"));
+}

package/tests/float_values.rs

@@ -0,0 +1,43 @@
+use ryl::config::YamlLintConfig;
+use ryl::rules::float_values::{Config, check};
+
+fn resolve_config(yaml: &str) -> Config {
+    let cfg = YamlLintConfig::from_yaml_str(yaml).expect("valid yaml config");
+    Config::resolve(&cfg)
+}
+
+#[test]
+fn float_values_flags_special_variants() {
+    let config = resolve_config(
+        "---\nrules:\n  float-values:\n    forbid-nan: true\n    forbid-inf: true\n    forbid-scientific-notation: true\n    require-numeral-before-decimal: true\n",
+    );
+
+    let buffer = "a: .NaN\nb: -.INF\nc: +.inf\nd: 1e2\ne: +.5\n";
+    let diagnostics = check(buffer, &config);
+    let messages: Vec<_> = diagnostics.iter().map(|d| d.message.as_str()).collect();
+    assert!(
+        messages.contains(&"forbidden not a number value \".NaN\""),
+        "messages: {:?}",
+        messages
+    );
+    assert!(
+        messages.contains(&"forbidden infinite value \"-.INF\""),
+        "messages: {:?}",
+        messages
+    );
+    assert!(
+        messages.contains(&"forbidden infinite value \"+.inf\""),
+        "messages: {:?}",
+        messages
+    );
+    assert!(
+        messages.contains(&"forbidden scientific notation \"1e2\""),
+        "messages: {:?}",
+        messages
+    );
+    assert!(
+        messages.contains(&"forbidden decimal missing 0 prefix \"+.5\""),
+        "messages: {:?}",
+        messages
+    );
+}

package/tests/lint_multi_errors.rs

@@ -0,0 +1,32 @@
+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 multiple_invalid_files_print_multiple_errors() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join("a.yaml"), "a: [1\n").unwrap();
+    fs::write(root.join("b.yaml"), "b: [2\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(Command::new(exe).arg(root));
+    assert_eq!(code, 1, "expected failure");
+    let count = err
+        .lines()
+        .filter(|l| l.trim().ends_with("(syntax)"))
+        .count();
+    assert!(
+        count >= 2,
+        "expected at least two syntax error lines, got: {err}"
+    );
+}

package/tests/main_yaml_ok_filtering.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 yaml_files_filtering_excludes_dir_and_explicit() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join("b.yaml"), "b: 1\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: ['*.none']\n")
+        .arg(root)
+        .arg(root.join("a.yaml")));
+    assert_eq!(code, 0, "expected success: {err}");
+    assert!(out.trim().is_empty(), "expected no files listed: {out}");
+}