@owenlamont/ryl 0.4.1

package/src/rules/truthy.rs

@@ -0,0 +1,420 @@
+use std::collections::HashSet;
+
+use saphyr_parser::{Event, Parser, ScalarStyle, Span, SpannedEventReceiver};
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "truthy";
+
+const TRUTHY_VALUES_YAML_1_1: [&str; 18] = [
+    "YES", "Yes", "yes", "NO", "No", "no", "TRUE", "True", "true", "FALSE", "False",
+    "false", "ON", "On", "on", "OFF", "Off", "off",
+];
+
+const TRUTHY_VALUES_YAML_1_2: [&str; 6] =
+    ["TRUE", "True", "true", "FALSE", "False", "false"];
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    allowed: HashSet<String>,
+    allowed_display: String,
+    pub check_keys: bool,
+}
+
+impl Config {
+    /// Resolve the rule configuration from the parsed yamllint config.
+    ///
+    /// # Panics
+    ///
+    /// Panics when `allowed-values` contains a non-string entry. The parser rejects
+    /// that configuration, so this only occurs with manual construction in tests.
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let mut allowed: HashSet<String> = HashSet::new();
+        allowed.insert("true".to_string());
+        allowed.insert("false".to_string());
+        let mut check_keys = true;
+
+        if let Some(node) = cfg.rule_option(ID, "allowed-values")
+            && let Some(seq) = node.as_sequence()
+        {
+            allowed.clear();
+            for value in seq {
+                let text = value
+                    .as_str()
+                    .expect("truthy allowed-values should be strings");
+                allowed.insert(text.to_owned());
+            }
+        }
+
+        if let Some(node) = cfg.rule_option(ID, "check-keys")
+            && let Some(flag) = node.as_bool()
+        {
+            check_keys = flag;
+        }
+
+        let mut display_values: Vec<&str> =
+            allowed.iter().map(String::as_str).collect();
+        display_values.sort_unstable();
+        let allowed_display = format!("[{}]", display_values.join(", "));
+
+        Self {
+            allowed,
+            allowed_display,
+            check_keys,
+        }
+    }
+
+    fn allows(&self, value: &str) -> bool {
+        self.allowed.contains(value)
+    }
+
+    fn allowed_display(&self) -> &str {
+        &self.allowed_display
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+    pub message: String,
+}
+
+#[derive(Debug)]
+struct ContainerState {
+    kind: ContainerKind,
+    key_context: bool,
+}
+
+#[derive(Debug)]
+enum ContainerKind {
+    Sequence,
+    Mapping { expect_key: bool },
+}
+
+#[derive(Debug)]
+struct TruthyState<'cfg> {
+    config: &'cfg Config,
+    containers: Vec<ContainerState>,
+    key_depth: usize,
+    current_version: (u32, u32),
+    bad_truthy: Option<HashSet<String>>,
+    directives: Vec<(usize, (u32, u32))>,
+    directive_index: usize,
+}
+
+impl<'cfg> TruthyState<'cfg> {
+    const fn new(config: &'cfg Config, directives: Vec<(usize, (u32, u32))>) -> Self {
+        Self {
+            config,
+            containers: Vec::new(),
+            key_depth: 0,
+            current_version: (1, 1),
+            bad_truthy: None,
+            directives,
+            directive_index: 0,
+        }
+    }
+
+    fn document_start(&mut self, span: Span) {
+        self.current_version = self.version_for_document(span.start.index());
+        self.bad_truthy = None;
+        self.key_depth = 0;
+        self.containers.clear();
+    }
+
+    fn document_end(&mut self) {
+        self.key_depth = 0;
+        self.containers.clear();
+    }
+
+    fn version_for_document(&mut self, doc_start: usize) -> (u32, u32) {
+        let mut version = None;
+        while self.directive_index < self.directives.len()
+            && self.directives[self.directive_index].0 < doc_start
+        {
+            version = Some(self.directives[self.directive_index].1);
+            self.directive_index += 1;
+        }
+        version.unwrap_or((1, 1))
+    }
+
+    fn begin_node(&mut self) -> bool {
+        let mut is_key_node = false;
+        if let Some(ContainerState {
+            kind: ContainerKind::Mapping { expect_key },
+            ..
+        }) = self.containers.last_mut()
+        {
+            if *expect_key {
+                is_key_node = true;
+                *expect_key = false;
+            } else {
+                *expect_key = true;
+            }
+        }
+
+        let active_key = is_key_node || self.key_depth > 0;
+        if active_key {
+            self.key_depth += 1;
+        }
+        active_key
+    }
+
+    fn enter_mapping(&mut self) {
+        let active_key = self.begin_node();
+        self.containers.push(ContainerState {
+            kind: ContainerKind::Mapping { expect_key: true },
+            key_context: active_key,
+        });
+    }
+
+    fn enter_sequence(&mut self) {
+        let active_key = self.begin_node();
+        self.containers.push(ContainerState {
+            kind: ContainerKind::Sequence,
+            key_context: active_key,
+        });
+    }
+
+    fn exit_container(&mut self) {
+        if let Some(container) = self.containers.pop()
+            && container.key_context
+            && self.key_depth > 0
+        {
+            self.key_depth -= 1;
+        }
+    }
+
+    const fn finish_scalar(&mut self, active_key: bool) {
+        if active_key && self.key_depth > 0 {
+            self.key_depth -= 1;
+        }
+    }
+
+    fn is_bad_truthy(&mut self, value: &str) -> bool {
+        if self.bad_truthy.is_none() {
+            let base = if self.current_version == (1, 2) {
+                &TRUTHY_VALUES_YAML_1_2[..]
+            } else {
+                &TRUTHY_VALUES_YAML_1_1[..]
+            };
+            let mut set: HashSet<String> = HashSet::new();
+            for candidate in base {
+                if !self.config.allows(candidate) {
+                    set.insert((*candidate).to_string());
+                }
+            }
+            self.bad_truthy = Some(set);
+        }
+        self.bad_truthy
+            .as_ref()
+            .expect("bad truthy set initialised")
+            .contains(value)
+    }
+
+    fn handle_scalar(
+        &mut self,
+        style: ScalarStyle,
+        value: &str,
+        tagged: bool,
+        span: Span,
+        diagnostics: &mut Vec<Violation>,
+    ) {
+        let active_key = self.begin_node();
+
+        if tagged {
+            self.finish_scalar(active_key);
+            return;
+        }
+
+        if !matches!(style, ScalarStyle::Plain) {
+            self.finish_scalar(active_key);
+            return;
+        }
+
+        if active_key && !self.config.check_keys {
+            self.finish_scalar(active_key);
+            return;
+        }
+
+        if self.is_bad_truthy(value) {
+            diagnostics.push(Violation {
+                line: span.start.line(),
+                column: span.start.col() + 1,
+                message: format!(
+                    "truthy value should be one of {}",
+                    self.config.allowed_display()
+                ),
+            });
+        }
+
+        self.finish_scalar(active_key);
+    }
+}
+
+struct TruthyReceiver<'cfg> {
+    state: TruthyState<'cfg>,
+    diagnostics: Vec<Violation>,
+}
+
+#[allow(clippy::missing_const_for_fn)]
+impl<'cfg> TruthyReceiver<'cfg> {
+    fn new(cfg: &'cfg Config, directives: Vec<(usize, (u32, u32))>) -> Self {
+        Self {
+            state: TruthyState::new(cfg, directives),
+            diagnostics: Vec::new(),
+        }
+    }
+}
+
+impl SpannedEventReceiver<'_> for TruthyReceiver<'_> {
+    fn on_event(&mut self, event: Event<'_>, span: Span) {
+        match event {
+            Event::StreamStart => {
+                self.state.current_version = (1, 1);
+                self.state.bad_truthy = None;
+                self.state.directive_index = 0;
+            }
+            Event::DocumentStart(_) => self.state.document_start(span),
+            Event::DocumentEnd => self.state.document_end(),
+            Event::SequenceStart(_, _) => self.state.enter_sequence(),
+            Event::SequenceEnd | Event::MappingEnd => self.state.exit_container(),
+            Event::MappingStart(_, _) => self.state.enter_mapping(),
+            Event::Scalar(value, style, _, tag) => {
+                let tagged = tag.is_some();
+                self.state.handle_scalar(
+                    style,
+                    value.as_ref(),
+                    tagged,
+                    span,
+                    &mut self.diagnostics,
+                );
+            }
+            Event::Alias(_) | Event::StreamEnd | Event::Nothing => {}
+        }
+    }
+}
+
+#[must_use]
+pub fn check(buffer: &str, cfg: &Config) -> Vec<Violation> {
+    let directives = collect_yaml_directives(buffer);
+    let mut parser = Parser::new_from_str(buffer);
+    let mut receiver = TruthyReceiver::new(cfg, directives);
+    let _ = parser.load(&mut receiver, true);
+    let mut diagnostics = receiver.diagnostics;
+    let disabled_lines = collect_truthy_disable_lines(buffer);
+    if !disabled_lines.is_empty() {
+        diagnostics.retain(|violation| !disabled_lines.contains(&violation.line));
+    }
+    diagnostics
+}
+
+fn collect_yaml_directives(buffer: &str) -> Vec<(usize, (u32, u32))> {
+    let mut directives = Vec::new();
+    let mut offset = 0;
+    for segment in buffer.split_inclusive(['\n']) {
+        let line = segment.trim_end_matches(['\n', '\r']);
+        if let Some(version) = parse_yaml_directive(line) {
+            let leading = line.len() - line.trim_start().len();
+            directives.push((offset + leading, version));
+        }
+        offset += segment.len();
+    }
+    directives
+}
+
+fn parse_yaml_directive(line: &str) -> Option<(u32, u32)> {
+    let trimmed = line.trim_start();
+    if !trimmed.starts_with("%YAML") {
+        return None;
+    }
+    let mut parts = trimmed.split_whitespace();
+    let _ = parts.next();
+    let version = parts.next()?;
+    let (major_raw, minor_raw) = version.split_once('.')?;
+    let major = major_raw.parse().ok()?;
+    let minor = minor_raw.parse().ok()?;
+    Some((major, minor))
+}
+
+fn collect_truthy_disable_lines(buffer: &str) -> HashSet<usize> {
+    let mut disabled = HashSet::new();
+    let mut disable_next = false;
+
+    for (index, segment) in buffer.split_inclusive(['\n']).enumerate() {
+        let line_number = index + 1;
+        let line = segment.trim_end_matches(['\n', '\r']);
+
+        if disable_next {
+            disabled.insert(line_number);
+            disable_next = false;
+        }
+
+        let Some(comment_start) = find_comment_start(line) else {
+            continue;
+        };
+
+        let inline = !line[..comment_start].trim().is_empty();
+        let comment = line[comment_start..].trim_end();
+
+        if disables_truthy(comment) {
+            if inline {
+                disabled.insert(line_number);
+            } else {
+                disable_next = true;
+            }
+        }
+    }
+
+    disabled
+}
+
+fn find_comment_start(line: &str) -> Option<usize> {
+    let mut in_single = false;
+    let mut in_double = false;
+    let mut escaped = false;
+    for (idx, ch) in line.char_indices() {
+        match ch {
+            '\\' if !in_single => {
+                escaped = !escaped;
+            }
+            '\'' if !escaped && !in_double => {
+                in_single = !in_single;
+            }
+            '"' if !escaped && !in_single => {
+                in_double = !in_double;
+            }
+            '#' if !escaped && !in_single && !in_double => return Some(idx),
+            _ => {
+                escaped = false;
+            }
+        }
+    }
+    None
+}
+
+fn disables_truthy(comment: &str) -> bool {
+    let trimmed = comment.trim_start_matches('#').trim_start();
+    if !trimmed.starts_with("yamllint disable-line") {
+        return false;
+    }
+    let rest = trimmed.trim_start_matches("yamllint disable-line").trim();
+    if rest.is_empty() {
+        return true;
+    }
+
+    let mut any_rules = false;
+    let mut matches = false;
+    for token in rest.split_whitespace() {
+        if let Some(name) = token.strip_prefix("rule:") {
+            any_rules = true;
+            if name == ID {
+                matches = true;
+            }
+        }
+    }
+
+    if any_rules { matches } else { true }
+}

package/tests/brackets_carriage_return.rs

@@ -0,0 +1,114 @@
+use ryl::rules::brackets::{Config, Forbid, check};
+
+fn config(forbid: Forbid) -> Config {
+    Config::new_for_tests(forbid, 0, 0, -1, -1)
+}
+
+#[test]
+fn brackets_carriage_return_without_line_feed_is_retained() {
+    let violations = check("[\r]", &config(Forbid::None));
+    assert!(violations.is_empty());
+}
+
+#[test]
+fn brackets_comment_crlf_is_ignored() {
+    let diagnostics = check("[# comment\r\n]", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_comment_carriage_return_is_ignored() {
+    let diagnostics = check("[# comment\r]", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_carriage_return_line_feed_is_ignored() {
+    let diagnostics = check("[\r\n]", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_comment_newline_is_ignored() {
+    let diagnostics = check("[# comment\n ]", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_non_scalar_marks_sequence_non_empty() {
+    let cfg = Config::new_for_tests(Forbid::NonEmpty, 0, 0, -1, -1);
+    let diagnostics = check("[ value ]", &cfg);
+    assert!(
+        diagnostics
+            .iter()
+            .any(|d| d.message == "forbidden flow sequence")
+    );
+}
+
+#[test]
+fn brackets_records_spacing_after_open() {
+    let cfg = Config::new_for_tests(Forbid::None, 1, 1, -1, -1);
+    let diagnostics = check("[value]", &cfg);
+    assert!(
+        diagnostics
+            .iter()
+            .any(|d| d.message == "too few spaces inside brackets")
+    );
+}
+
+#[test]
+fn brackets_records_spacing_too_many() {
+    let cfg = Config::new_for_tests(Forbid::None, -1, 0, -1, -1);
+    let diagnostics = check("[  value]", &cfg);
+    assert!(
+        diagnostics
+            .iter()
+            .any(|d| d.message == "too many spaces inside brackets")
+    );
+}
+
+#[test]
+fn brackets_spacing_ignored_across_newline() {
+    let diagnostics = check("[\n]", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_unmatched_closing_is_ignored() {
+    let diagnostics = check("]", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_plain_character_marks_sequence_non_empty() {
+    let cfg = Config::new_for_tests(Forbid::NonEmpty, 0, 0, -1, -1);
+    let diagnostics = check("[a]", &cfg);
+    assert!(
+        diagnostics
+            .iter()
+            .any(|d| d.message == "forbidden flow sequence")
+    );
+}
+
+#[test]
+fn brackets_comment_without_newline_is_ignored() {
+    let diagnostics = check("[# trailing comment", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_truncated_sequence_skips_spacing_checks() {
+    let diagnostics = check("[   ", &config(Forbid::None));
+    assert!(diagnostics.is_empty());
+}
+
+#[test]
+fn brackets_brace_content_marks_sequence_non_empty() {
+    let cfg = Config::new_for_tests(Forbid::NonEmpty, 0, 0, -1, -1);
+    let diagnostics = check("[{key: 1}]", &cfg);
+    assert!(
+        diagnostics
+            .iter()
+            .any(|d| d.message == "forbidden flow sequence")
+    );
+}

package/tests/build_global_cfg_error.rs

@@ -0,0 +1,23 @@
+use std::fs;
+use std::process::Command;
+
+use tempfile::tempdir;
+
+#[test]
+fn config_file_argument_pointing_to_directory_errors() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::create_dir(root.join("cfgdir")).unwrap();
+    fs::write(root.join("a.yaml"), "a: 1\n").unwrap();
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let out = Command::new(exe)
+        .arg("--list-files")
+        .arg("-c")
+        .arg(root.join("cfgdir"))
+        .arg(root)
+        .output()
+        .expect("run");
+    assert_eq!(out.status.code(), Some(2));
+    let err = String::from_utf8_lossy(&out.stderr);
+    assert!(err.contains("failed to read"));
+}

package/tests/cli_anchors_rule.rs

@@ -0,0 +1,143 @@
+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 anchors_reports_error() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("invalid.yaml");
+    fs::write(&file, "---\n- *missing\n- &missing 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("found undeclared alias \"missing\""),
+        "missing message: {output}"
+    );
+    assert!(
+        output.contains("anchors"),
+        "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- *missing\n- &missing value\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  anchors:\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 duplicate_anchor_reports_error_when_enabled() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("dupe.yaml");
+    fs::write(&file, "---\n- &anchor one\n- &anchor two\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  anchors:\n    forbid-duplicated-anchors: 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 = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("found duplicated anchor \"anchor\""),
+        "missing duplicate message: {output}"
+    );
+}
+
+#[test]
+fn unused_anchor_reports_error_when_enabled() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("unused.yaml");
+    fs::write(&file, "---\n- &anchor value\n- 1\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  anchors:\n    forbid-unused-anchors: 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 = if stderr.is_empty() { stdout } else { stderr };
+    assert!(
+        output.contains("found unused anchor \"anchor\""),
+        "missing unused message: {output}"
+    );
+}
+
+#[test]
+fn rule_ignore_skips_file() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("ignored.yaml");
+    fs::write(&file, "---\n- *missing\n").unwrap();
+    let config = dir.path().join("config.yml");
+    fs::write(
+        &config,
+        "rules:\n  document-start: disable\n  anchors:\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 alias_value_with_only_indent_prefix_is_supported() {
+    let dir = tempdir().unwrap();
+    let file = dir.path().join("alias.yaml");
+    fs::write(&file, "---\nvalue: &anchor literal\nalias:\n  *anchor\n").unwrap();
+
+    let exe = env!("CARGO_BIN_EXE_ryl");
+    let (code, stdout, stderr) = run(Command::new(exe).arg(&file));
+    assert_eq!(
+        code, 0,
+        "alias resolved successfully: stdout={stdout} stderr={stderr}"
+    );
+    assert!(stdout.trim().is_empty(), "expected no stdout: {stdout}");
+    assert!(stderr.trim().is_empty(), "expected no stderr: {stderr}");
+}