@ape-egg/vibe 2.3.0 → 3.0.0

package/compiler/src/compiler/state_extractor.rs

@@ -1,263 +0,0 @@
-use regex::Regex;
-use serde_json::{Value, Map};
-use std::path::PathBuf;
-use crate::compiler::js_analyzer::JsAnalyzer;
-
-pub struct StateExtractor;
-
-impl StateExtractor {
-    /// Extract state from all vibe() and component() calls in HTML
-    pub fn extract_from_html(html: &str, base_path: &PathBuf) -> Result<Value, String> {
-        // Try modern approach: parse script blocks with JsAnalyzer
-        if let Some(state) = Self::extract_from_scripts(html, base_path) {
-            return Ok(state);
-        }
-
-        // Fallback: legacy regex-based extraction for inline object literals
-        Self::extract_with_regex(html)
-    }
-
-    /// Extract state from <script> blocks using JavaScript AST analysis
-    fn extract_from_scripts(html: &str, base_path: &PathBuf) -> Option<Value> {
-        let script_regex = Regex::new(r#"(?s)<script[^>]*>(.*?)</script>"#).unwrap();
-        let mut analyzer = JsAnalyzer::new(base_path.clone());
-
-        let mut merged_state = Map::new();
-
-        for cap in script_regex.captures_iter(html) {
-            let script = cap.get(1)?.as_str();
-
-            // Parse and extract state with AST analysis
-            if let Some(Value::Object(state)) = analyzer.extract_state(script) {
-                for (k, v) in state {
-                    merged_state.insert(k, v);
-                }
-            }
-        }
-
-        if merged_state.is_empty() {
-            None
-        } else {
-            Some(Value::Object(merged_state))
-        }
-    }
-
-    /// Legacy regex-based extraction (fallback)
-    fn extract_with_regex(html: &str) -> Result<Value, String> {
-        let mut merged_state = Map::new();
-
-        // Find vibe({ ... }) and state({ ... }) patterns using brace counting
-        let start_regex = Regex::new(r"(?:vibe|state)\s*\(\s*\{").unwrap();
-
-        for start_match in start_regex.find_iter(html) {
-            if let Some(obj_literal) = Self::extract_balanced_object(&html[start_match.end()..]) {
-                match Self::parse_object_literal(&obj_literal) {
-                    Ok(state) => Self::merge_into(&mut merged_state, state),
-                    Err(_) => continue, // Skip unparseable state
-                }
-            }
-        }
-
-        // Find component({ ... }) patterns
-        let component_start_regex = Regex::new(r"component\s*\(\s*\{").unwrap();
-
-        for start_match in component_start_regex.find_iter(html) {
-            if let Some(obj_literal) = Self::extract_balanced_object(&html[start_match.end()..]) {
-                match Self::parse_object_literal(&obj_literal) {
-                    Ok(component_state) => Self::merge_into(&mut merged_state, component_state),
-                    Err(_) => continue,
-                }
-            }
-        }
-
-        Ok(Value::Object(merged_state))
-    }
-
-    /// Extract balanced object literal content (everything between { and matching })
-    /// Input should start right after the opening {
-    fn extract_balanced_object(s: &str) -> Option<String> {
-        let mut depth = 1;
-        let mut in_string = false;
-        let mut escape_next = false;
-        let mut quote_char = '\0';
-        let mut result = String::new();
-
-        for ch in s.chars() {
-            if escape_next {
-                result.push(ch);
-                escape_next = false;
-                continue;
-            }
-
-            if ch == '\\' {
-                result.push(ch);
-                escape_next = true;
-                continue;
-            }
-
-            if !in_string {
-                if ch == '"' || ch == '\'' || ch == '`' {
-                    in_string = true;
-                    quote_char = ch;
-                    result.push(ch);
-                } else if ch == '{' || ch == '[' {
-                    depth += 1;
-                    result.push(ch);
-                } else if ch == '}' || ch == ']' {
-                    depth -= 1;
-                    if depth == 0 {
-                        return Some(result);
-                    }
-                    result.push(ch);
-                } else {
-                    result.push(ch);
-                }
-            } else {
-                result.push(ch);
-                if ch == quote_char {
-                    in_string = false;
-                }
-            }
-        }
-
-        None
-    }
-
-    /// 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, &PathBuf::from(".")).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, &PathBuf::from(".")).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, &PathBuf::from(".")).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, &PathBuf::from(".")).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, &PathBuf::from(".")).unwrap();
-        assert_eq!(state["count"], 0);
-    }
-
-    #[test]
-    fn extract_component_state() {
-        let html = r#"component({ title: 'Hello' })"#;
-        let state = StateExtractor::extract_from_html(html, &PathBuf::from(".")).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""#));
-    }
-
-    #[test]
-    fn extract_array_of_objects() {
-        let html = r#"vibe({
-            categories: [
-                { name: 'Fruits', items: ['Apple', 'Banana'] },
-                { name: 'Veggies', items: ['Carrot'] }
-            ]
-        })"#;
-        let state = StateExtractor::extract_from_html(html, &PathBuf::from(".")).unwrap();
-        assert_eq!(state["categories"][0]["name"], "Fruits");
-        assert_eq!(state["categories"][0]["items"][0], "Apple");
-        assert_eq!(state["categories"][1]["name"], "Veggies");
-    }
-
-    #[test]
-    fn extract_balanced_object_simple() {
-        let input = "count: 0 }";
-        let result = StateExtractor::extract_balanced_object(input).unwrap();
-        assert_eq!(result, "count: 0 ");
-    }
-
-    #[test]
-    fn extract_balanced_object_nested() {
-        let input = "user: { name: 'John', items: [1, 2, 3] } }";
-        let result = StateExtractor::extract_balanced_object(input).unwrap();
-        assert_eq!(result, "user: { name: 'John', items: [1, 2, 3] } ");
-    }
-}