@devaloop/devalang 0.0.1-alpha.10 → 0.0.1-alpha.12

package/rust/config/loader.rs

@@ -1,5 +1,6 @@
 use std::{ fs, path::Path };
-use crate::config::Config;
+use std::collections::HashMap;
+use crate::config::driver::{ BankEntry, Config };
 
 pub fn load_config(path: Option<&Path>) -> Option<Config> {
     let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
@@ -11,3 +12,99 @@ pub fn load_config(path: Option<&Path>) -> Option<Config> {
         None
     }
 }
+
+pub fn update_bank_version_in_config(config: &mut Config, dependency: &str, new_version: &str) {
+    // Si le vecteur banks n'existe pas, on ne fait rien
+    if config.banks.is_none() {
+        println!("No banks configured.");
+        return;
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    if let Some(bank) = banks.iter_mut().find(|b| b.path.contains(dependency)) {
+        bank.version = Some(new_version.to_string());
+
+        if let Err(e) = config.write(config) {
+            eprintln!("❌ Failed to write config: {}", e);
+        } else {
+            println!("✅ Bank '{}' updated to version '{}'", dependency, new_version);
+        }
+    } else {
+        println!("Bank '{}' not found in config", dependency);
+    }
+}
+
+pub fn remove_bank_from_config(config: &mut Config, dependency: &str) {
+    if config.banks.is_none() {
+        println!("No banks configured.");
+        return;
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    if let Some(index) = banks.iter().position(|b| b.path.contains(dependency)) {
+        banks.remove(index);
+
+        if let Err(e) = config.write(config) {
+            eprintln!("❌ Failed to write config: {}", e);
+        } else {
+            println!("✅ Bank '{}' removed from config", dependency);
+        }
+    } else {
+        println!("Bank '{}' not found in config", dependency);
+    }
+}
+
+pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
+    if config.banks.is_none() {
+        config.banks = Some(Vec::new());
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    let exists = banks.iter().any(|b| b.path == dependency);
+    if exists {
+        println!("Bank '{}' already in config", dependency);
+        return;
+    }
+
+    let metadata_path = Path::new(real_path).join("bank.toml");
+
+    if !metadata_path.exists() {
+        eprintln!("❌ Bank metadata file '{}' does not exist", metadata_path.display());
+        return;
+    }
+
+    let metadata_content = fs
+        ::read_to_string(&metadata_path)
+        .expect("Failed to read bank metadata file");
+
+    let metadata: HashMap<String, String> = toml
+        ::from_str(&metadata_content)
+        .expect("Failed to parse bank metadata file");
+
+    let bank_to_insert = BankEntry {
+        path: dependency.to_string(),
+        version: Some(
+            metadata
+                .get("version")
+                .cloned()
+                .unwrap_or_else(|| "0.0.1".to_string())
+        ),
+        author: Some(
+            metadata
+                .get("author")
+                .cloned()
+                .unwrap_or_else(|| "unknown".to_string())
+        ),
+    };
+
+    banks.push(bank_to_insert);
+
+    if let Err(e) = config.write(config) {
+        eprintln!("❌ Failed to write config: {}", e);
+    } else {
+        println!("✅ Bank '{}' added to config", dependency);
+    }
+}

package/rust/config/mod.rs

@@ -1,16 +1,2 @@
 pub mod loader;
-
-use serde::Deserialize;
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct Config {
-    pub defaults: ConfigDefaults,
-}
-
-#[derive(Debug, Deserialize, Clone)]
-pub struct ConfigDefaults {
-    pub entry: Option<String>,
-    pub output: Option<String>,
-    pub watch: Option<bool>,
-    pub repeat: Option<bool>,
-}
+pub mod driver;

package/rust/core/audio/engine.rs

@@ -1,8 +1,9 @@
-use std::{ collections::HashMap, fs::File, io::BufReader };
+use std::{ collections::HashMap, fs::File, io::BufReader, path::Path };
 use hound::{ SampleFormat, WavSpec, WavWriter };
 use rodio::{ Decoder, Source };
 
 use crate::core::{
+    shared::value::Value,
     store::variable::VariableTable,
     utils::path::{ normalize_path, resolve_relative_path },
 };
@@ -167,11 +168,56 @@ impl AudioEngine {
         filepath: &str,
         time_secs: f32,
         dur_sec: f32,
-        effects: Option<HashMap<String, f32>>
+        effects: Option<HashMap<String, Value>>
     ) {
-        let resolved = resolve_relative_path(&self.module_name.clone(), filepath);
+        if filepath.is_empty() {
+            eprintln!("❌ Empty file path provided for audio sample.");
+            return;
+        }
+
+        let mut resolved_path = String::new();
+
+        if filepath.starts_with("devalang://") {
+            let root = Path::new(env!("CARGO_MANIFEST_DIR"));
+            let parts = filepath.split("devalang://").collect::<Vec<&str>>();
+            let object_parts = parts.get(1).unwrap_or(&"").split("/").collect::<Vec<&str>>();
+            let object_type = object_parts.get(0).unwrap_or(&"").to_lowercase();
+            let object_dir = object_parts.get(1).unwrap_or(&"").to_string();
+            let object_name = object_parts.get(2).unwrap_or(&"").to_string();
+
+            if object_type.contains("bank") {
+                resolved_path = root
+                    .join(".deva")
+                    .join("bank")
+                    .join(object_dir)
+                    .join(format!("{}.wav", object_name))
+                    .to_str()
+                    .unwrap_or("")
+                    .to_string();
+            } else {
+                eprintln!("❌ Unsupported devalang:// object type: {}", object_type);
+                return;
+            }
+        } else {
+            let module_path = &self.module_name;
+            let root = Path::new(module_path).parent();
+
+            if let Some(root_path) = root {
+                resolved_path = root_path.join(filepath).to_str().unwrap_or("").to_string();
+            } else {
+                eprintln!("❌ Could not resolve root path for module: {}", module_path);
+                return;
+            }
+        }
+
+        if !Path::new(&resolved_path).exists() {
+            eprintln!("❌ Audio file not found at: {}", resolved_path);
+            return;
+        }
 
-        let file = BufReader::new(File::open(resolved).expect("Failed to open audio file"));
+        let file = BufReader::new(
+            File::open(&resolved_path).expect(&format!("Failed to open audio file {}", filepath))
+        );
         let decoder = Decoder::new(file).expect("Failed to decode audio file");
 
         // Mono or stereo reading possible here, we will duplicate in L/R
@@ -183,7 +229,7 @@ impl AudioEngine {
             return;
         }
 
-        // TODO Apply effects here if needed
+        // Pad the buffer to ensure it can accommodate the new samples
         let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
         let required_len = offset + samples.len() * (CHANNELS as usize);
         let padded_required_len = if required_len % 2 == 1 {
@@ -193,21 +239,116 @@ impl AudioEngine {
         };
 
         self.buffer.resize(padded_required_len, 0);
-        self.pad_samples(&samples, time_secs);
+
+        // Apply effects
+        if let Some(effects_map) = effects {
+            self.pad_samples(&samples, time_secs, Some(effects_map));
+        } else {
+            self.pad_samples(&samples, time_secs, None);
+        }
     }
 
-    fn pad_samples(&mut self, samples: &[i16], time_secs: f32) {
+    fn pad_samples(
+        &mut self,
+        samples: &[i16],
+        time_secs: f32,
+        effects_map: Option<HashMap<String, Value>>
+    ) {
         let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
+        let total_samples = samples.len();
+
+        // Default values
+        let mut gain = 1.0;
+        let mut pan = 0.0;
+        let mut fade_in = 0.0;
+        let mut fade_out = 0.0;
+        let mut pitch = 1.0;
+        let mut drive = 0.0; 
+        let mut reverb = 0.0;
+
+        if let Some(map) = &effects_map {
+            for (key, val) in map {
+                match (key.as_str(), val) {
+                    ("gain", Value::Number(v)) => {
+                        gain = *v;
+                    }
+                    ("pan", Value::Number(v)) => {
+                        pan = *v;
+                    }
+                    ("fadeIn", Value::Number(v)) => {
+                        fade_in = *v;
+                    }
+                    ("fadeOut", Value::Number(v)) => {
+                        fade_out = *v;
+                    }
+                    ("pitch", Value::Number(v)) => {
+                        pitch = *v;
+                    }
+                    ("drive", Value::Number(v)) => {
+                        // Drive effect can be implemented here if needed
+                        drive = *v;
+                    }
+                    ("reverb", Value::Number(v)) => {
+                        reverb = *v;
+                    }
+                    _ => eprintln!("⚠️ Unknown or invalid effect '{}'", key),
+                }
+            }
+        }
+
+        let fade_in_samples = (fade_in * (SAMPLE_RATE as f32)) as usize;
+        let fade_out_samples = (fade_out * (SAMPLE_RATE as f32)) as usize;
 
         for (i, &sample) in samples.iter().enumerate() {
-            let adjusted_sample = ((sample as f32) * self.volume).round() as i16;
+            // Gain
+            let mut adjusted = (sample as f32) * gain;
+
+            // Fade in
+            if fade_in_samples > 0 && i < fade_in_samples {
+                adjusted *= (i as f32) / (fade_in_samples as f32);
+            }
+
+            // Fade out
+            if fade_out_samples > 0 && i >= total_samples.saturating_sub(fade_out_samples) {
+                adjusted *= ((total_samples - i) as f32) / (fade_out_samples as f32);
+            }
+
+            // Pitch adjustment
+            if pitch != 1.0 {
+                let pitch_adjusted_index = ((i as f32) / pitch) as usize;
+                if pitch_adjusted_index < total_samples {
+                    adjusted = (samples[pitch_adjusted_index] as f32) * gain;
+                } else {
+                    adjusted = 0.0; // Out of bounds, set to zero
+                }
+            }
+
+            // Drive effect
+            if drive > 0.0 {
+                adjusted = adjusted.tanh() * (1.0 + drive);
+            }
+
+            // Reverb effect
+            if reverb > 0.0 {
+                let reverb_delay = (reverb * (SAMPLE_RATE as f32)) as usize;
+                if i >= reverb_delay {
+                    adjusted += self.buffer[offset + i - reverb_delay] as f32 * 0.5; // Simple feedback
+                }
+            }
+
+            // Clamp
+            let adjusted_sample = adjusted.round().clamp(i16::MIN as f32, i16::MAX as f32) as i16;
+
+            // Pan (L/R split)
+            let left = ((adjusted_sample as f32) * (1.0 - pan.clamp(0.0, 1.0))) as i16;
+            let right = ((adjusted_sample as f32) * (1.0 + pan.clamp(-1.0, 0.0)).abs()) as i16;
 
             let left_pos = offset + i * 2;
             let right_pos = left_pos + 1;
 
             if right_pos < self.buffer.len() {
-                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(adjusted_sample); // gauche
-                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(adjusted_sample); // droite
+                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(left);
+                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(right);
             }
         }
     }

package/rust/core/audio/interpreter/arrow_call.rs

@@ -53,8 +53,8 @@ pub fn interprete_call_arrow_statement(
             return (*max_end_time, cursor_copy);
         };
 
-        let freq = extract_f32(params, "freq").unwrap_or(440.0);
-        let amp = extract_f32(params, "amp").unwrap_or(1.0);
+        let freq = extract_f32(params, "freq", base_bpm).unwrap_or(440.0);
+        let amp = extract_f32(params, "amp", base_bpm).unwrap_or(1.0);
 
         if method == "note" {
             let Some(Value::Identifier(note_name)) = args.get(0) else {
@@ -69,7 +69,9 @@ pub fn interprete_call_arrow_statement(
                 }
             }
 
-            let duration_ms = extract_f32(&final_note_params, "duration").unwrap_or(base_duration);
+            let duration_ms = extract_f32(&final_note_params, "duration", base_bpm).unwrap_or(
+                base_duration
+            );
             let duration_secs = duration_ms / 1000.0;
 
             let final_freq = note_to_freq(note_name);
@@ -101,10 +103,21 @@ pub fn interprete_call_arrow_statement(
     (*max_end_time, cursor_copy)
 }
 
-fn extract_f32(map: &HashMap<String, Value>, key: &str) -> Option<f32> {
+fn extract_f32(map: &HashMap<String, Value>, key: &str, base_bpm: f32) -> Option<f32> {
     map.get(key).and_then(|v| {
         match v {
             Value::Number(n) => Some(*n),
+            Value::Beat(beat_str) => {
+                let parts: Vec<&str> = beat_str.split('/').collect();
+                if parts.len() == 2 {
+                    let numerator = parts[0].parse::<f32>().ok()?;
+                    let denominator = parts[1].parse::<f32>().ok()?;
+
+                    Some((numerator / denominator) * ((60.0 / base_bpm) * 1000.0))
+                } else {
+                    None
+                }
+            }
             _ => None,
         }
     })

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

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::core::{
     audio::{ engine::AudioEngine, loader::trigger::load_trigger },
     parser::statement::{ Statement, StatementKind },
@@ -14,7 +16,7 @@ pub fn interprete_trigger_statement(
     max_end_time: f32
 ) -> Option<(f32, f32, AudioEngine)> {
     if let StatementKind::Trigger { entity, duration } = &stmt.kind {
-        if let Some(trigger_val) = variable_table.get(entity) {
+        if let Some(trigger_val) = resolve_namespaced_variable(entity, variable_table) {
             let duration_secs = match duration {
                 Duration::Number(n) => *n,
 
@@ -41,6 +43,20 @@ pub fn interprete_trigger_statement(
                     }
                 }
 
+                Duration::Beat(beat_str) => {
+                    // Assuming beat_str is in the format "numerator/denominator"
+                    let parts: Vec<&str> = beat_str.split('/').collect();
+
+                    if parts.len() != 2 {
+                        eprintln!("❌ Invalid beat duration format: {}", beat_str);
+                        return None;
+                    }
+
+                    let numerator: f32 = parts[0].parse().unwrap_or(1.0);
+                    let denominator: f32 = parts[1].parse().unwrap_or(1.0);
+                    numerator / denominator
+                }
+
                 Duration::Auto => 1.0,
             };
 
@@ -53,8 +69,13 @@ pub fn interprete_trigger_statement(
                 variable_table.clone()
             );
 
+            if let Some(effects) = extract_effects(stmt.value.clone()) {
+                audio_engine.insert_sample(&src, cursor_time, duration_final, Some(effects));
+            } else {
+                audio_engine.insert_sample(&src, cursor_time, duration_final, None);
+            }
+
             let mut updated_engine = audio_engine.clone();
-            updated_engine.insert_sample(&src, cursor_time, duration_final, None);
 
             let new_cursor_time = cursor_time + duration_final;
             let new_max_end_time = new_cursor_time.max(max_end_time);
@@ -67,3 +88,36 @@ pub fn interprete_trigger_statement(
 
     None
 }
+
+fn resolve_namespaced_variable<'a>(path: &str, variables: &'a VariableTable) -> Option<&'a Value> {
+    let mut current: Option<&Value> = None;
+
+    for (i, part) in path.split('.').enumerate() {
+        if i == 0 {
+            current = variables.get(part);
+        } else {
+            current = match current {
+                Some(Value::Map(map)) => map.get(part),
+                _ => {
+                    return None;
+                }
+            };
+        }
+    }
+
+    current
+}
+
+fn extract_effects(value: Value) -> Option<HashMap<String, Value>> {
+    if let Value::Map(map) = value.clone() {
+        let mut effects = HashMap::new();
+
+        for (key, val) in map {
+            effects.insert(key.clone(), val);
+        }
+
+        Some(effects)
+    } else {
+        None
+    }
+}

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

@@ -43,6 +43,18 @@ pub fn load_trigger(
             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);
+            }
+        }
+
         _ => {
             eprintln!("❌ Invalid duration type. Expected an identifier.");
         }

package/rust/core/lexer/handler/driver.rs

@@ -1,6 +1,6 @@
 use crate::core::lexer::{
     handler::{
-        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, string::handle_string_lexer
+        arrow::handle_arrow_lexer, at::handle_at_lexer, brace::{ handle_lbrace_lexer, handle_rbrace_lexer }, colon::handle_colon_lexer, comment::handle_comment_lexer, dot::handle_dot_lexer, identifier::handle_identifier_lexer, indent::handle_indent_lexer, newline::handle_newline_lexer, number::handle_number_lexer, operator::handle_operator_lexer, slash::handle_slash_lexer, string::handle_string_lexer
     },
     token::{ Token, TokenKind },
 };
@@ -101,6 +101,17 @@ pub fn handle_content_lexing(content: String) -> Result<Vec<Token>, String> {
                     &mut column
                 );
             }
+            '/' => {
+                handle_slash_lexer(
+                    ch,
+                    &mut chars,
+                    &mut current_indent,
+                    &mut indent_stack,
+                    &mut tokens,
+                    &mut line,
+                    &mut column
+                );
+            }
             '-' => {
                 handle_arrow_lexer(
                     ch,

package/rust/core/lexer/handler/mod.rs

@@ -12,3 +12,4 @@ pub mod number;
 pub mod indent;
 pub mod string;
 pub mod arrow;
+pub mod slash;

package/rust/core/lexer/handler/slash.rs

@@ -0,0 +1,21 @@
+use crate::core::lexer::token::{ Token, TokenKind };
+
+pub fn handle_slash_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    let mut slash = char.to_string();
+
+    tokens.push(Token {
+        kind: TokenKind::Slash,
+        lexeme: slash,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/token.rs

@@ -49,6 +49,7 @@ pub enum TokenKind {
     Comma,
     Equals,
     Dot,
+    Slash,
 
     // ───── Operators ─────
     DoubleEquals,

package/rust/core/parser/driver.rs

@@ -64,6 +64,10 @@ impl Parser {
         }
     }
 
+    pub fn peek_nth_kind(&self, n: usize) -> Option<TokenKind> {
+        self.peek_nth(n).map(|t| t.kind.clone())
+    }
+
     pub fn advance_if(&mut self, kind: TokenKind) -> bool {
         if self.match_token(kind) { true } else { false }
     }
@@ -172,6 +176,10 @@ impl Parser {
         self.peek().map_or(false, |t| t.kind == kind)
     }
 
+    pub fn peek_kind(&self) -> Option<TokenKind> {
+        self.peek().map(|t| t.kind.clone())
+    }
+
     pub fn parse_map_value(&mut self) -> Option<Value> {
         if !self.match_token(TokenKind::LBrace) {
             return None;
@@ -198,9 +206,35 @@ impl Parser {
                         Value::String(token.lexeme.clone())
                     }
                     TokenKind::Number => {
-                        self.advance();
-                        Value::Number(token.lexeme.parse().unwrap_or(0.0))
+                        let mut number_str = token.lexeme.clone();
+                        self.advance(); // consume the first number
+
+                        if let Some(dot_token) = self.peek_clone() {
+                            if dot_token.kind == TokenKind::Dot {
+                                self.advance(); // consume the dot
+
+                                if let Some(decimal_token) = self.peek_clone() {
+                                    if decimal_token.kind == TokenKind::Number {
+                                        self.advance(); // consume the number after the dot
+                                        number_str.push('.');
+                                        number_str.push_str(&decimal_token.lexeme);
+                                    } else {
+                                        println!(
+                                            "Expected number after dot, got {:?}",
+                                            decimal_token
+                                        );
+                                        return Some(Value::Null);
+                                    }
+                                } else {
+                                    println!("Expected number after dot, but reached EOF");
+                                    return Some(Value::Null);
+                                }
+                            }
+                        }
+
+                        Value::Number(number_str.parse::<f32>().unwrap_or(0.0))
                     }
+
                     TokenKind::Identifier => {
                         self.advance();
                         Value::Identifier(token.lexeme.clone())

package/rust/core/parser/handler/arrow_call.rs

@@ -89,14 +89,39 @@ pub fn parse_arrow_call(parser: &mut Parser, global_store: &mut GlobalStore) ->
                                     TokenKind::Identifier =>
                                         Value::Identifier(value_token.lexeme.clone()),
                                     TokenKind::String => Value::String(value_token.lexeme.clone()),
-                                    TokenKind::Number =>
-                                        Value::Number(
-                                            value_token.lexeme.parse::<f32>().unwrap_or(0.0)
-                                        ),
+                                    TokenKind::Number => {
+                                        if let Some(TokenKind::Slash) = parser.peek_kind() {
+                                            parser.advance(); // consume slash
+                                            if let Some(denominator_token) = parser.peek_clone() {
+                                                if denominator_token.kind == TokenKind::Number {
+                                                    parser.advance(); // consume denominator
+                                                    let denominator =
+                                                        denominator_token.lexeme.clone();
+                                                    Value::Beat(
+                                                        format!(
+                                                            "{}/{}",
+                                                            value_token.lexeme,
+                                                            denominator
+                                                        )
+                                                    )
+                                                } else {
+                                                    Value::Unknown
+                                                }
+                                            } else {
+                                                Value::Unknown
+                                            }
+                                        } else {
+                                            // Regular number without slash
+                                            Value::Number(
+                                                value_token.lexeme.parse::<f32>().unwrap_or(0.0)
+                                            )
+                                        }
+                                    }
                                     TokenKind::Boolean =>
                                         Value::Boolean(
                                             value_token.lexeme.parse::<bool>().unwrap_or(false)
                                         ),
+
                                     _ => Value::Unknown,
                                 };
                                 map.insert(key, value);