feat: Rethink parsing

crates/state/src/cursor.rs

@@ -1,6 +1,9 @@
-use std::sync::{
-    Arc,
-    Mutex,
+use std::{
+    num::ParseIntError,
+    sync::{
+        Arc,
+        Mutex,
+    },
 };
 
 use freya_common::{
@@ -72,7 +75,11 @@ impl ParseAttribute for CursorState {
             AttributeName::CursorIndex => {
                 if let Some(value) = attr.value.as_text() {
                     if value != "none" {
-                        self.position = Some(value.parse().map_err(|_| ParseError)?);
+                        self.position = Some(
+                            value
+                                .parse()
+                                .map_err(|err: ParseIntError| ParseError(err.to_string()))?,
+                        );
                     }
                 }
             }
@@ -88,7 +95,11 @@ impl ParseAttribute for CursorState {
             }
             AttributeName::CursorId => {
                 if let Some(value) = attr.value.as_text() {
-                    self.cursor_id = Some(value.parse().map_err(|_| ParseError)?);
+                    self.cursor_id = Some(
+                        value
+                            .parse()
+                            .map_err(|err: ParseIntError| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::Highlights => {

crates/state/src/font_style.rs

@@ -1,6 +1,12 @@
-use std::sync::{
-    Arc,
-    Mutex,
+use std::{
+    num::{
+        ParseFloatError,
+        ParseIntError,
+    },
+    sync::{
+        Arc,
+        Mutex,
+    },
 };
 
 use freya_common::CompositorDirtyNodes;
@@ -23,11 +29,13 @@ use torin::torin::Torin;
 
 use crate::{
     CustomAttributeValues,
-    ExtSplit,
     Parse,
     ParseAttribute,
+    ParseError,
     TextHeight,
+    TextHeightBehavior,
     TextOverflow,
+    Token,
 };
 
 #[derive(Debug, Clone, PartialEq, Component)]
@@ -123,7 +131,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() {
@@ -136,15 +144,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())
@@ -167,84 +173,67 @@ 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(|err: ParseIntError| ParseError(err.to_string()))?,
+                    );
                 }
             }
             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(|err: ParseFloatError| ParseError(err.to_string()))?;
                 }
             }
             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(|err: ParseFloatError| ParseError(err.to_string()))?;
                 }
             }
             AttributeName::TextHeight => {

crates/state/src/layer.rs

@@ -40,7 +40,9 @@ impl ParseAttribute for LayerState {
         match attr.attribute {
             AttributeName::Layer => {
                 if let Some(value) = attr.value.as_text() {
-                    let layer = value.parse::<i16>().map_err(|_| ParseError)?;
+                    let layer = value
+                        .parse::<i16>()
+                        .map_err(|err| ParseError(err.to_string()))?;
                     self.layer -= layer;
                     self.layer_for_children += layer;
                 }

crates/state/src/layout.rs

@@ -102,18 +102,32 @@ impl ParseAttribute for LayoutState {
                 if let Some(value) = attr.value.as_text() {
                     self.direction = match value {
                         "horizontal" => DirectionMode::Horizontal,
-                        _ => DirectionMode::Vertical,
+                        "vertical" => DirectionMode::Vertical,
+                        value => {
+                            return Err(ParseError::invalid_ident(
+                                value,
+                                &["horizontal", "vertical"],
+                            ))
+                        }
                     }
                 }
             }
             AttributeName::OffsetY => {
                 if let Some(value) = attr.value.as_text() {
-                    self.offset_y = Length::new(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.offset_y = Length::new(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::OffsetX => {
                 if let Some(value) = attr.value.as_text() {
-                    self.offset_x = Length::new(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.offset_x = Length::new(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::MainAlign => {
@@ -135,26 +149,38 @@ impl ParseAttribute for LayoutState {
             }
             AttributeName::PositionTop => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_top(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_top(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::PositionRight => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_right(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_right(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::PositionBottom => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_bottom(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_bottom(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::PositionLeft => {
                 if let Some(value) = attr.value.as_text() {
-                    self.position
-                        .set_left(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.position.set_left(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             AttributeName::Content => {
@@ -171,7 +197,11 @@ impl ParseAttribute for LayoutState {
             }
             AttributeName::Spacing => {
                 if let Some(value) = attr.value.as_text() {
-                    self.spacing = Length::new(value.parse::<f32>().map_err(|_| ParseError)?);
+                    self.spacing = Length::new(
+                        value
+                            .parse::<f32>()
+                            .map_err(|err| ParseError(err.to_string()))?,
+                    );
                 }
             }
             _ => {}