@owenlamont/ryl 0.4.1 → 0.4.3

package/tests/cli_new_lines_rule.rs

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

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

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

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

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

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

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