@owenlamont/ryl 0.4.1 → 0.4.2

package/src/rules/empty_values.rs

@@ -1,255 +0,0 @@
-use saphyr_parser::{Event, Parser, Span, SpannedEventReceiver};
-
-use crate::config::YamlLintConfig;
-
-pub const ID: &str = "empty-values";
-
-const BLOCK_MAPPING_MESSAGE: &str = "empty value in block mapping";
-const FLOW_MAPPING_MESSAGE: &str = "empty value in flow mapping";
-const BLOCK_SEQUENCE_MESSAGE: &str = "empty value in block sequence";
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct Config {
-    forbid_block_mappings: bool,
-    forbid_flow_mappings: bool,
-    forbid_block_sequences: bool,
-}
-
-impl Config {
-    #[must_use]
-    pub fn resolve(cfg: &YamlLintConfig) -> Self {
-        let forbid_block_mappings = cfg
-            .rule_option(ID, "forbid-in-block-mappings")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(true);
-
-        let forbid_flow_mappings = cfg
-            .rule_option(ID, "forbid-in-flow-mappings")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(true);
-
-        let forbid_block_sequences = cfg
-            .rule_option(ID, "forbid-in-block-sequences")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(true);
-
-        Self {
-            forbid_block_mappings,
-            forbid_flow_mappings,
-            forbid_block_sequences,
-        }
-    }
-}
-
-#[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 = EmptyValuesReceiver::new(cfg);
-    let _ = parser.load(&mut receiver, true);
-    receiver.diagnostics
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum MappingStyle {
-    Block,
-    Flow,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum SequenceStyle {
-    Block,
-    Flow,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-struct NodeContext {
-    mapping: Option<(MappingStyle, NodePosition)>,
-    in_block_sequence: bool,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum NodePosition {
-    Key,
-    Value,
-}
-
-struct EmptyValuesReceiver<'cfg> {
-    config: &'cfg Config,
-    containers: Vec<ContainerState>,
-    diagnostics: Vec<Violation>,
-}
-
-impl<'cfg> EmptyValuesReceiver<'cfg> {
-    const fn new(config: &'cfg Config) -> Self {
-        Self {
-            config,
-            containers: Vec::new(),
-            diagnostics: Vec::new(),
-        }
-    }
-
-    fn reset(&mut self) {
-        self.containers.clear();
-    }
-
-    fn begin_node(&mut self) -> NodeContext {
-        let mapping = if let Some(ContainerState::Mapping { style, expect_key }) =
-            self.containers.last_mut()
-        {
-            if *expect_key {
-                *expect_key = false;
-                Some((*style, NodePosition::Key))
-            } else {
-                *expect_key = true;
-                Some((*style, NodePosition::Value))
-            }
-        } else {
-            None
-        };
-
-        let in_block_sequence = matches!(
-            self.containers.last(),
-            Some(ContainerState::Sequence {
-                style: SequenceStyle::Block,
-            })
-        );
-
-        NodeContext {
-            mapping,
-            in_block_sequence,
-        }
-    }
-
-    fn push_mapping(&mut self, span: Span) {
-        let style = if span.is_empty() {
-            MappingStyle::Block
-        } else {
-            MappingStyle::Flow
-        };
-        self.containers.push(ContainerState::Mapping {
-            style,
-            expect_key: true,
-        });
-    }
-
-    fn push_sequence(&mut self, span: Span) {
-        let style = if span.is_empty() {
-            SequenceStyle::Block
-        } else {
-            SequenceStyle::Flow
-        };
-        self.containers.push(ContainerState::Sequence { style });
-    }
-
-    fn push_container(&mut self, span: Span, kind: ContainerKind) {
-        match kind {
-            ContainerKind::Mapping => self.push_mapping(span),
-            ContainerKind::Sequence => self.push_sequence(span),
-        }
-    }
-
-    fn pop_container(&mut self) {
-        let _ = self.containers.pop();
-    }
-
-    fn handle_scalar(&mut self, span: Span, ctx: NodeContext) {
-        if span.is_empty() {
-            if let Some((style, NodePosition::Value)) = ctx.mapping {
-                match style {
-                    MappingStyle::Block if self.config.forbid_block_mappings => {
-                        self.record(span, BLOCK_MAPPING_MESSAGE);
-                    }
-                    MappingStyle::Flow if self.config.forbid_flow_mappings => {
-                        self.record(span, FLOW_MAPPING_MESSAGE);
-                    }
-                    _ => {}
-                }
-                return;
-            }
-
-            if ctx.in_block_sequence && self.config.forbid_block_sequences {
-                self.record(span, BLOCK_SEQUENCE_MESSAGE);
-            }
-        }
-    }
-
-    fn record(&mut self, span: Span, message: &str) {
-        let line = span.start.line();
-        let column =
-            if let Some(ContainerState::Mapping { .. }) = self.containers.last() {
-                span.start.col() + 2
-            } else {
-                span.start.col() + 1
-            };
-        self.diagnostics.push(Violation {
-            line,
-            column,
-            message: message.to_string(),
-        });
-    }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum ContainerKind {
-    Mapping,
-    Sequence,
-}
-
-enum ContainerState {
-    Mapping {
-        style: MappingStyle,
-        expect_key: bool,
-    },
-    Sequence {
-        style: SequenceStyle,
-    },
-}
-
-impl SpannedEventReceiver<'_> for EmptyValuesReceiver<'_> {
-    fn on_event(&mut self, event: Event<'_>, span: Span) {
-        match event {
-            Event::StreamStart
-            | Event::DocumentStart(_)
-            | Event::StreamEnd
-            | Event::DocumentEnd => {
-                self.reset();
-            }
-            Event::MappingStart(_, _) => {
-                self.begin_node();
-                self.push_container(span, ContainerKind::Mapping);
-            }
-            Event::SequenceStart(_, _) => {
-                self.begin_node();
-                self.push_container(span, ContainerKind::Sequence);
-            }
-            Event::MappingEnd | Event::SequenceEnd => {
-                self.pop_container();
-            }
-            Event::Scalar(_, _, _, _) => {
-                let ctx = self.begin_node();
-                self.handle_scalar(span, ctx);
-            }
-            Event::Alias(_) => {
-                self.begin_node();
-            }
-            Event::Nothing => {}
-        }
-    }
-}
-
-#[allow(dead_code)]
-pub fn coverage_touch_nothing_branch() {
-    use saphyr_parser::{Marker, Span};
-
-    let cfg_struct = crate::config::YamlLintConfig::default();
-    let config = Config::resolve(&cfg_struct);
-    let mut receiver = EmptyValuesReceiver::new(&config);
-    receiver.on_event(Event::Nothing, Span::empty(Marker::default()));
-}

package/src/rules/float_values.rs

@@ -1,259 +0,0 @@
-use saphyr_parser::{Event, Parser, ScalarStyle, Span, SpannedEventReceiver};
-
-use crate::config::YamlLintConfig;
-use crate::rules::span_utils::span_char_index_to_byte;
-
-pub const ID: &str = "float-values";
-
-#[derive(Debug, Clone)]
-pub struct Config {
-    flags: u8,
-}
-
-const REQUIRE_NUMERAL_FLAG: u8 = 1 << 0;
-const FORBID_SCIENTIFIC_FLAG: u8 = 1 << 1;
-const FORBID_NAN_FLAG: u8 = 1 << 2;
-const FORBID_INF_FLAG: u8 = 1 << 3;
-
-impl Config {
-    #[must_use]
-    pub fn resolve(cfg: &YamlLintConfig) -> Self {
-        let require_numeral_before_decimal = cfg
-            .rule_option(ID, "require-numeral-before-decimal")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(false);
-
-        let forbid_scientific_notation = cfg
-            .rule_option(ID, "forbid-scientific-notation")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(false);
-
-        let forbid_nan = cfg
-            .rule_option(ID, "forbid-nan")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(false);
-
-        let forbid_inf = cfg
-            .rule_option(ID, "forbid-inf")
-            .and_then(saphyr::YamlOwned::as_bool)
-            .unwrap_or(false);
-
-        let mut flags = 0u8;
-        if require_numeral_before_decimal {
-            flags |= REQUIRE_NUMERAL_FLAG;
-        }
-        if forbid_scientific_notation {
-            flags |= FORBID_SCIENTIFIC_FLAG;
-        }
-        if forbid_nan {
-            flags |= FORBID_NAN_FLAG;
-        }
-        if forbid_inf {
-            flags |= FORBID_INF_FLAG;
-        }
-
-        Self { flags }
-    }
-
-    const fn require_numeral_before_decimal(&self) -> bool {
-        (self.flags & REQUIRE_NUMERAL_FLAG) != 0
-    }
-
-    const fn forbid_scientific_notation(&self) -> bool {
-        (self.flags & FORBID_SCIENTIFIC_FLAG) != 0
-    }
-
-    const fn forbid_nan(&self) -> bool {
-        (self.flags & FORBID_NAN_FLAG) != 0
-    }
-
-    const fn forbid_inf(&self) -> bool {
-        (self.flags & FORBID_INF_FLAG) != 0
-    }
-}
-
-#[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 = FloatValuesReceiver::new(cfg, buffer);
-    let _ = parser.load(&mut receiver, true);
-    receiver.diagnostics
-}
-
-struct FloatValuesReceiver<'cfg, 'input> {
-    config: &'cfg Config,
-    buffer: &'input str,
-    chars: Vec<(usize, char)>,
-    buffer_len: usize,
-    diagnostics: Vec<Violation>,
-}
-
-impl<'cfg, 'input> FloatValuesReceiver<'cfg, 'input> {
-    fn new(config: &'cfg Config, buffer: &'input str) -> Self {
-        Self {
-            config,
-            buffer,
-            chars: buffer.char_indices().collect(),
-            buffer_len: buffer.len(),
-            diagnostics: Vec::new(),
-        }
-    }
-
-    fn handle_scalar(&mut self, value: &str, span: Span) {
-        let line = span.start.line();
-        let column = span.start.col() + 1;
-
-        if self.config.forbid_nan() && is_nan(value) {
-            self.diagnostics.push(Violation {
-                line,
-                column,
-                message: format!(
-                    "forbidden not a number value \"{}\"",
-                    self.original_scalar(span, value)
-                ),
-            });
-        }
-
-        if self.config.forbid_inf() && is_inf(value) {
-            self.diagnostics.push(Violation {
-                line,
-                column,
-                message: format!(
-                    "forbidden infinite value \"{}\"",
-                    self.original_scalar(span, value)
-                ),
-            });
-        }
-
-        if self.config.forbid_scientific_notation() && is_scientific_notation(value) {
-            self.diagnostics.push(Violation {
-                line,
-                column,
-                message: format!(
-                    "forbidden scientific notation \"{}\"",
-                    self.original_scalar(span, value)
-                ),
-            });
-        }
-
-        if self.config.require_numeral_before_decimal()
-            && is_missing_numeral_before_decimal(value)
-        {
-            self.diagnostics.push(Violation {
-                line,
-                column,
-                message: format!(
-                    "forbidden decimal missing 0 prefix \"{}\"",
-                    self.original_scalar(span, value)
-                ),
-            });
-        }
-    }
-
-    fn original_scalar<'a>(&'a self, span: Span, fallback: &'a str) -> &'a str {
-        let start_char = span.start.index();
-        let end_char = span.end.index();
-        let start = span_char_index_to_byte(&self.chars, start_char, self.buffer_len);
-        let end = span_char_index_to_byte(&self.chars, end_char, self.buffer_len);
-        let range_start = start.min(end);
-        let range_end = start.max(end);
-        self.buffer.get(range_start..range_end).unwrap_or(fallback)
-    }
-}
-
-impl<'input> SpannedEventReceiver<'input> for FloatValuesReceiver<'_, 'input> {
-    fn on_event(&mut self, event: Event<'input>, span: Span) {
-        if let Event::Scalar(value, style, _, tag) = event {
-            if tag.is_some() || !matches!(style, ScalarStyle::Plain) {
-                return;
-            }
-            self.handle_scalar(value.as_ref(), span);
-        }
-    }
-}
-
-fn is_nan(value: &str) -> bool {
-    matches!(value, ".nan" | ".NaN" | ".NAN")
-}
-
-fn is_inf(value: &str) -> bool {
-    let trimmed = without_sign(value);
-    matches!(trimmed, ".inf" | ".Inf" | ".INF")
-}
-
-fn is_scientific_notation(value: &str) -> bool {
-    let trimmed = without_sign(value);
-    let Some((mantissa, exponent)) = split_exponent(trimmed) else {
-        return false;
-    };
-    if !is_valid_exponent(exponent) {
-        return false;
-    }
-    if let Some(digits) = mantissa.strip_prefix('.') {
-        return !digits.is_empty() && digits.chars().all(|c| c.is_ascii_digit());
-    }
-
-    if mantissa.is_empty() {
-        return false;
-    }
-
-    let mut parts = mantissa.splitn(2, '.');
-    let int_part = parts.next().unwrap();
-    if int_part.is_empty() || !int_part.chars().all(|c| c.is_ascii_digit()) {
-        return false;
-    }
-    if let Some(frac_part) = parts.next() {
-        return frac_part.chars().all(|c| c.is_ascii_digit());
-    }
-    true
-}
-
-fn is_missing_numeral_before_decimal(value: &str) -> bool {
-    let trimmed = without_sign(value);
-    if !trimmed.starts_with('.') {
-        return false;
-    }
-    let after_dot = &trimmed[1..];
-    if after_dot.is_empty() {
-        return false;
-    }
-
-    let (digits, exponent) = match split_exponent(after_dot) {
-        Some((mantissa, exponent)) => (mantissa, Some(exponent)),
-        None => (after_dot, None),
-    };
-
-    if digits.is_empty() || !digits.chars().all(|c| c.is_ascii_digit()) {
-        return false;
-    }
-
-    exponent.is_none_or(is_valid_exponent)
-}
-
-fn split_exponent(value: &str) -> Option<(&str, &str)> {
-    let idx = value.find(['e', 'E'])?;
-    Some(value.split_at(idx))
-}
-
-fn is_valid_exponent(exponent: &str) -> bool {
-    let rest = exponent
-        .strip_prefix('e')
-        .or_else(|| exponent.strip_prefix('E'))
-        .expect("exponent fragment must start with e/E");
-    let rest = without_sign(rest);
-    !rest.is_empty() && rest.chars().all(|c| c.is_ascii_digit())
-}
-
-fn without_sign(value: &str) -> &str {
-    value
-        .strip_prefix('+')
-        .or_else(|| value.strip_prefix('-'))
-        .unwrap_or(value)
-}