@devaloop/devalang 0.0.1-alpha.5 → 0.0.1-alpha.7

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

@@ -0,0 +1,113 @@
+use std::collections::HashMap;
+
+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_group(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &GlobalStore
+) -> Statement {
+    let logger = Logger::new();
+
+    if let Value::Map(value_map) = &stmt.value {
+        let group_name = match value_map.get("identifier") {
+            Some(Value::String(name)) => name.clone(),
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Group name must be a string, found {:?}", other)
+                );
+                return stmt.clone();
+            }
+            None => {
+                log_type_error(&logger, module, stmt, "Group name is required".to_string());
+                return stmt.clone();
+            }
+        };
+
+        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 group body statement: {:?}", statement);
+                        }
+                    }
+                }
+                Value::Block(resolved_block)
+            }
+            Some(other) => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    format!("Unexpected value for group body: {:?}", other)
+                );
+                Value::Null
+            }
+            None => {
+                log_type_error(
+                    &logger,
+                    module,
+                    stmt,
+                    "Missing 'body' key in group statement map".to_string()
+                );
+                Value::Null
+            }
+        };
+
+        let mut resolved_map = HashMap::new();
+
+        resolved_map.insert("identifier".to_string(), Value::String(group_name));
+        resolved_map.insert("body".to_string(), body_value);
+
+        return Statement {
+            kind: StatementKind::Group,
+            value: Value::Map(resolved_map),
+            ..stmt.clone()
+        };
+    } else {
+        log_type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Expected Map for group statement, found {:?}", stmt.value)
+        );
+
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a map for group statement".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/loop_.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::{
     core::{
         parser::statement::{ Statement, StatementKind },
@@ -16,9 +18,7 @@ pub fn resolve_loop(
 ) -> 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) {
@@ -69,7 +69,6 @@ pub fn resolve_loop(
             }
         };
 
-        // Résolution du body
         let body_value = match value_map.get("body") {
             Some(Value::Block(block)) => {
                 let mut resolved_block = Vec::new();
@@ -113,12 +112,10 @@ pub fn resolve_loop(
             }
         };
 
-        // ✅ Reconstruit proprement la valeur résolue
-        let mut resolved_map = std::collections::HashMap::new();
+        let mut resolved_map = 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),

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

@@ -2,6 +2,7 @@ pub mod trigger;
 pub mod loop_;
 pub mod bank;
 pub mod tempo;
+pub mod group;
 
 use std::collections::HashMap;
 use crate::{
@@ -11,6 +12,7 @@ use crate::{
             loader::ModuleLoader,
             resolver::{
                 bank::resolve_bank,
+                group::resolve_group,
                 loop_::resolve_loop,
                 tempo::resolve_tempo,
                 trigger::resolve_trigger,
@@ -138,6 +140,11 @@ pub fn resolve_and_flatten_all_modules(
                     resolved.push(stmt.clone());
                 }
 
+                StatementKind::Group => {
+                    let resolved_stmt = resolve_group(&stmt, &module, &path, &store_snapshot);
+                    resolved.push(resolved_stmt);
+                }
+
                 _ => {
                     resolved.push(stmt);
                 }

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

@@ -38,7 +38,6 @@ pub fn resolve_trigger(
         };
     }
 
-    // ✅ 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 {
@@ -56,7 +55,6 @@ pub fn resolve_trigger(
         }
     }
 
-    // ✅ Résolution de value (params, effets)
     final_value = match &stmt.value {
         Value::Identifier(ident) => {
             match module.variable_table.get(ident) {
@@ -87,7 +85,6 @@ pub fn resolve_trigger(
         other => other.clone(),
     };
 
-    // ✅ On reconstruit le Statement avec Trigger résolu
     if let StatementKind::Trigger { entity, .. } = &stmt.kind {
         return Statement {
             kind: StatementKind::Trigger {

package/rust/lib.rs

@@ -1,7 +1,6 @@
 pub mod core;
 pub mod utils;
 pub mod config;
-pub mod audio;
 
 use serde::{ Deserialize, Serialize };
 use wasm_bindgen::prelude::*;

package/rust/main.rs

@@ -4,7 +4,6 @@ pub mod core;
 pub mod cli;
 pub mod utils;
 pub mod config;
-pub mod audio;
 
 use std::io;
 use cli::{ Cli };

package/examples/exported.deva

@@ -1,7 +0,0 @@
-let duration = auto
-let default_bank = 808
-let params = {decay:10, delay:30}
-let loopCount = 5
-let tempo = 155
-
-@export { duration, default_bank, params, loopCount, tempo }

package/rust/audio/interpreter.rs

@@ -1,143 +0,0 @@
-use crate::{
-    audio::{ engine::AudioEngine, loader::load_trigger },
-    core::{
-        parser::statement::{ Statement, StatementKind },
-        shared::value::Value,
-        store::variable::VariableTable,
-    },
-};
-
-pub fn interprete_statements(
-    statements: &Vec<Statement>,
-    audio_engine: AudioEngine,
-    entry: String,
-    output: String
-) -> (AudioEngine, f32, f32) {
-    let mut base_bpm = 120.0;
-    let mut base_duration = 60.0 / base_bpm;
-
-    let variable_table = audio_engine.variables.clone();
-
-    let (updated_audio_engine, base_bpm, max_end_time) = execute_audio_statements(
-        audio_engine.clone(),
-        variable_table.clone(),
-        statements.clone(),
-        base_bpm.clone(),
-        base_duration.clone(),
-        0.0,
-        0.0
-    );
-
-    (updated_audio_engine, base_bpm, max_end_time)
-}
-
-pub fn execute_audio_statements(
-    mut audio_engine: AudioEngine,
-    mut variable_table: VariableTable,
-    mut statements: Vec<Statement>,
-    mut base_bpm: f32,
-    mut base_duration: f32,
-    mut max_end_time: f32,
-    mut cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    for stmt in statements {
-        match &stmt.kind {
-            StatementKind::Load { source, alias } => {
-                variable_table.set(alias.to_string(), Value::String(source.clone()));
-            }
-
-            StatementKind::Let { name } => {
-                variable_table.set(name.to_string(), stmt.value.clone());
-            }
-
-            StatementKind::Tempo => {
-                if let Value::Number(bpm_) = &stmt.value {
-                    base_bpm = *bpm_ as f32;
-                    base_duration = 60.0 / base_bpm;
-                } else {
-                    eprintln!("❌ Invalid tempo value: {:?}", stmt.value);
-                }
-            }
-
-            StatementKind::Trigger { entity, duration } => {
-                if let Some(trigger_val) = variable_table.get(entity) {
-                    let (src, duration_secs) = load_trigger(
-                        trigger_val,
-                        duration,
-                        base_duration,
-                        variable_table.clone()
-                    );
-
-                    audio_engine.insert(&src, cursor_time, duration_secs, None);
-
-                    cursor_time += duration_secs;
-
-                    if cursor_time > max_end_time {
-                        max_end_time = cursor_time;
-                    }
-                } else {
-                    eprintln!("❌ Unknown trigger entity: {}", entity);
-                }
-            }
-
-            StatementKind::Loop => {
-                if let Value::Map(loop_value) = &stmt.value {
-                    let iterator = loop_value.get("iterator");
-                    let body = loop_value.get("body");
-
-                    let loop_count = if let Some(Value::Number(n)) = iterator {
-                        *n as usize
-                    } else {
-                        eprintln!("❌ Loop iterator must be a number: {:?}", iterator);
-                        continue;
-                    };
-
-                    let loop_body = if let Some(Value::Block(body)) = body {
-                        body.clone()
-                    } else {
-                        eprintln!("❌ Loop body must be a block: {:?}", body);
-                        continue;
-                    };
-
-                    for _ in 0..loop_count {
-                        let (loop_engine, _, loop_end_time) = execute_audio_statements(
-                            audio_engine.clone(),
-                            variable_table.clone(),
-                            loop_body.clone(),
-                            base_bpm,
-                            base_duration,
-                            max_end_time,
-                            cursor_time
-                        );
-
-                        audio_engine = loop_engine;
-
-                        // Update time and max_end_time after each loop iteration
-                        cursor_time = loop_end_time;
-                        if loop_end_time > max_end_time {
-                            max_end_time = loop_end_time;
-                        }
-                    }
-                }
-            }
-
-            StatementKind::Bank => {}
-
-            StatementKind::Import { names, source } => {}
-
-            StatementKind::Export { names, source } => {}
-
-            StatementKind::Unknown => {
-                // Ignore unknown statements
-            }
-
-            _ => {
-                eprintln!("Unsupported statement kind: {:?}", stmt);
-            }
-        }
-    }
-
-    audio_engine.set_variables(variable_table);
-
-    (audio_engine, base_bpm, max_end_time)
-}