@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

package/rust/core/builder/mod.rs

@@ -1,80 +1,86 @@
-use crate::core::audio::renderer::render_audio_with_modules;
-use crate::core::parser::statement::Statement;
-use crate::core::store::global::GlobalStore;
-use std::{ collections::HashMap, fs::create_dir_all };
-use std::io::Write;
-
-use crate::utils::logger::Logger;
-
-pub struct Builder {}
-
-impl Builder {
-    pub fn new() -> Self {
-        Builder {}
-    }
-
-    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>, out_dir: &str) {
-        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 = 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
-    ) {
-        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('/')
-                .last()
-                .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) {
-                Ok(_) => {}
-                Err(msg) => {
-                    logger.log_error_with_stacktrace(
-                        &format!(
-                            "Unable to generate WAV file for module '{}': {}",
-                            formatted_module_name,
-                            msg
-                        ),
-                        &module_name
-                    );
-                }
-            }
-        }
-    }
-}
+use crate::core::audio::renderer::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,
+    ) {
+        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) {
+                Ok(_) => {}
+                Err(msg) => {
+                    logger.log_error_with_stacktrace(
+                        &format!(
+                            "Unable to generate WAV file for module '{}': {}",
+                            formatted_module_name, msg
+                        ),
+                        &module_name,
+                    );
+                }
+            }
+        }
+    }
+}

package/rust/core/debugger/lexer.rs

@@ -1,27 +1,27 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, lexer::token::Token };
-
-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_str("\n");
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+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/mod.rs

@@ -1,21 +1,30 @@
-pub mod preprocessor;
-pub mod lexer;
-pub mod store;
-
-use std::io::Write;
-
-pub struct Debugger {}
-
-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");
-    }
-}
+pub mod lexer;
+pub mod module;
+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/module.rs

@@ -0,0 +1,55 @@
+use crate::core::{
+    debugger::Debugger,
+    store::{function::FunctionTable, variable::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 = 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 = 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/preprocessor.rs

@@ -1,27 +1,27 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, parser::statement::Statement };
-
-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_str("\n");
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+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,25 +1,40 @@
-use std::{ collections::HashMap, fs::create_dir_all };
-use crate::core::{ debugger::Debugger, preprocessor::module::Module };
-
-pub fn write_store_log_file(output_dir: &str, file_name: &str, modules: HashMap<String, Module>) {
-    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, module) in modules {
-        content.push_str(&format!("--- Module: {} ---\n", path));
-
-        for (index, var_value) in module.variable_table.variables.iter().enumerate() {
-            let var_name = var_value.0.clone();
-            let var_data = var_value.1;
-
-            content.push_str(&format!("{}: {:?} = {:?}\n", index + 1, var_name, var_data));
-        }
-
-        content.push_str("\n");
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::{
+    debugger::Debugger,
+    store::{function::FunctionTable, variable::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);
+}