@owenlamont/ryl 0.4.1

package/src/rules/comments_indentation.rs

@@ -0,0 +1,243 @@
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "comments-indentation";
+pub const MESSAGE: &str = "comment not indented like content";
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct Config;
+
+impl Config {
+    #[must_use]
+    pub const fn resolve(_cfg: &YamlLintConfig) -> Self {
+        Self
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+}
+
+#[must_use]
+pub fn check(buffer: &str, _cfg: &Config) -> Vec<Violation> {
+    let mut diagnostics: Vec<Violation> = Vec::new();
+    if buffer.is_empty() {
+        return diagnostics;
+    }
+
+    let mut block_tracker = BlockScalarTracker::default();
+    let mut lines: Vec<LineInfo> = Vec::new();
+
+    for raw_line in buffer.lines() {
+        let line = raw_line.trim_end_matches('\r');
+        let indent = leading_whitespace_width(line);
+        let content = &line[indent..];
+
+        let consumed = block_tracker.consume_line(indent, content);
+        let kind = if consumed {
+            LineKind::BlockScalarContent
+        } else {
+            classify_line_kind(content)
+        };
+
+        lines.push(LineInfo { indent, kind });
+        block_tracker.observe_indicator(indent, content);
+    }
+
+    let prev_content_indents = compute_prev_content_indents(&lines);
+    let next_content_indents = compute_next_content_indents(&lines);
+
+    let mut last_comment_indent: Option<usize> = None;
+
+    for (idx, line) in lines.iter().enumerate() {
+        match line.kind {
+            LineKind::Comment => {
+                let prev_indent = prev_content_indents[idx].unwrap_or(0);
+                let next_indent = next_content_indents[idx].unwrap_or(0);
+
+                let reference_indent =
+                    last_comment_indent.unwrap_or_else(|| prev_indent.max(next_indent));
+
+                if line.indent != reference_indent && line.indent != next_indent {
+                    diagnostics.push(Violation {
+                        line: idx + 1,
+                        column: line.indent + 1,
+                    });
+                }
+
+                last_comment_indent = Some(line.indent);
+            }
+            LineKind::Other | LineKind::DirectiveComment => {
+                last_comment_indent = None;
+            }
+            LineKind::Empty | LineKind::BlockScalarContent => {}
+        }
+    }
+
+    diagnostics
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct LineInfo {
+    indent: usize,
+    kind: LineKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum LineKind {
+    Empty,
+    Comment,
+    DirectiveComment,
+    BlockScalarContent,
+    Other,
+}
+
+fn classify_line_kind(content: &str) -> LineKind {
+    let trimmed = content.trim_start_matches([' ', '\t']);
+
+    if trimmed.is_empty() {
+        LineKind::Empty
+    } else if trimmed.starts_with("# yamllint ") {
+        LineKind::DirectiveComment
+    } else if trimmed.starts_with('#') {
+        LineKind::Comment
+    } else {
+        LineKind::Other
+    }
+}
+
+fn leading_whitespace_width(line: &str) -> usize {
+    line.chars()
+        .take_while(|ch| matches!(ch, ' ' | '\t'))
+        .count()
+}
+
+#[derive(Debug, Default)]
+struct BlockScalarTracker {
+    state: Option<BlockScalarState>,
+}
+
+#[derive(Debug)]
+struct BlockScalarState {
+    indicator_indent: usize,
+    content_indent: Option<usize>,
+}
+
+impl BlockScalarTracker {
+    fn consume_line(&mut self, indent: usize, content: &str) -> bool {
+        let Some(state) = self.state.as_mut() else {
+            return false;
+        };
+
+        if content.trim().is_empty() {
+            return true;
+        }
+
+        let updated_indent = if let Some(content_indent) = state.content_indent {
+            if indent >= content_indent {
+                return true;
+            }
+            if indent <= state.indicator_indent {
+                self.state = None;
+                return false;
+            }
+            content_indent.min(indent)
+        } else {
+            if indent <= state.indicator_indent {
+                self.state = None;
+                return false;
+            }
+            indent
+        };
+        state.content_indent = Some(updated_indent);
+        true
+    }
+
+    fn observe_indicator(&mut self, indent: usize, content: &str) {
+        let candidate = strip_trailing_comment_for_block(content).trim_end();
+        if is_block_scalar_indicator(candidate) {
+            self.state = Some(BlockScalarState {
+                indicator_indent: indent,
+                content_indent: None,
+            });
+        }
+    }
+}
+
+fn compute_prev_content_indents(lines: &[LineInfo]) -> Vec<Option<usize>> {
+    let mut result: Vec<Option<usize>> = Vec::with_capacity(lines.len());
+    let mut latest: Option<usize> = None;
+    for line in lines {
+        if line.kind == LineKind::Other {
+            latest = Some(line.indent);
+        }
+        result.push(latest);
+    }
+    result
+}
+
+fn compute_next_content_indents(lines: &[LineInfo]) -> Vec<Option<usize>> {
+    let mut result: Vec<Option<usize>> = vec![None; lines.len()];
+    let mut upcoming: Option<usize> = None;
+    for (idx, line) in lines.iter().enumerate().rev() {
+        if line.kind == LineKind::Other {
+            upcoming = Some(line.indent);
+        }
+        result[idx] = upcoming;
+    }
+    result
+}
+
+fn strip_trailing_comment_for_block(content: &str) -> &str {
+    let mut in_single = false;
+    let mut in_double = false;
+    let mut escaped = false;
+    for (idx, ch) in content.char_indices() {
+        if ch == '\\' && !in_single {
+            escaped = !escaped;
+            continue;
+        }
+
+        if escaped {
+            escaped = false;
+            continue;
+        }
+
+        match ch {
+            '\'' if !in_double => {
+                in_single = !in_single;
+            }
+            '"' if !in_single => {
+                in_double = !in_double;
+            }
+            '#' if !in_single && !in_double => {
+                return content[..idx].trim_end();
+            }
+            _ => {}
+        }
+    }
+    content.trim_end()
+}
+
+fn is_block_scalar_indicator(content: &str) -> bool {
+    if content.is_empty() {
+        return false;
+    }
+
+    let trimmed = content.trim_end_matches(|ch: char| ch.is_whitespace());
+    let marker_idx = if trimmed.ends_with("|-")
+        || trimmed.ends_with("|+")
+        || trimmed.ends_with(">-")
+        || trimmed.ends_with(">+")
+    {
+        trimmed.len().saturating_sub(2)
+    } else if trimmed.ends_with('|') || trimmed.ends_with('>') {
+        trimmed.len().saturating_sub(1)
+    } else {
+        return false;
+    };
+
+    let prefix = trimmed[..marker_idx].trim_end();
+    prefix.ends_with(':') || prefix.ends_with('-') || prefix.ends_with('?')
+}

package/src/rules/document_end.rs

@@ -0,0 +1,175 @@
+use std::cmp;
+
+use saphyr_parser::{Event, Parser, Span, SpannedEventReceiver};
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "document-end";
+pub const MISSING_MESSAGE: &str = "missing document end \"...\"";
+pub const FORBIDDEN_MESSAGE: &str = "found forbidden document end \"...\"";
+
+#[must_use]
+pub fn classify_document_end_marker_bytes(bytes: &[u8]) -> Option<&'static str> {
+    let trimmed = trim_ascii(bytes);
+    if trimmed == b"..." {
+        Some("...")
+    } else if trimmed == b"---" {
+        Some("---")
+    } else {
+        None
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Config {
+    present: bool,
+}
+
+impl Config {
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let present = cfg
+            .rule_option(ID, "present")
+            .and_then(saphyr::YamlOwned::as_bool)
+            .unwrap_or(true);
+        Self { present }
+    }
+
+    #[must_use]
+    pub const fn new_for_tests(present: bool) -> Self {
+        Self { present }
+    }
+
+    #[must_use]
+    pub const fn requires_marker(&self) -> bool {
+        self.present
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Marker {
+    ExplicitEnd,
+    DocumentStart,
+    Other,
+}
+
+#[must_use]
+pub fn check(buffer: &str, cfg: &Config) -> Vec<Violation> {
+    let mut parser = Parser::new_from_str(buffer);
+    let mut receiver = DocumentEndReceiver::new(buffer, cfg);
+    let _ = parser.load(&mut receiver, true);
+    receiver.violations
+}
+
+struct DocumentEndReceiver<'src, 'cfg> {
+    source: &'src str,
+    config: &'cfg Config,
+    violations: Vec<Violation>,
+    pending_stream_end_violation: bool,
+}
+
+impl<'src, 'cfg> DocumentEndReceiver<'src, 'cfg> {
+    const fn new(source: &'src str, config: &'cfg Config) -> Self {
+        Self {
+            source,
+            config,
+            violations: Vec::new(),
+            pending_stream_end_violation: false,
+        }
+    }
+
+    fn handle_document_end(&mut self, span: Span) {
+        let marker = self.marker(span);
+
+        if !self.config.requires_marker() {
+            self.pending_stream_end_violation = false;
+            if matches!(marker, Marker::ExplicitEnd) {
+                self.violations.push(Violation {
+                    line: span.start.line(),
+                    column: span.start.col() + 1,
+                    message: FORBIDDEN_MESSAGE.to_string(),
+                });
+            }
+            return;
+        }
+
+        match marker {
+            Marker::ExplicitEnd => {
+                self.pending_stream_end_violation = false;
+            }
+            Marker::DocumentStart => {
+                self.pending_stream_end_violation = false;
+                self.violations.push(Violation {
+                    line: span.start.line(),
+                    column: 1,
+                    message: MISSING_MESSAGE.to_string(),
+                });
+            }
+            Marker::Other => {
+                self.pending_stream_end_violation = true;
+            }
+        }
+    }
+
+    fn handle_stream_end(&mut self, span: Span) {
+        if !self.config.requires_marker() || !self.pending_stream_end_violation {
+            return;
+        }
+
+        let raw_line = span.start.line();
+        let line = cmp::max(1, raw_line.saturating_sub(1));
+        self.violations.push(Violation {
+            line,
+            column: 1,
+            message: MISSING_MESSAGE.to_string(),
+        });
+        self.pending_stream_end_violation = false;
+    }
+
+    fn marker(&self, span: Span) -> Marker {
+        let start = span.start.index().min(self.source.len());
+        let end = span.end.index().min(self.source.len());
+        let slice = if start < end {
+            &self.source.as_bytes()[start..end]
+        } else {
+            &[]
+        };
+
+        match classify_document_end_marker_bytes(slice) {
+            Some("...") => Marker::ExplicitEnd,
+            Some("---") => Marker::DocumentStart,
+            _ => Marker::Other,
+        }
+    }
+}
+
+impl SpannedEventReceiver<'_> for DocumentEndReceiver<'_, '_> {
+    fn on_event(&mut self, event: Event<'_>, span: Span) {
+        match event {
+            Event::DocumentEnd => self.handle_document_end(span),
+            Event::StreamEnd => self.handle_stream_end(span),
+            _ => {}
+        }
+    }
+}
+
+fn trim_ascii(bytes: &[u8]) -> &[u8] {
+    let mut start = 0usize;
+    let mut end = bytes.len();
+
+    while start < end && bytes[start].is_ascii_whitespace() {
+        start += 1;
+    }
+    while start < end && bytes[end - 1].is_ascii_whitespace() {
+        end -= 1;
+    }
+
+    &bytes[start..end]
+}

package/src/rules/document_start.rs

@@ -0,0 +1,84 @@
+use saphyr_parser::{Event, Parser, Span, SpannedEventReceiver};
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "document-start";
+pub const MISSING_MESSAGE: &str = "missing document start \"---\"";
+pub const FORBIDDEN_MESSAGE: &str = "found forbidden document start \"---\"";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Config {
+    present: bool,
+}
+
+impl Config {
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let present = cfg
+            .rule_option(ID, "present")
+            .and_then(saphyr::YamlOwned::as_bool)
+            .unwrap_or(true);
+        Self { present }
+    }
+
+    #[must_use]
+    pub const fn new_for_tests(present: bool) -> Self {
+        Self { present }
+    }
+
+    #[must_use]
+    pub const fn requires_marker(&self) -> bool {
+        self.present
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+    pub message: String,
+}
+
+#[must_use]
+pub fn check(buffer: &str, cfg: &Config) -> Vec<Violation> {
+    let mut parser = Parser::new_from_str(buffer);
+    let mut receiver = DocumentStartReceiver::new(cfg);
+    let _ = parser.load(&mut receiver, true);
+    receiver.violations
+}
+
+struct DocumentStartReceiver<'cfg> {
+    config: &'cfg Config,
+    violations: Vec<Violation>,
+}
+
+impl<'cfg> DocumentStartReceiver<'cfg> {
+    const fn new(config: &'cfg Config) -> Self {
+        Self {
+            config,
+            violations: Vec::new(),
+        }
+    }
+}
+
+impl SpannedEventReceiver<'_> for DocumentStartReceiver<'_> {
+    fn on_event(&mut self, event: Event<'_>, span: Span) {
+        if let Event::DocumentStart(explicit) = event {
+            if self.config.requires_marker() {
+                if !explicit {
+                    self.violations.push(Violation {
+                        line: span.start.line(),
+                        column: 1,
+                        message: MISSING_MESSAGE.to_string(),
+                    });
+                }
+            } else if explicit {
+                self.violations.push(Violation {
+                    line: span.start.line(),
+                    column: span.start.col() + 1,
+                    message: FORBIDDEN_MESSAGE.to_string(),
+                });
+            }
+        }
+    }
+}

package/src/rules/empty_lines.rs

@@ -0,0 +1,152 @@
+use std::convert::TryFrom;
+
+use saphyr::YamlOwned;
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "empty-lines";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Config {
+    max: i64,
+    max_start: i64,
+    max_end: i64,
+}
+
+impl Config {
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let max = cfg
+            .rule_option(ID, "max")
+            .and_then(YamlOwned::as_integer)
+            .unwrap_or(2);
+        let max_start = cfg
+            .rule_option(ID, "max-start")
+            .and_then(YamlOwned::as_integer)
+            .unwrap_or(0);
+        let max_end = cfg
+            .rule_option(ID, "max-end")
+            .and_then(YamlOwned::as_integer)
+            .unwrap_or(0);
+
+        Self {
+            max,
+            max_start,
+            max_end,
+        }
+    }
+
+    const fn max(&self) -> i64 {
+        self.max
+    }
+
+    const fn max_start(&self) -> i64 {
+        self.max_start
+    }
+
+    const fn max_end(&self) -> i64 {
+        self.max_end
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+    pub message: String,
+}
+
+#[must_use]
+pub fn check(buffer: &str, cfg: &Config) -> Vec<Violation> {
+    let mut violations = Vec::new();
+
+    let mut iter = buffer.split_inclusive('\n').peekable();
+    let mut seen_nonblank = false;
+    let mut blank_run_len = 0usize;
+    let mut blank_run_start = 0usize;
+    let mut blank_run_is_start = false;
+    let mut offset = 0usize;
+    let total_len = buffer.len();
+    let mut line_no = 1usize;
+
+    while let Some(segment) = iter.next() {
+        let seg_len = segment.len();
+        let next_offset = offset + seg_len;
+        let is_blank_line = matches!(segment, "\n" | "\r\n");
+
+        if is_blank_line {
+            if blank_run_len == 0 {
+                blank_run_start = line_no;
+                blank_run_is_start = !seen_nonblank;
+            }
+            blank_run_len += 1;
+
+            let next_is_blank = iter
+                .peek()
+                .copied()
+                .is_some_and(|next_segment| matches!(next_segment, "\n" | "\r\n"));
+
+            if !next_is_blank {
+                let is_end = next_offset == total_len;
+                finalize_run(
+                    buffer,
+                    cfg,
+                    blank_run_start,
+                    blank_run_len,
+                    blank_run_is_start,
+                    is_end,
+                    &mut violations,
+                );
+                blank_run_len = 0;
+                blank_run_is_start = false;
+            }
+        } else {
+            seen_nonblank = true;
+        }
+
+        offset = next_offset;
+
+        if segment.ends_with('\n') {
+            if !is_blank_line {
+                seen_nonblank = true;
+            }
+            line_no += 1;
+        }
+    }
+
+    violations
+}
+
+fn finalize_run(
+    buffer: &str,
+    cfg: &Config,
+    start_line: usize,
+    length: usize,
+    is_start: bool,
+    is_end: bool,
+    out: &mut Vec<Violation>,
+) {
+    if is_end && matches!(buffer, "\n" | "\r\n") {
+        return;
+    }
+
+    let allowed = if is_end {
+        cfg.max_end()
+    } else if is_start {
+        cfg.max_start()
+    } else {
+        cfg.max()
+    };
+
+    let run_len = i64::try_from(length).unwrap_or(i64::MAX);
+    if run_len <= allowed {
+        return;
+    }
+
+    let last_line = start_line + length - 1;
+    out.push(Violation {
+        line: last_line,
+        column: 1,
+        message: format!("too many blank lines ({run_len} > {allowed})"),
+    });
+}