@devaloop/devalang 0.0.1-alpha.3 → 0.0.1-alpha.4

package/rust/core/preprocessor/resolver/bank.rs

@@ -0,0 +1,46 @@
+use crate::{core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::module::Module,
+    shared::value::Value,
+    store::global::GlobalStore,
+}, utils::logger::Logger};
+
+pub fn resolve_bank(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    _global_store: &GlobalStore
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
+            } else {
+                let message = format!("Bank identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message: message.clone(),
+                };
+                new_stmt.value = Value::Null;
+            }
+        }
+
+        Value::String(_) => {
+            // Pas de résolution nécessaire
+        }
+
+        other => {
+            let message = format!("Expected a string or identifier for bank, found {:?}", other);
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a string or identifier for bank".to_string(),
+            };
+            new_stmt.value = Value::Null;
+        }
+    }
+
+    new_stmt
+}

package/rust/core/preprocessor/resolver/loop_.rs

@@ -0,0 +1,143 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::trigger::resolve_trigger },
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_loop(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    // Vérifie que stmt.value est bien une Map
+    if let Value::Map(value_map) = &stmt.value {
+        // Résolution de l'iterator
+        let iterator_value = match value_map.get("iterator") {
+            Some(Value::Identifier(ident)) => {
+                match module.variable_table.get(ident) {
+                    Some(Value::Number(n)) => Value::Number(*n),
+                    Some(_) => {
+                        log_type_error(
+                            &logger,
+                            module,
+                            stmt,
+                            format!("Loop iterator '{ident}' must resolve to a number")
+                        );
+                        Value::Null
+                    }
+                    None => {
+                        log_type_error(
+                            &logger,
+                            module,
+                            stmt,
+                            format!("Loop iterator '{ident}' not found")
+                        );
+                        Value::Null
+                    }
+                }
+            }
+            Some(Value::Number(n)) => Value::Number(*n),
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for loop iterator: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'iterator' key in loop statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        // Résolution du body
+        let body_value = match value_map.get("body") {
+            Some(Value::Block(block)) => {
+                let mut resolved_block = Vec::new();
+                for ref statement in block.clone() {
+                    match &statement.kind {
+                        StatementKind::Trigger { entity, duration } => {
+                            let resolved = resolve_trigger(
+                                &mut statement.clone(),
+                                &entity,
+                                &mut duration.clone(),
+                                module,
+                                path,
+                                global_store
+                            );
+                            resolved_block.push(resolved);
+                        }
+                        _ => {
+                            println!("Unhandled loop body statement: {:?}", statement);
+                        }
+                    }
+                }
+                Value::Block(resolved_block)
+            }
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for loop body: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'body' key in loop statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        // ✅ Reconstruit proprement la valeur résolue
+        let mut resolved_map = std::collections::HashMap::new();
+        resolved_map.insert("iterator".to_string(), iterator_value);
+        resolved_map.insert("body".to_string(), body_value);
+
+        // ✅ Reconstruit le StatementLoop à partir des éléments résolus
+        Statement {
+            kind: StatementKind::Loop,
+            value: Value::Map(resolved_map),
+            ..stmt.clone()
+        }
+    } else {
+        log_type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Expected a map for loop value, found {:?}", stmt.value)
+        );
+
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a map for loop value".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    }
+}
+
+fn log_type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+}

package/rust/core/preprocessor/resolver/mod.rs

@@ -0,0 +1,152 @@
+pub mod trigger;
+pub mod loop_;
+pub mod bank;
+pub mod tempo;
+
+use std::collections::HashMap;
+use crate::{
+    core::{
+        parser::statement::{ self, Statement, StatementKind },
+        preprocessor::{
+            loader::ModuleLoader,
+            resolver::{
+                bank::resolve_bank,
+                loop_::resolve_loop,
+                tempo::resolve_tempo,
+                trigger::resolve_trigger,
+            },
+        },
+        shared::{ duration::Duration, value::Value },
+        store::global::GlobalStore,
+        utils::validation::{ is_valid_entity, is_valid_identifier },
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_all_modules(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for module in global_store.clone().modules.values_mut() {
+        resolve_imports(module_loader, global_store);
+    }
+}
+
+pub fn resolve_imports(module_loader: &ModuleLoader, global_store: &mut GlobalStore) {
+    for (module_path, module) in global_store.clone().modules.iter_mut() {
+        for (name, source_path) in &module.import_table.imports {
+            match source_path {
+                Value::String(source_path) => {
+                    if let Some(source_module) = global_store.modules.get(source_path) {
+                        if let Some(value) = source_module.export_table.get_export(name) {
+                            module.variable_table.set(name.clone(), value.clone());
+                        } else {
+                            println!(
+                                "[warn] '{module_path}': '{name}' not found in exports of '{source_path}'"
+                            );
+                        }
+                    } else {
+                        println!(
+                            "[warn] '{module_path}': cannot find source module '{source_path}'"
+                        );
+                    }
+                }
+                _ => {
+                    println!(
+                        "[warn] '{module_path}': expected string for import source, found {:?}",
+                        source_path
+                    );
+                }
+            }
+        }
+    }
+}
+
+pub fn resolve_and_flatten_all_modules(
+    global_store: &mut GlobalStore
+) -> HashMap<String, Vec<Statement>> {
+    let logger = Logger::new();
+    let snapshot = global_store.clone(); // pour éviter les emprunts mutables
+
+    // 1. Résolution des imports
+    for (module_path, module) in global_store.modules.iter_mut() {
+        for (name, source_path) in &module.import_table.imports {
+            if let Value::String(source_path_str) = source_path {
+                match snapshot.modules.get(source_path_str) {
+                    Some(source_module) => {
+                        if let Some(value) = source_module.export_table.get_export(name) {
+                            module.variable_table.set(name.clone(), value.clone());
+                        } else {
+                            logger.log_error_with_stacktrace(
+                                &format!("'{name}' not found in exports of '{source_path_str}'"),
+                                module_path
+                            );
+                        }
+                    }
+                    None => {
+                        logger.log_error_with_stacktrace(
+                            &format!("Cannot find source module '{source_path_str}'"),
+                            module_path
+                        );
+                    }
+                }
+            } else {
+                logger.log_error_with_stacktrace(
+                    &format!("Expected string for import source, found {:?}", source_path),
+                    module_path
+                );
+            }
+        }
+    }
+
+    // 2. Résolution des statements
+    let mut resolved_map = HashMap::new();
+    let store_snapshot = global_store.clone();
+
+    for (path, module) in &store_snapshot.modules {
+        let mut resolved = Vec::new();
+
+        for stmt in &module.statements {
+            let mut stmt = stmt.clone();
+
+            match &stmt.kind {
+                StatementKind::Trigger { entity, duration } => {
+                    let resolved_stmt = resolve_trigger(
+                        &stmt,
+                        entity.as_str(),
+                        &mut duration.clone(),
+                        &module,
+                        &path,
+                        &store_snapshot
+                    );
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Loop => {
+                    let resolved_stmt = resolve_loop(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Bank => {
+                    let resolved_stmt = resolve_bank(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Tempo => {
+                    let resolved_stmt = resolve_tempo(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
+                StatementKind::Import { .. } | StatementKind::Export { .. } => {
+                    // Rien à faire
+                    resolved.push(stmt.clone());
+                }
+
+                _ => {
+                    resolved.push(stmt);
+                }
+            }
+        }
+
+        resolved_map.insert(path.clone(), resolved);
+    }
+
+    resolved_map
+}

package/rust/core/preprocessor/resolver/tempo.rs

@@ -0,0 +1,49 @@
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::value::Value,
+        store::global::GlobalStore,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_tempo(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    _global_store: &GlobalStore
+) -> Statement {
+    let mut new_stmt = stmt.clone();
+    let logger = Logger::new();
+
+    match &stmt.value {
+        Value::Identifier(ident) => {
+            if let Some(val) = module.variable_table.get(ident) {
+                new_stmt.value = val.clone();
+            } else {
+                let message = format!("Tempo identifier '{ident}' not found in variable table");
+                logger.log_error_with_stacktrace(&message, &module.path);
+                new_stmt.kind = StatementKind::Error {
+                    message,
+                };
+                new_stmt.value = Value::Null;
+            }
+        }
+
+        Value::Number(_) => {
+            // Already resolved, no modification needed
+        }
+
+        other => {
+            let message = format!("Expected a number or identifier for tempo, found {:?}", other);
+            logger.log_error_with_stacktrace(&message, &module.path);
+            new_stmt.kind = StatementKind::Error {
+                message: "Expected a number or identifier for tempo".to_string(),
+            };
+            new_stmt.value = Value::Null;
+        }
+    }
+
+    new_stmt
+}

package/rust/core/preprocessor/resolver/trigger.rs

@@ -0,0 +1,114 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::module::Module,
+        shared::{ duration::Duration, value::Value },
+        store::global::GlobalStore,
+        utils::validation::is_valid_entity,
+    },
+    utils::logger::Logger,
+};
+
+pub fn resolve_trigger(
+    stmt: &Statement,
+    entity: &str,
+    duration: &mut Duration,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    let mut final_duration = duration.clone();
+    let mut final_value = stmt.value.clone();
+
+    if !is_valid_entity(entity, module, global_store) {
+        let message = format!("Invalid entity '{}', expected a valid identifier", entity);
+        let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+        logger.log_error_with_stacktrace(&message, &stacktrace);
+
+        return Statement {
+            kind: stmt.kind.clone(),
+            value: Value::Null,
+            line: stmt.line,
+            column: stmt.column,
+            indent: stmt.indent,
+        };
+    }
+
+    // ✅ Résolution de duration si c'est un identifiant
+    if let Duration::Identifier(ident) = duration {
+        if let Some(val) = module.variable_table.get(ident) {
+            match val {
+                Value::Number(num) => {
+                    final_duration = Duration::Number(*num);
+                }
+                Value::String(s) => {
+                    final_duration = Duration::Identifier(s.clone());
+                }
+                Value::Identifier(id) if id == "auto" => {
+                    final_duration = Duration::Auto;
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // ✅ Résolution de value (params, effets)
+    final_value = match &stmt.value {
+        Value::Identifier(ident) => {
+            match module.variable_table.get(ident) {
+                Some(val) => val.clone(),
+                None => {
+                    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+                    let message = format!(
+                        "'{path}': value identifier '{ident}' not found in variable table"
+                    );
+                    logger.log_error_with_stacktrace(&message, &stacktrace);
+                    Value::Null
+                }
+            }
+        }
+        Value::Map(map) => {
+            let mut resolved_map = HashMap::new();
+            for (k, v) in map.iter() {
+                let resolved_v = match v {
+                    Value::Identifier(id) => {
+                        module.variable_table.get(id).cloned().unwrap_or(Value::Null)
+                    }
+                    other => other.clone(),
+                };
+                resolved_map.insert(k.clone(), resolved_v);
+            }
+            Value::Map(resolved_map)
+        }
+        other => other.clone(),
+    };
+
+    // ✅ On reconstruit le Statement avec Trigger résolu
+    if let StatementKind::Trigger { entity, .. } = &stmt.kind {
+        return Statement {
+            kind: StatementKind::Trigger {
+                entity: entity.to_string(),
+                duration: final_duration,
+            },
+            value: final_value,
+            line: stmt.line,
+            column: stmt.column,
+            indent: stmt.indent,
+        };
+    }
+
+    return Statement {
+        kind: StatementKind::Trigger {
+            entity: entity.to_string(),
+            duration: final_duration,
+        },
+        value: final_value,
+        line: stmt.line,
+        column: stmt.column,
+        indent: stmt.indent,
+    };
+}

package/rust/main.rs

@@ -2,6 +2,7 @@ pub mod core;
 pub mod cli;
 pub mod utils;
 pub mod config;
+pub mod audio;
 
 use std::io;
 use cli::{ Cli };
@@ -11,6 +12,7 @@ use crate::{
         build::handle_build_command,
         check::handle_check_command,
         init::handle_init_command,
+        play::handle_play_command,
         template::{ handle_template_info_command, handle_template_list_command },
         Commands,
         TemplateCommand,
@@ -51,6 +53,10 @@ fn main() -> io::Result<()> {
             handle_build_command(config, entry, output, watch);
         }
 
+        Commands::Play { entry, output, watch, repeat } => {
+            handle_play_command(config, entry, output, watch, repeat);
+        }
+
         _ => {}
     }
 

package/rust/utils/watcher.rs

@@ -1,6 +1,8 @@
 use notify::{ Watcher, RecursiveMode, Config, RecommendedWatcher };
 use std::sync::mpsc::channel;
 
+use std::time::{ Duration, Instant };
+
 pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
     where F: Fn() + Send + 'static
 {
@@ -9,13 +11,19 @@ pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
     let mut watcher: RecommendedWatcher = Watcher::new(tx, Config::default())?;
     watcher.watch(&entry.as_ref(), RecursiveMode::Recursive)?;
 
+    let mut last_trigger = Instant::now();
+
     loop {
         match rx.recv() {
             Ok(_) => {
-                callback();
+                let now = Instant::now();
+                if now.duration_since(last_trigger) > Duration::from_millis(200) {
+                    callback();
+                    last_trigger = now;
+                }
             }
             Err(e) => {
-                eprintln!("Channel error : {:?}", e);
+                eprintln!("Channel error: {:?}", e);
                 break;
             }
         }