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

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,4 +1,4 @@
-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 };
 
@@ -169,9 +169,37 @@ impl AudioEngine {
         dur_sec: f32,
         effects: Option<HashMap<String, f32>>
     ) {
-        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;
+            }
+        }
 
-        let file = BufReader::new(File::open(resolved).expect("Failed to open audio file"));
+        let file = BufReader::new(File::open(resolved_path).expect("Failed to open audio file"));
         let decoder = Decoder::new(file).expect("Failed to decode audio file");
 
         // Mono or stereo reading possible here, we will duplicate in L/R

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

@@ -14,7 +14,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 +41,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,
             };
 
@@ -67,3 +81,22 @@ 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
+}

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;

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);

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

@@ -6,14 +6,55 @@ use crate::core::{
 };
 
 pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
-    parser.advance(); // consume the dot token
+    parser.advance(); // consume the first dot
 
     let Some(dot_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
 
-    // .kick
-    let Some(entity_token) = parser.peek_clone() else {
+    // Parse namespaced identifier: .808.kick.snare
+    let mut parts = Vec::new();
+
+    loop {
+        let Some(token) = parser.peek_clone() else {
+            break;
+        };
+
+        match token.kind {
+            // Stop if we encounter a likely duration keyword
+            TokenKind::Number => {
+                // If there's a slash after the number, it's probably a fraction (1/4)
+                if let Some(TokenKind::Slash) = parser.peek_nth_kind(1) {
+                    break;
+                }
+
+                parts.push(token.lexeme.clone());
+                parser.advance();
+            }
+
+            TokenKind::Identifier => {
+                // Stop if it's the duration keyword "auto"
+                if token.lexeme == "auto" {
+                    break;
+                }
+
+                parts.push(token.lexeme.clone());
+                parser.advance();
+            }
+
+            TokenKind::Dot => {
+                parser.advance(); // consume dot
+            }
+
+            _ => {
+                break;
+            }
+        }
+    }
+
+    let entity = parts.join(".");
+
+    if entity.is_empty() {
         return Statement {
             kind: StatementKind::Trigger {
                 entity: String::new(),
@@ -24,68 +65,93 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
             line: dot_token.line,
             column: dot_token.column,
         };
-    };
-
-    parser.advance(); // consume entity
-    let entity = entity_token.lexeme.clone();
+    }
 
     // Check if there's a duration
     let next = parser.peek_clone();
 
     let (duration, value) = match next {
-        // If no more tokens, it's just `.kick`
         None => (Duration::Auto, Value::Null),
 
         Some(token) =>
             match token.kind {
-                TokenKind::Newline | TokenKind::EOF => { (Duration::Auto, Value::Null) }
+                TokenKind::Newline | TokenKind::EOF => (Duration::Auto, Value::Null),
 
                 TokenKind::Number => {
-                    let duration_lexeme = token.lexeme.clone();
-                    parser.advance(); // consume duration
+                    let numerator = token.lexeme.clone();
+                    parser.advance(); // consume numerator
+
+                    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 {
+                                let denominator = denominator_token.lexeme.clone();
+                                parser.advance(); // consume denominator
+
+                                let beat_str = format!("{}/{}", numerator, denominator);
+                                let beat_duration = Duration::Beat(beat_str);
+
+                                let val = match parser.peek_clone() {
+                                    Some(param_token) if
+                                        param_token.kind == TokenKind::Identifier
+                                    => {
+                                        parser.advance();
+                                        Value::Identifier(param_token.lexeme.clone())
+                                    }
+                                    Some(param_token) if param_token.kind == TokenKind::LBrace => {
+                                        parser.parse_map_value().unwrap_or(Value::Null)
+                                    }
+                                    _ => Value::Null,
+                                };
+
+                                return Statement {
+                                    kind: StatementKind::Trigger {
+                                        entity,
+                                        duration: beat_duration,
+                                    },
+                                    value: val,
+                                    indent: dot_token.indent,
+                                    line: dot_token.line,
+                                    column: dot_token.column,
+                                };
+                            }
+                        }
+                    }
 
-                    // Try to parse optional value (ex: .kick 250 params)
-                    match parser.peek_clone() {
+                    // fallback: simple numeric duration
+                    let duration = parse_duration(numerator);
+
+                    let val = match parser.peek_clone() {
                         Some(param_token) if param_token.kind == TokenKind::Identifier => {
                             parser.advance();
-                            (
-                                parse_duration(duration_lexeme),
-                                Value::Identifier(param_token.lexeme.clone()),
-                            )
+                            Value::Identifier(param_token.lexeme.clone())
                         }
-
                         Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            // Handle value as Map
-                            let map = parser.parse_map_value(); // Assumes you have a helper for map
-                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                            parser.parse_map_value().unwrap_or(Value::Null)
                         }
+                        _ => Value::Null,
+                    };
 
-                        _ => (parse_duration(duration_lexeme), Value::Null),
-                    }
+                    (duration, val)
                 }
 
                 TokenKind::Identifier => {
                     let duration_lexeme = token.lexeme.clone();
                     parser.advance(); // consume duration
 
-                    // Try to parse optional value (ex: .kick auto params)
-                    match parser.peek_clone() {
+                    let val = match parser.peek_clone() {
                         Some(param_token) if param_token.kind == TokenKind::Identifier => {
                             parser.advance();
-                            (
-                                parse_duration(duration_lexeme),
-                                Value::Identifier(param_token.lexeme.clone()),
-                            )
+                            Value::Identifier(param_token.lexeme.clone())
                         }
-
                         Some(param_token) if param_token.kind == TokenKind::LBrace => {
-                            // Handle value as Map
-                            let map = parser.parse_map_value(); // Assumes you have a helper for map
-                            (parse_duration(duration_lexeme), map.unwrap_or(Value::Null))
+                            parser.parse_map_value().unwrap_or(Value::Null)
                         }
+                        _ => Value::Null,
+                    };
 
-                        _ => (parse_duration(duration_lexeme), Value::Null),
-                    }
+                    (parse_duration(duration_lexeme), val)
                 }
 
                 _ => (Duration::Auto, Value::Null),
@@ -104,8 +170,8 @@ pub fn parse_dot_token(parser: &mut Parser, _global_store: &mut GlobalStore) ->
 fn parse_duration(s: String) -> Duration {
     if s == "auto" {
         Duration::Auto
-    } else if s.parse::<f32>().is_ok() {
-        Duration::Number(s.parse().unwrap())
+    } else if let Ok(num) = s.parse::<f32>() {
+        Duration::Number(num)
     } else {
         Duration::Identifier(s)
     }