@owenlamont/ryl 0.4.1 → 0.4.2

package/src/rules/line_length.rs

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

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

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

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

@@ -1,121 +0,0 @@
-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))
-}