@owenlamont/ryl 0.4.1 → 0.4.2

package/src/rules/commas.rs

@@ -1,372 +0,0 @@
-use std::ops::Range;
-
-use saphyr_parser::{Event, Marker, Parser, Span, SpannedEventReceiver};
-
-use crate::config::YamlLintConfig;
-use crate::rules::span_utils::span_char_index_to_byte;
-
-pub const ID: &str = "commas";
-const TOO_MANY_BEFORE: &str = "too many spaces before comma";
-const TOO_FEW_AFTER: &str = "too few spaces after comma";
-const TOO_MANY_AFTER: &str = "too many spaces after comma";
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Config {
-    max_spaces_before: i64,
-    min_spaces_after: i64,
-    max_spaces_after: i64,
-}
-
-impl Config {
-    const DEFAULT_MAX_BEFORE: i64 = 0;
-    const DEFAULT_MIN_AFTER: i64 = 1;
-    const DEFAULT_MAX_AFTER: i64 = 1;
-
-    #[must_use]
-    pub fn resolve(cfg: &YamlLintConfig) -> Self {
-        let max_spaces_before = cfg
-            .rule_option(ID, "max-spaces-before")
-            .and_then(saphyr::YamlOwned::as_integer)
-            .unwrap_or(Self::DEFAULT_MAX_BEFORE);
-        let min_spaces_after = cfg
-            .rule_option(ID, "min-spaces-after")
-            .and_then(saphyr::YamlOwned::as_integer)
-            .unwrap_or(Self::DEFAULT_MIN_AFTER);
-        let max_spaces_after = cfg
-            .rule_option(ID, "max-spaces-after")
-            .and_then(saphyr::YamlOwned::as_integer)
-            .unwrap_or(Self::DEFAULT_MAX_AFTER);
-
-        Self {
-            max_spaces_before,
-            min_spaces_after,
-            max_spaces_after,
-        }
-    }
-
-    #[must_use]
-    pub const fn new_for_tests(
-        max_spaces_before: i64,
-        min_spaces_after: i64,
-        max_spaces_after: i64,
-    ) -> Self {
-        Self {
-            max_spaces_before,
-            min_spaces_after,
-            max_spaces_after,
-        }
-    }
-
-    #[must_use]
-    pub const fn max_spaces_before(&self) -> i64 {
-        self.max_spaces_before
-    }
-
-    #[must_use]
-    pub const fn min_spaces_after(&self) -> i64 {
-        self.min_spaces_after
-    }
-
-    #[must_use]
-    pub const fn max_spaces_after(&self) -> i64 {
-        self.max_spaces_after
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Violation {
-    pub line: usize,
-    pub column: usize,
-    pub message: String,
-}
-
-enum FlowKind {
-    Sequence,
-    Mapping,
-}
-
-struct ScalarRangeCollector {
-    ranges: Vec<Range<usize>>,
-}
-
-impl ScalarRangeCollector {
-    const fn new() -> Self {
-        Self { ranges: Vec::new() }
-    }
-
-    fn push_range(&mut self, span: Span) {
-        let start = span.start.index();
-        let end = span.end.index();
-        if start < end {
-            self.ranges.push(start..end);
-        }
-    }
-
-    fn into_sorted(self) -> Vec<Range<usize>> {
-        let mut ranges = self.ranges;
-        ranges.sort_by(|a, b| a.start.cmp(&b.start));
-        ranges
-    }
-}
-
-impl SpannedEventReceiver<'_> for ScalarRangeCollector {
-    fn on_event(&mut self, ev: Event<'_>, span: Span) {
-        if matches!(ev, Event::Scalar(..)) {
-            self.push_range(span);
-        }
-    }
-}
-
-enum BeforeResult {
-    SameLine { spaces: usize },
-    Ignored,
-}
-
-enum AfterResult {
-    SameLine { spaces: usize, next_char: usize },
-    Ignored,
-}
-
-#[must_use]
-pub fn check(buffer: &str, cfg: &Config) -> Vec<Violation> {
-    if buffer.is_empty() {
-        return Vec::new();
-    }
-
-    let mut parser = Parser::new_from_str(buffer);
-    let mut collector = ScalarRangeCollector::new();
-    let _ = parser.load(&mut collector, true);
-    let scalar_ranges = collector.into_sorted();
-
-    let chars: Vec<(usize, char)> = buffer.char_indices().collect();
-    let buffer_len = buffer.len();
-
-    let line_starts = build_line_starts(buffer);
-
-    let mut violations = Vec::new();
-    let mut contexts: Vec<FlowKind> = Vec::new();
-    let mut i = 0usize;
-    let mut range_idx = 0usize;
-
-    while i < chars.len() {
-        let (byte_idx, ch) = chars[i];
-
-        while range_idx < scalar_ranges.len()
-            && span_char_index_to_byte(&chars, scalar_ranges[range_idx].end, buffer_len)
-                <= byte_idx
-        {
-            range_idx += 1;
-        }
-
-        if let Some(range) = scalar_ranges.get(range_idx) {
-            let start_byte = span_char_index_to_byte(&chars, range.start, buffer_len);
-            let end_byte = span_char_index_to_byte(&chars, range.end, buffer_len);
-            if byte_idx >= start_byte && byte_idx < end_byte {
-                i = range.end;
-                continue;
-            }
-        }
-
-        match ch {
-            '[' => contexts.push(FlowKind::Sequence),
-            '{' => contexts.push(FlowKind::Mapping),
-            ']' | '}' => {
-                contexts.pop();
-            }
-            '#' => {
-                i = skip_comment(&chars, i);
-                continue;
-            }
-            ',' => {
-                if !contexts.is_empty() {
-                    evaluate_comma(cfg, &mut violations, &chars, i, &line_starts);
-                }
-            }
-            _ => {}
-        }
-
-        i += 1;
-    }
-
-    violations
-}
-
-fn skip_comment(chars: &[(usize, char)], mut idx: usize) -> usize {
-    idx += 1;
-    while idx < chars.len() {
-        let ch = chars[idx].1;
-        if ch == '\n' {
-            break;
-        }
-        if ch == '\r' {
-            if idx + 1 < chars.len() && chars[idx + 1].1 == '\n' {
-                idx += 1;
-            }
-            break;
-        }
-        idx += 1;
-    }
-    idx
-}
-
-fn evaluate_comma(
-    cfg: &Config,
-    violations: &mut Vec<Violation>,
-    chars: &[(usize, char)],
-    comma_idx: usize,
-    line_starts: &[usize],
-) {
-    if let BeforeResult::SameLine { spaces } = compute_spaces_before(chars, comma_idx)
-        && cfg.max_spaces_before >= 0
-    {
-        let spaces_i64 = i64::try_from(spaces).unwrap_or(i64::MAX);
-        if spaces_i64 > cfg.max_spaces_before {
-            let comma_byte = chars[comma_idx].0;
-            let (line, column) = line_and_column(line_starts, comma_byte);
-            let highlight_column = column.saturating_sub(1).max(1);
-            violations.push(Violation {
-                line,
-                column: highlight_column,
-                message: TOO_MANY_BEFORE.to_string(),
-            });
-        }
-    }
-
-    if let AfterResult::SameLine { spaces, next_char } =
-        compute_spaces_after(chars, comma_idx)
-    {
-        let spaces_i64 = i64::try_from(spaces).unwrap_or(i64::MAX);
-        let next_byte = chars[next_char].0;
-        let (line, column) = line_and_column(line_starts, next_byte);
-        if cfg.max_spaces_after >= 0 && spaces_i64 > cfg.max_spaces_after {
-            let highlight_column = column.saturating_sub(1).max(1);
-            violations.push(Violation {
-                line,
-                column: highlight_column,
-                message: TOO_MANY_AFTER.to_string(),
-            });
-        }
-        if cfg.min_spaces_after >= 0 && spaces_i64 < cfg.min_spaces_after {
-            violations.push(Violation {
-                line,
-                column,
-                message: TOO_FEW_AFTER.to_string(),
-            });
-        }
-    }
-}
-
-fn compute_spaces_before(chars: &[(usize, char)], comma_idx: usize) -> BeforeResult {
-    let mut spaces = 0usize;
-    let mut idx = comma_idx;
-
-    loop {
-        let Some(prev) = idx.checked_sub(1) else {
-            return BeforeResult::SameLine { spaces };
-        };
-
-        let ch = chars[prev].1;
-        if matches!(ch, ' ' | '\t') {
-            spaces += 1;
-            idx = prev;
-            continue;
-        }
-        if matches!(ch, '\n' | '\r') {
-            return BeforeResult::Ignored;
-        }
-        return BeforeResult::SameLine { spaces };
-    }
-}
-
-fn compute_spaces_after(chars: &[(usize, char)], comma_idx: usize) -> AfterResult {
-    let mut spaces = 0usize;
-    let mut idx = comma_idx + 1;
-    while idx < chars.len() {
-        match chars[idx].1 {
-            ' ' | '\t' => {
-                spaces += 1;
-                idx += 1;
-            }
-            '\n' | '\r' | '#' => return AfterResult::Ignored,
-            _ => {
-                return AfterResult::SameLine {
-                    spaces,
-                    next_char: idx,
-                };
-            }
-        }
-    }
-    AfterResult::Ignored
-}
-
-fn build_line_starts(buffer: &str) -> Vec<usize> {
-    let mut starts = Vec::new();
-    starts.push(0);
-    let bytes = buffer.as_bytes();
-    let mut idx = 0usize;
-    while idx < bytes.len() {
-        match bytes[idx] {
-            b'\n' => {
-                starts.push(idx + 1);
-                idx += 1;
-            }
-            b'\r' => {
-                if idx + 1 < bytes.len() && bytes[idx + 1] == b'\n' {
-                    starts.push(idx + 2);
-                    idx += 2;
-                } else {
-                    starts.push(idx + 1);
-                    idx += 1;
-                }
-            }
-            _ => idx += 1,
-        }
-    }
-    starts
-}
-
-fn line_and_column(line_starts: &[usize], byte_idx: usize) -> (usize, usize) {
-    let mut left = 0usize;
-    let mut right = line_starts.len();
-    while left + 1 < right {
-        let mid = usize::midpoint(left, right);
-        if line_starts[mid] <= byte_idx {
-            left = mid;
-        } else {
-            right = mid;
-        }
-    }
-    let line_start = line_starts[left];
-    (left + 1, byte_idx - line_start + 1)
-}
-
-#[doc(hidden)]
-#[must_use]
-pub fn coverage_compute_spaces_before(buffer: &str, comma_idx: usize) -> Option<usize> {
-    let chars: Vec<(usize, char)> = buffer.char_indices().collect();
-    debug_assert!(comma_idx < chars.len());
-    match compute_spaces_before(&chars, comma_idx) {
-        BeforeResult::SameLine { spaces } => Some(spaces),
-        BeforeResult::Ignored => None,
-    }
-}
-
-#[doc(hidden)]
-#[must_use]
-pub fn coverage_skip_zero_length_span() -> usize {
-    let mut collector = ScalarRangeCollector::new();
-    collector.push_range(Span::empty(Marker::default()));
-    collector.into_sorted().len()
-}
-
-#[doc(hidden)]
-#[must_use]
-pub fn coverage_skip_comment_crlf() -> (usize, usize) {
-    let chars_crlf: Vec<(usize, char)> = "#\r\n".char_indices().collect();
-    let idx_crlf = skip_comment(&chars_crlf, 0);
-
-    let chars_cr: Vec<(usize, char)> = "#\r".char_indices().collect();
-    let idx_cr = skip_comment(&chars_cr, 0);
-
-    (idx_crlf, idx_cr)
-}

package/src/rules/comments.rs

@@ -1,299 +0,0 @@
-use saphyr::YamlOwned;
-
-use crate::config::YamlLintConfig;
-
-pub const ID: &str = "comments";
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Config {
-    require_starting_space: bool,
-    ignore_shebangs: bool,
-    min_spaces_from_content: Option<usize>,
-}
-
-impl Config {
-    #[must_use]
-    pub fn resolve(cfg: &YamlLintConfig) -> Self {
-        let require_starting_space = cfg
-            .rule_option(ID, "require-starting-space")
-            .and_then(YamlOwned::as_bool)
-            .unwrap_or(true);
-
-        let ignore_shebangs = cfg
-            .rule_option(ID, "ignore-shebangs")
-            .and_then(YamlOwned::as_bool)
-            .unwrap_or(true);
-
-        let min_spaces_value = cfg
-            .rule_option(ID, "min-spaces-from-content")
-            .and_then(YamlOwned::as_integer)
-            .unwrap_or(2);
-
-        let min_spaces_from_content = if min_spaces_value < 0 {
-            None
-        } else {
-            Some(usize::try_from(min_spaces_value).unwrap_or(usize::MAX))
-        };
-
-        Self {
-            require_starting_space,
-            ignore_shebangs,
-            min_spaces_from_content,
-        }
-    }
-
-    const fn require_starting_space(&self) -> bool {
-        self.require_starting_space
-    }
-
-    const fn ignore_shebangs(&self) -> bool {
-        self.ignore_shebangs
-    }
-
-    const fn min_spaces_from_content(&self) -> Option<usize> {
-        self.min_spaces_from_content
-    }
-}
-
-#[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 quote_state = QuoteState::default();
-    let mut block_tracker = BlockScalarTracker::default();
-
-    for (line_idx, line) in buffer.lines().enumerate() {
-        let indent = leading_indent_width(line);
-        let content = &line[indent..];
-
-        if block_tracker.consume_line(indent, content) {
-            continue;
-        }
-
-        let Some(comment_start) = find_comment_start(line, &mut quote_state) else {
-            block_tracker.observe_indicator(indent, content);
-            continue;
-        };
-
-        if let Some(required) = cfg.min_spaces_from_content()
-            && is_inline_comment(line, comment_start)
-            && inline_spacing_width(line, comment_start) < required
-        {
-            violations.push(Violation {
-                line: line_idx + 1,
-                column: column_at(line, comment_start),
-                message: format!("too few spaces before comment: expected {required}"),
-            });
-        }
-
-        if !cfg.require_starting_space() {
-            continue;
-        }
-
-        let after_hash_idx = comment_start + skip_hashes(&line[comment_start..]);
-        if after_hash_idx >= line.len() {
-            continue;
-        }
-
-        let next_char = line[after_hash_idx..].chars().next().unwrap_or(' ');
-
-        if cfg.ignore_shebangs()
-            && line_idx == 0
-            && comment_start == 0
-            && next_char == '!'
-        {
-            continue;
-        }
-
-        if next_char != ' ' {
-            violations.push(Violation {
-                line: line_idx + 1,
-                column: column_at(line, after_hash_idx),
-                message: "missing starting space in comment".to_string(),
-            });
-        }
-
-        block_tracker.observe_indicator(indent, content);
-    }
-
-    violations
-}
-
-#[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;
-        }
-
-        if let Some(content_indent) = state.content_indent {
-            if indent >= content_indent {
-                return true;
-            }
-
-            if indent <= state.indicator_indent {
-                self.state = None;
-                return false;
-            }
-
-            state.content_indent = Some(content_indent.min(indent));
-            return true;
-        }
-
-        if indent > state.indicator_indent {
-            state.content_indent = Some(indent);
-            return true;
-        }
-
-        self.state = None;
-        false
-    }
-
-    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,
-            });
-        }
-    }
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-struct QuoteState {
-    in_single: bool,
-    in_double: bool,
-    escaped: bool,
-}
-
-fn find_comment_start(line: &str, state: &mut QuoteState) -> Option<usize> {
-    for (idx, ch) in line.char_indices() {
-        if ch == '\\' && !state.in_single {
-            state.escaped = !state.escaped;
-            continue;
-        }
-
-        if state.escaped {
-            state.escaped = false;
-            continue;
-        }
-
-        match ch {
-            '\'' if !state.in_double => {
-                state.in_single = !state.in_single;
-            }
-            '"' if !state.in_single => {
-                state.in_double = !state.in_double;
-            }
-            '#' if !state.in_single && !state.in_double => {
-                if is_comment_position(line, idx) {
-                    return Some(idx);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    state.escaped = false;
-    None
-}
-
-fn is_inline_comment(line: &str, comment_start: usize) -> bool {
-    !line[..comment_start].trim().is_empty()
-}
-
-fn inline_spacing_width(line: &str, comment_start: usize) -> usize {
-    line[..comment_start]
-        .chars()
-        .rev()
-        .take_while(|ch| ch.is_whitespace())
-        .count()
-}
-
-fn skip_hashes(slice: &str) -> usize {
-    slice
-        .chars()
-        .take_while(|ch| *ch == '#')
-        .map(char::len_utf8)
-        .sum()
-}
-
-fn column_at(line: &str, byte_idx: usize) -> usize {
-    line[..byte_idx].chars().count() + 1
-}
-
-fn leading_indent_width(line: &str) -> usize {
-    line.chars()
-        .take_while(|ch| matches!(ch, ' ' | '\t'))
-        .count()
-}
-
-fn is_comment_position(line: &str, idx: usize) -> bool {
-    line[..idx].chars().last().is_none_or(char::is_whitespace)
-}
-
-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());
-    trimmed.ends_with("|-")
-        || trimmed.ends_with("|+")
-        || trimmed.ends_with('|')
-        || trimmed.ends_with(">-")
-        || trimmed.ends_with(">+")
-        || trimmed.ends_with('>')
-}