@devaloop/devalang 0.0.1-beta.2 → 0.1.1

package/rust/core/builder/mod.rs

@@ -1,129 +0,0 @@
-use crate::core::audio::engine::render_audio_with_modules;
-use crate::core::parser::statement::Statement;
-use crate::core::store::global::GlobalStore;
-use devalang_utils::logger::Logger;
-use std::io::Write;
-use std::{collections::HashMap, fs::create_dir_all};
-
-pub struct Builder {}
-
-impl Default for Builder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Builder {
-    pub fn new() -> Self {
-        Builder {}
-    }
-
-    pub fn build_ast(
-        &self,
-        modules: &HashMap<String, Vec<Statement>>,
-        out_dir: &str,
-        compress: bool,
-    ) {
-        for (name, statements) in modules {
-            let formatted_name = name.split("/").last().unwrap_or(name);
-            let formatted_name = formatted_name.replace(".deva", "");
-
-            create_dir_all(format!("{}/ast", out_dir)).expect("Failed to create AST directory");
-
-            let file_path = format!("{}/ast/{}.json", out_dir, formatted_name);
-            let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
-            let content = if compress {
-                serde_json::to_string(&statements).expect("Failed to serialize AST")
-            } else {
-                serde_json::to_string_pretty(&statements).expect("Failed to serialize AST")
-            };
-
-            file.write_all(content.as_bytes())
-                .expect("Failed to write AST to file");
-        }
-    }
-
-    pub fn build_audio(
-        &self,
-        modules: &HashMap<String, Vec<Statement>>,
-        normalized_output_dir: &str,
-        global_store: &mut GlobalStore,
-        audio_format: Option<String>,
-        sample_rate: Option<u32>,
-    ) {
-        let logger = Logger::new();
-
-        let audio_engines =
-            render_audio_with_modules(modules.clone(), normalized_output_dir, global_store);
-
-        create_dir_all(format!("{}/audio", normalized_output_dir))
-            .expect("Failed to create audio directory");
-
-        for (module_name, mut audio_engine) in audio_engines {
-            let formatted_module_name = module_name
-                .split('/')
-                .next_back()
-                .unwrap_or(&module_name)
-                .replace(".deva", "");
-
-            let output_path = format!(
-                "{}/audio/{}.wav",
-                normalized_output_dir, formatted_module_name
-            );
-
-            match audio_engine.generate_wav_file(&output_path, audio_format.clone(), sample_rate) {
-                Ok(_) => {}
-                Err(msg) => {
-                    logger.log_error_with_stacktrace(
-                        &format!(
-                            "Unable to generate WAV file for module '{}': {}",
-                            formatted_module_name, msg
-                        ),
-                        &module_name,
-                    );
-                }
-            }
-        }
-    }
-
-    pub fn build_midi(
-        &self,
-        modules: &HashMap<String, Vec<Statement>>,
-        normalized_output_dir: &str,
-        global_store: &mut GlobalStore,
-    ) {
-        let logger = Logger::new();
-
-        let audio_engines =
-            render_audio_with_modules(modules.clone(), normalized_output_dir, global_store);
-
-        create_dir_all(format!("{}/midi", normalized_output_dir))
-            .expect("Failed to create MIDI directory");
-
-        for (module_name, mut audio_engine) in audio_engines {
-            let formatted_module_name = module_name
-                .split('/')
-                .next_back()
-                .unwrap_or(&module_name)
-                .replace(".deva", "");
-
-            let output_path = format!(
-                "{}/midi/{}.mid",
-                normalized_output_dir, formatted_module_name
-            );
-
-            match audio_engine.generate_midi_file(&output_path, None, None) {
-                Ok(_) => {}
-                Err(msg) => {
-                    logger.log_error_with_stacktrace(
-                        &format!(
-                            "Unable to generate MIDI file for module '{}': {}",
-                            formatted_module_name, msg
-                        ),
-                        &module_name,
-                    );
-                }
-            }
-        }
-    }
-}

package/rust/core/debugger/lexer.rs

@@ -1,27 +0,0 @@
-use crate::core::{debugger::Debugger, lexer::token::Token};
-use std::{collections::HashMap, fs::create_dir_all};
-
-pub fn write_lexer_log_file(
-    output_dir: &str,
-    file_name: &str,
-    modules: HashMap<String, Vec<Token>>,
-) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (path, tokens) in modules {
-        content.push_str(&format!("--- Resolved Tokens for {} ---\n", path));
-
-        for token in tokens {
-            content.push_str(&format!("{:?}\n", token));
-        }
-
-        content.push('\n');
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}

package/rust/core/debugger/logs.rs

@@ -1,52 +0,0 @@
-use devalang_types::{FunctionTable, VariableTable};
-use std::fs::create_dir_all;
-
-pub fn write_module_variable_log_file(
-    output_dir: &str,
-    module_path: &str,
-    variable_table: &VariableTable,
-) {
-    let debugger = crate::core::debugger::Debugger::new();
-    let mut content = String::new();
-    let module_name = module_path
-        .split('/')
-        .next_back()
-        .unwrap_or("index")
-        .replace(".deva", "");
-
-    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (var_name, var_data) in &variable_table.variables {
-        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, "variables.log", &content);
-}
-
-pub fn write_module_function_log_file(
-    output_dir: &str,
-    module_path: &str,
-    function_table: &FunctionTable,
-) {
-    let debugger = crate::core::debugger::Debugger::new();
-    let mut content = String::new();
-    let module_name = module_path
-        .split('/')
-        .next_back()
-        .unwrap_or("index")
-        .replace(".deva", "");
-
-    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (func_name, func_data) in &function_table.functions {
-        content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, "functions.log", &content);
-}

package/rust/core/debugger/mod.rs

@@ -1,30 +0,0 @@
-pub mod lexer;
-pub mod logs;
-pub mod preprocessor;
-pub mod store;
-
-use std::io::Write;
-
-pub struct Debugger {}
-
-impl Default for Debugger {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Debugger {
-    pub fn new() -> Self {
-        Debugger {}
-    }
-
-    pub fn write_log_file(&self, path: &str, filename: &str, content: &str) {
-        std::fs::create_dir_all(path).expect("Failed to create directory");
-
-        let file_path = format!("{}/{}", path, filename);
-        let mut file = std::fs::File::create(file_path).expect("Failed to create file");
-
-        file.write_all(content.as_bytes())
-            .expect("Failed to write to file");
-    }
-}

package/rust/core/debugger/preprocessor.rs

@@ -1,27 +0,0 @@
-use crate::core::{debugger::Debugger, parser::statement::Statement};
-use std::{collections::HashMap, fs::create_dir_all};
-
-pub fn write_preprocessor_log_file(
-    output_dir: &str,
-    file_name: &str,
-    modules: HashMap<String, Vec<Statement>>,
-) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (path, stmts) in modules {
-        content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
-
-        for stmt in stmts {
-            content.push_str(&format!("{:?}\n", stmt));
-        }
-
-        content.push('\n');
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}

package/rust/core/debugger/store.rs

@@ -1,38 +0,0 @@
-use crate::core::debugger::Debugger;
-use devalang_types::{FunctionTable, VariableTable};
-use std::fs::create_dir_all;
-
-pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (var_name, var_data) in variables.variables {
-        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
-
-pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (_index, function) in functions.functions {
-        content.push_str(&format!(
-            "'{}' = [{:?}] => {:?}\n",
-            function.name, function.parameters, function.body
-        ));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}

package/rust/core/error/mod.rs

@@ -1,269 +0,0 @@
-use crate::core::parser::{
-    driver::parser::Parser,
-    statement::{Statement, StatementKind},
-};
-use devalang_types::Value;
-use serde::{Deserialize, Serialize};
-
-pub struct ErrorHandler {
-    errors: Vec<Error>,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub enum Severity {
-    Warning,
-    Critical,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct StackFrame {
-    pub module: Option<String>,
-    pub context: Option<String>,
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug)]
-pub struct ErrorResult {
-    pub message: String,
-    pub line: usize,
-    pub column: usize,
-    pub severity: Severity,
-    pub stack: Vec<StackFrame>,
-}
-
-#[derive(Clone)]
-pub struct Error {
-    pub message: String,
-    pub line: usize,
-    pub column: usize,
-}
-
-impl Default for ErrorHandler {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ErrorHandler {
-    pub fn new() -> Self {
-        Self { errors: Vec::new() }
-    }
-
-    pub fn add_error(&mut self, message: String, line: usize, column: usize) {
-        let error_statement = Error {
-            message,
-            line,
-            column,
-        };
-        self.errors.push(error_statement);
-    }
-
-    pub fn has_errors(&self) -> bool {
-        !self.errors.is_empty()
-    }
-
-    pub fn get_errors(&self) -> &Vec<Error> {
-        &self.errors
-    }
-
-    pub fn clear_errors(&mut self) {
-        self.errors.clear();
-    }
-
-    pub fn detect_from_statements(&mut self, _parser: &mut Parser, statements: &[Statement]) {
-        for stmt in statements {
-            match &stmt.kind {
-                StatementKind::Unknown => {
-                    self.add_error("Unknown statement".to_string(), stmt.line, stmt.column);
-                }
-                StatementKind::Error { message } => {
-                    self.add_error(message.clone(), stmt.line, stmt.column);
-                }
-                _ => {}
-            }
-        }
-    }
-}
-
-/// Collects errors recursively from statements (mirrors old utils implementation).
-pub fn collect_errors_recursively(statements: &[Statement]) -> Vec<ErrorResult> {
-    let mut errors: Vec<ErrorResult> = Vec::new();
-
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Unknown => {
-                errors.push(ErrorResult {
-                    message: format!("Unknown statement at line {}:{}", stmt.line, stmt.column),
-                    line: stmt.line,
-                    column: stmt.column,
-                    severity: Severity::Warning,
-                    stack: vec![StackFrame {
-                        module: None,
-                        context: Some("Unknown".to_string()),
-                        line: stmt.line,
-                        column: stmt.column,
-                    }],
-                });
-            }
-            StatementKind::Error { message } => {
-                errors.push(ErrorResult {
-                    message: message.clone(),
-                    line: stmt.line,
-                    column: stmt.column,
-                    severity: Severity::Critical,
-                    stack: vec![StackFrame {
-                        module: None,
-                        context: Some("Error".to_string()),
-                        line: stmt.line,
-                        column: stmt.column,
-                    }],
-                });
-            }
-            StatementKind::Loop => {
-                if let Some(body_statements) = extract_loop_body_statements(&stmt.value) {
-                    let nested = collect_errors_recursively(body_statements);
-                    errors.extend(nested.into_iter().map(|mut e| {
-                        e.stack.insert(
-                            0,
-                            StackFrame {
-                                module: None,
-                                context: Some("loop".to_string()),
-                                line: stmt.line,
-                                column: stmt.column,
-                            },
-                        );
-                        e
-                    }));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    errors
-}
-
-fn extract_loop_body_statements(value: &Value) -> Option<&[Statement]> {
-    if let Value::Map(map) = value {
-        if let Some(Value::Block(statements)) = map.get("body") {
-            return Some(statements);
-        }
-    }
-    None
-}
-
-pub fn partition_errors(errors: Vec<ErrorResult>) -> (Vec<ErrorResult>, Vec<ErrorResult>) {
-    let mut warnings = Vec::new();
-    let mut criticals = Vec::new();
-    for e in errors {
-        match e.severity {
-            Severity::Warning => warnings.push(e),
-            Severity::Critical => criticals.push(e),
-        }
-    }
-    (warnings, criticals)
-}
-
-pub fn log_errors_with_stack(prefix: &str, warnings: &[ErrorResult], criticals: &[ErrorResult]) {
-    use devalang_utils::logger::LogLevel;
-    use devalang_utils::logger::Logger;
-
-    let logger = Logger::new();
-    if !warnings.is_empty() {
-        logger.log_message(
-            LogLevel::Warning,
-            &format!("{}: {} warning(s)", prefix, warnings.len()),
-        );
-        for w in warnings {
-            logger.log_message(LogLevel::Warning, &format!("- {}", w.message));
-            if let Some(frame) = w.stack.first() {
-                let module = frame.module.clone().unwrap_or_default();
-                logger.log_message(
-                    LogLevel::Debug,
-                    &format!(
-                        "     ↳ {}:{}:{} {}",
-                        module,
-                        frame.line,
-                        frame.column,
-                        frame.context.clone().unwrap_or_default()
-                    ),
-                );
-            }
-            if w.stack.len() > 1 {
-                for (i, f) in w.stack.iter().enumerate().skip(1) {
-                    let module = f.module.clone().unwrap_or_default();
-                    logger.log_message(
-                        LogLevel::Debug,
-                        &format!(
-                            "       #{} {}:{}:{} {}",
-                            i,
-                            module,
-                            f.line,
-                            f.column,
-                            f.context.clone().unwrap_or_default()
-                        ),
-                    );
-                }
-            }
-        }
-    }
-    if !criticals.is_empty() {
-        logger.log_message(
-            LogLevel::Error,
-            &format!("{}: {} critical error(s)", prefix, criticals.len()),
-        );
-        for c in criticals {
-            logger.log_message(LogLevel::Error, &format!("- {}", c.message));
-            if let Some(frame) = c.stack.first() {
-                let module = frame.module.clone().unwrap_or_default();
-                logger.log_message(
-                    LogLevel::Error,
-                    &format!(
-                        "     ↳ {}:{}:{} {}",
-                        module,
-                        frame.line,
-                        frame.column,
-                        frame.context.clone().unwrap_or_default()
-                    ),
-                );
-            }
-            if c.stack.len() > 1 {
-                for (i, f) in c.stack.iter().enumerate().skip(1) {
-                    let module = f.module.clone().unwrap_or_default();
-                    logger.log_message(
-                        LogLevel::Error,
-                        &format!(
-                            "       #{} {}:{}:{} {}",
-                            i,
-                            module,
-                            f.line,
-                            f.column,
-                            f.context.clone().unwrap_or_default()
-                        ),
-                    );
-                }
-            }
-        }
-    }
-}
-
-/// Collects errors from all modules and annotates stack frames with module names.
-pub fn collect_all_errors_with_modules(
-    statements_by_module: &std::collections::HashMap<String, Vec<Statement>>,
-) -> Vec<ErrorResult> {
-    let mut all: Vec<ErrorResult> = Vec::new();
-    for (module, stmts) in statements_by_module.iter() {
-        let mut errs = collect_errors_recursively(stmts);
-        for e in errs.iter_mut() {
-            // annotate first stack frame module if missing
-            if let Some(first) = e.stack.first_mut() {
-                if first.module.is_none() {
-                    first.module = Some(module.clone());
-                }
-            }
-        }
-        all.extend(errs.into_iter());
-    }
-    all
-}

package/rust/core/lexer/driver.rs

@@ -1,59 +0,0 @@
-use crate::core::lexer::{handler::driver::handle_content_lexing, token::Token};
-use devalang_utils::path::normalize_path;
-use std::fs;
-use std::path::Path;
-
-pub struct Lexer {}
-
-impl Default for Lexer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Lexer {
-    pub fn new() -> Self {
-        Lexer {}
-    }
-
-    pub fn lex_from_source(&self, source: &str) -> Result<Vec<Token>, String> {
-        handle_content_lexing(source.to_string())
-    }
-
-    pub fn lex_tokens(&self, entrypoint: &str) -> Result<Vec<Token>, String> {
-        let path = normalize_path(entrypoint);
-        let resolved_path = Self::resolve_entry_path(&path)?;
-
-        let file_content = fs::read_to_string(&resolved_path).map_err(|e| {
-            format!(
-                "Failed to read the entrypoint file '{}': {}",
-                resolved_path, e
-            )
-        })?;
-
-        handle_content_lexing(file_content).map_err(|e| format!("Failed to lex the content: {}", e))
-    }
-
-    fn resolve_entry_path(path: &str) -> Result<String, String> {
-        let candidate = Path::new(path);
-
-        if candidate.is_dir() {
-            let index_path = candidate.join("index.deva");
-            if index_path.exists() {
-                Ok(index_path.to_string_lossy().replace("\\", "/"))
-            } else {
-                Err(format!(
-                    "Expected 'index.deva' in directory '{}', but it was not found",
-                    path
-                ))
-            }
-        } else if candidate.is_file() {
-            return Ok(path.to_string());
-        } else {
-            return Err(format!(
-                "Provided entrypoint '{}' is not a valid file or directory",
-                path
-            ));
-        }
-    }
-}