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

package/rust/core/parser/at.rs

@@ -1,142 +0,0 @@
-use crate::core::types::{
-    parser::Parser,
-    statement::{ Statement, StatementKind },
-    token::TokenKind,
-    variable::VariableValue,
-};
-
-pub fn parse_at(parser: &mut Parser) -> Result<Statement, String> {
-    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
-
-    if token.kind != TokenKind::At {
-        return Err(format!("Expected '@', found {:?}", token.kind));
-    }
-
-    parser.next();
-
-    let identifier_token = parser.peek().ok_or("Expected identifier after '@'")?.clone();
-    if identifier_token.kind != TokenKind::Identifier {
-        return Err(format!("Expected Identifier, found {:?}", identifier_token.kind));
-    }
-
-    match identifier_token.lexeme.as_str() {
-        "export" => {
-            parser.next();
-
-            if let Some(next_token) = parser.peek() {
-                if next_token.kind == TokenKind::LBrace {
-                    parser.next(); // Consomme le LBrace
-                }
-            }
-
-            let exportable_tokens = parser.collect_until(|t| { t.kind == TokenKind::RBrace });
-
-            exportable_tokens.iter().for_each(|t| {
-                let variable_value = parser.variable_table
-                    .get(&t.lexeme)
-                    .cloned()
-                    .unwrap_or_else(|| VariableValue::Text(t.lexeme.clone()));
-
-                parser.export_table.exports.insert(t.lexeme.clone(), variable_value);
-            });
-
-            return Ok(Statement {
-                kind: StatementKind::Export,
-                value: VariableValue::Array(exportable_tokens),
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            });
-        }
-        "import" => {
-            parser.next();
-
-            if let Some(next_token) = parser.peek() {
-                if next_token.kind == TokenKind::LBrace {
-                    parser.next();
-                }
-            }
-
-            let importable_tokens = parser.collect_until(|t| { t.kind == TokenKind::RBrace });
-
-            parser.next();
-
-            if let Some(from_token) = parser.peek() {
-                if from_token.kind == TokenKind::Identifier && from_token.lexeme == "from" {
-                    parser.next();
-                } else {
-                    return Err(format!("Expected 'from', found {:?}", from_token.kind));
-                }
-            } else {
-                return Err("Expected 'from' after import declaration".into());
-            }
-
-            let source_token = parser.peek().ok_or("Expected source after 'from'")?.clone();
-            if source_token.kind != TokenKind::String {
-                return Err(format!("Expected String, found {:?}", source_token.kind));
-            }
-
-            let statement = Statement {
-                kind: StatementKind::Import {
-                    names: importable_tokens
-                        .iter()
-                        .map(|t| t.lexeme.clone())
-                        .collect(),
-                    source: source_token.lexeme.clone(),
-                },
-                value: VariableValue::Array(importable_tokens),
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            };
-
-            return Ok(statement);
-        }
-        "load" => {
-            parser.next();
-
-            let source_token = parser.peek().ok_or("Expected source after load")?.clone();
-            if source_token.kind != TokenKind::String {
-                return Err(format!("Expected String, found {:?}", source_token.kind));
-            }
-
-            parser.next();
-
-            let as_token = parser.peek().ok_or("Expected 'as' after load")?.clone();
-            if as_token.kind != TokenKind::Identifier || as_token.lexeme != "as" {
-                return Err(format!("Expected 'as', found {:?}", as_token.kind));
-            }
-
-            parser.next();
-
-            let alias_token = parser.peek().ok_or("Expected alias after load")?.clone();
-            if alias_token.kind != TokenKind::Identifier {
-                return Err(format!("Expected Identifier, found {:?}", alias_token.kind));
-            }
-
-            parser.next();
-
-            let statement = Statement {
-                kind: StatementKind::Load {
-                    source: source_token.lexeme.clone(),
-                    alias: alias_token.lexeme.clone(),
-                },
-                value: VariableValue::Text(alias_token.lexeme.clone()),
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            };
-
-            return Ok(statement);
-        }
-
-        _ => {
-            return Err(
-                format!(
-                    "Expected 'export', 'import' or 'load', found '{}'",
-                    identifier_token.lexeme
-                )
-            );
-        }
-    }
-}

package/rust/core/parser/bank.rs

@@ -1,42 +0,0 @@
-use crate::core::types::{
-    parser::Parser,
-    statement::{ Statement, StatementKind },
-    store::GlobalStore,
-    token::TokenKind,
-    variable::VariableValue,
-};
-
-pub fn parse_bank(
-    parser: &mut Parser,
-    global_store: &mut GlobalStore
-) -> Result<Statement, String> {
-    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
-
-    let mut bank_name = String::new();
-
-    if parser.next().map(|t| t.kind.clone()) != Some(TokenKind::Bank) {
-        return Err("Expected 'bank' keyword".to_string());
-    }
-
-    if let Some(token) = parser.next() {
-        if token.kind == TokenKind::Identifier {
-            bank_name = token.lexeme.clone();
-        } else if token.kind == TokenKind::String {
-            bank_name = token.lexeme.trim_matches('"').to_string();
-        } else if token.kind == TokenKind::Number {
-            bank_name = token.lexeme.clone();
-        } else {
-            return Err(format!("Expected bank name, found {:?}", token.kind));
-        }
-    } else {
-        return Err("Expected bank name after 'bank' keyword".to_string());
-    }
-
-    Ok(Statement {
-        kind: StatementKind::Bank,
-        value: VariableValue::Text(bank_name.clone()),
-        indent: token.indent,
-        line: token.line,
-        column: token.column,
-    })
-}

package/rust/core/parser/dot.rs

@@ -1,107 +0,0 @@
-use std::{ collections::HashMap, hash::Hash };
-
-use crate::core::types::{
-    statement::{ Statement, StatementKind },
-    token::{ Token, TokenDuration, TokenKind, TokenParamValue },
-    variable::{ Variable, VariableValue },
-};
-
-pub fn parse_dot(
-    parser: &mut crate::core::parser::Parser,
-    global_store: &mut crate::core::types::store::GlobalStore
-) -> Result<crate::core::types::statement::Statement, String> {
-    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
-    let mut trigger_value: String = String::from("Unknown Trigger");
-
-    if token.kind != crate::core::types::token::TokenKind::Dot {
-        return Err(format!("Expected Dot, found {:?}", token.kind));
-    }
-
-    parser.next();
-
-    let next_token = parser.peek().ok_or("Expected identifier after dot")?.clone();
-    if next_token.kind != crate::core::types::token::TokenKind::Identifier {
-        return Err(format!("Expected Identifier after Dot, found {:?}", next_token.kind));
-    }
-
-    parser.next(); 
-
-    let duration_token = parser.peek().ok_or("Expected duration after identifier")?.clone();
-    let mut duration = TokenDuration::Unknown;
-
-    match duration_token.lexeme.as_str() {
-        "auto" => {
-            duration = TokenDuration::Auto;
-        }
-        "infinite" => {
-            duration = TokenDuration::Infinite;
-        }
-        _ => {
-            if let Ok(num) = duration_token.lexeme.parse::<f32>() {
-                duration = TokenDuration::Number(num);
-            } else if let Ok(boolean) = duration_token.lexeme.parse::<bool>() {
-                duration = TokenDuration::Unknown;
-            } else if duration_token.kind == TokenKind::Identifier {
-                duration = TokenDuration::Identifier(duration_token.lexeme.clone());
-            } else {
-                return Err(format!("Invalid duration format: {}", duration_token.lexeme));
-            }
-        }
-    }
-
-    parser.next();
-   
-    let dot_params: Vec<Token> = parser.collect_until(|t| {
-        t.kind == TokenKind::Newline
-    });
-
-    let mut params_value: VariableValue = VariableValue::Null;
-
-    for param in dot_params {
-        let token_value = match param.kind {
-            TokenKind::String => VariableValue::Text(param.lexeme),
-            TokenKind::Number => VariableValue::Number(param.lexeme.parse().unwrap_or(0.0)),
-            TokenKind::Boolean => VariableValue::Boolean(param.lexeme.parse().unwrap_or(false)),
-            TokenKind::Map => {
-                let mut map: HashMap<String, TokenParamValue> = HashMap::new();
-                let entries: Vec<&str> = param.lexeme.split(',').collect();
-                for entry in entries {
-                    let parts: Vec<&str> = entry.split(':').collect();
-                    if parts.len() == 2 {
-                        let key = parts[0].trim().to_string();
-                        let value = match parts[1].trim() {
-                            "true" => TokenParamValue::Boolean(true),
-                            "false" => TokenParamValue::Boolean(false),
-                            _ => TokenParamValue::String(parts[1].trim().to_string()),
-                        };
-                        map.insert(key, value);
-                    }
-                }
-                VariableValue::Map(map)
-            }
-            TokenKind::Identifier => {
-                VariableValue::Text(param.lexeme.clone())
-            }
-            TokenKind::Unknown => {
-                Err(format!("Unsupported token type in dot parameters: {:?}", param.kind))?;
-                VariableValue::Null
-            },
-            _ => {
-                Err(format!("Unsupported token type in dot parameters: {:?}", param.kind))?;
-                VariableValue::Unknown
-            },
-        };
-        params_value = token_value;
-    }
-
-    Ok(Statement {
-        kind: StatementKind::Trigger {
-            entity: next_token.lexeme.clone(),
-            duration: duration.clone(),
-        },
-        value: params_value,
-        indent: token.indent,
-        line: token.line,
-        column: token.column,
-    })
-}

package/rust/core/parser/identifer.rs

@@ -1,91 +0,0 @@
-use crate::core::{
-    parser::{ bank::parse_bank, variable::parse_let_statement, Parser },
-    types::{
-        statement::{ Statement, StatementKind },
-        store::GlobalStore,
-        token::{ Token, TokenKind },
-        variable::VariableValue,
-    },
-};
-
-pub fn parse_identifier(
-    parser: &mut Parser,
-    global_store: &mut GlobalStore
-) -> Result<Statement, String> {
-    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
-
-    if token.kind != TokenKind::Identifier {
-        return Err(format!("Expected Identifier, found {:?}", token.kind));
-    }
-
-    match token.lexeme.as_str() {
-        "let" => {
-            parser.next();
-            return parse_let_statement(parser); 
-        }
-        "bank" => {
-            parser.next(); 
-            return parse_bank(parser, global_store);
-        }
-        _ => {
-            parser.next();
-        }
-    }
-
-    let statment_value = match token.kind {
-        TokenKind::Identifier => {
-            let var_name = &token.lexeme;
-            let current_module = global_store.modules
-                .get(&parser.current_module);
-            let mut variable_value = VariableValue::Unknown;
-
-            if current_module.is_none() {
-                return Err(format!("Module '{}' not found", parser.current_module));
-            } else {
-                variable_value = current_module.unwrap()
-                    .variable_table
-                    .variables
-                    .get(var_name)
-                    .cloned()
-                    .unwrap_or(VariableValue::Unknown);
-            }
-
-            println!("Trying to get variable '{}' in module '{}'", var_name, parser.current_module);
-
-            variable_value
-        }
-        TokenKind::Number => VariableValue::Number(token.lexeme.parse().unwrap_or(0.0)),
-        TokenKind::String => {
-            let var_name = &token.lexeme;
-            let current_module = global_store.modules
-                .get(&parser.current_module);
-            let mut variable_value = VariableValue::Unknown;
-
-            if current_module.is_none() {
-                return Err(format!("Module '{}' not found", parser.current_module));
-            } else {
-                variable_value = current_module.unwrap()
-                    .variable_table
-                    .variables
-                    .get(var_name)
-                    .cloned()
-                    .unwrap_or(VariableValue::Unknown);
-            }
-
-            println!("Trying to get variable '{}' in module '{}'", var_name, parser.current_module);
-
-            variable_value
-        }
-        _ => VariableValue::Unknown,
-    };
-
-    println!("Trying get variable : {:?}", global_store.modules);
-
-    Ok(Statement {
-        kind: StatementKind::Unknown,
-        value: statment_value,
-        indent: token.indent,
-        line: token.line,
-        column: token.column,
-    })
-}

package/rust/core/parser/loop_.rs

@@ -1,62 +0,0 @@
-use std::{ collections::HashMap, iter };
-
-use crate::core::types::{
-    statement::{ Statement, StatementIterator, StatementKind },
-    token::{ Token, TokenDuration, TokenKind, TokenParamValue },
-    variable::VariableValue,
-};
-
-pub fn parse_loop(
-    parser: &mut crate::core::parser::Parser,
-    global_store: &mut crate::core::types::store::GlobalStore
-) -> Result<crate::core::types::statement::Statement, String> {
-    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
-
-    parser.next();
-
-    let mut iterator = StatementIterator::Unknown;
-
-    let iterable_tokens: Vec<Token> = parser.collect_until(|t| { t.kind == TokenKind::Colon });
-
-    iterable_tokens.iter().for_each(|t| {
-        match t.kind {
-            TokenKind::Identifier => {
-                iterator = StatementIterator::Identifier(t.lexeme.clone());
-            }
-            TokenKind::Number => {
-                if let Ok(num) = t.lexeme.parse::<f32>() {
-                    iterator = StatementIterator::Number(num);
-                } else {
-                    eprintln!("⚠️ Invalid number in loop iterator: {}", t.lexeme);
-                }
-            }
-            TokenKind::Array => {
-                println!("🔍 Parsing array in loop iterator: {:?}", t.lexeme);
-                iterator = StatementIterator::Array(vec![]);
-            }
-            TokenKind::Map => {
-                println!("🔍 Parsing map in loop iterator: {:?}", t.lexeme);
-                iterator = StatementIterator::Map(HashMap::new());
-            }
-            _ => {
-                eprintln!("⚠️ Unsupported token type in loop iterator: {:?}", t.kind);
-            }
-        }
-    });
-
-    parser.next(); 
-
-    let loop_body_tokens: Vec<Token> = parser.collect_until(|t| { t.kind == TokenKind::Dedent });
-
-    let loop_statement = Statement {
-        kind: StatementKind::Loop {
-            iterator,
-        },
-        value: VariableValue::Array(loop_body_tokens),
-        line: token.line,
-        column: token.column,
-        indent: token.indent,
-    };
-
-    Ok(loop_statement)
-}

package/rust/core/parser/tempo.rs

@@ -1,42 +0,0 @@
-use crate::core::types::{
-    parser::Parser,
-    statement::{ Statement, StatementKind },
-    store::GlobalStore,
-    token::TokenKind,
-    variable::VariableValue,
-};
-
-pub fn parse_tempo(
-    parser: &mut Parser,
-    global_store: &mut GlobalStore
-) -> Result<Statement, String> {
-    let token = parser.peek().ok_or("Unexpected EOF")?.clone();
-
-    parser.next();
-
-    if let Some(token) = parser.next() {
-
-        if token.kind == TokenKind::Number {
-            let value = token.lexeme.parse::<f32>().map_err(|_| "Invalid tempo value".to_string())?;
-            return Ok(Statement {
-                kind: StatementKind::Tempo,
-                value: VariableValue::Number(value as f32),
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            });
-        } else if token.kind == TokenKind::Identifier {
-            let value = token.lexeme.clone();
-
-            return Ok(Statement {
-                kind: StatementKind::Tempo,
-                value: VariableValue::Text(value),
-                indent: token.indent,
-                line: token.line,
-                column: token.column,
-            });
-        }
-    }
-
-    Err(format!("Expected a number after tempo keyword, found {}", token.lexeme))
-}

package/rust/core/parser/variable.rs

@@ -1,129 +0,0 @@
-use std::collections::HashMap;
-
-use crate::core::{
-    parser::Parser,
-    types::{
-        statement::{ Statement, StatementKind },
-        token::{ Token, TokenKind, TokenParamValue },
-        variable::VariableValue,
-    },
-};
-
-pub fn parse_let_statement(parser: &mut Parser) -> Result<Statement, String> {
-    let name_token = parser.next().ok_or("Expected variable name after 'let'")?.clone();
-    if name_token.kind != TokenKind::Identifier {
-        return Err(format!("Expected variable name, found {:?}", name_token.kind));
-    }
-
-    let variable_name = name_token.lexeme.clone();
-
-    let equal_token = parser.next().ok_or("Expected '=' after variable name")?.clone();
-    if equal_token.kind != TokenKind::Equals {
-        return Err(format!("Expected '=', found {:?} after variable name", equal_token.kind));
-    }
-
-    let value_token = parser.next().ok_or("Expected value after '='")?.clone();
-    let value = match value_token.kind {
-        TokenKind::String => VariableValue::Text(value_token.lexeme.clone()),
-        TokenKind::Number =>
-            value_token.lexeme
-                .parse::<f32>()
-                .map(VariableValue::Number)
-                .map_err(|_| "Invalid number value".to_string())?,
-        TokenKind::Boolean =>
-            value_token.lexeme
-                .parse::<bool>()
-                .map(VariableValue::Boolean)
-                .map_err(|_| "Invalid boolean value".to_string())?,
-        TokenKind::Identifier => VariableValue::Text(value_token.lexeme.clone()),
-        TokenKind::LBrace => {
-            let mut object: HashMap<String, VariableValue> = HashMap::new();
-            while let Some(next_token) = parser.next() {
-                if next_token.kind == TokenKind::RBrace {
-                    break;
-                }
-                if next_token.kind != TokenKind::Identifier {
-                    return Err(
-                        format!("Expected identifier in object, found {:?}", next_token.kind)
-                    );
-                }
-                let key = next_token.lexeme.clone();
-
-                let colon_token = parser.next().ok_or("Expected ':' after object key")?.clone();
-                if colon_token.kind != TokenKind::Colon {
-                    return Err(format!("Expected ':', found {:?}", colon_token.kind));
-                }
-
-                let value_token = parser.next().ok_or("Expected value after ':'")?.clone();
-                let value = match value_token.kind {
-                    TokenKind::String => VariableValue::Text(value_token.lexeme.clone()),
-                    TokenKind::Number =>
-                        value_token.lexeme
-                            .parse::<f32>()
-                            .map(VariableValue::Number)
-                            .map_err(|_| "Invalid number value".to_string())?,
-                    TokenKind::Boolean =>
-                        value_token.lexeme
-                            .parse::<bool>()
-                            .map(VariableValue::Boolean)
-                            .map_err(|_| "Invalid boolean value".to_string())?,
-                    _ => {
-                        return Err(format!("Invalid object value token: {:?}", value_token.kind));
-                    }
-                };
-                object.insert(key, value);
-            }
-
-            let mut variable_object_map: HashMap<String, TokenParamValue> = HashMap::new();
-
-            for (key, value) in object {
-                let token_value = match value {
-                    VariableValue::Text(s) => TokenParamValue::String(s),
-                    VariableValue::Number(n) => TokenParamValue::Number(n),
-                    VariableValue::Boolean(b) => TokenParamValue::Boolean(b),
-                    _ => {
-                        continue;
-                    }
-                };
-                variable_object_map.insert(key, token_value);
-            }
-
-            VariableValue::Map(variable_object_map)
-        }
-        _ => {
-            return Err(format!("Invalid value token: {:?}", value_token.kind));
-        }
-    };
-
-    parser.variable_table.variables.insert(variable_name.clone(), value.clone());
-
-    Ok(Statement {
-        kind: StatementKind::Let {
-            name: variable_name,
-        },
-        value: value,
-        indent: name_token.indent,
-        line: name_token.line,
-        column: name_token.column,
-    })
-}
-
-pub fn parse_variable_value(parser: &mut Parser, token: &Token) -> Result<VariableValue, String> {
-    match token.kind {
-        TokenKind::String => Ok(VariableValue::Text(token.lexeme.clone())),
-        TokenKind::Number => {
-            token.lexeme
-                .parse::<f32>()
-                .map(VariableValue::Number)
-                .map_err(|_| "Invalid number value".to_string())
-        }
-        TokenKind::Boolean => {
-            token.lexeme
-                .parse::<bool>()
-                .map(VariableValue::Boolean)
-                .map_err(|_| "Invalid boolean value".to_string())
-        }
-        TokenKind::Identifier => Ok(VariableValue::Text(token.lexeme.clone())),
-        _ => Err(format!("Invalid variable value token: {:?}", token.kind)),
-    }
-}

package/rust/core/preprocessor/dependencies.rs

@@ -1,54 +0,0 @@
-use std::{ collections::{ HashSet, VecDeque }, fs };
-
-pub fn collect_dependencies_recursively(entry_file: &str) -> Vec<String> {
-    let mut queue = VecDeque::new();
-    let mut loaded = HashSet::new();
-
-    queue.push_back(entry_file.to_string());
-
-    while let Some(file_ref) = queue.pop_front() {
-        if loaded.contains(&file_ref) {
-            continue;
-        }
-
-        let deps = get_direct_dependencies(&file_ref);
-        for dep in deps {
-            queue.push_back(dep.clone());
-        }
-
-        loaded.insert(file_ref);
-    }
-
-    loaded.into_iter().collect()
-}
-
-fn get_direct_dependencies(file: &str) -> Vec<String> {
-    let content = match fs::read_to_string(file) {
-        Ok(c) => c,
-        Err(_) => {
-            eprintln!("⚠️ Unable to read file: {}", file);
-            return vec![];
-        }
-    };
-
-    let mut deps = Vec::new();
-
-    for line in content.lines() {
-        let line = line.trim();
-
-        if line.starts_with("@import") {
-            if let Some(from_index) = line.find("from") {
-                let after_from = line[from_index + 4..].trim();
-                if after_from.starts_with('"') || after_from.starts_with('\'') {
-                    let delimiter = after_from.chars().next().unwrap();
-                    if let Some(end_quote) = after_from[1..].find(delimiter) {
-                        let path = &after_from[1..=end_quote];
-                        deps.push(path.to_string());
-                    }
-                }
-            }
-        }
-    }
-
-    deps
-}

package/rust/core/preprocessor/resolver/at.rs

@@ -1,24 +0,0 @@
-use crate::core::types::{
-    module::Module,
-    statement::{ Statement, StatementResolved, StatementResolvedValue },
-    variable::VariableValue,
-};
-
-pub fn resolve_load_statement(
-    stmt: &Statement,
-    source: &str,
-    alias: &str,
-    module: &mut Module
-) -> StatementResolved {
-    let source_string = source.to_string();
-
-    module.set_variable(alias.to_string(), VariableValue::Sample(source_string.clone()));
-
-    StatementResolved {
-        kind: stmt.kind.clone(),
-        value: StatementResolvedValue::Null,
-        indent: stmt.indent,
-        line: stmt.line,
-        column: stmt.column,
-    }
-}