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

package/rust/audio/interpreter.rs

@@ -0,0 +1,143 @@
+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)
+}

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 },
@@ -10,6 +12,7 @@ use crate::{
 };
 use std::{ thread, time::Duration };
 
+#[cfg(feature = "cli")]
 pub fn handle_build_command(
     config: Option<Config>,
     entry: Option<String>,
@@ -102,13 +105,23 @@ 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_modules(&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);
+    builder.build_ast(&modules_statements, &normalized_output_dir);
+    builder.build_audio(&modules_statements, &normalized_output_dir, &mut global_store);
 
-    // TODO: Implement debugging
+    // SECTION Logging
+    let logger = Logger::new();
 
     let success_message = format!(
         "Build completed successfully in {:.2?}. Output files written to: '{}'",
@@ -116,6 +129,5 @@ fn begin_build(entry: String, output: String) {
         normalized_output_dir
     );
 
-    let logger = Logger::new();
     logger.log_message(LogLevel::Success, &success_message);
 }

package/rust/cli/check.rs

@@ -9,6 +9,7 @@ use crate::{
 };
 use std::{ thread, time::Duration };
 
+#[cfg(feature = "cli")]
 pub fn handle_check_command(
     config: Option<Config>,
     entry: Option<String>,
@@ -101,7 +102,7 @@ fn begin_check(entry: String, output: String) {
 
     // SECTION Load
     // NOTE: We don't use modules in the check command, but we still need to load them
-    let modules = module_loader.load_all(&mut global_store);
+    let modules = module_loader.load_all_modules(&mut global_store);
 
     // TODO: Implement debugging
 

package/rust/cli/init.rs

@@ -1,11 +1,13 @@
 use std::{ fs, path::Path };
 use include_dir::{ include_dir, Dir };
-use inquire::{ Select, Confirm };
-
 use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
 
+#[cfg(feature = "cli")]
+use inquire::{ Select, Confirm };
+
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
 
+#[cfg(feature = "cli")]
 pub fn handle_init_command(name: Option<String>, template: Option<String>) {
     let current_dir = std::env::current_dir().unwrap();
     let project_name = name

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,192 @@
+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;
+
+#[cfg(feature = "cli")]
+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_modules(&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, &output);
+    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/cli/template.rs

@@ -1,9 +1,9 @@
 use include_dir::{ include_dir, Dir, DirEntry };
-
 use crate::utils::file::format_file_size;
 
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
 
+#[cfg(feature = "cli")]
 pub fn handle_template_list_command() {
     let available_templates = get_available_templates();
 
@@ -16,6 +16,7 @@ pub fn handle_template_list_command() {
     println!("\nUsage : devalang init --name <project-name> --template <template-name>");
 }
 
+#[cfg(feature = "cli")]
 pub fn handle_template_info_command(name: String) {
     let template_dir = TEMPLATES_DIR.get_dir(name.clone()).unwrap_or_else(|| {
         println!("❌ The template '{}' is not found.", name);

package/rust/config/loader.rs

@@ -1,5 +1,4 @@
 use std::{ fs, path::Path };
-
 use crate::config::Config;
 
 pub fn load_config(path: Option<&Path>) -> Option<Config> {

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>,
 }