Finished core parsing and spawning functionality.

Signed-off-by: TheDudeFromCI <thedudefromci@gmail.com>

Author: TheDudeFromCI

Cargo.lock

@@ -11,10 +11,16 @@ bevy = { version = "0.17", default-features = false, features = [
   "bevy_ui_render",
   "bevy_text",
   "bevy_asset",
+  "bevy_log",
 ] }
-common_macros = "0.1.1"
-lazy_static = "1.5.0"
-thiserror = "2.0.17"
+lazy_static = "1.5"
+regex = "1.12"
+thiserror = "2"
 
 [dev-dependencies]
-pretty_assertions = "1.4.1"
+bevy = { version = "0.17", default-features = true }
+pretty_assertions = "1.4"
+
+[features]
+default = ["hot-reload"]
+hot-reload = ["bevy/file_watcher"]

Cargo.toml

@@ -1,28 +1,12 @@
-import "global_theme";
-
-var sky: #7777ff;
-
-style div +pressed {
-  background_color: red;
-}
-
-style div +hovered !disabled {
-  with p {
-    text-size: 16;
-  }
+style div +outer-menu {
+  background-color: #D5A96E;
+  border-color: #5B4A31;
+  border-thickness: 4px;
 }
 
 layout div {
-  +outer-menu
-
-  background_color: $sky;
-  anchor: top-left;
-
-  with div {
-    // Comment
+  class outer-menu;
 
-    anchor: top;
-    width: 150px;
-    height: 100px;
-  }
+  width: 400px;
+  height: 600px;
 }

assets/example.neko_ui

@@ -0,0 +1,17 @@
+use bevy::prelude::*;
+use neko_maid::components::NekoUITree;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_plugins(neko_maid::NekoMaidPlugin)
+        .add_systems(Startup, setup)
+        .run();
+}
+
+fn setup(asset_server: Res<AssetServer>, mut commands: Commands) {
+    commands.spawn(Camera2d);
+
+    let handle = asset_server.load("example.neko_ui");
+    commands.spawn(NekoUITree::new(handle));
+}

example/menu.rs

@@ -0,0 +1,94 @@
+//! The NekoMaid style asset, and asset loader for NekoMaid ui files.
+
+use std::time::Instant;
+
+use bevy::asset::io::Reader;
+use bevy::asset::{AssetLoader, LoadContext, LoadDirectError};
+use bevy::prelude::*;
+
+use crate::native::NATIVE_WIDGETS;
+use crate::parse::module::Module;
+use crate::parse::{NekoMaidParseError, NekoMaidParser};
+
+/// A NekoMaid UI asset.
+#[derive(Debug, Asset, TypePath, Deref)]
+pub struct NekoMaidUI(Module);
+
+/// The asset loader for NekoMaid ui files.
+#[derive(Debug, Default)]
+pub struct NekoMaidAssetLoader;
+impl AssetLoader for NekoMaidAssetLoader {
+    type Asset = NekoMaidUI;
+    type Settings = ();
+    type Error = NekoMaidAssetLoaderError;
+
+    async fn load(
+        &self,
+        reader: &mut dyn Reader,
+        _: &Self::Settings,
+        load_context: &mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let now = Instant::now();
+
+        let mut bytes = Vec::new();
+        reader.read_to_end(&mut bytes).await?;
+
+        let text_file = String::from_utf8(bytes)?;
+        let mut parser = NekoMaidParser::tokenize(&text_file)?;
+
+        for native in NATIVE_WIDGETS.iter() {
+            parser.register_native_widget(native.clone());
+        }
+
+        for import in parser.predict_imports().clone() {
+            let path = load_context.asset_path();
+            let Ok(module_path) = path.resolve(&format!("../{}.neko_ui", import)) else {
+                continue;
+            };
+
+            let asset = load_context
+                .loader()
+                .immediate()
+                .load::<NekoMaidUI>(&module_path)
+                .await?;
+
+            let module = asset.get().0.clone();
+            parser.add_module(import.clone(), module);
+        }
+
+        let module = parser.finish()?;
+
+        let elapsed = now.elapsed().as_millis();
+        debug!(
+            "Loaded NekoMaid UI asset {} in {} ms.",
+            load_context.path().display(),
+            elapsed,
+        );
+
+        Ok(NekoMaidUI(module))
+    }
+
+    fn extensions(&self) -> &[&str] {
+        &["neko_ui"]
+    }
+}
+
+/// Errors that can occur while loading a NekoMaid asset.
+#[derive(Debug, thiserror::Error)]
+pub enum NekoMaidAssetLoaderError {
+    /// An I/O error occurred while loading the asset.
+    #[error("I/O error: {0}")]
+    IO(#[from] std::io::Error),
+
+    /// The asset contained invalid UTF-8.
+    #[error("Invalid UTF-8: {0}")]
+    InvalidUtf8(#[from] std::string::FromUtf8Error),
+
+    /// An error occurred while parsing the asset.
+    #[error("Syntax error: {0}")]
+    FailedToParse(#[from] NekoMaidParseError),
+
+    /// An error occurred while loading a dependency.
+    #[error("{0}")]
+    FailedToLoadDependency(#[from] LoadDirectError),
+}

src/asset.rs

@@ -0,0 +1,43 @@
+//! Components used for the NekoMaid plugin.
+
+use bevy::prelude::*;
+
+use crate::asset::NekoMaidUI;
+
+/// A component representing the root of a NekoMaid UI tree.
+#[derive(Debug, Component)]
+#[require(Node)]
+pub struct NekoUITree {
+    /// The NekoMaid UI asset associated with this tree.
+    asset: Handle<NekoMaidUI>,
+
+    /// Whether the tree needs to be re-spawned.
+    dirty: bool,
+}
+
+impl NekoUITree {
+    /// Creates a new NekoUITree with the given asset handle.
+    pub fn new(asset: Handle<NekoMaidUI>) -> Self {
+        Self { asset, dirty: true }
+    }
+
+    /// Returns a reference to the asset handle of this tree.
+    pub fn asset(&self) -> &Handle<NekoMaidUI> {
+        &self.asset
+    }
+
+    /// Marks the tree as dirty, indicating that it needs to be re-spawned.
+    pub fn mark_dirty(&mut self) {
+        self.dirty = true;
+    }
+
+    /// Clears the dirty flag.
+    pub fn clear_dirty(&mut self) {
+        self.dirty = false;
+    }
+
+    /// Returns whether the tree is dirty.
+    pub fn is_dirty(&self) -> bool {
+        self.dirty
+    }
+}

src/components.rs

@@ -4,14 +4,39 @@
 
 use bevy::prelude::*;
 
+use crate::asset::{NekoMaidAssetLoader, NekoMaidUI};
+
+pub mod asset;
+pub mod components;
+pub mod native;
 pub mod parse;
-pub mod vm;
+mod systems;
 
 /// A Bevy UI plugin: NekoMaid
 ///
 /// This plugin provides core functionality for the NekoMaid framework,
 /// including UI components and systems, assets, and high-level widgets.
 pub struct NekoMaidPlugin;
 impl Plugin for NekoMaidPlugin {
-    fn build(&self, _: &mut App) {}
+    fn build(&self, app_: &mut App) {
+        app_.init_asset::<NekoMaidUI>()
+            .init_asset_loader::<NekoMaidAssetLoader>()
+            .add_systems(
+                Update,
+                (
+                    systems::spawn_tree.in_set(NekoMaidSystems::UpdateTree),
+                    systems::update_tree.in_set(NekoMaidSystems::AssetListener),
+                ),
+            );
+    }
+}
+
+/// System sets used by the NekoMaid plugin.
+#[derive(Debug, SystemSet, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum NekoMaidSystems {
+    /// System for spawning UI trees.
+    UpdateTree,
+
+    /// System for listening for asset changes.
+    AssetListener,
 }

src/lib.rs

@@ -0,0 +1,141 @@
+//! Defines the native widgets available in NekoMaid UI.
+
+use bevy::platform::collections::HashMap;
+use bevy::prelude::*;
+use lazy_static::lazy_static;
+
+use crate::parse::element::NekoElement;
+use crate::parse::property::PropertyValue;
+use crate::parse::widget::NativeWidget;
+
+lazy_static! {
+    /// The list of native widgets available in NekoMaid UI.
+    pub static ref NATIVE_WIDGETS: Vec<NativeWidget> = vec![NativeWidget {
+        name: String::from("div"),
+        properties: {
+            let mut m = HashMap::new();
+            m.insert("width".into(), "auto".into());
+            m.insert("height".into(), "auto".into());
+            m.insert("background-color".into(), Color::NONE.into());
+
+            m.insert("border-color".into(), Color::NONE.into());
+            m.insert("border-color-top".into(), Color::NONE.into());
+            m.insert("border-color-left".into(), Color::NONE.into());
+            m.insert("border-color-right".into(), Color::NONE.into());
+            m.insert("border-color-bottom".into(), Color::NONE.into());
+
+            m.insert("border-thickness".into(), Color::NONE.into());
+            m.insert("border-thickness-top".into(), Color::NONE.into());
+            m.insert("border-thickness-left".into(), Color::NONE.into());
+            m.insert("border-thickness-right".into(), Color::NONE.into());
+            m.insert("border-thickness-bottom".into(), Color::NONE.into());
+            m
+        },
+        spawn_func: spawn_div,
+    }];
+}
+
+/// Spawns a `div` native widget.
+fn spawn_div(commands: &mut Commands, parent: Entity, element: &NekoElement) -> Entity {
+    commands
+        .spawn((
+            ChildOf(parent),
+            node_bundle(element),
+            background_color_bundle(element),
+            border_color_bundle(element),
+        ))
+        .id()
+}
+
+/// Build [`Node`] bundle
+fn node_bundle(element: &NekoElement) -> Node {
+    let width = element.get_property("width").map_or(Val::Auto, as_val);
+    let height = element.get_property("height").map_or(Val::Auto, as_val);
+
+    let border_thickness = element
+        .get_property("border-thickness")
+        .map_or(Val::Auto, as_val);
+    let border_thickness_top = element
+        .get_property("border-thickness-top")
+        .map_or(border_thickness, as_val);
+    let border_thickness_left = element
+        .get_property("border-thickness-left")
+        .map_or(border_thickness, as_val);
+    let border_thickness_right = element
+        .get_property("border-thickness-right")
+        .map_or(border_thickness, as_val);
+    let border_thickness_bottom = element
+        .get_property("border-thickness-bottom")
+        .map_or(border_thickness, as_val);
+
+    Node {
+        width,
+        height,
+        border: UiRect {
+            top: border_thickness_top,
+            left: border_thickness_left,
+            right: border_thickness_right,
+            bottom: border_thickness_bottom,
+        },
+        ..default()
+    }
+}
+
+/// Build [`BorderColor`] bundle
+fn border_color_bundle(element: &NekoElement) -> BorderColor {
+    let border_color = element
+        .get_property("border-color")
+        .map_or(Color::NONE, as_color);
+    let border_color_top = element
+        .get_property("border-color-top")
+        .map_or(border_color, as_color);
+    let border_color_left = element
+        .get_property("border-color-left")
+        .map_or(border_color, as_color);
+    let border_color_right = element
+        .get_property("border-color-right")
+        .map_or(border_color, as_color);
+    let border_color_bottom = element
+        .get_property("border-color-bottom")
+        .map_or(border_color, as_color);
+
+    BorderColor {
+        top: border_color_top,
+        left: border_color_left,
+        right: border_color_right,
+        bottom: border_color_bottom,
+    }
+}
+
+/// Build [`BackgroundColor`] bundle
+fn background_color_bundle(element: &NekoElement) -> BackgroundColor {
+    let bg_color = element
+        .get_property("background-color")
+        .map_or(Color::NONE, as_color);
+
+    BackgroundColor(bg_color)
+}
+
+/// Converts a [`PropertyValue`] to a Bevy UI [`Val`].
+fn as_val(property: &PropertyValue) -> Val {
+    match property {
+        PropertyValue::String(s) if s == "auto" => Val::Auto,
+        PropertyValue::Pixels(n) => Val::Px(*n as f32),
+        PropertyValue::Percent(n) => Val::Percent(*n as f32),
+        _ => {
+            warn_once!("Failed to convert PropertyValue {:?} to Val", property);
+            Val::Auto
+        }
+    }
+}
+
+/// Converts a [`PropertyValue`] to a Bevy UI [`Color`].
+fn as_color(property: &PropertyValue) -> Color {
+    match property {
+        PropertyValue::Color(c) => *c,
+        _ => {
+            warn_once!("Failed to convert PropertyValue {:?} to Color", property);
+            Color::NONE
+        }
+    }
+}