@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/cli_hyphens_rule.rs

@@ -1,104 +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("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

@@ -1,65 +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("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

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

@@ -1,104 +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("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

@@ -1,59 +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("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

@@ -1,85 +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("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

@@ -1,29 +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("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

@@ -1,141 +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("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}"
-    );
-}