@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.3

package/rust/cli/play/mod.rs

@@ -1,5 +1,5 @@
-pub mod commands;
-pub mod io;
-pub mod process;
-pub mod realtime;
-pub mod utils;
+pub mod commands;
+pub mod io;
+pub mod process;
+pub mod realtime;
+pub mod utils;

package/rust/cli/play/process.rs

@@ -1,150 +1,159 @@
-use crate::{
-    config::driver::ProjectConfig,
-    core::{
-        builder::Builder,
-        debugger::{
-            lexer::write_lexer_log_file,
-            module::{write_module_function_log_file, write_module_variable_log_file},
-            preprocessor::write_preprocessor_log_file,
-            store::{write_function_log_file, write_variables_log_file},
-        },
-        preprocessor::loader::ModuleLoader,
-        store::global::GlobalStore,
-        utils::path::normalize_path,
-    },
-};
-use devalang_utils::{
-    logger::{LogLevel, Logger},
-    spinner::start_spinner,
-};
-
-pub fn process_play(
-    _config: &Option<ProjectConfig>,
-    entry_file: &str,
-    output: &str,
-    debug: bool,
-) -> Result<
-    (
-        f32,
-        Vec<crate::core::parser::statement::Statement>,
-        crate::core::store::variable::VariableTable,
-        crate::core::store::function::FunctionTable,
-        crate::core::store::global::GlobalStore,
-    ),
-    String,
-> {
-    let spinner = start_spinner("Building...");
-
-    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);
-
-    // Try to detect initial BPM from statements (fallback to 120.0)
-    let mut detected_bpm: f32 = 120.0;
-    let mut entry_statements: Vec<crate::core::parser::statement::Statement> = Vec::new();
-    // Prefer the entry module if present
-    if let Some(entry_stmts) = modules_statements.get(&normalized_entry) {
-        entry_statements = entry_stmts.clone();
-        for stmt in entry_stmts {
-            if let crate::core::parser::statement::StatementKind::Tempo = &stmt.kind {
-                use devalang_types::Value;
-                if let Value::Number(n) = &stmt.value {
-                    detected_bpm = *n;
-                    break;
-                }
-            }
-        }
-    }
-    // If still default, scan other modules for a tempo directive
-    if (detected_bpm - 120.0).abs() < f32::EPSILON {
-        'outer: for (_name, stmts) in modules_statements.iter() {
-            for stmt in stmts {
-                if let crate::core::parser::statement::StatementKind::Tempo = &stmt.kind {
-                    use devalang_types::Value;
-                    if let Value::Number(n) = &stmt.value {
-                        detected_bpm = *n;
-                        break 'outer;
-                    }
-                }
-            }
-        }
-    }
-
-    // SECTION Write logs
-    if debug {
-        for (module_path, module) in global_store.modules.clone() {
-            write_module_variable_log_file(
-                &normalized_output_dir,
-                &module_path,
-                &module.variable_table,
-            );
-            write_module_function_log_file(
-                &normalized_output_dir,
-                &module_path,
-                &module.function_table,
-            );
-        }
-
-        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(),
-        );
-        write_variables_log_file(
-            &normalized_output_dir,
-            "global_variables.log",
-            global_store.variables.clone(),
-        );
-        write_function_log_file(
-            &normalized_output_dir,
-            "global_functions.log",
-            global_store.functions.clone(),
-        );
-    }
-
-    // SECTION Detect errors before building (like build.rs)
-    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules_statements);
-    let (warnings, criticals) = crate::core::error::partition_errors(all_errors);
-    crate::core::error::log_errors_with_stack("Play", &warnings, &criticals);
-    if !criticals.is_empty() {
-        spinner.finish_and_clear();
-        return Err(format!(
-            "play failed with {} critical error(s): {}",
-            criticals.len(),
-            criticals[0].message
-        ));
-    }
-
-    // SECTION Building AST and Audio
-    let builder = Builder::new();
-    builder.build_ast(&modules_statements, output, false);
-    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
-    );
-
-    spinner.finish_and_clear();
-    logger.log_message(LogLevel::Success, &success_message);
-
-    Ok((
-        detected_bpm,
-        entry_statements,
-        global_store.variables.clone(),
-        global_store.functions.clone(),
-        global_store,
-    ))
-}
+use crate::{
+    config::driver::ProjectConfig,
+    core::{
+        builder::Builder,
+        debugger::{
+            lexer::write_lexer_log_file,
+            logs::{write_module_function_log_file, write_module_variable_log_file},
+            preprocessor::write_preprocessor_log_file,
+            store::{write_function_log_file, write_variables_log_file},
+        },
+        preprocessor::loader::ModuleLoader,
+        store::global::GlobalStore,
+    },
+};
+use devalang_utils::path::normalize_path;
+use devalang_utils::{
+    logger::{LogLevel, Logger},
+    spinner::start_spinner,
+};
+
+pub fn process_play(
+    _config: &Option<ProjectConfig>,
+    entry_file: &str,
+    output: &str,
+    audio_format: crate::cli::parser::AudioFormat,
+    sample_rate: u32,
+    debug: bool,
+) -> Result<
+    (
+        f32,
+        Vec<crate::core::parser::statement::Statement>,
+        devalang_types::VariableTable,
+        devalang_types::FunctionTable,
+        crate::core::store::global::GlobalStore,
+    ),
+    String,
+> {
+    let spinner = start_spinner("Building...");
+
+    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);
+
+    // Try to detect initial BPM from statements (fallback to 120.0)
+    let mut detected_bpm: f32 = 120.0;
+    let mut entry_statements: Vec<crate::core::parser::statement::Statement> = Vec::new();
+    // Prefer the entry module if present
+    if let Some(entry_stmts) = modules_statements.get(&normalized_entry) {
+        entry_statements = entry_stmts.clone();
+        for stmt in entry_stmts {
+            if let crate::core::parser::statement::StatementKind::Tempo = &stmt.kind {
+                use devalang_types::Value;
+                if let Value::Number(n) = &stmt.value {
+                    detected_bpm = *n;
+                    break;
+                }
+            }
+        }
+    }
+    // If still default, scan other modules for a tempo directive
+    if (detected_bpm - 120.0).abs() < f32::EPSILON {
+        'outer: for (_name, stmts) in modules_statements.iter() {
+            for stmt in stmts {
+                if let crate::core::parser::statement::StatementKind::Tempo = &stmt.kind {
+                    use devalang_types::Value;
+                    if let Value::Number(n) = &stmt.value {
+                        detected_bpm = *n;
+                        break 'outer;
+                    }
+                }
+            }
+        }
+    }
+
+    // SECTION Write logs
+    if debug {
+        for (module_path, module) in global_store.modules.clone() {
+            write_module_variable_log_file(
+                &normalized_output_dir,
+                &module_path,
+                &module.variable_table,
+            );
+            write_module_function_log_file(
+                &normalized_output_dir,
+                &module_path,
+                &module.function_table,
+            );
+        }
+
+        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(),
+        );
+        write_variables_log_file(
+            &normalized_output_dir,
+            "global_variables.log",
+            global_store.variables.clone(),
+        );
+        write_function_log_file(
+            &normalized_output_dir,
+            "global_functions.log",
+            global_store.functions.clone(),
+        );
+    }
+
+    // SECTION Detect errors before building (like build.rs)
+    let all_errors = crate::core::error::collect_all_errors_with_modules(&modules_statements);
+    let (warnings, criticals) = crate::core::error::partition_errors(all_errors);
+    crate::core::error::log_errors_with_stack("Play", &warnings, &criticals);
+    if !criticals.is_empty() {
+        spinner.finish_and_clear();
+        return Err(format!(
+            "play failed with {} critical error(s): {}",
+            criticals.len(),
+            criticals[0].message
+        ));
+    }
+
+    // SECTION Building AST and Audio
+    let builder = Builder::new();
+    builder.build_ast(&modules_statements, output, false);
+    let audio_format_str = format!("{:?}", audio_format);
+    builder.build_audio(
+        &modules_statements,
+        output,
+        &mut global_store,
+        Some(audio_format_str),
+        Some(sample_rate),
+    );
+
+    // SECTION Logging
+    let logger = Logger::new();
+    let success_message = format!(
+        "Build completed successfully in {:.2?}. Output files written to: '{}'",
+        duration.elapsed(),
+        normalized_output_dir
+    );
+
+    spinner.finish_and_clear();
+    logger.log_message(LogLevel::Success, &success_message);
+
+    Ok((
+        detected_bpm,
+        entry_statements,
+        global_store.variables.clone(),
+        global_store.functions.clone(),
+        global_store,
+    ))
+}

package/rust/cli/play/realtime.rs

@@ -1,91 +1,91 @@
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::Duration;
-
-use devalang_types::Value;
-
-pub struct RtRunner {
-    pub stop: Arc<AtomicBool>,
-    pub handle: std::thread::JoinHandle<()>,
-}
-
-pub struct RtContext {
-    pub bpm: f32,
-    pub entry_stmts: Vec<crate::core::parser::statement::Statement>,
-    pub variables: crate::core::store::variable::VariableTable,
-    pub functions: crate::core::store::function::FunctionTable,
-    pub global_store: crate::core::store::global::GlobalStore,
-}
-
-pub fn start_realtime_runner(ctx: RtContext, total_secs: f32) -> RtRunner {
-    use crate::core::audio::engine::AudioEngine;
-    use crate::core::audio::interpreter::driver::execute_audio_block;
-    use crate::core::parser::statement::StatementKind;
-    use devalang_utils::logger::Logger;
-
-    let stop = Arc::new(AtomicBool::new(false));
-    let stop_clone = stop.clone();
-
-    let handle = std::thread::spawn(move || {
-        let _logger = Logger::new();
-        let bpm = if ctx.bpm > 0.0 { ctx.bpm } else { 120.0 };
-        let beat_secs = 60.0f32 / bpm;
-        let mut elapsed = 0.0f32;
-
-        let mut variables = ctx.variables.clone();
-        variables.set("__rt".to_string(), Value::Boolean(true));
-        let functions = ctx.functions.clone();
-        let _global_store = ctx.global_store.clone();
-        let mut audio_engine = AudioEngine::new("rt".to_string());
-
-        let i: usize = 0;
-        let mut _current_loop: Option<()> = None; // simplified state
-        let mut _beat_index: u64 = 0;
-        while elapsed + 1e-3 < total_secs && i < ctx.entry_stmts.len() {
-            if stop_clone.load(Ordering::Relaxed) {
-                break;
-            }
-
-            std::thread::sleep(Duration::from_secs_f32(beat_secs));
-            elapsed += beat_secs;
-            _beat_index += 1;
-            if stop_clone.load(Ordering::Relaxed) {
-                break;
-            }
-
-            // Only fire periodic handlers when not in a loop - simplified
-            if let Some(handlers) = ctx.global_store.get_event_handlers("beat") {
-                for h in handlers {
-                    if let StatementKind::On { body, .. } = &h.kind {
-                        let _ = execute_audio_block(
-                            &mut audio_engine,
-                            &ctx.global_store,
-                            variables.clone(),
-                            functions.clone(),
-                            body,
-                            bpm,
-                            60.0 / bpm,
-                            0.0,
-                            0.0,
-                        );
-                    }
-                }
-            }
-        }
-    });
-
-    RtRunner { stop, handle }
-}
-
-pub fn stop_realtime_runner(runner_opt: &mut Option<RtRunner>) {
-    if let Some(r) = runner_opt.take() {
-        r.stop.store(true, Ordering::Relaxed);
-        let _ = r.handle.join();
-    }
-}
-
-pub fn join_realtime_runner(runner_opt: &mut Option<RtRunner>) {
-    if let Some(r) = runner_opt.take() {
-        let _ = r.handle.join();
-    }
-}
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+
+use devalang_types::Value;
+
+pub struct RtRunner {
+    pub stop: Arc<AtomicBool>,
+    pub handle: std::thread::JoinHandle<()>,
+}
+
+pub struct RtContext {
+    pub bpm: f32,
+    pub entry_stmts: Vec<crate::core::parser::statement::Statement>,
+    pub variables: devalang_types::store::VariableTable,
+    pub functions: devalang_types::store::FunctionTable,
+    pub global_store: crate::core::store::global::GlobalStore,
+}
+
+pub fn start_realtime_runner(ctx: RtContext, total_secs: f32) -> RtRunner {
+    use crate::core::audio::engine::AudioEngine;
+    use crate::core::audio::interpreter::driver::execute_audio_block;
+    use crate::core::parser::statement::StatementKind;
+    use devalang_utils::logger::Logger;
+
+    let stop = Arc::new(AtomicBool::new(false));
+    let stop_clone = stop.clone();
+
+    let handle = std::thread::spawn(move || {
+        let _logger = Logger::new();
+        let bpm = if ctx.bpm > 0.0 { ctx.bpm } else { 120.0 };
+        let beat_secs = 60.0f32 / bpm;
+        let mut elapsed = 0.0f32;
+
+        let mut variables = ctx.variables.clone();
+        variables.set("__rt".to_string(), Value::Boolean(true));
+        let functions = ctx.functions.clone();
+        let _global_store = ctx.global_store.clone();
+        let mut audio_engine = AudioEngine::new("rt".to_string());
+
+        let i: usize = 0;
+        let mut _current_loop: Option<()> = None; // simplified state
+        let mut _beat_index: u64 = 0;
+        while elapsed + 1e-3 < total_secs && i < ctx.entry_stmts.len() {
+            if stop_clone.load(Ordering::Relaxed) {
+                break;
+            }
+
+            std::thread::sleep(Duration::from_secs_f32(beat_secs));
+            elapsed += beat_secs;
+            _beat_index += 1;
+            if stop_clone.load(Ordering::Relaxed) {
+                break;
+            }
+
+            // Only fire periodic handlers when not in a loop - simplified
+            if let Some(handlers) = ctx.global_store.get_event_handlers("beat") {
+                for h in handlers {
+                    if let StatementKind::On { body, .. } = &h.kind {
+                        let _ = execute_audio_block(
+                            &mut audio_engine,
+                            &ctx.global_store,
+                            variables.clone(),
+                            functions.clone(),
+                            body,
+                            bpm,
+                            60.0 / bpm,
+                            0.0,
+                            0.0,
+                        );
+                    }
+                }
+            }
+        }
+    });
+
+    RtRunner { stop, handle }
+}
+
+pub fn stop_realtime_runner(runner_opt: &mut Option<RtRunner>) {
+    if let Some(r) = runner_opt.take() {
+        r.stop.store(true, Ordering::Relaxed);
+        let _ = r.handle.join();
+    }
+}
+
+pub fn join_realtime_runner(runner_opt: &mut Option<RtRunner>) {
+    if let Some(r) = runner_opt.take() {
+        let _ = r.handle.join();
+    }
+}

package/rust/cli/telemetry/commands.rs

@@ -1,22 +1,22 @@
-use crate::config::settings::set_user_config_value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-#[cfg(feature = "cli")]
-pub async fn handle_telemetry_enable_command() -> Result<(), String> {
-    set_user_config_value("telemetry", serde_json::Value::Bool(true));
-
-    let logger = Logger::new();
-    logger.log_message(LogLevel::Info, "Telemetry has been enabled.");
-
-    Ok(())
-}
-
-#[cfg(feature = "cli")]
-pub async fn handle_telemetry_disable_command() -> Result<(), String> {
-    set_user_config_value("telemetry", serde_json::Value::Bool(false));
-
-    let logger = Logger::new();
-    logger.log_message(LogLevel::Info, "Telemetry has been disabled.");
-
-    Ok(())
-}
+use crate::config::settings::set_user_config_value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+#[cfg(feature = "cli")]
+pub async fn handle_telemetry_enable_command() -> Result<(), String> {
+    set_user_config_value("telemetry", serde_json::Value::Bool(true));
+
+    let logger = Logger::new();
+    logger.log_message(LogLevel::Info, "Telemetry has been enabled.");
+
+    Ok(())
+}
+
+#[cfg(feature = "cli")]
+pub async fn handle_telemetry_disable_command() -> Result<(), String> {
+    set_user_config_value("telemetry", serde_json::Value::Bool(false));
+
+    let logger = Logger::new();
+    logger.log_message(LogLevel::Info, "Telemetry has been disabled.");
+
+    Ok(())
+}