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

package/rust/core/builder/mod.rs

@@ -1,86 +1,129 @@
-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,
-                    );
-                }
-            }
-        }
-    }
-}
+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/{module.rs → logs.rs}

@@ -1,55 +1,52 @@
-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);
-}
+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 +1,30 @@
-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");
-    }
-}
+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/store.rs

@@ -1,40 +1,38 @@
-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);
-}
+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);
+}