@owenlamont/ryl 0.4.1

package/tests/cli_braces_rule.rs

@@ -0,0 +1,104 @@
+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 braces_reports_errors() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "---\nobject: { key: 1 }\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("too many spaces inside braces"),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("braces"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn forbid_flow_mappings_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("flow.yaml");
+    fs::write(&file, "---\nobject: {key: 1}\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  braces:\n    forbid: 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 failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("forbidden flow mapping"),
+        "missing message: {output}"
+    );
+}
+
+#[test]
+fn empty_spacing_config_is_respected() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("empty.yaml");
+    fs::write(&file, "---\nobject: {}\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  braces:\n    min-spaces-inside-empty: 1\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 = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("too few spaces inside empty braces"),
+        "missing message: {output}"
+    );
+}
+
+#[test]
+fn warning_level_does_not_fail() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "---\nobject: { key: 1 }\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  braces:\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}"
+    );
+}

package/tests/cli_brackets_rule.rs

@@ -0,0 +1,104 @@
+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 brackets_reports_errors() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "---\nobject: [ 1, 2 ]\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("too many spaces inside brackets"),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("brackets"),
+        "rule id missing from output: {output}"
+    );
+}
+
+#[test]
+fn forbid_flow_sequences_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("flow.yaml");
+    fs::write(&file, "---\nobject: [1, 2]\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  brackets:\n    forbid: 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 failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("forbidden flow sequence"),
+        "missing message: {output}"
+    );
+}
+
+#[test]
+fn empty_spacing_config_is_respected() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("empty.yaml");
+    fs::write(&file, "---\nobject: []\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  brackets:\n    min-spaces-inside-empty: 1\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 = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("too few spaces inside empty brackets"),
+        "missing message: {output}"
+    );
+}
+
+#[test]
+fn warning_level_does_not_fail() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "---\nobject: [ 1, 2 ]\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  brackets:\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}"
+    );
+}

package/tests/cli_colons_rule.rs

@@ -0,0 +1,65 @@
+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 colons_reports_spacing_errors() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "---\nkey :  value\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  colons: 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 failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("too many spaces before colon"),
+        "missing before-colon message: {output}"
+    );
+    assert!(
+        output.contains("too many spaces after colon"),
+        "missing after-colon message: {output}"
+    );
+    assert!(output.contains("colons"), "rule id missing: {output}");
+}
+
+#[test]
+fn colons_reports_explicit_key_spacing() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("explicit.yaml");
+    fs::write(&file, "---\n?  key\n: value\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  colons: 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 failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("too many spaces after question mark"),
+        "missing question mark message: {output}"
+    );
+}

package/tests/cli_commas_rule.rs

@@ -0,0 +1,104 @@
+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 commas_reports_errors() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "---\n[1,2]\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("too few spaces after comma"),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("commas"),
+        "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, "---\n[1,2]\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  commas:\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, "---\n[1,2]\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  commas:\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}");
+}
+
+#[test]
+fn relaxed_spacing_allows_compact_flow() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("compact.yaml");
+    fs::write(&file, "---\n[1,2]\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  commas:\n    max-spaces-before: -1\n    min-spaces-after: 0\n    max-spaces-after: -1\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,
+        "relaxed spacing 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_comments_indentation_rule.rs

@@ -0,0 +1,61 @@
+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 comments_indentation_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "obj:\n # wrong\n  value: 1\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  comments-indentation: 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 exit 1: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("comments-indentation"),
+        "missing rule id: {output}"
+    );
+    assert!(
+        output.contains("comment not indented like content"),
+        "missing message: {output}"
+    );
+}
+
+#[test]
+fn comments_indentation_allows_aligned_comment() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ok.yaml");
+    fs::write(&file, "obj:\n  # ok\n  value: 1\n").unwrap();
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  comments-indentation: 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, 0, "expected success: stdout={stdout} stderr={stderr}");
+    assert!(stdout.is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_comments_rule.rs

@@ -0,0 +1,67 @@
+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 comments_rule_emits_diagnostics() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "#comment\nkey: value # comment\nvalue: foo #bar\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  comments:\n    require-starting-space: true\n    ignore-shebangs: true\n    min-spaces-from-content: 2\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 exit 1: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("comments"),
+        "missing rule identifier in output: {output}"
+    );
+    assert!(
+        output.contains("missing starting space in comment"),
+        "missing starting-space message: {output}"
+    );
+    assert!(
+        output.contains("too few spaces before comment: expected 2"),
+        "missing spacing message: {output}"
+    );
+}
+
+#[test]
+fn comments_rule_ignores_shebang_when_enabled() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("shebang.yaml");
+    fs::write(&file, "#!/usr/bin/env foo\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  comments:\n    require-starting-space: true\n    ignore-shebangs: 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, 0, "expected success: stdout={stdout} stderr={stderr}");
+    assert!(stdout.is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_config_data_error.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("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 invalid_inline_config_causes_exit_2() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("file.yaml");
+    fs::write(&file, "key: value\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(Command::new(exe)
+        .arg("-d")
+        .arg("extends: missing-config")
+        .arg(&file));
+    assert_eq!(code, 2, "missing inline extends should exit 2: {err}");
+    assert!(
+        err.contains("failed to read"),
+        "expected config read error: {err}"
+    );
+}

package/tests/cli_config_flags.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 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 config_file_ignores_docs_globally() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir_all(root.join("docs")).unwrap();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join("docs/ignored.yaml"), "x: 0\n").unwrap();
+
+    let cfg = root.join("cfg.yml");
+    fs::write(&cfg, "ignore: ['docs/**']\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, out, err) = run(Command::new(exe)
+        .arg("--list-files")
+        .arg("-c")
+        .arg(&cfg)
+        .arg(root));
+    assert_eq!(code, 0, "expected success: {err}");
+    assert!(out.contains("a.yaml"));
+    assert!(!out.contains("docs/ignored.yaml"));
+}
+
+#[test]
+fn config_data_yaml_files_only_lists_dot_yamllint_yml() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    fs::write(root.join(".yamllint.yml"), "rules: {}\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: ['**/.yamllint.yml']\n")
+        .arg(root));
+    assert_eq!(code, 0, "expected success: {err}");
+    assert!(out.contains(".yamllint.yml"));
+    assert!(!out.contains("a.yaml"));
+}
+
+#[test]
+fn format_strict_no_warnings_are_accepted() {
+    let td = tempdir().unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(Command::new(exe)
+        .arg("--list-files")
+        .arg("-f")
+        .arg("standard")
+        .arg("-s")
+        .arg("--no-warnings")
+        .arg(td.path()));
+    assert_eq!(code, 0, "expected success: {err}");
+}