feat: Rethink parsing

crates/state/src/font_style.rs

@@ -22,10 +22,11 @@ use torin::torin::Torin;
 
 use crate::{
     CustomAttributeValues,
-    ExtSplit,
     Parse,
     ParseAttribute,
+    ParseError,
     TextOverflow,
+    Token,
 };
 
 #[derive(Debug, Clone, PartialEq, Component)]
@@ -105,7 +106,7 @@ impl ParseAttribute for FontStyleState {
     fn parse_attribute(
         &mut self,
         attr: freya_native_core::prelude::OwnedAttributeView<CustomAttributeValues>,
-    ) -> Result<(), crate::ParseError> {
+    ) -> Result<(), ParseError> {
         match attr.attribute {
             AttributeName::Color => {
                 if let Some(value) = attr.value.as_text() {
@@ -118,15 +119,13 @@ impl ParseAttribute for FontStyleState {
             }
             AttributeName::TextShadow => {
                 if let Some(value) = attr.value.as_text() {
-                    self.text_shadows = value
-                        .split_excluding_group(',', '(', ')')
-                        .map(|chunk| TextShadow::parse(chunk).unwrap_or_default())
-                        .collect();
+                    self.text_shadows = TextShadow::parse_with_separator(value, &Token::Comma)?;
                 }
             }
             AttributeName::FontFamily => {
                 if let Some(value) = attr.value.as_text() {
                     let families = value.split(',');
+
                     self.font_family = families
                         .into_iter()
                         .map(|f| f.trim().to_string())
@@ -149,84 +148,59 @@ impl ParseAttribute for FontStyleState {
             }
             AttributeName::TextAlign => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(text_align) = TextAlign::parse(value) {
-                        self.text_align = text_align;
-                    }
+                    self.text_align = TextAlign::parse(value)?;
                 }
             }
             AttributeName::MaxLines => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(max_lines) = value.parse() {
-                        self.max_lines = Some(max_lines);
-                    }
+                    self.max_lines = Some(value.parse().map_err(|_| ParseError)?);
                 }
             }
             AttributeName::TextOverflow => {
-                let value = attr.value.as_text();
-                if let Some(value) = value {
-                    if let Ok(text_overflow) = TextOverflow::parse(value) {
-                        self.text_overflow = text_overflow;
-                    }
+                if let Some(value) = attr.value.as_text() {
+                    self.text_overflow = TextOverflow::parse(value)?;
                 }
             }
             AttributeName::FontStyle => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(font_slant) = Slant::parse(value) {
-                        self.font_slant = font_slant;
-                    }
+                    self.font_slant = Slant::parse(value)?;
                 }
             }
             AttributeName::FontWeight => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(font_weight) = Weight::parse(value) {
-                        self.font_weight = font_weight;
-                    }
+                    self.font_weight = Weight::parse(value)?;
                 }
             }
             AttributeName::FontWidth => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(font_width) = Width::parse(value) {
-                        self.font_width = font_width;
-                    }
+                    self.font_width = Width::parse(value)?;
                 }
             }
             AttributeName::Decoration => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(decoration) = TextDecoration::parse(value) {
-                        self.decoration.ty = decoration;
-                    }
+                    self.decoration.ty = TextDecoration::parse(value)?;
                 }
             }
             AttributeName::DecorationStyle => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(style) = TextDecorationStyle::parse(value) {
-                        self.decoration.style = style;
-                    }
+                    self.decoration.style = TextDecorationStyle::parse(value)?;
                 }
             }
             AttributeName::DecorationColor => {
                 if let Some(value) = attr.value.as_text() {
-                    if let Ok(new_decoration_color) = Color::parse(value) {
-                        self.decoration.color = new_decoration_color;
-                    }
+                    self.decoration.color = Color::parse(value)?;
                 } else {
                     self.decoration.color = self.color;
                 }
             }
             AttributeName::WordSpacing => {
-                let value = attr.value.as_text();
-                if let Some(value) = value {
-                    if let Ok(word_spacing) = value.parse() {
-                        self.word_spacing = word_spacing;
-                    }
+                if let Some(value) = attr.value.as_text() {
+                    self.word_spacing = value.parse().map_err(|_| ParseError)?;
                 }
             }
             AttributeName::LetterSpacing => {
-                let value = attr.value.as_text();
-                if let Some(value) = value {
-                    if let Ok(letter_spacing) = value.parse() {
-                        self.letter_spacing = letter_spacing;
-                    }
+                if let Some(value) = attr.value.as_text() {
+                    self.letter_spacing = value.parse().map_err(|_| ParseError)?;
                 }
             }
             _ => {}

crates/state/src/layout.rs

@@ -100,7 +100,8 @@ impl ParseAttribute for LayoutState {
                 if let Some(value) = attr.value.as_text() {
                     self.direction = match value {
                         "horizontal" => DirectionMode::Horizontal,
-                        _ => DirectionMode::Vertical,
+                        "vertical" => DirectionMode::Vertical,
+                        _ => return Err(ParseError),
                     }
                 }
             }

crates/state/src/lexing.rs

@@ -0,0 +1,186 @@
+use std::iter;
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Token {
+    Ident(String),
+    Float(f32),
+    Integer(i64),
+    ParenOpen,
+    ParenClose,
+    Minus,
+    Plus,
+    Slash,
+    Star,
+    Pound,
+    Percent,
+    Comma,
+    Unknown(char),
+}
+
+impl Token {
+    pub fn ident<T: Into<String>>(value: T) -> Self {
+        Self::Ident(value.into())
+    }
+
+    pub fn is_ident(&self) -> bool {
+        matches!(self, Token::Ident(_))
+    }
+
+    pub fn is_f32(&self) -> bool {
+        matches!(self, Token::Float(_))
+    }
+
+    pub fn is_i64(&self) -> bool {
+        matches!(self, Token::Integer(_))
+    }
+
+    pub fn is_i64_or_f32(&self) -> bool {
+        matches!(self, Token::Integer(_) | Token::Float(_))
+    }
+
+    pub fn into_string(self) -> String {
+        if let Token::Ident(value) = self {
+            value
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn into_f32(self) -> f32 {
+        if let Token::Float(value) = self {
+            value
+        } else if let Token::Integer(value) = self {
+            value as f32
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn into_i64(self) -> i64 {
+        if let Token::Integer(value) = self {
+            value
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        if let Token::Ident(value) = self {
+            value.as_str()
+        } else {
+            unreachable!()
+        }
+    }
+
+    pub fn try_as_str(&self) -> Option<&str> {
+        if let Token::Ident(value) = self {
+            Some(value.as_str())
+        } else {
+            None
+        }
+    }
+
+    pub fn try_as_f32(&self) -> Option<f32> {
+        if let Token::Float(value) = self {
+            Some(*value)
+        } else if let Token::Integer(value) = self {
+            Some(*value as f32)
+        } else {
+            None
+        }
+    }
+
+    pub fn try_as_i64(&self) -> Option<i64> {
+        if let Token::Integer(value) = self {
+            Some(*value)
+        } else {
+            None
+        }
+    }
+
+    pub fn try_as_u8(&self) -> Option<u8> {
+        if let Token::Integer(value) = self {
+            u8::try_from(*value).ok()
+        } else {
+            None
+        }
+    }
+}
+
+pub struct Lexer;
+
+impl Lexer {
+    pub fn parse<T: AsRef<str>>(data: T) -> Vec<Token> {
+        let mut tokens = vec![];
+        let mut chars = data.as_ref().chars().peekable();
+
+        while let Some(character) = chars.next() {
+            match character {
+                ' ' => continue,
+                'A'..='z' => {
+                    tokens.push(Token::Ident(
+                        iter::once(character)
+                            .chain(iter::from_fn(|| {
+                                chars
+                                    .by_ref()
+                                    .next_if(|s| s.is_ascii_alphanumeric() || s == &'-')
+                            }))
+                            .collect::<String>()
+                            .parse()
+                            .unwrap(),
+                    ));
+                }
+                '0'..='9' => {
+                    let value = iter::once(character)
+                        .chain(iter::from_fn(|| {
+                            chars.by_ref().next_if(|s| s.is_ascii_digit() || s == &'.')
+                        }))
+                        .collect::<String>();
+
+                    if value.contains('.') {
+                        tokens.push(Token::Float(value.parse().unwrap()));
+                    } else {
+                        tokens.push(Token::Integer(value.parse().unwrap()));
+                    }
+                }
+                '(' => tokens.push(Token::ParenOpen),
+                ')' => tokens.push(Token::ParenClose),
+                '+' => tokens.push(Token::Plus),
+                '-' => {
+                    if chars.peek().is_some_and(char::is_ascii_digit) {
+                        let value = iter::once(character)
+                            .chain(iter::from_fn(|| {
+                                chars.by_ref().next_if(|s| s.is_ascii_digit() || s == &'.')
+                            }))
+                            .collect::<String>();
+
+                        if value.contains('.') {
+                            tokens.push(Token::Float(value.parse().unwrap()));
+                        } else {
+                            tokens.push(Token::Integer(value.parse().unwrap()));
+                        }
+                    } else {
+                        tokens.push(Token::Minus);
+                    }
+                }
+                '*' => tokens.push(Token::Star),
+                '/' => tokens.push(Token::Slash),
+                '#' => {
+                    tokens.push(Token::Pound);
+
+                    if chars.peek().is_some_and(char::is_ascii_alphanumeric) {
+                        tokens.push(Token::Ident(
+                            iter::from_fn(|| chars.by_ref().next_if(char::is_ascii_alphanumeric))
+                                .collect::<String>(),
+                        ));
+                    }
+                }
+                '%' => tokens.push(Token::Percent),
+                ',' => tokens.push(Token::Comma),
+                character => tokens.push(Token::Unknown(character)),
+            }
+        }
+
+        tokens
+    }
+}

crates/state/src/lib.rs

@@ -4,6 +4,7 @@ mod custom_attributes;
 mod font_style;
 mod layer;
 mod layout;
+mod lexing;
 mod parsing;
 mod references;
 mod style;
@@ -17,6 +18,7 @@ pub use custom_attributes::*;
 pub use font_style::*;
 pub use layer::*;
 pub use layout::*;
+pub use lexing::*;
 pub use parsing::*;
 pub use references::*;
 pub use style::*;