@ape-egg/vibe 1.2.0 → 1.3.0

package/compiler/src/compiler/manifest_builder.rs

@@ -0,0 +1,432 @@
+use html5ever::parse_document;
+use html5ever::tendril::TendrilSink;
+use markup5ever_rcdom::{RcDom, NodeData, Handle};
+use regex::Regex;
+use serde::{Serialize, Serializer};
+use serde_json::Value;
+use std::collections::HashMap;
+
+pub struct ManifestBuilder {
+    binding_regex: Regex,
+}
+
+impl ManifestBuilder {
+    pub fn new() -> Self {
+        Self {
+            binding_regex: Regex::new(r"@\[((?:[^\[\]]|\[[^\]]*\])+)\]").unwrap(),
+        }
+    }
+
+    pub fn build_from_html(&self, html: &str, _state: &Value) -> Result<ManifestNode, String> {
+        // Parse HTML
+        let dom = parse_document(RcDom::default(), Default::default())
+            .from_utf8()
+            .read_from(&mut html.as_bytes())
+            .map_err(|e| format!("Failed to parse HTML: {:?}", e))?;
+
+        // Walk tree starting from document root
+        let root_node = self.walk_node(&dom.document, &mut 0);
+
+        Ok(root_node)
+    }
+
+    fn walk_node(&self, node: &Handle, _counter: &mut usize) -> ManifestNode {
+        self.walk_node_impl(node, &node.children.borrow())
+    }
+
+    fn walk_node_impl(&self, node: &Handle, siblings: &[Handle]) -> ManifestNode {
+        let mut manifest_node = ManifestNode {
+            element: None,
+            parsed: vec![],
+            children: HashMap::new(),
+            hyperspeed_restoration: None,
+            node_type: None,
+        };
+
+        match &node.data {
+            NodeData::Text { contents } => {
+                let text = contents.borrow().to_string();
+
+                // Check for @[...] bindings
+                if self.binding_regex.is_match(&text) {
+                    let parsed = self.split_by_bindings(&text);
+                    manifest_node.hyperspeed_restoration = Some(RestorationData {
+                        parsed: Some(parsed),
+                        ..Default::default()
+                    });
+                }
+            }
+
+            NodeData::Element { name, attrs, .. } => {
+                let _tag_name = name.local.to_string();
+
+                // Check attribute bindings
+                let mut attr_bindings = HashMap::new();
+                for attr in attrs.borrow().iter() {
+                    let attr_name = attr.name.local.to_string();
+                    let attr_value = attr.value.to_string();
+
+                    if self.binding_regex.is_match(&attr_value) {
+                        attr_bindings.insert(attr_name, attr_value);
+                    }
+                }
+
+                if !attr_bindings.is_empty() {
+                    manifest_node.hyperspeed_restoration = Some(RestorationData {
+                        attributes: Some(attr_bindings),
+                        ..Default::default()
+                    });
+                }
+            }
+
+            NodeData::Comment { contents } => {
+                let comment = contents.to_string();
+                let trimmed = comment.trim();
+
+                // Check for iteration: <!-- each items as item -->
+                if trimmed.starts_with("each ") {
+                    manifest_node.node_type = Some("iteration".to_string());
+
+                    // Find node index in siblings
+                    let node_idx = siblings.iter().position(|n| std::ptr::eq(n as *const _, node as *const _));
+
+                    // Extract template if we can find this node in siblings
+                    let template = if let Some(idx) = node_idx {
+                        self.extract_template_from_siblings(siblings, idx, "each ", "/each")
+                    } else {
+                        String::new()
+                    };
+
+                    manifest_node.hyperspeed_restoration = Some(RestorationData {
+                        template: Some(template),
+                        ..Default::default()
+                    });
+                }
+
+                // Check for conditionals: <!-- if condition -->
+                if trimmed.starts_with("if ") {
+                    manifest_node.node_type = Some("conditional".to_string());
+
+                    let node_idx = siblings.iter().position(|n| std::ptr::eq(n as *const _, node as *const _));
+
+                    let template = if let Some(idx) = node_idx {
+                        self.extract_template_from_siblings(siblings, idx, "if ", "/if")
+                    } else {
+                        String::new()
+                    };
+
+                    manifest_node.hyperspeed_restoration = Some(RestorationData {
+                        template: Some(template),
+                        ..Default::default()
+                    });
+                }
+            }
+
+            _ => {}
+        }
+
+        // Recursively process children using local indices (to match runtime key generation)
+        let children = node.children.borrow();
+        let mut skip_indices = std::collections::HashSet::new();
+
+        // First pass: identify indices to skip (iteration/conditional template content)
+        for (i, child) in children.iter().enumerate() {
+            if let NodeData::Comment { contents } = &child.data {
+                let trimmed = contents.trim();
+
+                // Find iteration blocks and mark template indices to skip
+                if trimmed.starts_with("each ") {
+                    if let Some(end_idx) = self.find_matching_end(&children, i, "each ", "/each") {
+                        // Skip all nodes between start and end comments (including end comment)
+                        for j in (i + 1)..=end_idx {
+                            skip_indices.insert(j);
+                        }
+                    }
+                }
+
+                // Find conditional blocks and mark template indices to skip
+                if trimmed.starts_with("if ") {
+                    if let Some(end_idx) = self.find_matching_end(&children, i, "if ", "/if") {
+                        for j in (i + 1)..=end_idx {
+                            skip_indices.insert(j);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Second pass: process children that aren't skipped
+        for (local_index, child) in children.iter().enumerate() {
+            if skip_indices.contains(&local_index) {
+                continue;
+            }
+
+            let child_key = self.generate_child_key(child, &local_index);
+            manifest_node.children.insert(
+                child_key.clone(),
+                self.walk_node_impl(child, &children)
+            );
+        }
+
+        manifest_node
+    }
+
+    /// Split text by @[...] bindings: "Hello @[name]!" -> ["Hello ", "@[name]", "!"]
+    fn split_by_bindings(&self, text: &str) -> Vec<String> {
+        let mut result = vec![];
+        let mut last_end = 0;
+
+        for mat in self.binding_regex.find_iter(text) {
+            // Add text before match
+            if mat.start() > last_end {
+                result.push(text[last_end..mat.start()].to_string());
+            }
+            // Add binding
+            result.push(mat.as_str().to_string());
+            last_end = mat.end();
+        }
+
+        // Add remaining text
+        if last_end < text.len() {
+            result.push(text[last_end..].to_string());
+        }
+
+        result
+    }
+
+    /// Generate child key: "text_0", "div_1", etc.
+    fn generate_child_key(&self, node: &Handle, index: &usize) -> String {
+        match &node.data {
+            NodeData::Text { .. } => format!("text_{}", index),
+            NodeData::Element { name, .. } => {
+                format!("{}_{}", name.local.to_lowercase(), index)
+            }
+            NodeData::Comment { contents } => {
+                let trimmed = contents.trim();
+                if trimmed.starts_with("each ") {
+                    format!("iteration_{}", index)
+                } else if trimmed.starts_with("if ") {
+                    format!("conditional_{}", index)
+                } else {
+                    format!("comment_{}", index)
+                }
+            }
+            _ => format!("node_{}", index),
+        }
+    }
+
+    /// Find the index of matching end comment
+    fn find_matching_end(&self, siblings: &[Handle], start_idx: usize, start_marker: &str, end_marker: &str) -> Option<usize> {
+        let mut depth = 0;
+
+        for (idx, sibling) in siblings.iter().enumerate().skip(start_idx + 1) {
+            if let NodeData::Comment { contents } = &sibling.data {
+                let trimmed = contents.trim();
+                if trimmed.starts_with(start_marker) {
+                    depth += 1;
+                } else if trimmed == end_marker {
+                    if depth == 0 {
+                        return Some(idx);
+                    } else {
+                        depth -= 1;
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    /// Extract template between start and end comments (generic for iterations and conditionals)
+    fn extract_template_from_siblings(&self, siblings: &[Handle], start_idx: usize, start_marker: &str, end_marker: &str) -> String {
+        // Find matching end comment
+        let mut depth = 0;
+        let mut end_idx = None;
+
+        for (idx, sibling) in siblings.iter().enumerate().skip(start_idx + 1) {
+            if let NodeData::Comment { contents } = &sibling.data {
+                let trimmed = contents.trim();
+                if trimmed.starts_with(start_marker) {
+                    depth += 1;
+                } else if trimmed == end_marker {
+                    if depth == 0 {
+                        end_idx = Some(idx);
+                        break;
+                    } else {
+                        depth -= 1;
+                    }
+                }
+            }
+        }
+
+        // Extract template HTML between start and end
+        if let Some(end) = end_idx {
+            let template_nodes: Vec<_> = siblings.iter()
+                .skip(start_idx + 1)
+                .take(end - start_idx - 1)
+                .filter(|node| {
+                    // Skip whitespace-only text nodes
+                    if let NodeData::Text { contents } = &node.data {
+                        !contents.borrow().trim().is_empty()
+                    } else {
+                        true // Keep all non-text nodes
+                    }
+                })
+                .collect();
+
+            return self.serialize_nodes(&template_nodes);
+        }
+
+        String::new()
+    }
+
+    /// Serialize nodes to HTML string
+    fn serialize_nodes(&self, nodes: &[&Handle]) -> String {
+        use html5ever::serialize::{serialize, SerializeOpts, TraversalScope};
+        use markup5ever_rcdom::SerializableHandle;
+
+        let mut html = String::new();
+
+        for node in nodes.iter() {
+            let mut bytes = Vec::new();
+
+            // Serialize with IncludeNode to include the element tags
+            let opts = SerializeOpts {
+                traversal_scope: TraversalScope::IncludeNode,
+                ..Default::default()
+            };
+
+            let serializable = SerializableHandle::from((*node).clone());
+            serialize(&mut bytes, &serializable, opts).ok();
+
+            if let Ok(node_html) = String::from_utf8(bytes) {
+                html.push_str(&node_html);
+            }
+        }
+
+        html
+    }
+}
+
+#[derive(Debug)]
+pub struct ManifestNode {
+    element: Option<()>,  // Always null in static manifest
+    parsed: Vec<String>,
+    children: HashMap<String, ManifestNode>,
+
+    #[allow(dead_code)]
+    hyperspeed_restoration: Option<RestorationData>,
+
+    #[allow(dead_code)]
+    node_type: Option<String>,
+}
+
+// Custom Serialize implementation to control output format
+impl Serialize for ManifestNode {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use serde::ser::SerializeMap;
+
+        let mut map = serializer.serialize_map(None)?;
+
+        // Always include element (null)
+        map.serialize_entry("element", &self.element)?;
+
+        // Always include parsed (empty array if no data)
+        map.serialize_entry("parsed", &self.parsed)?;
+
+        // Always include children
+        map.serialize_entry("children", &self.children)?;
+
+        // Optional: hyperspeedRestoration
+        if let Some(ref restoration) = self.hyperspeed_restoration {
+            map.serialize_entry("hyperspeedRestoration", restoration)?;
+        }
+
+        // Optional: type
+        if let Some(ref node_type) = self.node_type {
+            map.serialize_entry("type", node_type)?;
+        }
+
+        map.end()
+    }
+}
+
+#[derive(Debug, Serialize, Default)]
+pub struct RestorationData {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parsed: Option<Vec<String>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attributes: Option<HashMap<String, String>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub template: Option<String>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn build_simple_text_binding() {
+        let html = r#"<div>Hello @[name]</div>"#;
+        let state = json!({ "name": "World" });
+        let builder = ManifestBuilder::new();
+        let manifest = builder.build_from_html(html, &state).unwrap();
+
+        // Should have children
+        assert!(!manifest.children.is_empty());
+    }
+
+    #[test]
+    fn build_attribute_binding() {
+        let html = r#"<input value="@[firstName]">"#;
+        let state = json!({ "firstName": "John" });
+        let builder = ManifestBuilder::new();
+        let manifest = builder.build_from_html(html, &state).unwrap();
+
+        // Should have children
+        assert!(!manifest.children.is_empty());
+    }
+
+    #[test]
+    fn build_iteration_with_template() {
+        let html = r#"<body><!-- each items as item --><div>@[item]</div><!-- /each --></body>"#;
+        let state = json!({ "items": [1, 2, 3] });
+        let builder = ManifestBuilder::new();
+        let manifest = builder.build_from_html(html, &state).unwrap();
+
+        // Serialize to JSON to inspect
+        let json = serde_json::to_string_pretty(&manifest).unwrap();
+        eprintln!("Manifest JSON:\n{}", json);
+
+        // Find iteration node
+        // Note: might be nested under body
+        assert!(!manifest.children.is_empty());
+    }
+
+    #[test]
+    fn split_bindings_simple() {
+        let builder = ManifestBuilder::new();
+        let result = builder.split_by_bindings("Hello @[name]!");
+        assert_eq!(result, vec!["Hello ", "@[name]", "!"]);
+    }
+
+    #[test]
+    fn split_bindings_multiple() {
+        let builder = ManifestBuilder::new();
+        let result = builder.split_by_bindings("@[firstName] @[lastName]");
+        assert_eq!(result, vec!["@[firstName]", " ", "@[lastName]"]);
+    }
+
+    #[test]
+    fn split_bindings_no_match() {
+        let builder = ManifestBuilder::new();
+        let result = builder.split_by_bindings("Hello World");
+        assert_eq!(result, vec!["Hello World"]);
+    }
+}

package/compiler/src/compiler/mod.rs

@@ -1,4 +1,7 @@
 pub mod compile;
+mod state_extractor;
+mod manifest_builder;
+mod value_stamper;
 
 pub use compile::Compiler;
 #[allow(unused_imports)]

package/compiler/src/compiler/state_extractor.rs

@@ -0,0 +1,148 @@
+use regex::Regex;
+use serde_json::{Value, Map};
+
+pub struct StateExtractor;
+
+impl StateExtractor {
+    /// Extract state from all vibe() and component() calls in HTML
+    pub fn extract_from_html(html: &str) -> Result<Value, String> {
+        let mut merged_state = Map::new();
+
+        // Find vibe({ ... }) and state({ ... }) patterns
+        let vibe_regex = Regex::new(
+            r"(?:vibe|state)\s*\(\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}\s*[,)]"
+        ).map_err(|e| format!("Failed to compile vibe regex: {}", e))?;
+
+        for caps in vibe_regex.captures_iter(html) {
+            let obj_literal = &caps[1];
+            let state = Self::parse_object_literal(obj_literal)?;
+            Self::merge_into(&mut merged_state, state);
+        }
+
+        // Find component({ ... }) patterns
+        let component_regex = Regex::new(
+            r"component\s*\(\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}\s*[,)]"
+        ).map_err(|e| format!("Failed to compile component regex: {}", e))?;
+
+        for caps in component_regex.captures_iter(html) {
+            let obj_literal = &caps[1];
+            let component_state = Self::parse_object_literal(obj_literal)?;
+
+            // Component state needs namespacing with component ID
+            // For now, merge directly (components already resolved)
+            Self::merge_into(&mut merged_state, component_state);
+        }
+
+        Ok(Value::Object(merged_state))
+    }
+
+    /// Parse JavaScript object literal to JSON Value
+    fn parse_object_literal(js: &str) -> Result<Map<String, Value>, String> {
+        // 1. Normalize to valid JSON
+        let normalized = Self::normalize_js_to_json(js);
+
+        // 2. Parse as JSON
+        serde_json::from_str::<Value>(&normalized)
+            .map_err(|e| format!("Failed to parse state: {}", e))?
+            .as_object()
+            .cloned()
+            .ok_or_else(|| "Expected object".to_string())
+    }
+
+    /// Convert JS object literal syntax to valid JSON
+    fn normalize_js_to_json(js: &str) -> String {
+        let mut json = js.trim().to_string();
+
+        // Convert single quotes to double quotes (before key quoting to avoid conflicts)
+        json = json.replace("'", "\"");
+
+        // Quote unquoted keys: name: value -> "name": value
+        // Match at start of string or after { , or whitespace
+        let key_regex = Regex::new(r#"(^|[\{,]\s*)(\w+)(\s*:)"#).unwrap();
+        json = key_regex.replace_all(&json, r#"$1"$2"$3"#).to_string();
+
+        // Wrap in braces
+        let wrapped = format!("{{{}}}", json);
+
+        // Remove trailing commas before } and ] (after wrapping)
+        let trailing_comma_regex = Regex::new(r#",(\s*[}\]])"#).unwrap();
+        trailing_comma_regex.replace_all(&wrapped, "$1").to_string()
+    }
+
+    /// Merge source into target (mutates target)
+    fn merge_into(target: &mut Map<String, Value>, source: Map<String, Value>) {
+        for (key, value) in source {
+            target.insert(key, value);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extract_simple_state() {
+        let html = r#"<script>vibe({ count: 0 })</script>"#;
+        let state = StateExtractor::extract_from_html(html).unwrap();
+        assert_eq!(state["count"], 0);
+    }
+
+    #[test]
+    fn extract_nested_state() {
+        let html = r#"vibe({ user: { name: 'John', age: 30 } })"#;
+        let state = StateExtractor::extract_from_html(html).unwrap();
+        assert_eq!(state["user"]["name"], "John");
+        assert_eq!(state["user"]["age"], 30);
+    }
+
+    #[test]
+    fn extract_array_state() {
+        let html = r#"vibe({ items: [1, 2, 3] })"#;
+        let state = StateExtractor::extract_from_html(html).unwrap();
+        assert_eq!(state["items"][0], 1);
+        assert_eq!(state["items"][1], 2);
+        assert_eq!(state["items"][2], 3);
+    }
+
+    #[test]
+    fn extract_multiple_calls() {
+        let html = r#"
+            <script>vibe({ count: 0 })</script>
+            <script>vibe({ name: 'Test' })</script>
+        "#;
+        let state = StateExtractor::extract_from_html(html).unwrap();
+        assert_eq!(state["count"], 0);
+        assert_eq!(state["name"], "Test");
+    }
+
+    #[test]
+    fn extract_with_trailing_comma() {
+        let html = r#"vibe({ count: 0, })"#;
+        let state = StateExtractor::extract_from_html(html).unwrap();
+        assert_eq!(state["count"], 0);
+    }
+
+    #[test]
+    fn extract_component_state() {
+        let html = r#"component({ title: 'Hello' })"#;
+        let state = StateExtractor::extract_from_html(html).unwrap();
+        assert_eq!(state["title"], "Hello");
+    }
+
+    #[test]
+    fn normalize_unquoted_keys() {
+        let js = "count: 0, name: 'Test'";
+        let normalized = StateExtractor::normalize_js_to_json(js);
+        eprintln!("Normalized: {}", normalized);
+        assert!(normalized.contains(r#""count""#));
+        assert!(normalized.contains(r#""name""#));
+    }
+
+    #[test]
+    fn normalize_single_quotes() {
+        let js = "name: 'John'";
+        let normalized = StateExtractor::normalize_js_to_json(js);
+        assert!(normalized.contains(r#""John""#));
+    }
+}