@owenlamont/ryl 0.4.1

package/tests/colons_rule.rs

@@ -0,0 +1,303 @@
+use ryl::rules::colons::{self, Config};
+
+fn violation_points(content: &str, cfg: Config) -> Vec<(usize, usize, String)> {
+    let mut hits = colons::check(content, &cfg);
+    hits.sort_by(|a, b| a.line.cmp(&b.line).then(a.column.cmp(&b.column)));
+    hits.into_iter()
+        .map(|hit| (hit.line, hit.column, hit.message))
+        .collect()
+}
+
+#[test]
+fn config_getters_return_values() {
+    let cfg = Config::new_for_tests(3, 4);
+    assert_eq!(cfg.max_spaces_before(), 3);
+    assert_eq!(cfg.max_spaces_after(), 4);
+}
+
+#[test]
+fn no_violation_with_defaults() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("key: value\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn empty_input_returns_no_violations() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn detects_excess_spaces_before_colon() {
+    let cfg = Config::new_for_tests(0, -1);
+    let points = violation_points("key : value\n", cfg);
+    assert_eq!(
+        points,
+        vec![(1, 4, "too many spaces before colon".to_string())]
+    );
+}
+
+#[test]
+fn detects_excess_spaces_after_colon() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("key:  value\n", cfg);
+    assert_eq!(
+        points,
+        vec![(1, 6, "too many spaces after colon".to_string())]
+    );
+}
+
+#[test]
+fn detects_excess_spaces_after_question_mark() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("?  key\n: value\n", cfg);
+    assert_eq!(
+        points,
+        vec![(1, 3, "too many spaces after question mark".to_string())],
+    );
+}
+
+#[test]
+fn ignores_alias_immediately_before_colon() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("- anchor: &a key\n- *a: 42\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn flags_alias_with_extra_spaces() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("- anchor: &a key\n- *a  : 42\n", cfg);
+    assert_eq!(
+        points,
+        vec![(2, 6, "too many spaces before colon".to_string())]
+    );
+}
+
+#[test]
+fn skips_colons_inside_comments() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("# comment: text\nkey: value\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn handles_crlf_after_colon() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("key:\r\n  value\rnext: pair\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn question_mark_not_explicit_is_ignored() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("value? trailing\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn sequence_question_mark_spacing_detected() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("- ?  key\n  :  value\n", cfg);
+    assert_eq!(
+        points,
+        vec![
+            (1, 5, "too many spaces after question mark".to_string()),
+            (2, 5, "too many spaces after colon".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn question_mark_spacing_disabled_skips_check() {
+    let cfg = Config::new_for_tests(-1, -1);
+    let points = violation_points("?  key\n: value\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn comment_with_crlf_is_ignored() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("# note: here\r\nkey: value\r\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn colon_at_line_start_reports_after_spacing() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points(":  value\n", cfg);
+    assert_eq!(
+        points,
+        vec![(1, 3, "too many spaces after colon".to_string())]
+    );
+}
+
+#[test]
+fn colon_at_end_of_file_is_ignored() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("key:", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn colon_followed_by_carriage_return_is_ignored() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("key:\rvalue\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn flow_question_mark_spacing_detected() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("[?  key: value]\n", cfg);
+    assert_eq!(
+        points,
+        vec![(1, 4, "too many spaces after question mark".to_string())]
+    );
+}
+
+#[test]
+fn indented_sequence_question_mark_spacing_detected() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("parent:\n  - ?  child\n    :  value\n", cfg);
+    assert_eq!(
+        points,
+        vec![
+            (2, 7, "too many spaces after question mark".to_string()),
+            (3, 7, "too many spaces after colon".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn hyphen_not_sequence_does_not_trigger_question_mark_rule() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("a- ? key\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn question_mark_without_space_not_explicit() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("?key: value\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn dash_without_space_before_question_mark_is_ignored() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let points = violation_points("-?  key\n  : value\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn colons_inside_scalars_with_multibyte_chars_are_ignored() {
+    let cfg = Config::new_for_tests(0, 1);
+    let points = violation_points("key: \"café: menu\"\n", cfg);
+    assert!(points.is_empty());
+}
+
+#[test]
+fn inline_comment_after_colon_is_ignored_for_spacing() {
+    let cfg = Config::new_for_tests(-1, 0);
+    let points = violation_points("key:  # note\n", cfg);
+    assert!(
+        points.is_empty(),
+        "inline comment should bypass spacing check: {points:?}"
+    );
+}
+
+#[test]
+fn coverage_explicit_question_mark_handles_non_whitespace_next() {
+    let chars: Vec<(usize, char)> = "?key".char_indices().collect();
+    assert!(!colons::coverage_is_explicit_question_mark(&chars, 0));
+}
+
+#[test]
+fn coverage_explicit_question_mark_handles_sequence_indicator_branch() {
+    let chars: Vec<(usize, char)> = " - ? key".char_indices().collect();
+    assert!(colons::coverage_is_explicit_question_mark(&chars, 3));
+}
+
+#[test]
+fn coverage_sequence_indicator_false_branch() {
+    let chars: Vec<(usize, char)> = "a-".char_indices().collect();
+    assert!(!colons::coverage_is_sequence_indicator(&chars, 1));
+}
+
+#[test]
+fn coverage_explicit_question_mark_handles_regular_char_before() {
+    let chars: Vec<(usize, char)> = "a ? ".char_indices().collect();
+    assert!(!colons::coverage_is_explicit_question_mark(&chars, 2));
+}
+
+#[test]
+fn coverage_evaluate_question_mark_reports_violation() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let violations = colons::coverage_evaluate_question_mark("?  key\n: value\n", &cfg);
+    assert!(
+        violations
+            .iter()
+            .any(|v| v.message.contains("too many spaces after question mark"))
+    );
+}
+
+#[test]
+fn coverage_explicit_question_mark_handles_flow_prefix_variants() {
+    let bracket_chars: Vec<(usize, char)> = "[ ? key".char_indices().collect();
+    assert!(colons::coverage_is_explicit_question_mark(
+        &bracket_chars,
+        2
+    ));
+    let brace_chars: Vec<(usize, char)> = "{ ? key".char_indices().collect();
+    assert!(colons::coverage_is_explicit_question_mark(&brace_chars, 2));
+    let comma_chars: Vec<(usize, char)> = ", ? key".char_indices().collect();
+    assert!(colons::coverage_is_explicit_question_mark(&comma_chars, 2));
+}
+
+#[test]
+fn coverage_question_mark_immediate_newline_is_ignored() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let violations = colons::coverage_evaluate_question_mark("? \n: value\n", &cfg);
+    assert!(violations.is_empty());
+}
+
+#[test]
+fn coverage_question_mark_crlf_is_ignored() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let violations = colons::coverage_evaluate_question_mark("? \r\n: value\n", &cfg);
+    assert!(violations.is_empty());
+}
+
+#[test]
+fn coverage_skip_comment_handles_crlf() {
+    assert!(colons::coverage_skip_comment("# comment\r\nrest"));
+}
+
+#[test]
+fn coverage_skip_comment_handles_standalone_cr() {
+    assert!(!colons::coverage_skip_comment("# comment\rrest"));
+}
+
+#[test]
+fn coverage_evaluate_question_mark_without_marker_is_noop() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let violations = colons::coverage_evaluate_question_mark("key: value\n", &cfg);
+    assert!(violations.is_empty());
+}
+
+#[test]
+fn coverage_question_mark_within_limit_on_same_line() {
+    let cfg = Config::new_for_tests(-1, 1);
+    let violations = colons::coverage_evaluate_question_mark("? key: value\n", &cfg);
+    assert!(violations.is_empty());
+}
+
+#[test]
+fn coverage_check_handles_comment_crlf() {
+    let cfg = Config::new_for_tests(0, 1);
+    let result = colons::check("# heading\r\nkey: value\n", &cfg);
+    assert!(result.is_empty());
+}

package/tests/common/compat.rs

@@ -0,0 +1,114 @@
+use std::process::Command;
+
+pub 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)
+}
+
+pub fn ensure_yamllint_installed() {
+    let ok = Command::new("yamllint")
+        .arg("--version")
+        .output()
+        .map(|out| out.status.success())
+        .unwrap_or(false);
+    assert!(ok, "yamllint must be installed for compatibility tests");
+}
+
+pub fn normalize_output(stdout: String, stderr: String) -> String {
+    let output = if stderr.is_empty() { stdout } else { stderr };
+    // Normalize line endings to LF for cross-platform compatibility
+    output.replace("\r\n", "\n")
+}
+
+pub fn capture_with_env(
+    mut cmd: Command,
+    envs: &[(&str, Option<&str>)],
+) -> (i32, String) {
+    cmd.env_remove("GITHUB_ACTIONS");
+    cmd.env_remove("GITHUB_WORKFLOW");
+    cmd.env_remove("CI");
+    cmd.env_remove("FORCE_COLOR");
+    cmd.env_remove("NO_COLOR");
+    for (key, value) in envs {
+        if let Some(v) = value {
+            cmd.env(key, v);
+        } else {
+            cmd.env_remove(key);
+        }
+    }
+    let (code, stdout, stderr) = run(&mut cmd);
+    (code, normalize_output(stdout, stderr))
+}
+
+#[derive(Clone, Copy)]
+pub struct Scenario {
+    pub label: &'static str,
+    pub envs: &'static [(&'static str, Option<&'static str>)],
+    pub ryl_format: Option<&'static str>,
+    pub yam_format: Option<&'static str>,
+}
+
+pub const STANDARD_ENV: &[(&str, Option<&str>)] = &[];
+pub const GITHUB_ENV: &[(&str, Option<&str>)] = &[
+    ("GITHUB_ACTIONS", Some("true")),
+    ("GITHUB_WORKFLOW", Some("test-workflow")),
+    ("CI", Some("true")),
+];
+
+pub const SCENARIOS: &[Scenario] = &[
+    Scenario {
+        label: "auto-standard",
+        envs: STANDARD_ENV,
+        ryl_format: None,
+        yam_format: None,
+    },
+    Scenario {
+        label: "auto-github",
+        envs: GITHUB_ENV,
+        ryl_format: None,
+        yam_format: None,
+    },
+    Scenario {
+        label: "format-standard",
+        envs: STANDARD_ENV,
+        ryl_format: Some("standard"),
+        yam_format: Some("standard"),
+    },
+    Scenario {
+        label: "format-colored",
+        envs: STANDARD_ENV,
+        ryl_format: Some("colored"),
+        yam_format: Some("colored"),
+    },
+    Scenario {
+        label: "format-github",
+        envs: STANDARD_ENV,
+        ryl_format: Some("github"),
+        yam_format: Some("github"),
+    },
+    Scenario {
+        label: "format-parsable",
+        envs: STANDARD_ENV,
+        ryl_format: Some("parsable"),
+        yam_format: Some("parsable"),
+    },
+];
+
+pub fn build_ryl_command(exe: &str, format: Option<&str>) -> Command {
+    let mut cmd = Command::new(exe);
+    if let Some(fmt) = format {
+        cmd.arg("--format").arg(fmt);
+    }
+    cmd
+}
+
+pub fn build_yamllint_command(format: Option<&str>) -> Command {
+    let mut cmd = Command::new("yamllint");
+    if let Some(fmt) = format {
+        cmd.arg("-f").arg(fmt);
+    }
+    cmd
+}

package/tests/common/fake_env.rs

@@ -0,0 +1,93 @@
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+use ryl::config::Env;
+
+#[derive(Clone, Default)]
+pub struct FakeEnv {
+    cwd: PathBuf,
+    files: HashMap<PathBuf, String>,
+    exists: HashSet<PathBuf>,
+    vars: HashMap<String, String>,
+    config_dir: Option<PathBuf>,
+    home: Option<PathBuf>,
+}
+
+#[allow(dead_code)]
+impl FakeEnv {
+    pub fn new() -> Self {
+        Self {
+            cwd: PathBuf::from("."),
+            ..Self::default()
+        }
+    }
+
+    pub fn with_cwd(mut self, path: impl Into<PathBuf>) -> Self {
+        self.cwd = path.into();
+        self
+    }
+
+    pub fn with_config_dir(mut self, path: impl Into<PathBuf>) -> Self {
+        self.config_dir = Some(path.into());
+        self
+    }
+
+    pub fn with_file(
+        mut self,
+        path: impl Into<PathBuf>,
+        content: impl Into<String>,
+    ) -> Self {
+        self.files.insert(path.into(), content.into());
+        self
+    }
+
+    pub fn with_exists(mut self, path: impl Into<PathBuf>) -> Self {
+        self.exists.insert(path.into());
+        self
+    }
+
+    pub fn with_var(
+        mut self,
+        key: impl Into<String>,
+        value: impl Into<String>,
+    ) -> Self {
+        self.vars.insert(key.into(), value.into());
+        self
+    }
+
+    pub fn with_home(mut self, path: impl Into<PathBuf>) -> Self {
+        self.home = Some(path.into());
+        self
+    }
+}
+
+impl Env for FakeEnv {
+    fn current_dir(&self) -> PathBuf {
+        self.cwd.clone()
+    }
+
+    fn config_dir(&self) -> Option<PathBuf> {
+        self.config_dir.clone()
+    }
+
+    fn read_to_string(&self, p: &Path) -> Result<String, String> {
+        self.files.get(p).cloned().ok_or_else(|| {
+            format!("failed to read config file {}: not found", p.display())
+        })
+    }
+
+    fn path_exists(&self, p: &Path) -> bool {
+        self.files.contains_key(p) || self.exists.contains(p)
+    }
+
+    fn env_var(&self, key: &str) -> Option<String> {
+        self.vars.get(key).cloned()
+    }
+
+    fn home_dir(&self) -> Option<PathBuf> {
+        self.home
+            .clone()
+            .or_else(|| self.vars.get("HOME").map(PathBuf::from))
+            .or_else(|| self.vars.get("USERPROFILE").map(PathBuf::from))
+    }
+}

package/tests/common/mod.rs

@@ -0,0 +1 @@
+pub mod fake_env;

package/tests/conf_builtin.rs

@@ -0,0 +1,9 @@
+use ryl::conf::builtin;
+
+#[test]
+fn builtin_presets_are_available() {
+    assert!(builtin("default").is_some());
+    assert!(builtin("relaxed").is_some());
+    assert!(builtin("empty").is_some());
+    assert!(builtin("nonexistent").is_none());
+}

package/tests/config_anchors.rs

@@ -0,0 +1,84 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn anchors_allows_boolean_options() {
+    let cfg = r#"
+rules:
+  anchors:
+    forbid-undeclared-aliases: false
+    forbid-duplicated-anchors: true
+    forbid-unused-anchors: true
+"#;
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("parse");
+
+    assert!(ctx.config.rule_names().iter().any(|r| r == "anchors"));
+}
+
+#[test]
+fn anchors_rejects_non_bool_option() {
+    let cfg = r#"
+rules:
+  anchors:
+    forbid-duplicated-anchors: "yes"
+"#;
+
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect_err("invalid value");
+
+    assert!(err.contains("forbid-duplicated-anchors"));
+}
+
+#[test]
+fn anchors_rejects_unknown_option() {
+    let cfg = r#"
+rules:
+  anchors:
+    unknown: true
+"#;
+
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect_err("unknown option");
+
+    assert!(err.contains("unknown option \"unknown\" for rule \"anchors\""));
+}
+
+#[test]
+fn anchors_rejects_non_string_option_key() {
+    let cfg = r#"
+rules:
+  anchors:
+    ? [1, 2]
+    : true
+"#;
+
+    let err = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect_err("non-string key");
+
+    assert!(err.contains("unknown option") && err.contains("anchors"));
+}