@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/decoder_decode.rs

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

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

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

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

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

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

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

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

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

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

@@ -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 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}");
-}