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

package/rust/core/audio/loader/trigger.rs

@@ -1,98 +1,98 @@
-use crate::core::parser::statement::StatementKind;
-use devalang_types::store::VariableTable;
-use devalang_types::{Duration, Value};
-
-pub fn load_trigger(
-    trigger: &Value,
-    duration: &Duration,
-    _effects: &Option<Value>,
-    base_duration: f32,
-    variable_table: VariableTable,
-) -> (String, f32) {
-    let mut trigger_path = String::new();
-    let mut duration_as_secs = 0.0;
-
-    match trigger {
-        Value::String(src) => {
-            trigger_path = src.to_string();
-        }
-        Value::Identifier(src) => {
-            trigger_path = src.to_string();
-        }
-
-        Value::Map(map) => {
-            if let Some(Value::String(src)) = map.get("entity") {
-                trigger_path = format!("devalang://bank/{}", src);
-            } else if let Some(Value::Identifier(src)) = map.get("entity") {
-                trigger_path = format!("devalang://bank/{}", src);
-            } else {
-                eprintln!(
-                    "❌ Trigger map must contain an 'entity' key with a string or identifier value."
-                );
-            }
-        }
-        Value::Sample(src) => {
-            trigger_path = src.to_string();
-        }
-        Value::Statement(stmt) => {
-            if let StatementKind::Trigger {
-                entity,
-                duration: _,
-                effects: _,
-            } = &stmt.kind
-            {
-                trigger_path = entity.clone();
-            } else {
-                eprintln!(
-                    "❌ Trigger statement must be of type 'Trigger', found: {:?}",
-                    stmt.kind
-                );
-            }
-        }
-        _ => {
-            eprintln!(
-                "❌ Invalid trigger type. Expected a string or identifier variable, found: {:?}",
-                trigger
-            );
-        }
-    }
-
-    match duration {
-        Duration::Identifier(duration_identifier) => {
-            if duration_identifier == "auto" {
-                duration_as_secs = base_duration;
-            } else if let Some(Value::Number(num)) = variable_table.get(duration_identifier) {
-                duration_as_secs = *num;
-            } else if let Some(Value::String(num_str)) = variable_table.get(duration_identifier) {
-                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
-            } else if let Some(Value::Identifier(num_str)) = variable_table.get(duration_identifier)
-            {
-                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
-            } else {
-                eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
-            }
-        }
-
-        Duration::Number(num) => {
-            duration_as_secs = *num;
-        }
-
-        Duration::Auto => {
-            duration_as_secs = base_duration;
-        }
-
-        Duration::Beat(beat_str) => {
-            let parts: Vec<&str> = beat_str.split('/').collect();
-
-            if parts.len() == 2 {
-                let numerator: f32 = parts[0].parse().unwrap_or(1.0);
-                let denominator: f32 = parts[1].parse().unwrap_or(1.0);
-                duration_as_secs = (numerator / denominator) * base_duration;
-            } else {
-                eprintln!("❌ Invalid beat duration format: {}", beat_str);
-            }
-        }
-    }
-
-    (trigger_path, duration_as_secs)
-}
+use crate::core::parser::statement::StatementKind;
+use devalang_types::store::VariableTable;
+use devalang_types::{Duration, Value};
+
+pub fn load_trigger(
+    trigger: &Value,
+    duration: &Duration,
+    _effects: &Option<Value>,
+    base_duration: f32,
+    variable_table: VariableTable,
+) -> (String, f32) {
+    let mut trigger_path = String::new();
+    let mut duration_as_secs = 0.0;
+
+    match trigger {
+        Value::String(src) => {
+            trigger_path = src.to_string();
+        }
+        Value::Identifier(src) => {
+            trigger_path = src.to_string();
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::String(src)) = map.get("entity") {
+                trigger_path = format!("devalang://bank/{}", src);
+            } else if let Some(Value::Identifier(src)) = map.get("entity") {
+                trigger_path = format!("devalang://bank/{}", src);
+            } else {
+                eprintln!(
+                    "❌ Trigger map must contain an 'entity' key with a string or identifier value."
+                );
+            }
+        }
+        Value::Sample(src) => {
+            trigger_path = src.to_string();
+        }
+        Value::Statement(stmt) => {
+            if let StatementKind::Trigger {
+                entity,
+                duration: _,
+                effects: _,
+            } = &stmt.kind
+            {
+                trigger_path = entity.clone();
+            } else {
+                eprintln!(
+                    "❌ Trigger statement must be of type 'Trigger', found: {:?}",
+                    stmt.kind
+                );
+            }
+        }
+        _ => {
+            eprintln!(
+                "❌ Invalid trigger type. Expected a string or identifier variable, found: {:?}",
+                trigger
+            );
+        }
+    }
+
+    match duration {
+        Duration::Identifier(duration_identifier) => {
+            if duration_identifier == "auto" {
+                duration_as_secs = base_duration;
+            } else if let Some(Value::Number(num)) = variable_table.get(duration_identifier) {
+                duration_as_secs = *num;
+            } else if let Some(Value::String(num_str)) = variable_table.get(duration_identifier) {
+                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
+            } else if let Some(Value::Identifier(num_str)) = variable_table.get(duration_identifier)
+            {
+                duration_as_secs = num_str.parse::<f32>().unwrap_or(base_duration);
+            } else {
+                eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
+            }
+        }
+
+        Duration::Number(num) => {
+            duration_as_secs = *num;
+        }
+
+        Duration::Auto => {
+            duration_as_secs = base_duration;
+        }
+
+        Duration::Beat(beat_str) => {
+            let parts: Vec<&str> = beat_str.split('/').collect();
+
+            if parts.len() == 2 {
+                let numerator: f32 = parts[0].parse().unwrap_or(1.0);
+                let denominator: f32 = parts[1].parse().unwrap_or(1.0);
+                duration_as_secs = (numerator / denominator) * base_duration;
+            } else {
+                eprintln!("❌ Invalid beat duration format: {}", beat_str);
+            }
+        }
+    }
+
+    (trigger_path, duration_as_secs)
+}

package/rust/core/audio/player.rs

@@ -1,70 +1,70 @@
-use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
-use std::{fs::File, io::BufReader};
-
-pub struct AudioPlayer {
-    _stream: OutputStream,
-    handle: OutputStreamHandle,
-    sink: Sink,
-    last_path: Option<String>,
-}
-
-impl Default for AudioPlayer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl AudioPlayer {
-    pub fn new() -> Self {
-        let (stream, handle) = OutputStream::try_default().unwrap();
-        let sink = Sink::try_new(&handle).unwrap();
-
-        Self {
-            _stream: stream,
-            handle,
-            sink,
-            last_path: None,
-        }
-    }
-
-    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
-        if let Ok(file) = File::open(path) {
-            let reader = BufReader::new(file);
-            match Decoder::new(reader) {
-                Ok(decoder) => Some(decoder.convert_samples()),
-                Err(e) => {
-                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
-                    None
-                }
-            }
-        } else {
-            eprintln!("❌ Could not open audio file: {}", path);
-            None
-        }
-    }
-
-    pub fn play_file_once(&mut self, path: &str) {
-        self.sink.stop();
-        self.sink = Sink::try_new(&self.handle).unwrap();
-        self.sink.set_volume(1.0);
-
-        if let Some(source) = self.load_source(path) {
-            self.sink.append(source);
-            self.last_path = Some(path.to_string());
-        } else {
-            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
-        }
-    }
-
-    pub fn replay_last(&mut self) {
-        if let Some(path) = self.last_path.clone() {
-            self.play_file_once(&path);
-        } else {
-            eprintln!("⚠️ No previous audio to replay.");
-        }
-    }
-
-    pub fn wait_until_end(&self) {
-        self.sink.sleep_until_end();
-    }
-}
+use rodio::{Decoder, OutputStream, OutputStreamHandle, Sink, Source};
+use std::{fs::File, io::BufReader};
+
+pub struct AudioPlayer {
+    _stream: OutputStream,
+    handle: OutputStreamHandle,
+    sink: Sink,
+    last_path: Option<String>,
+}
+
+impl Default for AudioPlayer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AudioPlayer {
+    pub fn new() -> Self {
+        let (stream, handle) = OutputStream::try_default().unwrap();
+        let sink = Sink::try_new(&handle).unwrap();
+
+        Self {
+            _stream: stream,
+            handle,
+            sink,
+            last_path: None,
+        }
+    }
+
+    fn load_source(&self, path: &str) -> Option<impl Source<Item = f32> + Send + 'static> {
+        if let Ok(file) = File::open(path) {
+            let reader = BufReader::new(file);
+            match Decoder::new(reader) {
+                Ok(decoder) => Some(decoder.convert_samples()),
+                Err(e) => {
+                    eprintln!("❌ Failed to decode audio file '{}': {}", path, e);
+                    None
+                }
+            }
+        } else {
+            eprintln!("❌ Could not open audio file: {}", path);
+            None
+        }
+    }
+
+    pub fn play_file_once(&mut self, path: &str) {
+        self.sink.stop();
+        self.sink = Sink::try_new(&self.handle).unwrap();
+        self.sink.set_volume(1.0);
+
+        if let Some(source) = self.load_source(path) {
+            self.sink.append(source);
+            self.last_path = Some(path.to_string());
+        } else {
+            eprintln!("⚠️ Skipping playback: failed to load '{}'", path);
+        }
+    }
+
+    pub fn replay_last(&mut self) {
+        if let Some(path) = self.last_path.clone() {
+            self.play_file_once(&path);
+        } else {
+            eprintln!("⚠️ No previous audio to replay.");
+        }
+    }
+
+    pub fn wait_until_end(&self) {
+        self.sink.sleep_until_end();
+    }
+}

package/rust/core/audio/special/mod.rs

@@ -1,9 +1,9 @@
-pub mod easing;
-pub mod env;
-pub mod math;
-pub mod modulator;
-
-pub use easing::find_and_eval_first_easing_call;
-pub use env::resolve_env_atom;
-pub use math::find_and_eval_first_math_call;
-pub use modulator::find_and_eval_first_mod_call;
+pub mod easing;
+pub mod env;
+pub mod math;
+pub mod modulator;
+
+pub use easing::find_and_eval_first_easing_call;
+pub use env::resolve_env_atom;
+pub use math::find_and_eval_first_math_call;
+pub use modulator::find_and_eval_first_mod_call;

package/rust/core/builder/mod.rs

@@ -1,129 +1,129 @@
-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,
-                    );
-                }
-            }
-        }
-    }
-}
+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 +1,27 @@
-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);
-}
+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);
+}