@owenlamont/ryl 0.4.1

package/src/rules/empty_values.rs

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

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