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

package/rust/audio/loader.rs

@@ -0,0 +1,46 @@
+use crate::core::{ shared::{ duration::Duration, value::Value }, store::variable::VariableTable };
+
+pub fn load_trigger(
+    trigger: &Value,
+    duration: &Duration,
+    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();
+        }
+        _ => {
+            eprintln!("❌ Invalid trigger type. Expected a text variable.");
+        }
+    }
+
+    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 {
+                eprintln!("❌ Invalid duration identifier: {}", duration_identifier);
+            }
+        }
+
+        Duration::Number(num) => {
+            duration_as_secs = *num;
+        }
+
+        Duration::Auto => {
+            duration_as_secs = base_duration;
+        }
+
+        _ => {
+            eprintln!("❌ Invalid duration type. Expected an identifier.");
+        }
+    }
+
+    (trigger_path, duration_as_secs)
+}

package/rust/audio/mod.rs

@@ -0,0 +1,5 @@
+pub mod engine;
+pub mod interpreter;
+pub mod loader;
+pub mod player;
+pub mod render;

package/rust/audio/player.rs

@@ -0,0 +1,54 @@
+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 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) -> impl Source<Item = f32> + Send + 'static {
+        let file = File::open(path).unwrap();
+        let reader = BufReader::new(file);
+
+        Decoder::new(reader).unwrap().convert_samples()
+    }
+
+    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);
+
+        let source = self.load_source(path);
+
+        self.sink.append(source);
+        self.last_path = Some(path.to_string());
+    }
+
+    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/audio/render.rs

@@ -0,0 +1,57 @@
+use std::collections::HashMap;
+
+use crate::{
+    audio::{ engine::AudioEngine, interpreter::interprete_statements },
+    core::{
+        parser::statement::Statement,
+        store::global::GlobalStore,
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+pub fn render_audio_with_modules(
+    modules: HashMap<String, Vec<Statement>>,
+    output_dir: &str,
+    global_store: &mut GlobalStore
+) -> HashMap<String, AudioEngine> {
+    let mut result = HashMap::new();
+
+    for (module_name, statements) in modules {
+        let mut global_max_end_time = 0.0;
+        let mut audio_engine = AudioEngine::new();
+
+        // Apply the module's variable table if it exists
+        if let Some(module) = global_store.get_module(&module_name) {
+            audio_engine.set_variables(module.variable_table.clone());
+        }
+
+        // Interpret the statements to fill the audio buffer
+        let (mut audio_engine, module_base_bpm, module_max_end_time) = interprete_statements(
+            &statements,
+            audio_engine,
+            module_name.clone(),
+            output_dir.to_string()
+        );
+
+        // Calculate the module's maximum duration
+        global_max_end_time = module_max_end_time.max(global_max_end_time);
+        audio_engine.set_duration(global_max_end_time);
+
+        // Check if the buffer contains at least one non-zero sample
+        if audio_engine.buffer.iter().all(|&s| s == 0) {
+            let logger = Logger::new();
+
+            logger.log_message(
+                LogLevel::Warning,
+                format!("Module '{}' ignored: silent buffer (no non-zero samples)", module_name).as_str()
+            );
+
+            continue;
+        }
+
+        // Insert only if the module produces sound
+        result.insert(module_name, audio_engine);
+    }
+
+    result
+}

package/rust/cli/build.rs

@@ -1,7 +1,9 @@
 use crate::{
+    audio::render::render_audio_with_modules,
     config::Config,
     core::{
         builder::Builder,
+        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
         preprocessor::loader::ModuleLoader,
         store::global::GlobalStore,
         utils::path::{ find_entry_file, normalize_path },
@@ -102,20 +104,29 @@ fn begin_build(entry: String, output: String) {
 
     // SECTION Load
     // NOTE: We use modules in the build command, so we need to load them
-    let modules = module_loader.load_all(&mut global_store);
+    let (modules_tokens, modules_statements) = module_loader.load_all(&mut global_store);
+
+    // SECTION Write logs
+    write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
+    write_preprocessor_log_file(
+        &normalized_output_dir,
+        "resolved_statements.log",
+        modules_statements.clone()
+    );
 
-    // SECTION Build
+    // SECTION Building AST and Audio
     let builder = Builder::new();
-    builder.build_ast(&modules);
-
-    // TODO: Implement debugging
+    builder.build_ast(&modules_statements);
+    builder.build_audio(&modules_statements, &normalized_output_dir, &mut global_store);
 
+    // SECTION Logging
+    let logger = Logger::new();
+    
     let success_message = format!(
         "Build completed successfully in {:.2?}. Output files written to: '{}'",
         duration.elapsed(),
         normalized_output_dir
     );
 
-    let logger = Logger::new();
     logger.log_message(LogLevel::Success, &success_message);
 }

package/rust/cli/mod.rs

@@ -2,6 +2,7 @@ pub mod check;
 pub mod build;
 pub mod init;
 pub mod template;
+pub mod play;
 
 use clap::{ Parser, Subcommand };
 use crate::utils::version::get_version;
@@ -173,4 +174,32 @@ pub enum Commands {
         ///
         debug: bool,
     },
+
+    Play {
+        #[arg(short, long)]
+        /// The entry point of the program to play.
+        ///
+        entry: Option<String>,
+
+        #[arg(short, long)]
+        /// The directory where the output files will be generated.
+        ///
+        output: Option<String>,
+
+        #[arg(long, default_value_t = false)]
+        /// Whether to watch for changes and re-play.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        watch: bool,
+
+        #[arg(long, default_value_t = false)]
+        /// Whether to replay the program after it finishes.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        repeat: bool,
+    },
 }

package/rust/cli/play.rs

@@ -0,0 +1,191 @@
+use crate::{
+    audio::player::AudioPlayer,
+    config::Config,
+    core::{
+        builder::Builder,
+        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
+        preprocessor::loader::ModuleLoader,
+        store::global::GlobalStore,
+        utils::path::{ find_entry_file, normalize_path },
+    },
+    utils::{ logger::{ LogLevel, Logger }, spinner::with_spinner, watcher::watch_directory },
+};
+
+use std::{ path::Path, sync::mpsc::channel, thread, time::Duration };
+use std::fs;
+use std::collections::HashMap;
+
+pub fn handle_play_command(
+    config: Option<Config>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool,
+    repeat: bool
+) {
+    let logger = Logger::new();
+
+    let entry_path = entry
+        .or_else(|| config.as_ref().and_then(|c| c.defaults.entry.clone()))
+        .unwrap_or_else(|| "".to_string());
+
+    let output_path = output
+        .or_else(|| config.as_ref().and_then(|c| c.defaults.output.clone()))
+        .unwrap_or_else(|| "".to_string());
+
+    let fetched_repeat = if repeat {
+        true
+    } else {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.repeat)
+            .unwrap_or(false)
+    };
+
+    if entry_path.is_empty() || output_path.is_empty() {
+        logger.log_message(LogLevel::Error, "Entry or output path not specified.");
+        std::process::exit(1);
+    }
+
+    let entry_file = find_entry_file(&entry_path).unwrap_or_else(|| {
+        logger.log_message(LogLevel::Error, "index.deva not found");
+        std::process::exit(1);
+    });
+
+    let audio_file = format!("{}/audio/index.wav", normalize_path(&output_path));
+    let mut audio_player = AudioPlayer::new();
+
+    if watch && fetched_repeat {
+        logger.log_message(
+            LogLevel::Error,
+            "Watch and repeat cannot be used together. Use repeat instead."
+        );
+        std::process::exit(1);
+    }
+
+    if watch {
+        let (tx, rx) = channel::<()>();
+
+        // Thread 1 : Watcher sending changes
+        let entry_clone = entry_path.clone();
+        thread::spawn(move || {
+            let _ = watch_directory(entry_clone, move || {
+                let _ = tx.send(()); // signal a change
+            });
+        });
+
+        // Main thread: build + play in a loop
+        begin_play(&config, &entry_file, &output_path);
+        audio_player.play_file_once(&audio_file);
+
+        logger.log_message(LogLevel::Watcher, "Watching for changes... Press Ctrl+C to exit.");
+
+        while let Ok(_) = rx.recv() {
+            logger.log_message(LogLevel::Watcher, "Change detected, rebuilding...");
+
+            begin_play(&config, &entry_file, &output_path);
+
+            logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
+
+            audio_player.play_file_once(&audio_file);
+        }
+    } else if fetched_repeat {
+        // Initial build to start from a clean slate
+        begin_play(&config, &entry_file, &output_path);
+
+        logger.log_message(LogLevel::Info, "🎵 Playback started (repeat mode)...");
+
+        let mut last_snapshot = snapshot_files(&entry_path);
+        let mut audio_player = AudioPlayer::new();
+        audio_player.play_file_once(&audio_file);
+
+        loop {
+            let current_snapshot = snapshot_files(&entry_path);
+            let has_changed = files_changed(&last_snapshot, &current_snapshot);
+
+            if has_changed {
+                logger.log_message(LogLevel::Info, "Change detected, rebuilding in background...");
+                let entry_file = entry_file.clone();
+                let output_path = output_path.clone();
+                let config_clone = config.clone();
+
+                // Rebuild in a separate thread
+                std::thread::spawn(move || {
+                    begin_play(&config_clone, &entry_file, &output_path);
+                });
+
+                last_snapshot = current_snapshot;
+            }
+
+            // Wait for the audio to finish without blocking the current playback
+            audio_player.wait_until_end();
+
+            // Then replay the audio (rebuilt or not)
+            audio_player.play_file_once(&audio_file);
+        }
+    } else {
+        // Single execution
+        begin_play(&config, &entry_file, &output_path);
+        
+        logger.log_message(LogLevel::Info, "🎵 Playback started (once mode)...");
+
+        audio_player.play_file_once(&audio_file);
+        audio_player.wait_until_end();
+    }
+}
+
+fn begin_play(config: &Option<Config>, entry_file: &str, output: &str) {
+    let spinner = with_spinner("Building...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
+
+    let normalized_entry = normalize_path(entry_file);
+    let normalized_output_dir = normalize_path(&output);
+
+    let duration = std::time::Instant::now();
+    let mut global_store = GlobalStore::new();
+    let loader = ModuleLoader::new(&normalized_entry, &normalized_output_dir);
+    let (modules_tokens, modules_statements) = loader.load_all(&mut global_store);
+
+    // SECTION Write logs
+    write_lexer_log_file(&normalized_output_dir, "lexer_tokens.log", modules_tokens.clone());
+    write_preprocessor_log_file(
+        &normalized_output_dir,
+        "resolved_statements.log",
+        modules_statements.clone()
+    );
+
+    // SECTION Building AST and Audio
+    let builder = Builder::new();
+    builder.build_ast(&modules_statements);
+    builder.build_audio(&modules_statements, &output, &mut global_store);
+
+    // SECTION Logging
+    let logger = Logger::new();
+    let success_message = format!(
+        "Build completed successfully in {:.2?}. Output files written to: '{}'",
+        duration.elapsed(),
+        normalized_output_dir
+    );
+
+    logger.log_message(LogLevel::Success, &success_message);
+}
+
+fn snapshot_files<P: AsRef<Path>>(dir: P) -> HashMap<String, u64> {
+    let mut map = HashMap::new();
+    if let Ok(entries) = fs::read_dir(dir) {
+        for entry in entries.flatten() {
+            if let Ok(meta) = entry.metadata() {
+                if let Ok(mtime) = meta.modified() {
+                    if let Ok(duration) = mtime.duration_since(std::time::UNIX_EPOCH) {
+                        map.insert(entry.path().display().to_string(), duration.as_secs());
+                    }
+                }
+            }
+        }
+    }
+    map
+}
+
+fn files_changed(old: &HashMap<String, u64>, new: &HashMap<String, u64>) -> bool {
+    old != new
+}

package/rust/config/mod.rs

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

package/rust/core/builder/mod.rs

@@ -1,4 +1,7 @@
+use crate::audio::render::render_audio_with_modules;
 use crate::core::parser::statement::Statement;
+use crate::core::store::global::GlobalStore;
+use crate::utils::logger::Logger;
 use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
 
@@ -28,4 +31,49 @@ impl Builder {
             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
+    ) {
+        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('/')
+                .last()
+                .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) {
+                Ok(_) => {}
+                Err(msg) => {
+                    logger.log_error_with_stacktrace(
+                        &format!(
+                            "Unable to generate WAV file for module '{}': {}",
+                            formatted_module_name,
+                            msg
+                        ),
+                        &module_name
+                    );
+                }
+            }
+        }
+    }
 }

package/rust/core/debugger/lexer.rs

@@ -1,12 +1,27 @@
-use crate::core::{ debugger::Debugger, lexer::token::Token };
+use std::{ collections::HashMap, fs::create_dir_all };
+use crate::core::{ debugger::Debugger, lexer::token::Token, parser::statement::Statement };
 
-pub fn write_lexer_log_file(output_dir: &str, file_name: &str, tokens: Vec<Token>) {
+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();
 
-    for token in tokens {
-        content.push_str(&format!("{:?}\n", token));
+    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_str("\n");
     }
 
-    debugger.write_log_file(output_dir, file_name, &content);
+    debugger.write_log_file(&log_directory, file_name, &content);
 }

package/rust/core/debugger/preprocessor.rs

@@ -1,17 +1,21 @@
-use std::collections::HashMap;
+use std::{ collections::HashMap, fs::create_dir_all };
 use crate::core::{ debugger::Debugger, parser::statement::Statement };
 
 pub fn write_preprocessor_log_file(
     output_dir: &str,
     file_name: &str,
-    statements: HashMap<String, Vec<Statement>>
+    modules: HashMap<String, Vec<Statement>>
 ) {
     let debugger = Debugger::new();
     let mut content = String::new();
 
-    for (path, stmts) in statements {
+    let log_directory = format!("{}/logs", output_dir);
+
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, stmts) in modules {
         content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
-        
+
         for stmt in stmts {
             content.push_str(&format!("{:?}\n", stmt));
         }
@@ -19,5 +23,5 @@ pub fn write_preprocessor_log_file(
         content.push_str("\n");
     }
 
-    debugger.write_log_file(output_dir, file_name, &content);
+    debugger.write_log_file(&log_directory, file_name, &content);
 }

package/rust/core/preprocessor/loader.rs

@@ -2,9 +2,8 @@ use std::collections::HashMap;
 
 use crate::{
     core::{
-        debugger::{ lexer::write_lexer_log_file, preprocessor::write_preprocessor_log_file },
         error::ErrorHandler,
-        lexer::Lexer,
+        lexer::{ token::Token, Lexer },
         parser::{ statement::{ Statement, StatementKind }, Parser },
         preprocessor::{
             module::Module,
@@ -13,7 +12,7 @@ use crate::{
         },
         store::global::GlobalStore,
     },
-    utils::logger::{ LogLevel, Logger },
+    utils::logger::{ Logger },
 };
 
 pub struct ModuleLoader {
@@ -29,26 +28,29 @@ impl ModuleLoader {
         }
     }
 
-    pub fn load_all(&self, global_store: &mut GlobalStore) -> HashMap<String, Vec<Statement>> {
+    pub fn load_all(
+        &self,
+        global_store: &mut GlobalStore
+    ) -> (HashMap<String, Vec<Token>>, HashMap<String, Vec<Statement>>) {
         // SECTION Load the entry module and its dependencies
-        self.load_module_recursively(&self.entry, global_store);
+        let tokens_by_module = self.load_module_recursively(&self.entry, global_store);
 
         // SECTION Process and resolve modules
         process_modules(self, global_store);
         resolve_all_modules(self, global_store);
 
-        let resolved = resolve_and_flatten_all_modules(global_store);
+        let statemnts_by_module = resolve_and_flatten_all_modules(global_store);
 
-        // SECTION Write resolved statements to log file
-        write_preprocessor_log_file(&self.output, "resolved_statements.log", resolved.clone());
-
-        // Return the resolved statements
-        resolved
+        (tokens_by_module, statemnts_by_module)
     }
 
-    fn load_module_recursively(&self, path: &str, global_store: &mut GlobalStore) {
+    fn load_module_recursively(
+        &self,
+        path: &str,
+        global_store: &mut GlobalStore
+    ) -> HashMap<String, Vec<Token>> {
         if global_store.modules.contains_key(path) {
-            return;
+            return HashMap::new();
         }
 
         let lexer = Lexer::new();
@@ -75,13 +77,22 @@ impl ModuleLoader {
 
         // SECTION Module creation
         let mut module = Module::new(path);
-        module.tokens = tokens;
-        module.statements = statements;
+        module.tokens = tokens.clone();
+        module.statements = statements.clone();
 
         global_store.insert_module(path.to_string(), module);
 
         // Then load the imports recursively
         self.load_module_imports(&path.to_string(), global_store);
+
+        // Return all tokens by module
+        let mut tokens_by_module = HashMap::new();
+
+        global_store.modules.iter().for_each(|(path, module)| {
+            tokens_by_module.insert(path.clone(), module.tokens.clone());
+        });
+
+        tokens_by_module
     }
 
     fn load_module_imports(&self, path: &String, global_store: &mut GlobalStore) {