@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/colons_rule.rs

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

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

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

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

package/tests/conf_builtin.rs

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

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