@owenlamont/ryl 0.4.1

package/tests/cli_new_lines_rule.rs

@@ -0,0 +1,119 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("process");
+    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)
+}
+
+fn command_output<'a>(stdout: &'a str, stderr: &'a str) -> &'a str {
+    if stderr.is_empty() { stdout } else { stderr }
+}
+
+#[test]
+fn unix_type_reports_crlf() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("crlf.yaml");
+    fs::write(&file, "key: value\r\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: unix\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("wrong new line character: expected \\n"),
+        "missing expected message: {output}"
+    );
+    assert!(output.contains("new-lines"), "rule id missing: {output}");
+    assert!(output.contains("1:11"), "incorrect column: {output}");
+}
+
+#[test]
+fn dos_type_reports_lf() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("lf.yaml");
+    fs::write(&file, "key: value\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: dos\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("wrong new line character: expected \\r\\n"),
+        "missing expected message: {output}"
+    );
+    assert!(output.contains("new-lines"), "rule id missing: {output}");
+}
+
+#[test]
+fn dos_type_accepts_crlf() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ok.yaml");
+    fs::write(&file, "key: value\r\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: dos\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 0, "expected success: stdout={stdout} stderr={stderr}");
+}
+
+#[test]
+fn platform_type_uses_detected_newline() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("platform.yaml");
+    let mismatch = if cfg!(windows) {
+        "key: value\n"
+    } else {
+        "key: value\r\n"
+    };
+    fs::write(&file, mismatch).unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  new-lines:\n    type: platform\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = command_output(&stdout, &stderr);
+    if cfg!(windows) {
+        assert!(
+            output.contains("wrong new line character: expected \\r\\n"),
+            "windows platform expectation mismatch: {output}"
+        );
+    } else {
+        assert!(
+            output.contains("wrong new line character: expected \\n"),
+            "unix platform expectation mismatch: {output}"
+        );
+    }
+    assert!(output.contains("new-lines"), "rule id missing: {output}");
+}

package/tests/cli_octal_values_rule.rs

@@ -0,0 +1,60 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("process");
+    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)
+}
+
+fn command_output<'a>(stdout: &'a str, stderr: &'a str) -> &'a str {
+    if stderr.is_empty() { stdout } else { stderr }
+}
+
+#[test]
+fn octal_rule_reports_plain_values() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("values.yaml");
+    fs::write(&file, "foo: 010\nbar: 0o10\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  octal-values: enable\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 1,
+        "expected lint failure: stdout={stdout} stderr={stderr}"
+    );
+
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("forbidden implicit octal value \"010\""),
+        "missing implicit message: {output}"
+    );
+    assert!(
+        output.contains("forbidden explicit octal value \"0o10\""),
+        "missing explicit message: {output}"
+    );
+    assert!(
+        output.contains("octal-values"),
+        "rule label missing: {output}"
+    );
+    assert!(
+        output.contains("1:9"),
+        "expected implicit octal position: {output}"
+    );
+    assert!(
+        output.contains("2:10"),
+        "expected explicit octal position: {output}"
+    );
+}

package/tests/cli_quoted_strings_rule.rs

@@ -0,0 +1,47 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("process");
+    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)
+}
+
+fn command_output<'a>(stdout: &'a str, stderr: &'a str) -> &'a str {
+    if stderr.is_empty() { stdout } else { stderr }
+}
+
+#[test]
+fn quoted_strings_reports_redundant_quotes() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("data.yaml");
+    fs::write(&file, "foo: \"bar\"\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  quoted-strings:\n    required: only-when-needed\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 1,
+        "expected lint failure: stdout={stdout} stderr={stderr}"
+    );
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("string value is redundantly quoted with any quotes"),
+        "missing redundant quote message: {output}"
+    );
+    assert!(
+        output.contains("quoted-strings"),
+        "rule label missing: {output}"
+    );
+}

package/tests/cli_toml_config.rs

@@ -0,0 +1,119 @@
+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 project_toml_overrides_yaml_and_emits_single_warning() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir_all(root.join("dir")).unwrap();
+    fs::write(root.join("dir/a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join("dir/b.yaml"), "b: 2\n").unwrap();
+    fs::write(
+        root.join(".ryl.toml"),
+        "yaml-files = ['**/a.yaml', '**/b.yaml']\n[rules]\nanchors = 'disable'\n",
+    )
+    .unwrap();
+    fs::write(root.join(".yamllint"), "yaml-files: ['**/a.yaml']\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe).arg("--list-files").arg(root));
+    assert_eq!(code, 0, "expected success: stdout={stdout} stderr={stderr}");
+    assert!(stdout.contains("a.yaml"));
+    assert!(stdout.contains("b.yaml"));
+    let warning_count = stderr
+        .matches("warning: ignoring legacy YAML config discovery because TOML config")
+        .count();
+    assert_eq!(warning_count, 1, "stderr={stderr}");
+}
+
+#[test]
+fn explicit_pyproject_without_tool_ryl_errors() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    let pyproject = root.join("pyproject.toml");
+    fs::write(
+        &pyproject,
+        "[project]\nname = 'demo'\nversion = '0.1.0'\nrequires-python = '>=3.10'\n",
+    )
+    .unwrap();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--list-files")
+        .arg("-c")
+        .arg(&pyproject)
+        .arg(root.join("a.yaml")));
+    assert_eq!(code, 2);
+    assert!(stderr.contains("missing [tool.ryl] section"));
+}
+
+#[test]
+fn global_config_notice_is_emitted_when_env_var_triggers_global_discovery() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join(".ryl.toml"), "[rules]\nanchors = 'disable'\n").unwrap();
+    fs::write(root.join(".yamllint"), "rules: {}\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .env("YAMLLINT_CONFIG_FILE", "/does/not/exist.yml")
+        .arg("--list-files")
+        .arg(root.join("a.yaml")));
+    assert_eq!(code, 0, "stderr={stderr}");
+    assert!(stderr.contains(
+        "warning: ignoring legacy YAML config discovery because TOML config"
+    ));
+}
+
+#[test]
+fn explicit_file_discovery_emits_notice() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join(".ryl.toml"), "[rules]\nanchors = 'disable'\n").unwrap();
+    fs::write(root.join(".yamllint"), "rules: {}\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--list-files")
+        .arg(root.join("a.yaml")));
+    assert_eq!(code, 0, "stderr={stderr}");
+    assert!(stderr.contains(
+        "warning: ignoring legacy YAML config discovery because TOML config"
+    ));
+}
+
+#[test]
+fn explicit_notice_is_deduplicated_after_directory_notice() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir_all(root.join("one")).unwrap();
+    fs::create_dir_all(root.join("two")).unwrap();
+    fs::write(root.join("one/from_dir.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join("two/from_file.yaml"), "b: 2\n").unwrap();
+    fs::write(root.join(".ryl.toml"), "[rules]\nanchors = 'disable'\n").unwrap();
+    fs::write(root.join(".yamllint"), "rules: {}\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _stdout, stderr) = run(Command::new(exe)
+        .arg("--list-files")
+        .arg(root.join("one"))
+        .arg(root.join("two/from_file.yaml")));
+    assert_eq!(code, 0, "stderr={stderr}");
+    let warning_count = stderr
+        .matches("warning: ignoring legacy YAML config discovery because TOML config")
+        .count();
+    assert_eq!(warning_count, 1, "stderr={stderr}");
+}

package/tests/cli_trailing_spaces_rule.rs

@@ -0,0 +1,77 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("process");
+    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 trailing_spaces_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "key: value \n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("trailing spaces"),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("trailing-spaces"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn warning_level_does_not_fail() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "key: value \n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(&config, "rules:\n  trailing-spaces:\n    level: warning\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 0,
+        "warnings should not fail: stdout={stdout} stderr={stderr}"
+    );
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("warning"),
+        "expected warning output: {output}"
+    );
+}
+
+#[test]
+fn rule_ignore_skips_file() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ignored.yaml");
+    fs::write(&file, "key: value \n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  trailing-spaces:\n    ignore:\n      - ignored.yaml\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 0,
+        "ignored file should pass: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_truthy_rule.rs

@@ -0,0 +1,83 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn run(cmd: &mut Command) -> (i32, String, String) {
+    let out = cmd.output().expect("process");
+    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)
+}
+
+fn command_output<'a>(stdout: &'a str, stderr: &'a str) -> &'a str {
+    if stderr.is_empty() { stdout } else { stderr }
+}
+
+#[test]
+fn truthy_rule_reports_plain_truthy_values() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("values.yaml");
+    fs::write(&file, "foo: True\nbar: yes\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  truthy: enable\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 1,
+        "expected lint failure: stdout={stdout} stderr={stderr}"
+    );
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("truthy value should be one of [false, true]"),
+        "missing truthy message: {output}"
+    );
+    assert!(output.contains("truthy"), "rule label missing: {output}");
+    assert!(
+        output.contains("1:6"),
+        "expected position for value 'True': {output}"
+    );
+    assert!(
+        output.contains("2:6"),
+        "expected position for value 'yes': {output}"
+    );
+}
+
+#[test]
+fn truthy_rule_respects_check_keys_false() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("keys.yaml");
+    fs::write(&file, "True: yes\nvalue: True\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  truthy:\n    allowed-values: []\n    check-keys: false\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&config).arg(&file));
+    assert_eq!(
+        code, 1,
+        "expected lint failure: stdout={stdout} stderr={stderr}"
+    );
+    let output = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("2:8"),
+        "value position should be reported when keys are skipped: {output}"
+    );
+    assert!(
+        !output.contains("1:1"),
+        "keys should be ignored when disabled: {output}"
+    );
+}

package/tests/cli_yaml_files_negation.rs

@@ -0,0 +1,45 @@
+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 command");
+    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_negation_excludes_files_via_cli() {
+    let dir = tempdir().unwrap();
+    let root = dir.path();
+    let cfg_path = root.join("config.yml");
+
+    fs::write(
+        &cfg_path,
+        "rules:\n  truthy: enable\nyaml-files: ['*.yaml', '!skip.yaml']\n",
+    )
+    .unwrap();
+    fs::write(root.join("keep.yaml"), "value: Yes\n").unwrap();
+    fs::write(root.join("skip.yaml"), "value: Yes\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&cfg_path).arg(root));
+
+    assert_eq!(
+        code, 1,
+        "expected lint failure: stdout={stdout} stderr={stderr}"
+    );
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("keep.yaml"),
+        "expected keep.yaml diagnostics, got:\n{output}"
+    );
+    assert!(
+        !output.contains("skip.yaml"),
+        "unexpected diagnostics for skip.yaml:\n{output}"
+    );
+}