@owenlamont/ryl 0.4.1

package/src/rules/line_length.rs

@@ -0,0 +1,326 @@
+use std::convert::TryFrom;
+
+use saphyr::YamlOwned;
+use saphyr_parser::{Event, Parser, Span, SpannedEventReceiver};
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "line-length";
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    max: i64,
+    allow_non_breakable_words: bool,
+    allow_non_breakable_inline_mappings: bool,
+}
+
+impl Config {
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let max = cfg
+            .rule_option(ID, "max")
+            .and_then(YamlOwned::as_integer)
+            .unwrap_or(80);
+
+        let allow_inline = cfg
+            .rule_option(ID, "allow-non-breakable-inline-mappings")
+            .and_then(YamlOwned::as_bool)
+            .unwrap_or(false);
+
+        let allow_words = cfg
+            .rule_option(ID, "allow-non-breakable-words")
+            .and_then(YamlOwned::as_bool)
+            .unwrap_or(true)
+            || allow_inline;
+
+        Self {
+            max,
+            allow_non_breakable_words: allow_words,
+            allow_non_breakable_inline_mappings: allow_inline,
+        }
+    }
+
+    const fn max(&self) -> i64 {
+        self.max
+    }
+
+    const fn allow_non_breakable_words(&self) -> bool {
+        self.allow_non_breakable_words
+    }
+
+    const fn allow_non_breakable_inline_mappings(&self) -> bool {
+        self.allow_non_breakable_inline_mappings
+    }
+
+    fn diagnostic_column(&self) -> usize {
+        if self.max < 0 {
+            0
+        } else {
+            let value = self.max.saturating_add(1);
+            usize::try_from(value).unwrap_or(usize::MAX)
+        }
+    }
+}
+
+#[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 bytes = buffer.as_bytes();
+    let mut line_no = 1usize;
+    let mut line_start = 0usize;
+    let mut idx = 0usize;
+    let mut directive_state = DirectiveState::new();
+
+    while idx < bytes.len() {
+        if bytes[idx] == b'\n' {
+            let line_end = if idx > line_start && bytes[idx - 1] == b'\r' {
+                idx - 1
+            } else {
+                idx
+            };
+            process_line(
+                buffer,
+                line_no,
+                line_start,
+                line_end,
+                cfg,
+                &mut violations,
+                &mut directive_state,
+            );
+            idx += 1;
+            line_start = idx;
+            line_no += 1;
+        } else {
+            idx += 1;
+        }
+    }
+
+    process_line(
+        buffer,
+        line_no,
+        line_start,
+        bytes.len(),
+        cfg,
+        &mut violations,
+        &mut directive_state,
+    );
+    violations
+}
+
+fn process_line(
+    buffer: &str,
+    line_no: usize,
+    start: usize,
+    end: usize,
+    cfg: &Config,
+    out: &mut Vec<Violation>,
+    directive_state: &mut DirectiveState,
+) {
+    let disable_line_applies = std::mem::take(&mut directive_state.disable_next_line);
+    if start == end {
+        return;
+    }
+
+    let line = &buffer[start..end];
+    match line_length_directive(line) {
+        Directive::Disable => {
+            directive_state.disabled = true;
+            return;
+        }
+        Directive::DisableLine => {
+            directive_state.disable_next_line = true;
+            return;
+        }
+        Directive::Enable => {
+            directive_state.disabled = false;
+            return;
+        }
+        Directive::None => {}
+    }
+    if directive_state.disabled || disable_line_applies {
+        return;
+    }
+
+    let length = line.chars().count();
+    let length_i64 = i64::try_from(length).unwrap_or(i64::MAX);
+
+    if length_i64 <= cfg.max() {
+        return;
+    }
+
+    if cfg.allow_non_breakable_words() && allows_overflow(line, cfg) {
+        return;
+    }
+
+    out.push(Violation {
+        line: line_no,
+        column: cfg.diagnostic_column(),
+        message: format!("line too long ({} > {} characters)", length, cfg.max()),
+    });
+}
+
+fn allows_overflow(line: &str, cfg: &Config) -> bool {
+    let mut idx = 0usize;
+    let bytes = line.as_bytes();
+
+    while idx < bytes.len() && bytes[idx] == b' ' {
+        idx += 1;
+    }
+
+    if idx >= bytes.len() {
+        return false;
+    }
+
+    if bytes[idx] == b'#' {
+        while idx < bytes.len() && bytes[idx] == b'#' {
+            idx += 1;
+        }
+        idx = (idx + 1).min(bytes.len());
+    } else if bytes[idx] == b'-' {
+        idx = (idx + 1).min(bytes.len());
+        idx = (idx + 1).min(bytes.len());
+    }
+
+    if idx >= bytes.len() {
+        return false;
+    }
+
+    let tail_bytes = &line.as_bytes()[idx..];
+    if !tail_bytes.contains(&b' ') {
+        return true;
+    }
+
+    cfg.allow_non_breakable_inline_mappings() && check_inline_mapping(line)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Directive {
+    None,
+    Disable,
+    DisableLine,
+    Enable,
+}
+
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+struct DirectiveState {
+    disabled: bool,
+    disable_next_line: bool,
+}
+
+impl DirectiveState {
+    const fn new() -> Self {
+        Self {
+            disabled: false,
+            disable_next_line: false,
+        }
+    }
+}
+
+fn line_length_directive(line: &str) -> Directive {
+    let trimmed = line.trim_start();
+    if !trimmed.starts_with('#') {
+        return Directive::None;
+    }
+    let payload = trimmed.trim_start_matches('#').trim_start();
+    if payload == "yamllint disable rule:line-length" {
+        return Directive::Disable;
+    }
+    if payload == "yamllint disable-line rule:line-length" {
+        return Directive::DisableLine;
+    }
+    if payload == "yamllint enable rule:line-length" {
+        return Directive::Enable;
+    }
+    Directive::None
+}
+
+fn check_inline_mapping(line: &str) -> bool {
+    let mut parser = Parser::new_from_str(line);
+    let mut detector = InlineMappingDetector::new(line);
+    let _ = parser.load(&mut detector, true);
+    detector.allowed()
+}
+
+struct InlineMappingDetector<'a> {
+    line: &'a str,
+    mappings: Vec<MappingState>,
+    allowed: bool,
+}
+
+impl<'a> InlineMappingDetector<'a> {
+    const fn new(line: &'a str) -> Self {
+        Self {
+            line,
+            mappings: Vec::new(),
+            allowed: false,
+        }
+    }
+
+    const fn allowed(&self) -> bool {
+        self.allowed
+    }
+
+    fn tail_from_column(&self, column: usize) -> &str {
+        self.line
+            .char_indices()
+            .nth(column)
+            .map_or("", |(idx, _)| &self.line[idx..])
+    }
+
+    fn handle_scalar_event(&mut self, span: Span) {
+        let state = self
+            .mappings
+            .last_mut()
+            .expect("scalar event handler requires active mapping");
+
+        if state.expect_key {
+            state.expect_key = false;
+            return;
+        }
+
+        state.expect_key = true;
+        let single_line = span.start.line() == 1 && span.end.line() == 1;
+        if single_line && !self.tail_from_column(span.start.col()).contains(' ') {
+            self.allowed = true;
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct MappingState {
+    expect_key: bool,
+}
+
+impl SpannedEventReceiver<'_> for InlineMappingDetector<'_> {
+    fn on_event(&mut self, event: Event<'_>, span: Span) {
+        if self.allowed {
+            return;
+        }
+
+        match event {
+            Event::MappingStart(_, _) => {
+                self.mappings.push(MappingState { expect_key: true });
+            }
+            Event::MappingEnd => {
+                self.mappings.pop();
+            }
+            Event::Scalar(_, _, _, _) if self.mappings.is_empty() => {}
+            Event::Scalar(_, _, _, _) => self.handle_scalar_event(span),
+            Event::SequenceStart(_, _)
+            | Event::SequenceEnd
+            | Event::StreamStart
+            | Event::StreamEnd
+            | Event::DocumentStart(_)
+            | Event::DocumentEnd
+            | Event::Alias(_)
+            | Event::Nothing => {}
+        }
+    }
+}

package/src/rules/mod.rs

@@ -0,0 +1,25 @@
+pub mod anchors;
+pub mod braces;
+pub mod brackets;
+pub mod colons;
+pub mod commas;
+pub mod comments;
+pub mod comments_indentation;
+pub mod document_end;
+pub mod document_start;
+pub mod empty_lines;
+pub mod empty_values;
+pub mod float_values;
+pub(crate) mod flow_collection;
+pub mod hyphens;
+pub mod indentation;
+pub mod key_duplicates;
+pub mod key_ordering;
+pub mod line_length;
+pub mod new_line_at_end_of_file;
+pub mod new_lines;
+pub mod octal_values;
+pub mod quoted_strings;
+pub(crate) mod span_utils;
+pub mod trailing_spaces;
+pub mod truthy;

package/src/rules/new_line_at_end_of_file.rs

@@ -0,0 +1,23 @@
+pub const ID: &str = "new-line-at-end-of-file";
+pub const MESSAGE: &str = "no new line character at the end of file";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+}
+
+#[must_use]
+pub fn check(buffer: &str) -> Option<Violation> {
+    if buffer.is_empty() || buffer.ends_with('\n') {
+        return None;
+    }
+
+    let line = buffer.lines().count();
+    let tail = buffer
+        .rsplit_once('\n')
+        .map_or(buffer, |(_, trailing)| trailing);
+    let column = tail.chars().count() + 1;
+
+    Some(Violation { line, column })
+}

package/src/rules/new_lines.rs

@@ -0,0 +1,95 @@
+use std::borrow::Cow;
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "new-lines";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LineKind {
+    Unix,
+    Dos,
+    Platform,
+}
+
+impl LineKind {
+    fn expected(self, platform_newline: &str) -> Cow<'_, str> {
+        match self {
+            Self::Unix => Cow::Borrowed("\n"),
+            Self::Dos => Cow::Borrowed("\r\n"),
+            Self::Platform => Cow::Owned(platform_newline.to_string()),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Config {
+    pub kind: LineKind,
+}
+
+impl Config {
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let kind = match cfg.rule_option_str(ID, "type") {
+            Some("dos") => LineKind::Dos,
+            Some("platform") => LineKind::Platform,
+            _ => LineKind::Unix,
+        };
+        Self { kind }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Violation {
+    pub line: usize,
+    pub column: usize,
+    pub message: String,
+}
+
+#[cfg(windows)]
+#[must_use]
+pub const fn platform_newline() -> &'static str {
+    "\r\n"
+}
+
+#[cfg(not(windows))]
+#[must_use]
+pub const fn platform_newline() -> &'static str {
+    "\n"
+}
+
+#[must_use]
+pub fn check(buffer: &str, cfg: Config, platform_newline: &str) -> Option<Violation> {
+    let expected = cfg.kind.expected(platform_newline);
+    let (index, actual) = first_line_ending(buffer)?;
+    if actual == expected.as_ref() {
+        return None;
+    }
+
+    let column = buffer[..index].chars().count() + 1;
+    Some(Violation {
+        line: 1,
+        column,
+        message: format!(
+            "wrong new line character: expected {}",
+            display_sequence(expected.as_ref())
+        ),
+    })
+}
+
+fn first_line_ending(buffer: &str) -> Option<(usize, &'static str)> {
+    let bytes = buffer.as_bytes();
+    let mut idx = 0;
+    while idx < bytes.len() {
+        match bytes[idx] {
+            b'\n' => return Some((idx, "\n")),
+            b'\r' if bytes.get(idx + 1) == Some(&b'\n') => return Some((idx, "\r\n")),
+            _ => {}
+        }
+        idx += 1;
+    }
+    None
+}
+
+fn display_sequence(input: &str) -> &'static str {
+    if input == "\r\n" { "\\r\\n" } else { "\\n" }
+}

package/src/rules/octal_values.rs

@@ -0,0 +1,121 @@
+use saphyr::YamlOwned;
+use saphyr_parser::{Event, Parser, ScalarStyle, Span, SpannedEventReceiver};
+
+use crate::config::YamlLintConfig;
+
+pub const ID: &str = "octal-values";
+
+#[derive(Debug, Clone)]
+pub struct Config {
+    forbid_implicit: bool,
+    forbid_explicit: bool,
+}
+
+impl Config {
+    #[must_use]
+    pub fn resolve(cfg: &YamlLintConfig) -> Self {
+        let forbid_implicit = cfg
+            .rule_option(ID, "forbid-implicit-octal")
+            .and_then(YamlOwned::as_bool)
+            .unwrap_or(true);
+
+        let forbid_explicit = cfg
+            .rule_option(ID, "forbid-explicit-octal")
+            .and_then(YamlOwned::as_bool)
+            .unwrap_or(true);
+
+        Self {
+            forbid_implicit,
+            forbid_explicit,
+        }
+    }
+
+    const fn forbid_implicit(&self) -> bool {
+        self.forbid_implicit
+    }
+
+    const fn forbid_explicit(&self) -> bool {
+        self.forbid_explicit
+    }
+}
+
+#[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 = OctalValuesReceiver::new(cfg);
+    let _ = parser.load(&mut receiver, true);
+    receiver.diagnostics
+}
+
+struct OctalValuesReceiver<'cfg> {
+    config: &'cfg Config,
+    diagnostics: Vec<Violation>,
+}
+
+impl<'cfg> OctalValuesReceiver<'cfg> {
+    const fn new(config: &'cfg Config) -> Self {
+        Self {
+            config,
+            diagnostics: Vec::new(),
+        }
+    }
+
+    fn handle_scalar(&mut self, span: Span, value: &str) {
+        let line = span.end.line();
+        let column = span.end.col() + 1;
+
+        if self.config.forbid_implicit() && is_implicit_octal(value) {
+            self.diagnostics.push(Violation {
+                line,
+                column,
+                message: format!("forbidden implicit octal value \"{value}\""),
+            });
+            return;
+        }
+
+        if self.config.forbid_explicit() && is_explicit_octal(value) {
+            self.diagnostics.push(Violation {
+                line,
+                column,
+                message: format!("forbidden explicit octal value \"{value}\""),
+            });
+        }
+    }
+}
+
+impl SpannedEventReceiver<'_> for OctalValuesReceiver<'_> {
+    fn on_event(&mut self, event: Event<'_>, span: Span) {
+        if let Event::Scalar(value, style, _, tag) = event {
+            if tag.is_some() || !matches!(style, ScalarStyle::Plain) {
+                return;
+            }
+            self.handle_scalar(span, value.as_ref());
+        }
+    }
+}
+
+fn is_implicit_octal(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    if bytes.len() <= 1 || bytes[0] != b'0' {
+        return false;
+    }
+    if !bytes.iter().all(u8::is_ascii_digit) {
+        return false;
+    }
+    bytes[1..].iter().all(|b| (b'0'..=b'7').contains(b))
+}
+
+fn is_explicit_octal(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    if bytes.len() <= 2 || bytes[0] != b'0' || bytes[1] != b'o' {
+        return false;
+    }
+    bytes[2..].iter().all(|b| (b'0'..=b'7').contains(b))
+}