@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.3

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

@@ -0,0 +1,112 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ statement::{ Statement, StatementKind }, Parser },
+    shared::{ duration::Duration, value::Value },
+    store::global::GlobalStore,
+};
+
+pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume the dot token
+
+    let Some(dot_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // .kick
+    let Some(entity_token) = parser.peek_clone() else {
+        return Statement {
+            kind: StatementKind::Trigger {
+                entity: String::new(),
+                duration: Duration::Auto,
+            },
+            value: Value::Null,
+            indent: dot_token.indent,
+            line: dot_token.line,
+            column: dot_token.column,
+        };
+    };
+
+    parser.advance(); // consume entity
+    let entity = entity_token.lexeme.clone();
+
+    // Check if there's a duration
+    let next = parser.peek_clone();
+
+    let (duration, value) = match next {
+        // If no more tokens, it's just `.kick`
+        None => (Duration::Auto, Value::Null),
+
+        Some(token) =>
+            match token.kind {
+                TokenKind::Newline | TokenKind::EOF => { (Duration::Auto, Value::Null) }
+
+                TokenKind::Number => {
+                    let duration_lexeme = token.lexeme.clone();
+                    parser.advance(); // consume duration
+
+                    // Try to parse optional value (ex: .kick 250 params)
+                    match parser.peek_clone() {
+                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
+                            parser.advance();
+                            (
+                                parse_duration(duration_lexeme),
+                                Value::Identifier(param_token.lexeme.clone()),
+                            )
+                        }
+
+                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                            // Handle value as Map
+                            let map = parser.parse_map_value(); // Assumes you have a helper for map
+                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                        }
+
+                        _ => (parse_duration(duration_lexeme), Value::Null),
+                    }
+                }
+
+                TokenKind::Identifier => {
+                    let duration_lexeme = token.lexeme.clone();
+                    parser.advance(); // consume duration
+
+                    // Try to parse optional value (ex: .kick auto params)
+                    match parser.peek_clone() {
+                        Some(param_token) if param_token.kind == TokenKind::Identifier => {
+                            parser.advance();
+                            (
+                                parse_duration(duration_lexeme),
+                                Value::Identifier(param_token.lexeme.clone()),
+                            )
+                        }
+
+                        Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                            // Handle value as Map
+                            let map = parser.parse_map_value(); // Assumes you have a helper for map
+                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                        }
+
+                        _ => (parse_duration(duration_lexeme), Value::Null),
+                    }
+                }
+
+                _ => (Duration::Auto, Value::Null),
+            }
+    };
+
+    Statement {
+        kind: StatementKind::Trigger { entity, duration },
+        value,
+        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 s.parse::<f32>().is_ok() {
+        Duration::Number(s.parse().unwrap())
+    } else {
+        Duration::Identifier(s)
+    }
+}

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

@@ -0,0 +1,134 @@
+use crate::core::{
+    lexer::token::{ Token, TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+use std::collections::HashMap;
+
+pub fn parse_identifier_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    let Some(current_token) = parser.peek_clone() else {
+        return Statement::unknown();
+    };
+
+    if current_token.lexeme == "let" {
+        parser.advance(); // consume "let"
+
+        let identifier = if let Some(token) = parser.peek_clone() {
+            if token.kind == TokenKind::Identifier {
+                parser.advance();
+                token.lexeme.clone()
+            } else {
+                return Statement::error(token, "Expected identifier after 'let'".to_string());
+            }
+        } else {
+            return Statement::error(current_token, "Expected identifier after 'let'".to_string());
+        };
+
+        if !parser.match_token(TokenKind::Equals) {
+            return Statement::error(current_token, "Expected '=' after identifier".to_string());
+        }
+
+        let value = match parser.peek_clone() {
+            Some(token) if token.kind == TokenKind::Identifier => {
+                parser.advance();
+                Value::Identifier(token.lexeme.clone())
+            }
+            Some(token) if token.kind == TokenKind::String => {
+                parser.advance();
+                Value::String(token.lexeme.clone())
+            }
+            Some(token) if token.kind == TokenKind::Number => {
+                parser.advance();
+                Value::Number(token.lexeme.parse().unwrap_or(0.0))
+            }
+            Some(token) if token.kind == TokenKind::LBrace => {
+                parser.advance(); // consume '{'
+                let mut map = HashMap::new();
+
+                while let Some(key_token) = parser.peek_clone() {
+                    if key_token.kind == TokenKind::RBrace {
+                        parser.advance(); // consume '}'
+                        break;
+                    }
+
+                    if key_token.kind != TokenKind::Identifier {
+                        return Statement::error(
+                            token,
+                            "Expected key identifier in map".to_string()
+                        );
+                    }
+                    parser.advance();
+                    let key = key_token.lexeme.clone();
+
+                    if !parser.match_token(TokenKind::Colon) {
+                        let message = format!("Expected ':' after key '{}'", key);
+                        return Statement::error(token, message);
+                    }
+
+                    let val = match parser.peek_clone() {
+                        Some(t) if t.kind == TokenKind::Number => {
+                            parser.advance();
+                            Value::Number(t.lexeme.parse().unwrap_or(0.0))
+                        }
+                        Some(t) if t.kind == TokenKind::String => {
+                            parser.advance();
+                            Value::String(t.lexeme.clone())
+                        }
+                        Some(t) if t.kind == TokenKind::Identifier => {
+                            parser.advance();
+                            Value::Identifier(t.lexeme.clone())
+                        }
+                        _ => { Value::Null }
+                    };
+
+                    if val == Value::Null {
+                        let message = format!("Invalid value for key '{}'", key);
+                        return Statement::error(token, message);
+                    }
+
+                    map.insert(key, val);
+
+                    if let Some(t) = parser.peek() {
+                        if t.kind == TokenKind::Comma {
+                            parser.advance(); // skip comma
+                        }
+                    }
+                }
+
+                Value::Map(map)
+            }
+            other => {
+                let message = format!("Unexpected value token in let: {:?}", other);
+                return Statement::error(current_token, message);
+            }
+        };
+
+        return Statement {
+            kind: StatementKind::Let { name: identifier },
+            value,
+            indent: current_token.indent,
+            line: current_token.line,
+            column: current_token.column,
+        };
+    } else {
+        // Unknown identifier handling
+        Statement {
+            kind: StatementKind::Unknown,
+            value: Value::String(current_token.lexeme.clone()),
+            indent: current_token.indent,
+            line: current_token.line,
+            column: current_token.column,
+        };
+    }
+
+    parser.advance(); // unknown identifier fallback
+
+    Statement {
+        kind: StatementKind::Unknown,
+        value: Value::String(current_token.lexeme.clone()),
+        indent: current_token.indent,
+        line: current_token.line,
+        column: current_token.column,
+    }
+}

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

@@ -0,0 +1,55 @@
+use std::collections::HashMap;
+
+use crate::core::{
+    lexer::{ token::TokenKind },
+    parser::{ statement::{ Statement, StatementKind }, Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'loop'
+
+    let Some(loop_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect an identifier (iterator)
+    let Some(iterator_token) = parser.peek_clone() else {
+        return Statement::error(loop_token, "Expected identifier after 'loop'".to_string());
+    };
+
+    let iterator_name = iterator_token.lexeme.clone();
+    parser.advance(); // consume iterator
+
+    // Expect colon
+    let Some(colon_token) = parser.peek_clone() else {
+        return Statement::error(iterator_token.clone(), "Expected ':' after iterator".to_string());
+    };
+
+    if colon_token.kind != TokenKind::Colon {
+        let message = format!("Expected ':' after iterator, got {:?}", colon_token.kind);
+        return Statement::error(colon_token.clone(), message);
+    }
+
+    parser.advance(); // consume ':'
+
+    // Collect all indented statements
+    let tokens = parser.collect_until(
+        |t| (t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF)
+    );
+    let loop_body = parser.parse_block(tokens.clone(), global_store);
+
+    let mut value_map = HashMap::new();
+
+    value_map.insert("iterator".to_string(), Value::Identifier(iterator_name));
+    value_map.insert("body".to_string(), Value::Block(loop_body.clone()));
+
+    Statement {
+        kind: StatementKind::Loop,
+        value: Value::Map(value_map),
+        indent: loop_token.indent,
+        line: loop_token.line,
+        column: loop_token.column,
+    }
+}

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

@@ -0,0 +1,6 @@
+pub mod at;
+pub mod identifier;
+pub mod dot;
+pub mod tempo;
+pub mod bank;
+pub mod loop_;

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

@@ -0,0 +1,47 @@
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{ statement::{ Statement, StatementKind }, Parser },
+    shared::value::Value,
+    store::global::GlobalStore,
+};
+
+pub fn parse_tempo_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    parser.advance(); // consume 'bpm'
+
+    let Some(tempo_token) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Expect a number or identifier
+    let Some(value_token) = parser.peek_clone() else {
+        return Statement::error(
+            tempo_token,
+            "Expected a number or identifier after 'bpm'".to_string()
+        );
+    };
+
+    let value = match value_token.kind {
+        TokenKind::Number => {
+            parser.advance();
+            Value::Number(value_token.lexeme.parse().unwrap_or(0.0))
+        }
+        TokenKind::Identifier => {
+            parser.advance();
+            Value::Identifier(value_token.lexeme.clone())
+        }
+        _ => {
+            return Statement::error(
+                value_token.clone(),
+                format!("Expected a number or identifier after 'bpm', got {:?}", value_token.kind)
+            );
+        }
+    };
+
+    Statement {
+        kind: StatementKind::Tempo,
+        value,
+        indent: tempo_token.indent,
+        line: tempo_token.line,
+        column: tempo_token.column,
+    }
+}