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

package/rust/core/types/module.rs

@@ -1,41 +0,0 @@
-use crate::core::types::{
-    statement::Statement,
-    store::{ ExportTable, ImportTable, VariableTable },
-    token::Token,
-    variable::VariableValue,
-};
-
-#[derive(Debug, Clone)]
-pub struct Module {
-    pub path: String,
-    pub tokens: Vec<Token>,
-    pub statements: Vec<Statement>,
-    pub variable_table: VariableTable,
-    pub export_table: ExportTable,
-    pub import_table: ImportTable,
-}
-
-impl Module {
-    pub fn new(path: String) -> Self {
-        Module {
-            path,
-            tokens: Vec::new(),
-            statements: Vec::new(),
-            variable_table: VariableTable::new(),
-            export_table: ExportTable::new(),
-            import_table: ImportTable::new(),
-        }
-    }
-
-    pub fn add_statement(&mut self, statement: Statement) {
-        self.statements.push(statement);
-    }
-
-    pub fn set_variable(&mut self, name: String, value: VariableValue) {
-        self.variable_table.set(name, value);
-    }
-
-    pub fn get_variable(&self, name: &str) -> Option<&VariableValue> {
-        self.variable_table.get(name)
-    }
-}

package/rust/core/types/parser.rs

@@ -1,73 +0,0 @@
-use crate::core::types::{
-    store::{ ExportTable, ImportTable, VariableTable },
-    token::{ Token, TokenKind },
-};
-
-#[derive(Debug, Clone)]
-pub struct Parser {
-    pub tokens: Vec<Token>,
-    pub token_index: usize,
-    pub variable_table: VariableTable,
-    pub export_table: ExportTable,
-    pub import_table: ImportTable,
-    pub current_module: String,
-}
-
-impl Parser {
-    pub fn new(tokens: Vec<Token>) -> Self {
-        Self {
-            tokens,
-            token_index: 0,
-            variable_table: VariableTable::new(),
-            export_table: ExportTable::new(),
-            import_table: ImportTable::new(),
-            current_module: String::new(),
-        }
-    }
-
-    pub fn set_tokens(&mut self, tokens: Vec<Token>) {
-        self.tokens = tokens;
-        self.token_index = 0;
-    }
-
-    pub fn peek(&self) -> Option<&Token> {
-        self.tokens.get(self.token_index)
-    }
-
-    pub fn next(&mut self) -> Option<&Token> {
-        let tok = self.tokens.get(self.token_index);
-        self.token_index += 1;
-        tok
-    }
-
-    pub fn expect(&mut self, kind: TokenKind) -> Result<&Token, String> {
-        let tok = self.next().ok_or("Unexpected end of input")?;
-        if tok.kind == kind {
-            Ok(tok)
-        } else {
-            Err(format!("Expected {:?}, got {:?}", kind, tok.kind))
-        }
-    }
-
-    pub fn collect_until<F>(&mut self, condition: F) -> Vec<Token> where F: Fn(&Token) -> bool {
-        let mut collected = Vec::new();
-        while let Some(token) = self.peek() {
-            if token.kind == TokenKind::Newline || token.kind == TokenKind::Indent {
-                self.next(); // Skip newlines and indents
-                continue;
-            }
-            if token.kind == TokenKind::EOF {
-                break;
-            }
-            if condition(token) {
-                break;
-            }
-            collected.push(self.next().unwrap().clone());
-        }
-        collected
-    }
-
-    pub fn is_eof(&self) -> bool {
-        self.token_index >= self.tokens.len()
-    }
-}

package/rust/core/types/statement.rs

@@ -1,105 +0,0 @@
-use std::collections::HashMap;
-use serde::Serialize;
-use crate::core::types::{ token::{ Token, TokenDuration, TokenParam }, variable::VariableValue };
-
-#[derive(Debug, Clone, Serialize)]
-pub struct Statement {
-    pub kind: StatementKind,
-    pub value: VariableValue,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct StatementResolved {
-    pub kind: StatementKind,
-    pub value: StatementResolvedValue,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub enum StatementValue {
-    Boolean(bool),
-    Number(f32),
-    String(String),
-    Array(Vec<Statement>),
-    Map(HashMap<String, VariableValue>),
-    Unknown,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub enum StatementResolvedValue {
-    Boolean(bool),
-    Number(f32),
-    String(String),
-    Array(Vec<StatementResolved>),
-    Map(HashMap<String, StatementResolvedValue>),
-    Unknown,
-    Null,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub enum StatementIterator {
-    Identifier(String),
-    Number(f32),
-    Array(Vec<Statement>),
-    Map(HashMap<String, VariableValue>),
-    Unknown,
-}
-
-#[derive(Debug, Serialize, Clone)]
-/// Represents the kind of a statement
-pub enum StatementKind {
-    // Trigger statements
-    Trigger {
-        entity: String,
-        duration: TokenDuration,
-        // params: Vec<TokenParam>,
-    },
-
-    // Variable statements
-    Let {
-        name: String,
-    },
-
-    // Loop statements
-    Loop {
-        iterator: StatementIterator,
-    },
-
-    // Conditional statements
-    // If {
-    //     // condition: ConditionParts,
-    //     condition_state: bool,
-    //     body: Vec<Statement>,
-    // },
-
-    // Keyword statements
-    Tempo,
-    Bank,
-
-    // At (@) statements
-    Include(String),
-    Export,
-    Import {
-        names: Vec<String>,
-        source: String,
-    },
-    Load {
-        source: String,
-        alias: String,
-    },
-
-    // Error & Unknown statements
-    Unknown,
-    Error,
-
-    // Empty or ignored statements
-    Comment(String),
-    Indent,
-    Dedent,
-    NewLine,
-}

package/rust/core/types/store.rs

@@ -1,116 +0,0 @@
-use std::collections::HashMap;
-
-use crate::core::types::{ module::Module, variable::VariableValue };
-
-#[derive(Debug, Default)]
-pub struct GlobalStore {
-    pub modules: HashMap<String, Module>,
-}
-
-impl GlobalStore {
-    pub fn new() -> Self {
-        GlobalStore {
-            modules: HashMap::new(),
-        }
-    }
-
-    pub fn insert_module(&mut self, path: String, module: Module) {
-        self.modules.insert(path, module);
-    }
-
-    pub fn update_module(&mut self, path: String, module: Module) {
-        if !self.modules.contains_key(&path) {
-            eprintln!("❌ Module {} not found in global store for update", path);
-            return;
-        }
-        
-        // Remove the existing module if it exists
-        self.modules.remove(&path);
-
-        // Insert the updated module
-        self.modules.insert(path, module);
-    }
-
-    pub fn get_module(&self, path: &str) -> Option<&Module> {
-        self.modules.get(path)
-    }
-
-    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
-        self.modules.remove(path)
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct VariableTable {
-    pub variables: HashMap<String, VariableValue>,
-}
-
-impl VariableTable {
-    pub fn new() -> Self {
-        VariableTable {
-            variables: HashMap::new(),
-        }
-    }
-
-    pub fn set(&mut self, name: String, value: VariableValue) {
-        self.variables.insert(name, value);
-    }
-
-    pub fn get(&self, name: &str) -> Option<&VariableValue> {
-        self.variables.get(name)
-    }
-
-    pub fn remove(&mut self, name: &str) -> Option<VariableValue> {
-        self.variables.remove(name)
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ExportTable {
-    pub exports: HashMap<String, VariableValue>,
-}
-
-impl ExportTable {
-    pub fn new() -> Self {
-        ExportTable {
-            exports: HashMap::new(),
-        }
-    }
-
-    pub fn add_export(&mut self, name: String, value: VariableValue) {
-        self.exports.insert(name, value);
-    }
-
-    pub fn get_export(&self, name: &str) -> Option<&VariableValue> {
-        self.exports.get(name)
-    }
-
-    pub fn remove_export(&mut self, name: &str) -> Option<VariableValue> {
-        self.exports.remove(name)
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ImportTable {
-    pub imports: HashMap<String, VariableValue>,
-}
-
-impl ImportTable {
-    pub fn new() -> Self {
-        ImportTable {
-            imports: HashMap::new(),
-        }
-    }
-
-    pub fn add_import(&mut self, name: String, value: VariableValue) {
-        self.imports.insert(name, value);
-    }
-
-    pub fn get_import(&self, name: &str) -> Option<&VariableValue> {
-        self.imports.get(name)
-    }
-
-    pub fn remove_import(&mut self, name: &str) -> Option<VariableValue> {
-        self.imports.remove(name)
-    }
-}

package/rust/core/types/token.rs

@@ -1,83 +0,0 @@
-use std::collections::HashMap;
-
-use serde::Serialize;
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
-pub struct Token {
-    pub kind: TokenKind,
-    pub lexeme: String,
-    pub indent: usize,
-    pub line: usize,
-    pub column: usize,
-}
-
-impl Token {
-    pub fn is_error(&self) -> bool {
-        match &self.kind {
-            TokenKind::Error(_) => {
-                return true;
-            },
-            _ => {
-                return false;
-            },
-        };
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
-pub enum TokenKind {
-    At,
-    Tempo,
-    Bank,
-    Loop,
-    Identifier,
-    Map,
-    Array,
-    Number,
-    String,
-    Boolean,
-    Colon,
-    Comma,
-    Equals,
-    DoubleEquals,
-    Dot,
-    LBrace,
-    RBrace,
-    DbQuote,
-    Quote,
-    LBracket,
-    RBracket,
-    Newline,
-    Indent,
-    Dedent,
-    Comment(String),
-    Unknown,
-    Error(String),
-    EOF,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
-pub enum TokenDuration {
-    Number(f32),
-    Identifier(String),
-    Infinite,
-    Auto,
-    Unknown,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
-pub struct TokenParam {
-    pub name: String,
-    pub value: TokenParamValue,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
-pub enum TokenParamValue {
-    Number(f32),
-    String(String),
-    Boolean(bool),
-    Identifier(String),
-    Map(HashMap<String, TokenParamValue>),
-    Array(Vec<TokenParamValue>),
-    Unknown,
-}

package/rust/core/types/variable.rs

@@ -1,32 +0,0 @@
-use std::collections::HashMap;
-use serde::Serialize;
-use crate::core::types::token::{Token, TokenParamValue};
-
-#[derive(Debug, Clone, Serialize)]
-pub enum VariableValue {
-    Number(f32),
-    Array(Vec<Token>),
-    Map(HashMap<String, TokenParamValue>),
-    Text(String),
-    Boolean(bool),
-    Sample(String),
-    Unknown,
-    Null,
-}
-pub struct Variable {
-    pub value: VariableValue,
-}
-
-impl Variable {
-    pub fn from_number(value: f32) -> Self {
-        Variable {
-            value: VariableValue::Number(value),
-        }
-    }
-
-    pub fn from_token(value: Token) -> Self {
-        Variable {
-            value: VariableValue::Text(value.lexeme),
-        }
-    }
-}

package/rust/runner/executer.rs

@@ -1,44 +0,0 @@
-use crate::core::{
-    preprocessor::resolver::resolve_statement,
-    types::{
-        module::Module,
-        statement::{ StatementKind, StatementResolved, StatementResolvedValue },
-    },
-};
-
-/// Exécute tous les statements d'un module avec résolution des variables
-pub fn execute_statements(module: &mut Module) -> Vec<StatementResolved> {
-    let mut resolved_statements: Vec<StatementResolved> = Vec::new();
-
-    if module.clone().statements.is_empty() {
-        return resolved_statements;
-    }
-
-    for stmt in module.clone().statements {
-        match &stmt.kind {
-            StatementKind::Tempo { .. } => {
-                let resolved = resolve_statement(&stmt, module);
-                resolved_statements.push(resolved);
-            }
-            StatementKind::Trigger { .. } => {
-                let resolved = resolve_statement(&stmt, module);
-                resolved_statements.push(resolved);
-            }
-            StatementKind::Bank { .. } => {
-                let resolved = resolve_statement(&stmt, module);
-                resolved_statements.push(resolved);
-            }
-            StatementKind::Loop { .. } => {
-                let resolved = resolve_statement(&stmt, module);
-                resolved_statements.push(resolved);
-            }
-            StatementKind::Load { .. } => {
-                let resolved = resolve_statement(&stmt, module);
-                resolved_statements.push(resolved);
-            }
-            _ => {}
-        }
-    }
-
-    resolved_statements
-}

package/rust/runner/mod.rs

@@ -1 +0,0 @@
-pub mod executer;