@owenlamont/ryl 0.4.1 → 0.4.2

package/src/rules/comments_indentation.rs

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

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

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

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