@devaloop/devalang 0.0.1-alpha.15 → 0.0.1-alpha.16

package/rust/core/parser/handler/condition.rs

@@ -1,74 +1,80 @@
-use std::collections::HashMap;
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{statement::{Statement, StatementKind}, driver::Parser},
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-
-pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume 'if'
-    let Some(if_token) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    let Some(condition) = parser.parse_condition_until_colon() else {
-        return Statement::error(if_token, "Expected condition after 'if'".to_string());
-    };
-
-    parser.advance_if(TokenKind::Colon);
-    let base_indent = if_token.indent;
-
-    let if_body = parser.parse_block_until_else_or_dedent(base_indent, global_store);
-
-    let mut root_map = HashMap::new();
-    root_map.insert("condition".to_string(), condition);
-    root_map.insert("body".to_string(), Value::Block(if_body));
-
-    let mut current = &mut root_map;
-
-    // Loop for else / else if
-    while let Some(tok) = parser.peek_clone() {
-        // Only continue if we see `else` at same indent level
-        if tok.lexeme != "else" || tok.indent != base_indent {
-            break;
-        }
-
-        parser.advance(); // consume 'else'
-
-        // Check if it's an 'else if'
-        let next_condition = if parser.peek_is("if") {
-            parser.advance(); // consume 'if'
-            let Some(cond) = parser.parse_condition_until_colon() else {
-                return Statement::error(tok.clone(), "Expected condition after 'else if'".to_string());
-            };
-            parser.advance_if(TokenKind::Colon);
-            Some(cond)
-        } else {
-            parser.advance_if(TokenKind::Colon);
-            None
-        };
-
-        let body = parser.parse_block_until_else_or_dedent(base_indent, global_store);
-
-        let mut next_map = HashMap::new();
-        if let Some(cond) = next_condition {
-            next_map.insert("condition".to_string(), cond);
-        }
-        next_map.insert("body".to_string(), Value::Block(body));
-
-        current.insert("next".to_string(), Value::Map(next_map));
-        current = match current.get_mut("next") {
-            Some(Value::Map(map)) => map,
-            _ => break,
-        };
-    }
-
-    Statement {
-        kind: StatementKind::If,
-        value: Value::Map(root_map),
-        indent: if_token.indent,
-        line: if_token.line,
-        column: if_token.column,
-    }
-}
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+use std::collections::HashMap;
+
+pub fn parse_condition_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'if'
+    let Some(if_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    let Some(condition) = parser.parse_condition_until_colon() else {
+        return Statement::error(if_token, "Expected condition after 'if'".to_string());
+    };
+
+    parser.advance_if(TokenKind::Colon);
+    let base_indent = if_token.indent;
+
+    let if_body = parser.parse_block_until_else_or_dedent(base_indent, global_store);
+
+    let mut root_map = HashMap::new();
+    root_map.insert("condition".to_string(), condition);
+    root_map.insert("body".to_string(), Value::Block(if_body));
+
+    let mut current = &mut root_map;
+
+    // Loop for else / else if
+    while let Some(tok) = parser.peek_clone() {
+        // Only continue if we see `else` at same indent level
+        if tok.lexeme != "else" || tok.indent != base_indent {
+            break;
+        }
+
+        parser.advance(); // consume 'else'
+
+        // Check if it's an 'else if'
+        let next_condition = if parser.peek_is("if") {
+            parser.advance(); // consume 'if'
+            let Some(cond) = parser.parse_condition_until_colon() else {
+                return Statement::error(
+                    tok.clone(),
+                    "Expected condition after 'else if'".to_string(),
+                );
+            };
+            parser.advance_if(TokenKind::Colon);
+            Some(cond)
+        } else {
+            parser.advance_if(TokenKind::Colon);
+            None
+        };
+
+        let body = parser.parse_block_until_else_or_dedent(base_indent, global_store);
+
+        let mut next_map = HashMap::new();
+        if let Some(cond) = next_condition {
+            next_map.insert("condition".to_string(), cond);
+        }
+        next_map.insert("body".to_string(), Value::Block(body));
+
+        current.insert("next".to_string(), Value::Map(next_map));
+        current = match current.get_mut("next") {
+            Some(Value::Map(map)) => map,
+            _ => break,
+        };
+    }
+
+    Statement {
+        kind: StatementKind::If,
+        value: Value::Map(root_map),
+        indent: if_token.indent,
+        line: if_token.line,
+        column: if_token.column,
+    }
+}

package/rust/core/parser/handler/dot.rs

@@ -1,135 +1,143 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{driver::Parser, statement::{Statement, StatementKind}},
-    shared::{duration::Duration, value::Value},
-};
-
-pub fn parse_dot_token(
-    parser: &mut Parser,
-    _global_store: &mut crate::core::store::global::GlobalStore
-) -> Statement {
-    parser.advance(); // consume '.'
-
-    let Some(dot_token) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // Parse a single entity (namespace-friendly, stops at newline)
-    let mut parts = Vec::new();
-    let current_line = dot_token.line;
-
-    while let Some(token) = parser.peek_clone() {
-        // Never cross a newline
-        if token.line != current_line {
-            break;
-        }
-        match token.kind {
-            TokenKind::Identifier | TokenKind::Number => {
-                parts.push(token.lexeme.clone());
-                parser.advance();
-                // The separator must be a '.' on the same line, otherwise stop
-                if let Some(next) = parser.peek_clone() {
-                    if next.line != current_line || next.kind != TokenKind::Dot {
-                        break;
-                    }
-                } else {
-                    break;
-                }
-            }
-            TokenKind::Dot => {
-                parser.advance();
-            }
-            TokenKind::Newline | TokenKind::EOF | TokenKind::Indent | TokenKind::Dedent => {
-                break; // Stop at newline or dedent
-            }
-            _ => {
-                break;
-            }
-        }
-    }
-
-    // Build entity name properly
-    let entity = if !parts.is_empty() {
-        parts.join(".") // only join within the same line
-    } else {
-        eprintln!("⚠️ Empty entity after '.' at line {}", dot_token.line);
-        String::new()
-    };
-
-    // Optional duration and effects map
-    let mut duration = Duration::Auto;
-    let mut value = Value::Null;
-
-    if let Some(token) = parser.peek_clone() {
-    // Duration and effects map are only valid on the same line
-        if token.line == current_line {
-            match token.kind {
-            TokenKind::Number => {
-                let numerator = token.lexeme.clone();
-                parser.advance();
-                    if let Some(peek) = parser.peek_clone() {
-                        if peek.line == current_line {
-                            if let Some(TokenKind::Slash) = parser.peek_kind() {
-                                parser.advance();
-                                if let Some(denominator_token) = parser.peek_clone() {
-                                    if denominator_token.line == current_line && denominator_token.kind == TokenKind::Number {
-                                        let denominator = denominator_token.lexeme.clone();
-                                        parser.advance();
-                                        duration = Duration::Beat(format!("{}/{}", numerator, denominator));
-                                    }
-                                }
-                            } else {
-                                duration = parse_duration(numerator);
-                            }
-                        } else {
-                            duration = parse_duration(numerator);
-                        }
-                    } else {
-                        duration = parse_duration(numerator);
-                    }
-                    if let Some(next) = parser.peek_clone() {
-                        if next.line == current_line && next.kind == TokenKind::LBrace {
-                            value = parser.parse_map_value().unwrap_or(Value::Null);
-                        }
-                    }
-            }
-            TokenKind::Identifier => {
-                let id = token.lexeme.clone();
-                parser.advance();
-                duration = parse_duration(id);
-                    if let Some(next) = parser.peek_clone() {
-                        if next.line == current_line && next.kind == TokenKind::LBrace {
-                            value = parser.parse_map_value().unwrap_or(Value::Null);
-                        }
-                    }
-            }
-            TokenKind::LBrace => {
-                    value = parser.parse_map_value().unwrap_or(Value::Null);
-            }
-                _ => {}
-            }
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Trigger {
-            entity,
-            duration,
-            effects: Some(value.clone()),
-        },
-        value: Value::Null,
-        indent: dot_token.indent,
-        line: dot_token.line,
-        column: dot_token.column,
-    }
-}
-
-fn parse_duration(s: String) -> Duration {
-    if s == "auto" {
-        Duration::Auto
-    } else if let Ok(num) = s.parse::<f32>() {
-        Duration::Number(num)
-    } else {
-        Duration::Identifier(s)
-    }
-}
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    shared::{duration::Duration, value::Value},
+};
+
+pub fn parse_dot_token(
+    parser: &mut Parser,
+    _global_store: &mut crate::core::store::global::GlobalStore,
+) -> Statement {
+    parser.advance(); // consume '.'
+
+    let Some(dot_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Parse a single entity (namespace-friendly, stops at newline)
+    let mut parts = Vec::new();
+    let current_line = dot_token.line;
+
+    while let Some(token) = parser.peek_clone() {
+        // Never cross a newline
+        if token.line != current_line {
+            break;
+        }
+        match token.kind {
+            TokenKind::Identifier | TokenKind::Number => {
+                parts.push(token.lexeme.clone());
+                parser.advance();
+                // The separator must be a '.' on the same line, otherwise stop
+                if let Some(next) = parser.peek_clone() {
+                    if next.line != current_line || next.kind != TokenKind::Dot {
+                        break;
+                    }
+                } else {
+                    break;
+                }
+            }
+            TokenKind::Dot => {
+                parser.advance();
+            }
+            TokenKind::Newline | TokenKind::EOF | TokenKind::Indent | TokenKind::Dedent => {
+                break; // Stop at newline or dedent
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+
+    // Build entity name properly
+    let entity = if !parts.is_empty() {
+        parts.join(".") // only join within the same line
+    } else {
+        eprintln!("⚠️ Empty entity after '.' at line {}", dot_token.line);
+        String::new()
+    };
+
+    // Optional duration and effects map
+    let mut duration = Duration::Auto;
+    let mut value = Value::Null;
+
+    if let Some(token) = parser.peek_clone() {
+        // Duration and effects map are only valid on the same line
+        if token.line == current_line {
+            match token.kind {
+                TokenKind::Number => {
+                    let numerator = token.lexeme.clone();
+                    parser.advance();
+                    if let Some(peek) = parser.peek_clone() {
+                        if peek.line == current_line {
+                            if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                parser.advance();
+                                if let Some(denominator_token) = parser.peek_clone() {
+                                    if denominator_token.line == current_line
+                                        && denominator_token.kind == TokenKind::Number
+                                    {
+                                        let denominator = denominator_token.lexeme.clone();
+                                        parser.advance();
+                                        duration = Duration::Beat(format!(
+                                            "{}/{}",
+                                            numerator, denominator
+                                        ));
+                                    }
+                                }
+                            } else {
+                                duration = parse_duration(numerator);
+                            }
+                        } else {
+                            duration = parse_duration(numerator);
+                        }
+                    } else {
+                        duration = parse_duration(numerator);
+                    }
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
+                        }
+                    }
+                }
+                TokenKind::Identifier => {
+                    let id = token.lexeme.clone();
+                    parser.advance();
+                    duration = parse_duration(id);
+                    if let Some(next) = parser.peek_clone() {
+                        if next.line == current_line && next.kind == TokenKind::LBrace {
+                            value = parser.parse_map_value().unwrap_or(Value::Null);
+                        }
+                    }
+                }
+                TokenKind::LBrace => {
+                    value = parser.parse_map_value().unwrap_or(Value::Null);
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Trigger {
+            entity,
+            duration,
+            effects: Some(value.clone()),
+        },
+        value: Value::Null,
+        indent: dot_token.indent,
+        line: dot_token.line,
+        column: dot_token.column,
+    }
+}
+
+fn parse_duration(s: String) -> Duration {
+    if s == "auto" {
+        Duration::Auto
+    } else if let Ok(num) = s.parse::<f32>() {
+        Duration::Number(num)
+    } else {
+        Duration::Identifier(s)
+    }
+}