@owenlamont/ryl 0.4.1

package/tests/cli_hyphens_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 hyphens_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "---\n-  item\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 after hyphen"),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("hyphens"),
+        "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-  item\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  hyphens:\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-  item\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  hyphens:\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 custom_max_allows_extra_spacing() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("custom.yaml");
+    fs::write(&file, "---\n-   item\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  hyphens:\n    max-spaces-after: 3\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,
+        "custom max 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_indentation_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 indentation_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "root:\n- item\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("indentation"), "missing rule id: {output}");
+    assert!(
+        output.contains("wrong indentation"),
+        "missing message: {output}"
+    );
+}
+
+#[test]
+fn indentation_warning_respected() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "root:\n- item\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(&config, "rules:\n  indentation:\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, "expected warning exit");
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    assert!(output.contains("warning"), "missing warning line: {output}");
+}
+
+#[test]
+fn indentation_sequences_false_skips() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ok.yaml");
+    fs::write(&file, "root:\n- item\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  indentation:\n    indent-sequences: 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, 0, "indent-sequences false should pass");
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}

package/tests/cli_invalid_project_config.rs

@@ -0,0 +1,39 @@
+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 invalid_project_config_in_dir_causes_exit_2() {
+    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_ryl");
+    let (code, _out, err) = run(Command::new(exe).arg("--list-files").arg(root));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to read"));
+}
+
+#[test]
+fn invalid_project_config_for_explicit_file_causes_exit_2() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir(root.join(".yamllint")).unwrap();
+    let f = root.join("a.yaml");
+    fs::write(&f, "a: 1\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, _out, err) = run(Command::new(exe).arg("--list-files").arg(&f));
+    assert_eq!(code, 2, "expected exit 2: {err}");
+    assert!(err.contains("failed to read"));
+}

package/tests/cli_key_duplicates_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)
+}
+
+fn command_output<'a>(stdout: &'a str, stderr: &'a str) -> &'a str {
+    if stderr.is_empty() { stdout } else { stderr }
+}
+
+#[test]
+fn duplicate_keys_reported() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("dup.yaml");
+    fs::write(&file, "foo: 1\nbar: 2\nfoo: 3\n").unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  key-duplicates: 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 = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("duplication of key \"foo\" in mapping"),
+        "missing key duplication message: {output}"
+    );
+    assert!(
+        output.contains("key-duplicates"),
+        "rule id missing: {output}"
+    );
+}
+
+#[test]
+fn merge_keys_allowed_by_default() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("merge.yaml");
+    fs::write(
+        &file,
+        "anchor: &a\n  value: 1\nmerged:\n  <<: *a\n  <<: *a\n",
+    )
+    .unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  key-duplicates: 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,
+        "merge keys allowed by default: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}
+
+#[test]
+fn merge_keys_forbidden_when_configured() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("merge.yaml");
+    fs::write(
+        &file,
+        "anchor: &a\n  value: 1\nmerged:\n  <<: *a\n  <<: *a\n",
+    )
+    .unwrap();
+
+    let config = dir.path().join("config.yaml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  key-duplicates:\n    forbid-duplicated-merge-keys: 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 = command_output(&stdout, &stderr);
+    assert!(
+        output.contains("duplication of key \"<<\" in mapping"),
+        "missing merge duplication message: {output}"
+    );
+    assert!(
+        output.contains("key-duplicates"),
+        "rule id missing: {output}"
+    );
+}

package/tests/cli_key_ordering_rule.rs

@@ -0,0 +1,59 @@
+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 key_ordering_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(&file, "block mapping:\n  second: value\n  first: value\n").unwrap();
+
+    let cfg = dir.path().join("config.yml");
+    fs::write(
+        &cfg,
+        "rules:\n  document-start: disable\n  key-ordering: enable\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe).arg("-c").arg(&cfg).arg(&file));
+    assert_eq!(code, 1, "expected failure: stdout={stdout} stderr={stderr}");
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("wrong ordering of key \"first\" in mapping"),
+        "missing message: {output}"
+    );
+    assert!(output.contains("key-ordering"), "rule id missing: {output}");
+}
+
+#[test]
+fn ignored_keys_skip_enforcement() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ignored.yaml");
+    fs::write(&file, "name: zed\nfirst-name: zed\na: 1\n").unwrap();
+
+    let cfg = dir.path().join("config.yml");
+    fs::write(
+        &cfg,
+        "rules:\n  document-start: disable\n  key-ordering:\n    ignored-keys: [\"name\", \"first-name\"]\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe).arg("-c").arg(&cfg).arg(&file));
+    assert_eq!(
+        code, 0,
+        "ignored keys should not fail: 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_line_length_rule.rs

@@ -0,0 +1,85 @@
+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 line_length_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("bad.yaml");
+    fs::write(
+        &file,
+        "key: this line is deliberately far longer than the eighty character default limit so it should fail\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("line too long"),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("line-length"),
+        "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, format!("{}\n", "W".repeat(40))).unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  line-length:\n    max: 20\n    allow-non-breakable-words: false\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, format!("{}\n", "Z".repeat(120))).unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  line-length:\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_list_files.rs

@@ -0,0 +1,29 @@
+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 list_files_outputs_expected_entries() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("sample.yaml");
+    fs::write(&file, "key: value\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) =
+        run(Command::new(exe).arg("--list-files").arg(dir.path()));
+    assert_eq!(code, 0, "list-files should succeed: stderr={stderr}");
+    assert!(stderr.trim().is_empty(), "unexpected stderr: {stderr}");
+    assert!(
+        stdout.contains("sample.yaml"),
+        "expected stdout to include listed file: {stdout}"
+    );
+}

package/tests/cli_new_line_rule.rs

@@ -0,0 +1,141 @@
+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 missing_newline_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("no_newline.yaml");
+    fs::write(&file, "key: value").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("no new line character at the end of file"),
+        "missing rule message: {output}"
+    );
+    assert!(
+        output.contains("new-line-at-end-of-file"),
+        "rule id missing: {output}"
+    );
+}
+
+#[test]
+fn newline_present_succeeds() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ok.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, 0, "expected success: stdout={stdout} stderr={stderr}");
+}
+
+#[test]
+fn warning_level_does_not_fail() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "key: value").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  new-line-at-end-of-file:\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 disabled_new_line_rule_allows_success() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("no_newline.yaml");
+    fs::write(&file, "key: value").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(&config, "rules:\n  new-line-at-end-of-file: disable\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,
+        "disabled rule should pass: stdout={stdout} stderr={stderr}"
+    );
+}
+
+#[test]
+fn no_warnings_flag_suppresses_output() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "key: value").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  new-line-at-end-of-file:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--no-warnings")
+        .arg("-c")
+        .arg(&config)
+        .arg(&file));
+    assert_eq!(
+        code, 0,
+        "no-warnings should suppress warning exit: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}
+
+#[test]
+fn strict_mode_with_warning_exits_with_two() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("warn.yaml");
+    fs::write(&file, "key: value").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  new-line-at-end-of-file:\n    level: warning\n",
+    )
+    .unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe)
+        .arg("--strict")
+        .arg("-c")
+        .arg(&config)
+        .arg(&file));
+    assert_eq!(
+        code, 2,
+        "strict mode should return 2 for warnings: stdout={stdout} stderr={stderr}"
+    );
+    let output = if stderr.is_empty() { &stdout } else { &stderr };
+    assert!(
+        output.contains("warning"),
+        "expected warning output: {output}"
+    );
+}