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

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,
-    }
-}

package/rust/core/types/cli.rs

@@ -1,182 +0,0 @@
-use clap::{ Parser, Subcommand };
-use crate::utils::version::get_version;
-
-#[derive(Parser)]
-#[command(name = "devalang")]
-#[command(author = "Devaloop")]
-#[command(version = get_version())]
-#[command(about = "🦊 Devalang – A programming language for music and sound.")]
-pub struct Cli {
-    #[arg(long, global = true)]
-    /// Skips loading the configuration file.
-    pub no_config: bool,
-
-    #[command(subcommand)]
-    pub command: CliCommands,
-}
-
-#[derive(Subcommand)]
-pub enum CliTemplateCommand {
-    /// Lists all available templates for Devalang projects.
-    List,
-    /// Displays information about a specific template.
-    Info {
-        name: String,
-    },
-}
-
-pub enum CompilationMode {
-    /// Real-time compilation mode, for compiling files as soon as possible.
-    RealTime,
-
-    /// Batch compilation mode, for compiling files one by one.
-    Batch,
-
-    /// Check mode, used for analyzing the code without compiling it.
-    Check,
-}
-
-#[derive(Subcommand)]
-pub enum CliCommands {
-    /// Create a new Devalang project.
-    ///
-    /// ### Arguments
-    /// - `name` - The name of the project to create.
-    /// - `template` - The template to use for the project. Defaults to "default".
-    ///
-    /// ### Example
-    /// ```bash
-    /// devalang init --name my_project --template default
-    ///
-    Init {
-        #[arg(short, long)]
-        /// The optional name (directory) of the project to create.
-        name: Option<String>,
-
-        #[arg(short, long)]
-        /// The template to use for the project.
-        ///
-        /// ### Default value
-        /// - `default`
-        ///
-        template: Option<String>,
-    },
-
-    Template {
-        #[command(subcommand)]
-        /// The template command to execute.
-        command: CliTemplateCommand,
-    },
-
-    /// Build the program and generate output files.
-    ///
-    /// ### Arguments
-    /// - `entry` - The entry point of the program to build. Defaults to "./src".
-    /// - `output` - The directory where the output files will be generated. Defaults to "./output".
-    /// - `watch` - Whether to watch for changes and rebuild. Defaults to "true".
-    ///
-    /// ### Example
-    /// ```bash
-    /// devalang build --entry ./src --output ./output --watch true
-    /// ```
-    ///
-    Build {
-        #[arg(short, long)]
-        /// The entry point of the program to build.
-        ///
-        entry: Option<String>,
-
-        #[arg(short, long)]
-        /// The directory where the output files will be generated.
-        ///
-        output: Option<String>,
-
-        #[arg(long, default_value_t = false)]
-        /// Whether to watch for changes and rebuild.
-        ///
-        /// ### Default value
-        /// - `false`
-        ///
-        watch: bool,
-
-        #[arg(long, default_value = "real-time")]
-        /// The mode of compilation.
-        ///
-        /// ### Default value
-        /// - `real-time`
-        ///
-        /// ### Possible values
-        /// - `real-time` - Compiles files as soon as possible.
-        /// - `batch` - Compiles files one by one.
-        /// - `check` - Analyzes the code without compiling it.
-        ///
-        compilation_mode: String,
-
-        #[arg(short, long, default_value_t = false)]
-        /// Whether to print debug information.
-        ///
-        /// ### Default value
-        /// - `false`
-        ///
-        debug: bool,
-
-        #[arg(short, long, default_value_t = false)]
-        /// Whether to compress the output files.
-        ///
-        /// ### Default value
-        /// - `false`
-        ///
-        compress: bool,
-    },
-
-    /// Analyze the program for errors and warnings.
-    ///
-    /// ### Arguments
-    /// - `entry` - The entry point of the program to analyze. Defaults to "./src".
-    /// - `watch` - Whether to watch for changes and re-analyze. Defaults to "true".
-    ///
-    /// ### Example
-    /// ```bash
-    /// devalang check --entry ./src --watch true --compilation-mode real-time
-    /// ```
-    Check {
-        #[arg(short, long)]
-        /// The entry point of the program to analyze.
-        ///
-        entry: Option<String>,
-
-        #[arg(short, long)]
-        /// The directory where the output files will be generated.
-        ///
-        output: Option<String>,
-
-        #[arg(long, default_value_t = false)]
-        /// Whether to watch for changes and re-analyze.
-        ///
-        /// ### Default value
-        /// - `false`
-        ///
-        watch: bool,
-
-        #[arg(short, long, default_value = "real-time")]
-        /// The mode of compilation.
-        ///
-        /// ### Default value
-        /// - `real-time`
-        ///
-        /// ### Possible values
-        /// - `real-time` - Analyzes files as soon as possible.
-        /// - `batch` - Analyzes files one by one.
-        /// - `check` - Analyzes the code without compiling it.
-        ///
-        compilation_mode: String,
-
-        #[arg(short, long, default_value_t = false)]
-        /// Whether to print debug information.
-        ///
-        /// ### Default value
-        /// - `false`
-        ///
-        debug: bool,
-    },
-}

package/rust/core/types/config.rs

@@ -1,15 +0,0 @@
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize)]
-pub struct DevalangConfig {
-    pub defaults: Defaults,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct Defaults {
-    pub entry: Option<String>,
-
-    pub output: Option<String>,
-
-    pub watch: Option<bool>,
-}

package/rust/core/types/mod.rs

@@ -1,8 +0,0 @@
-pub mod token;
-pub mod statement;
-pub mod variable;
-pub mod store;
-pub mod parser;
-pub mod module;
-pub mod cli;
-pub mod config;

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)
-    }
-}