@owenlamont/ryl 0.4.1

package/tests/cli_file_encoding.rs

@@ -0,0 +1,203 @@
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+fn write_utf16le(path: &Path, content: &str) {
+    let mut data = Vec::with_capacity(2 + content.len() * 2);
+    data.extend_from_slice(&[0xFF, 0xFE]);
+    for unit in content.encode_utf16() {
+        let bytes = unit.to_le_bytes();
+        data.extend_from_slice(&bytes);
+    }
+    fs::write(path, data).unwrap();
+}
+
+fn write_latin1(path: &Path, content: &str) {
+    let mut data = Vec::with_capacity(content.len());
+    for ch in content.chars() {
+        let code = ch as u32;
+        assert!(
+            code <= 0xFF,
+            "latin-1 helper only supports code points <= 0xFF"
+        );
+        data.push(code as u8);
+    }
+    fs::write(path, data).unwrap();
+}
+
+fn write_utf32le(path: &Path, content: &str) {
+    let mut data = Vec::with_capacity(4 + content.len() * 4);
+    data.extend_from_slice(&[0xFF, 0xFE, 0x00, 0x00]);
+    for ch in content.chars() {
+        let code = ch as u32;
+        data.extend_from_slice(&code.to_le_bytes());
+    }
+    fs::write(path, data).unwrap();
+}
+
+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 cli_reads_utf16_config_file() {
+    let dir = tempdir().unwrap();
+    let cfg_path = dir.path().join("utf16-config.yml");
+    let yaml_path = dir.path().join("bad.yaml");
+
+    write_utf16le(&cfg_path, "rules:\n  truthy: enable\n");
+    fs::write(&yaml_path, "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(&yaml_path));
+    assert_eq!(
+        code, 1,
+        "expected lint failures: stdout={stdout} stderr={stderr}"
+    );
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("truthy"),
+        "expected truthy diagnostics in output, got:\n{output}"
+    );
+}
+
+#[test]
+fn cli_reads_utf16_yaml_input() {
+    let dir = tempdir().unwrap();
+    let cfg_path = dir.path().join("config.yml");
+    let yaml_path = dir.path().join("utf16.yaml");
+
+    write_utf16le(&cfg_path, "rules:\n  truthy: enable\n");
+    write_utf16le(&yaml_path, "value: Yes\n");
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("-c").arg(&cfg_path).arg(&yaml_path));
+    assert_eq!(
+        code, 1,
+        "expected lint failures: stdout={stdout} stderr={stderr}"
+    );
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("truthy"),
+        "expected truthy diagnostics in output, got:\n{output}"
+    );
+}
+
+#[test]
+fn cli_honors_yamllint_file_encoding_override() {
+    let dir = tempdir().unwrap();
+    let cfg_path = dir.path().join("latin-config.yml");
+    let yaml_path = dir.path().join("latin.yaml");
+
+    write_latin1(&cfg_path, "rules:\n  truthy: enable\n");
+    write_latin1(&yaml_path, "acción: yes\n");
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("YAMLLINT_FILE_ENCODING", "latin-1")
+        .arg("-c")
+        .arg(&cfg_path)
+        .arg(&yaml_path));
+
+    assert_eq!(
+        code, 1,
+        "expected lint failures: stdout={stdout} stderr={stderr}"
+    );
+    let message = if stderr.is_empty() {
+        stdout.clone()
+    } else {
+        stderr.clone()
+    };
+    assert!(
+        message.contains("truthy"),
+        "expected truthy diagnostics in output, got:\n{message}"
+    );
+    assert!(
+        stderr.contains("YAMLLINT_FILE_ENCODING is meant for temporary workarounds"),
+        "expected override warning on stderr, got:\n{stderr}"
+    );
+}
+
+#[test]
+fn cli_override_utf16_variants() {
+    let dir = tempdir().unwrap();
+    let yaml_path = dir.path().join("data.yaml");
+
+    write_utf16le(&yaml_path, "value: Yes\n");
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("YAMLLINT_FILE_ENCODING", "UTF_16")
+        .arg("--config-data")
+        .arg("rules:\n  truthy: enable\n")
+        .arg(&yaml_path));
+
+    assert_eq!(
+        code, 1,
+        "expected lint failures: stdout={stdout} stderr={stderr}"
+    );
+    let message = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        message.contains("truthy"),
+        "expected truthy diagnostics, got:\n{message}"
+    );
+}
+
+#[test]
+fn cli_override_utf32_variants() {
+    let dir = tempdir().unwrap();
+    let yaml_path = dir.path().join("utf32.yaml");
+
+    write_utf32le(&yaml_path, "value: Yes\n");
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("YAMLLINT_FILE_ENCODING", "utf32le")
+        .arg("--config-data")
+        .arg("rules:\n  truthy: enable\n")
+        .arg(&yaml_path));
+
+    assert_eq!(
+        code, 1,
+        "expected lint failures: stdout={stdout} stderr={stderr}"
+    );
+    let message = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        message.contains("truthy"),
+        "expected truthy diagnostics, got:\n{message}"
+    );
+}
+
+#[test]
+fn cli_override_unknown_label_errors() {
+    let dir = tempdir().unwrap();
+    let cfg_path = dir.path().join("config.yml");
+    let yaml_path = dir.path().join("file.yaml");
+
+    fs::write(&cfg_path, "rules:\n  truthy: enable\n").unwrap();
+    fs::write(&yaml_path, "value: Yes\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("YAMLLINT_FILE_ENCODING", "unsupported-encoding")
+        .arg("-c")
+        .arg(&cfg_path)
+        .arg(&yaml_path));
+
+    assert_eq!(
+        code, 2,
+        "expected usage error: stdout={stdout} stderr={stderr}"
+    );
+    assert!(
+        stderr.contains("unsupported label"),
+        "expected unsupported label error, got:\n{stderr}"
+    );
+}

package/tests/cli_float_values_rule.rs

@@ -0,0 +1,64 @@
+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 float_values_rule_reports_forbidden_variants() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("values.yaml");
+    fs::write(&file, "a: .5\nb: 1e2\nc: .nan\nd: .inf\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  float-values:\n    require-numeral-before-decimal: true\n    forbid-scientific-notation: true\n    forbid-nan: true\n    forbid-inf: true\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 decimal missing 0 prefix \".5\""),
+        "missing decimal prefix message: {output}"
+    );
+    assert!(
+        output.contains("forbidden scientific notation \"1e2\""),
+        "missing scientific notation message: {output}"
+    );
+    assert!(
+        output.contains("forbidden not a number value \".nan\""),
+        "missing nan message: {output}"
+    );
+    assert!(
+        output.contains("forbidden infinite value \".inf\""),
+        "missing inf message: {output}"
+    );
+    assert!(
+        output.contains("float-values"),
+        "rule label missing: {output}"
+    );
+    assert!(output.contains("1:4"), "expected .5 position: {output}");
+    assert!(output.contains("2:4"), "expected 1e2 position: {output}");
+    assert!(output.contains("3:4"), "expected .nan position: {output}");
+    assert!(output.contains("4:4"), "expected .inf position: {output}");
+}

package/tests/cli_format_options.rs

@@ -0,0 +1,316 @@
+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)
+}
+
+fn disable_doc_start_config(dir: &std::path::Path) -> std::path::PathBuf {
+    let cfg = dir.join("config.yml");
+    fs::write(
+        &cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file: enable\n",
+    )
+    .unwrap();
+    cfg
+}
+
+#[test]
+fn parsable_format_outputs_expected_diagnostic() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("parsable")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "parsable format should keep error exit");
+    assert!(stdout.is_empty(), "parsable format should write to stderr");
+    let lines: Vec<&str> = stderr.lines().collect();
+    assert_eq!(lines.len(), 1, "expected single diagnostic line: {stderr}");
+    let line = lines[0];
+    assert!(
+        line.contains(&format!(":{}:{}: [error]", 1, 11)),
+        "missing location: {line}"
+    );
+    assert!(
+        line.contains(
+            "no new line character at the end of file (new-line-at-end-of-file)"
+        ),
+        "unexpected diagnostic payload: {line}"
+    );
+
+    let warn_cfg = dir.path().join("config-warning.yml");
+    fs::write(
+        &warn_cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file:\n    level: warning\n",
+    )
+    .unwrap();
+    let (warn_code, warn_stdout, warn_stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("parsable")
+        .arg("-c")
+        .arg(&warn_cfg)
+        .arg(&file));
+    assert_eq!(warn_code, 0, "warning-level parsable format should exit 0");
+    assert!(warn_stdout.is_empty(), "warnings should emit on stderr");
+    assert!(
+        warn_stderr.contains("[warning]"),
+        "expected warning line: {warn_stderr}"
+    );
+}
+
+#[test]
+fn parsable_format_omits_rule_suffix_for_syntax_errors() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("invalid.yaml");
+    fs::write(&file, "foo: [1, 2\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("parsable")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "syntax errors should exit 1");
+    assert!(
+        stdout.is_empty(),
+        "syntax diagnostics should print to stderr"
+    );
+    let lines: Vec<&str> = stderr.lines().collect();
+    assert_eq!(lines.len(), 1, "expected single diagnostic line: {stderr}");
+    let diagnostic = lines[0];
+    assert!(
+        diagnostic.contains("[error]"),
+        "syntax diagnostic must report an error: {diagnostic}"
+    );
+    assert!(
+        diagnostic.contains("(syntax)"),
+        "missing syntax marker: {diagnostic}"
+    );
+    assert!(
+        !diagnostic.contains("(syntax) ("),
+        "syntax diagnostics must not include rule suffix: {diagnostic}"
+    );
+}
+
+#[test]
+fn github_format_emits_workflow_commands() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("github")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "github format should keep error exit");
+    assert!(stdout.is_empty(), "github format writes to stderr");
+    assert!(
+        stderr.contains("::group::"),
+        "missing GitHub group: {stderr}"
+    );
+    assert!(
+        stderr.contains("::error file="),
+        "missing GitHub error command: {stderr}"
+    );
+    assert!(
+        stderr.contains("::endgroup::"),
+        "missing GitHub endgroup: {stderr}"
+    );
+}
+
+#[test]
+fn colored_format_uses_ansi_sequences() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("colored")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "colored format should keep error exit");
+    assert!(stdout.is_empty(), "colored format writes to stderr");
+    assert!(
+        stderr.contains("\u{001b}[4m") && stderr.contains("\u{001b}[31m"),
+        "expected ANSI sequences in colored output: {stderr}"
+    );
+
+    let warn_cfg = dir.path().join("config-warning.yml");
+    fs::write(
+        &warn_cfg,
+        "rules:\n  document-start: disable\n  new-line-at-end-of-file:\n    level: warning\n",
+    )
+    .unwrap();
+    let (warn_code, warn_stdout, warn_stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("colored")
+        .arg("-c")
+        .arg(&warn_cfg)
+        .arg(&file));
+    assert_eq!(warn_code, 0, "warning-level colored output should exit 0");
+    assert!(warn_stdout.is_empty(), "warnings should emit on stderr");
+    assert!(
+        warn_stderr.contains("\u{001b}[33mwarning")
+            && warn_stderr.contains("(new-line-at-end-of-file)"),
+        "expected colored warning payload: {warn_stderr}"
+    );
+}
+
+#[test]
+fn colored_format_omits_rule_suffix_for_syntax_errors() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("syntax.yaml");
+    fs::write(&file, "foo: [1, 2\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("colored")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "syntax errors should exit 1");
+    assert!(
+        stdout.is_empty(),
+        "syntax diagnostics should print to stderr"
+    );
+    let lines: Vec<&str> = stderr
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+        .collect();
+    assert!(
+        lines.len() >= 2,
+        "expected path and diagnostic lines: {stderr}"
+    );
+    let diagnostic = lines[1];
+    assert!(
+        diagnostic.contains("(syntax)"),
+        "missing syntax marker: {diagnostic}"
+    );
+    assert!(
+        !diagnostic.contains("  \u{001b}[2m("),
+        "syntax diagnostics must not include colored rule suffix: {diagnostic}"
+    );
+}
+
+#[test]
+fn colored_format_matches_reference_layout() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("layout.yaml");
+    fs::write(&file, "list: [1,2]\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("--format").arg("colored").arg(&file));
+    assert_eq!(code, 1, "colored format should exit 1 when errors occur");
+    assert!(
+        stdout.is_empty(),
+        "colored format diagnostics must print on stderr"
+    );
+    let expected = format!(
+        "\u{001b}[4m{path}\u{001b}[0m\n  \u{001b}[2m1:1\u{001b}[0m       \u{001b}[33mwarning\u{001b}[0m  missing document start \"---\"  \u{001b}[2m(document-start)\u{001b}[0m\n  \u{001b}[2m1:10\u{001b}[0m      \u{001b}[31merror\u{001b}[0m    too few spaces after comma  \u{001b}[2m(commas)\u{001b}[0m\n\n",
+        path = file.display()
+    );
+    assert_eq!(stderr, expected, "colored diagnostic payload mismatch");
+}
+
+#[test]
+fn standard_format_remains_plain_text() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--format")
+        .arg("standard")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "standard format should keep error exit");
+    assert!(stdout.is_empty(), "standard format writes to stderr");
+    assert!(
+        !stderr.contains("\u{001b}"),
+        "standard format should not use ANSI: {stderr}"
+    );
+    assert!(
+        !stderr.contains("::group::"),
+        "standard format should not emit GitHub commands: {stderr}"
+    );
+}
+
+#[test]
+fn auto_format_honors_force_color_env() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("FORCE_COLOR", "1")
+        .env_remove("NO_COLOR")
+        .env_remove("GITHUB_ACTIONS")
+        .env_remove("GITHUB_WORKFLOW")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "auto format should keep error exit");
+    assert!(
+        stdout.is_empty(),
+        "auto format writes diagnostics to stderr"
+    );
+    assert!(
+        stderr.contains("\u{001b}[4m") && stderr.contains("\u{001b}[31m"),
+        "force color should enable colored output: {stderr}"
+    );
+}
+
+#[test]
+fn auto_format_respects_no_color_env() {
+    let dir = tempdir().unwrap();
+    let cfg = disable_doc_start_config(dir.path());
+    let file = dir.path().join("missing.yaml");
+    fs::write(&file, "key: value").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .env("FORCE_COLOR", "1")
+        .env("NO_COLOR", "1")
+        .env_remove("GITHUB_ACTIONS")
+        .env_remove("GITHUB_WORKFLOW")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(&file));
+    assert_eq!(code, 1, "auto format with NO_COLOR keeps error exit");
+    assert!(stdout.is_empty(), "diagnostics should be on stderr");
+    assert!(
+        !stderr.contains("\u{001b}"),
+        "NO_COLOR should disable ANSI sequences: {stderr}"
+    );
+}

package/tests/cli_global_cfg_relaxed.rs

@@ -0,0 +1,20 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+#[test]
+fn cli_inline_preset_expands_relaxed() {
+    let td = tempdir().unwrap();
+    let yaml = td.path().join("file.yaml");
+    fs::write(&yaml, "key: value\n").unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let output = Command::new(exe)
+        .arg("--list-files")
+        .arg("-d")
+        .arg("relaxed")
+        .arg(td.path())
+        .output()
+        .expect("run cli");
+    assert_eq!(output.status.code(), Some(0));
+}