@devaloop/devalang 0.0.1-beta.3 → 0.1.1

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

@@ -1,104 +0,0 @@
-use devalang_types::Value;
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-
-pub fn parse_bank_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    // consume 'bank'
-    parser.advance();
-
-    let Some(bank_tok) = parser.previous_clone() else {
-        return Statement::unknown();
-    };
-
-    // Parse bank name
-    let bank_value: Value = match parser.peek_clone() {
-        Some(tok) => match tok.kind {
-            TokenKind::Identifier | TokenKind::Number => {
-                // base name
-                parser.advance();
-                let mut base = tok.lexeme.clone();
-                // optional .suffix (identifier or number)
-                if let Some(dot) = parser.peek_clone() {
-                    if dot.kind == TokenKind::Dot {
-                        // consume '.' and the following ident/number
-                        parser.advance();
-                        if let Some(suffix) = parser.peek_clone() {
-                            match suffix.kind {
-                                TokenKind::Identifier | TokenKind::Number => {
-                                    parser.advance();
-                                    base.push('.');
-                                    base.push_str(&suffix.lexeme);
-                                    Value::String(base)
-                                }
-                                _ => Value::Identifier(base),
-                            }
-                        } else {
-                            Value::Identifier(base)
-                        }
-                    } else {
-                        match tok.kind {
-                            TokenKind::Identifier => Value::String(base),
-                            TokenKind::Number => Value::Number(base.parse::<f32>().unwrap_or(0.0)),
-                            _ => Value::Unknown,
-                        }
-                    }
-                } else {
-                    match tok.kind {
-                        TokenKind::Identifier => Value::String(base),
-                        TokenKind::Number => Value::Number(base.parse::<f32>().unwrap_or(0.0)),
-                        _ => Value::Unknown,
-                    }
-                }
-            }
-            TokenKind::String => {
-                parser.advance();
-                Value::String(tok.lexeme.clone())
-            }
-            _ => Value::Unknown,
-        },
-        None => Value::Unknown,
-    };
-
-    if matches!(bank_value, Value::Unknown | Value::Null) {
-        return crate::core::parser::statement::error_from_token(
-            bank_tok,
-            "Expected a bank name".to_string(),
-        );
-    }
-
-    // Optional alias: as <identifier>
-    let mut alias: Option<String> = None;
-    if parser.peek_is("as") {
-        // consume 'as'
-        parser.advance();
-        let Some(next) = parser.peek_clone() else {
-            return crate::core::parser::statement::error_from_token(
-                bank_tok,
-                "Expected identifier after 'as'".to_string(),
-            );
-        };
-        if next.kind != TokenKind::Identifier {
-            return crate::core::parser::statement::error_from_token(
-                next,
-                "Expected identifier after 'as'".to_string(),
-            );
-        }
-        parser.advance();
-        alias = Some(next.lexeme.clone());
-    }
-
-    Statement {
-        kind: StatementKind::Bank { alias },
-        value: bank_value,
-        indent: bank_tok.indent,
-        line: bank_tok.line,
-        column: bank_tok.column,
-    }
-}

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

@@ -1,83 +0,0 @@
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-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 crate::core::parser::statement::error_from_token(
-            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 crate::core::parser::statement::error_from_token(
-                    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,148 +0,0 @@
-use devalang_types::{Duration, Value};
-
-use crate::core::{
-    lexer::token::TokenKind,
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-};
-
-pub fn parse_dot_token(
-    parser: &mut Parser,
-    _global_store: &mut crate::core::store::global::GlobalStore,
-) -> Statement {
-    parser.advance(); // consume '.'
-    let logger = devalang_utils::logger::Logger::new();
-    use devalang_utils::logger::LogLevel;
-    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 {
-        logger.log_message(
-            LogLevel::Warning,
-            &format!("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)
-    }
-}

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

@@ -1,254 +0,0 @@
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use std::collections::HashMap;
-
-pub fn parse_automate_token(
-    parser: &mut Parser,
-    current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume 'automate'
-
-    // Expect target identifier
-    let Some(target_token) = parser.peek_clone() else {
-        return crate::core::parser::statement::error_from_token(
-            current_token,
-            "Expected target after 'automate'".to_string(),
-        );
-    };
-
-    if target_token.kind != TokenKind::Identifier && target_token.kind != TokenKind::String {
-        return crate::core::parser::statement::error_from_token(
-            target_token,
-            "Expected valid target after 'automate'".to_string(),
-        );
-    }
-    parser.advance(); // consume target
-
-    // Expect ':'
-    let Some(colon_token) = parser.peek_clone() else {
-        return crate::core::parser::statement::error_from_token(
-            target_token,
-            "Expected ':' after automate target".to_string(),
-        );
-    };
-    if colon_token.kind != TokenKind::Colon {
-        return crate::core::parser::statement::error_from_token(
-            colon_token,
-            "Expected ':' after automate target".to_string(),
-        );
-    }
-    parser.advance(); // consume ':'
-
-    let base_indent = current_token.indent;
-
-    // Collect tokens inside block (indented > base_indent)
-    let mut index = parser.token_index;
-    let mut tokens_inside = Vec::new();
-    while index < parser.tokens.len() {
-        let tok = parser.tokens[index].clone();
-        if tok.indent <= base_indent && tok.kind != TokenKind::Newline {
-            break;
-        }
-        tokens_inside.push(tok);
-        index += 1;
-    }
-    parser.token_index = index;
-
-    // Now parse block manually to capture 'param' entries without reusing general parser kinds
-    let mut local = Parser {
-        resolve_modules: parser.resolve_modules,
-        tokens: tokens_inside,
-        token_index: 0,
-        current_module: parser.current_module.clone(),
-        previous: None,
-    };
-
-    let mut params: HashMap<String, Value> = HashMap::new();
-
-    while let Some(tok) = local.peek_clone() {
-        match tok.kind {
-            TokenKind::Identifier if tok.lexeme == "param" => {
-                local.advance(); // consume 'param'
-                // param name
-                let Some(name_tok) = local.peek_clone() else {
-                    return crate::core::parser::statement::error_from_token(
-                        tok,
-                        "Expected parameter name after 'param'".to_string(),
-                    );
-                };
-                if name_tok.kind != TokenKind::Identifier && name_tok.kind != TokenKind::String {
-                    return crate::core::parser::statement::error_from_token(
-                        name_tok,
-                        "Expected valid parameter name".to_string(),
-                    );
-                }
-                local.advance(); // consume name
-
-                // Expect '{'
-                if !local.match_token(TokenKind::LBrace) {
-                    return crate::core::parser::statement::error_from_token(
-                        name_tok,
-                        "Expected '{' to start parameter block".to_string(),
-                    );
-                }
-
-                // Collect entries like: 0% = 0.0
-                let mut envelope: HashMap<String, Value> = HashMap::new();
-                while let Some(inner) = local.peek_clone() {
-                    if inner.kind == TokenKind::RBrace {
-                        local.advance();
-                        break;
-                    }
-                    // Skip formatting tokens inside the param block
-                    if matches!(
-                        inner.kind,
-                        TokenKind::Newline
-                            | TokenKind::Indent
-                            | TokenKind::Dedent
-                            | TokenKind::Comma
-                    ) {
-                        local.advance();
-                        continue;
-                    }
-
-                    // Read percentage token: could be number followed by '%' as Dot or Identifier? '%' not defined.
-                    // Our lexer has no Percent token, so accept either Number or Identifier containing e.g. '0%'.
-                    let percent_token = inner.clone();
-                    local.advance();
-
-                    let percent_key = percent_token.lexeme.clone();
-
-                    // Expect '='
-                    // Skip any stray formatting between key and '='
-                    while let Some(t) = local.peek_kind() {
-                        if matches!(
-                            t,
-                            TokenKind::Indent | TokenKind::Dedent | TokenKind::Newline
-                        ) {
-                            local.advance();
-                            continue;
-                        }
-                        break;
-                    }
-                    if !local.match_token(TokenKind::Equals) {
-                        return crate::core::parser::statement::error_from_token(
-                            percent_token,
-                            "Expected '=' in param entry".to_string(),
-                        );
-                    }
-
-                    // Read value (number or identifier)
-                    // Skip formatting before value
-                    while let Some(t) = local.peek_kind() {
-                        if matches!(
-                            t,
-                            TokenKind::Indent | TokenKind::Dedent | TokenKind::Newline
-                        ) {
-                            local.advance();
-                            continue;
-                        }
-                        break;
-                    }
-
-                    let value = if let Some(vtok) = local.peek_clone() {
-                        match vtok.kind {
-                            // Handle negative numbers where '-' is lexed as Arrow
-                            TokenKind::Arrow => {
-                                // Check if next token is a number
-                                let mut num_str = String::from("-");
-                                local.advance(); // consume '-'
-                                if let Some(ntok) = local.peek_clone() {
-                                    if ntok.kind == TokenKind::Number {
-                                        num_str.push_str(&ntok.lexeme);
-                                        local.advance(); // consume number
-                                        if let Some(dot) = local.peek_clone() {
-                                            if dot.kind == TokenKind::Dot {
-                                                local.advance();
-                                                if let Some(frac) = local.peek_clone() {
-                                                    if frac.kind == TokenKind::Number {
-                                                        num_str.push('.');
-                                                        num_str.push_str(&frac.lexeme);
-                                                        local.advance();
-                                                    }
-                                                }
-                                            }
-                                        }
-                                        Value::Number(num_str.parse::<f32>().unwrap_or(0.0))
-                                    } else {
-                                        Value::Unknown
-                                    }
-                                } else {
-                                    Value::Unknown
-                                }
-                            }
-                            TokenKind::Number => {
-                                // Possibly a float with dot
-                                let mut number_str = vtok.lexeme.clone();
-                                local.advance();
-                                if let Some(dot) = local.peek_clone() {
-                                    if dot.kind == TokenKind::Dot {
-                                        local.advance();
-                                        if let Some(frac) = local.peek_clone() {
-                                            if frac.kind == TokenKind::Number {
-                                                number_str.push('.');
-                                                number_str.push_str(&frac.lexeme);
-                                                local.advance();
-                                            }
-                                        }
-                                    }
-                                }
-                                Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
-                            }
-                            TokenKind::Identifier => {
-                                local.advance();
-                                Value::Identifier(vtok.lexeme.clone())
-                            }
-                            TokenKind::String => {
-                                local.advance();
-                                Value::String(vtok.lexeme.clone())
-                            }
-                            _ => {
-                                local.advance();
-                                Value::Unknown
-                            }
-                        }
-                    } else {
-                        Value::Null
-                    };
-
-                    envelope.insert(percent_key, value);
-                }
-
-                params.insert(name_tok.lexeme.clone(), Value::Map(envelope));
-            }
-            _ => {
-                local.advance();
-            }
-        }
-    }
-
-    let mut value_map = HashMap::new();
-    value_map.insert(
-        "target".to_string(),
-        Value::String(target_token.lexeme.clone()),
-    );
-    value_map.insert("params".to_string(), Value::Map(params));
-
-    Statement {
-        kind: StatementKind::Automate {
-            target: target_token.lexeme.clone(),
-        },
-        value: Value::Map(value_map),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}

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

@@ -1,91 +0,0 @@
-use crate::core::{
-    lexer::token::{Token, TokenKind},
-    parser::{
-        driver::parser::Parser,
-        statement::{Statement, StatementKind},
-    },
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-
-pub fn parse_call_token(
-    parser: &mut Parser,
-    current_token: Token,
-    _global_store: &mut GlobalStore,
-) -> Statement {
-    parser.advance(); // consume "call"
-
-    // Expect function name
-    let name_token = match parser.peek_clone() {
-        Some(t) => t,
-        None => {
-            return crate::core::parser::statement::error_from_token(
-                current_token,
-                "Expected function name after 'call'".to_string(),
-            );
-        }
-    };
-
-    if name_token.kind != TokenKind::Identifier {
-        return crate::core::parser::statement::error_from_token(
-            name_token,
-            "Expected function name to be an identifier".to_string(),
-        );
-    }
-
-    let func_name = name_token.lexeme.clone();
-    parser.advance(); // consume function name
-
-    // Expect '('
-    let mut args: Vec<Value> = Vec::new();
-    if let Some(open_paren) = parser.peek_clone() {
-        if open_paren.kind == TokenKind::LParen {
-            parser.advance(); // consume '('
-
-            // Collect args until ')'
-            while let Some(token) = parser.peek_clone() {
-                if token.kind == TokenKind::RParen {
-                    parser.advance(); // consume ')'
-                    break;
-                }
-
-                match token.kind {
-                    TokenKind::Number => {
-                        if let Ok(num) = token.lexeme.parse::<f32>() {
-                            args.push(Value::Number(num));
-                        }
-                        parser.advance();
-                    }
-                    TokenKind::String => {
-                        args.push(Value::String(token.lexeme.clone()));
-                        parser.advance();
-                    }
-                    TokenKind::Identifier => {
-                        args.push(Value::Identifier(token.lexeme.clone()));
-                        parser.advance();
-                    }
-                    TokenKind::Comma => {
-                        parser.advance(); // skip comma
-                    }
-                    _ => {
-                        return crate::core::parser::statement::error_from_token(
-                            token,
-                            "Unexpected token in call arguments".to_string(),
-                        );
-                    }
-                }
-            }
-        }
-    }
-
-    Statement {
-        kind: StatementKind::Call {
-            name: func_name,
-            args,
-        },
-        value: Value::Null,
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}