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

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(())
+}

package/rust/cli/telemetry/event_creator.rs

@@ -1,80 +1,80 @@
-use crate::config::settings::get_user_config;
-use devalang_types::{
-    TelemetryErrorLevel as SharedTelemetryErrorLevel, TelemetryEvent as SharedTelemetryEvent,
-};
-use uuid::Uuid;
-
-pub type TelemetryEvent = SharedTelemetryEvent;
-pub type TelemetryErrorLevel = SharedTelemetryErrorLevel;
-
-pub trait TelemetryEventExt {
-    fn set_timestamp(&mut self, timestamp: String);
-    fn set_duration(&mut self, duration: u64);
-    fn set_success(&mut self, success: bool);
-    fn set_error(
-        &mut self,
-        level: TelemetryErrorLevel,
-        message: Option<String>,
-        exit_code: Option<i32>,
-    );
-}
-
-impl TelemetryEventExt for SharedTelemetryEvent {
-    fn set_timestamp(&mut self, timestamp: String) {
-        self.timestamp = timestamp;
-    }
-
-    fn set_duration(&mut self, duration: u64) {
-        self.duration = duration;
-    }
-
-    fn set_success(&mut self, success: bool) {
-        self.success = success;
-    }
-
-    fn set_error(
-        &mut self,
-        level: TelemetryErrorLevel,
-        message: Option<String>,
-        exit_code: Option<i32>,
-    ) {
-        self.error_level = level;
-        self.error_message = message;
-        self.exit_code = exit_code;
-    }
-}
-
-pub struct TelemetryEventCreator {
-    pub events: Vec<TelemetryEvent>,
-}
-
-impl TelemetryEventCreator {
-    pub fn new() -> Self {
-        TelemetryEventCreator { events: Vec::new() }
-    }
-
-    pub fn create_event(&mut self, event: TelemetryEvent) {
-        self.events.push(event.clone());
-    }
-
-    pub fn get_base_event(&self) -> TelemetryEvent {
-        let uuid = match get_user_config() {
-            Some(cfg) if !cfg.telemetry.uuid.is_empty() => cfg.telemetry.uuid.clone(),
-            _ => Uuid::new_v4().to_string(),
-        };
-
-        TelemetryEvent {
-            uuid,
-            cli_version: env!("CARGO_PKG_VERSION").to_string(),
-            os: std::env::consts::OS.to_string(),
-            command: std::env::args().collect::<Vec<_>>(),
-            project_info: None,
-            error_level: TelemetryErrorLevel::None,
-            error_message: None,
-            exit_code: None,
-            timestamp: chrono::Utc::now().to_string(),
-            duration: 0,
-            success: true,
-        }
-    }
-}
+use crate::config::settings::get_user_config;
+use devalang_types::{
+    TelemetryErrorLevel as SharedTelemetryErrorLevel, TelemetryEvent as SharedTelemetryEvent,
+};
+use uuid::Uuid;
+
+pub type TelemetryEvent = SharedTelemetryEvent;
+pub type TelemetryErrorLevel = SharedTelemetryErrorLevel;
+
+pub trait TelemetryEventExt {
+    fn set_timestamp(&mut self, timestamp: String);
+    fn set_duration(&mut self, duration: u64);
+    fn set_success(&mut self, success: bool);
+    fn set_error(
+        &mut self,
+        level: TelemetryErrorLevel,
+        message: Option<String>,
+        exit_code: Option<i32>,
+    );
+}
+
+impl TelemetryEventExt for SharedTelemetryEvent {
+    fn set_timestamp(&mut self, timestamp: String) {
+        self.timestamp = timestamp;
+    }
+
+    fn set_duration(&mut self, duration: u64) {
+        self.duration = duration;
+    }
+
+    fn set_success(&mut self, success: bool) {
+        self.success = success;
+    }
+
+    fn set_error(
+        &mut self,
+        level: TelemetryErrorLevel,
+        message: Option<String>,
+        exit_code: Option<i32>,
+    ) {
+        self.error_level = level;
+        self.error_message = message;
+        self.exit_code = exit_code;
+    }
+}
+
+pub struct TelemetryEventCreator {
+    pub events: Vec<TelemetryEvent>,
+}
+
+impl TelemetryEventCreator {
+    pub fn new() -> Self {
+        TelemetryEventCreator { events: Vec::new() }
+    }
+
+    pub fn create_event(&mut self, event: TelemetryEvent) {
+        self.events.push(event.clone());
+    }
+
+    pub fn get_base_event(&self) -> TelemetryEvent {
+        let uuid = match get_user_config() {
+            Some(cfg) if !cfg.telemetry.uuid.is_empty() => cfg.telemetry.uuid.clone(),
+            _ => Uuid::new_v4().to_string(),
+        };
+
+        TelemetryEvent {
+            uuid,
+            cli_version: env!("CARGO_PKG_VERSION").to_string(),
+            os: std::env::consts::OS.to_string(),
+            command: std::env::args().collect::<Vec<_>>(),
+            project_info: None,
+            error_level: TelemetryErrorLevel::None,
+            error_message: None,
+            exit_code: None,
+            timestamp: chrono::Utc::now().to_string(),
+            duration: 0,
+            success: true,
+        }
+    }
+}

package/rust/cli/telemetry/mod.rs

@@ -1,3 +1,3 @@
-pub mod commands;
-pub mod event_creator;
-pub mod send;
+pub mod commands;
+pub mod event_creator;
+pub mod send;

package/rust/cli/telemetry/send.rs

@@ -1,51 +1,51 @@
-use std::time::Duration;
-
-use crate::{config::settings::get_user_config, web::api::get_api_url};
-use devalang_types::{TelemetryEvent, TelemetrySendError};
-
-pub async fn send_telemetry_event(event: &TelemetryEvent) -> Result<(), TelemetrySendError> {
-    if let Some(cfg) = get_user_config() {
-        if cfg.telemetry.enabled == false {
-            return Ok(());
-        }
-    } else {
-        return Ok(());
-    }
-
-    let telemetry_url = format!("{}/v1/telemetry/send", get_api_url());
-    let client = reqwest::Client::builder()
-        .timeout(Duration::from_secs(5))
-        .build()
-        .map_err(|e| TelemetrySendError::Http(format!("client build error: {}", e)))?;
-
-    let mut last_err: Option<String> = None;
-    for (i, delay_ms) in [0u64, 250, 500, 1000].iter().enumerate() {
-        if *delay_ms > 0 {
-            tokio::time::sleep(Duration::from_millis(*delay_ms)).await;
-        }
-
-        let res = client
-            .post(telemetry_url.clone())
-            .json(event)
-            .send()
-            .await
-            .and_then(|r| r.error_for_status());
-
-        match res {
-            Ok(_) => {
-                return Ok(());
-            }
-            Err(err) => {
-                last_err = Some(err.to_string());
-
-                if i == 3 {
-                    break;
-                }
-            }
-        }
-    }
-
-    Err(TelemetrySendError::Http(
-        last_err.unwrap_or_else(|| "unknown error".to_string()),
-    ))
-}
+use std::time::Duration;
+
+use crate::{config::settings::get_user_config, web::api::get_api_url};
+use devalang_types::{TelemetryEvent, TelemetrySendError};
+
+pub async fn send_telemetry_event(event: &TelemetryEvent) -> Result<(), TelemetrySendError> {
+    if let Some(cfg) = get_user_config() {
+        if cfg.telemetry.enabled == false {
+            return Ok(());
+        }
+    } else {
+        return Ok(());
+    }
+
+    let telemetry_url = format!("{}/v1/telemetry/send", get_api_url());
+    let client = reqwest::Client::builder()
+        .timeout(Duration::from_secs(5))
+        .build()
+        .map_err(|e| TelemetrySendError::Http(format!("client build error: {}", e)))?;
+
+    let mut last_err: Option<String> = None;
+    for (i, delay_ms) in [0u64, 250, 500, 1000].iter().enumerate() {
+        if *delay_ms > 0 {
+            tokio::time::sleep(Duration::from_millis(*delay_ms)).await;
+        }
+
+        let res = client
+            .post(telemetry_url.clone())
+            .json(event)
+            .send()
+            .await
+            .and_then(|r| r.error_for_status());
+
+        match res {
+            Ok(_) => {
+                return Ok(());
+            }
+            Err(err) => {
+                last_err = Some(err.to_string());
+
+                if i == 3 {
+                    break;
+                }
+            }
+        }
+    }
+
+    Err(TelemetrySendError::Http(
+        last_err.unwrap_or_else(|| "unknown error".to_string()),
+    ))
+}

package/rust/cli/template/commands.rs

@@ -1,69 +1,69 @@
-use devalang_utils::file::format_file_size;
-use include_dir::{Dir, DirEntry, include_dir};
-
-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();
-
-    println!("📦 Available templates ({}) :\n", available_templates.len());
-
-    for dir in available_templates {
-        println!("• {}", dir);
-    }
-
-    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);
-
-        std::process::exit(1);
-    });
-
-    let mut file_count = 0;
-    let mut dir_count = 0;
-    let mut total_size: u64 = 0;
-
-    fn walk(dir: &Dir, file_count: &mut u32, dir_count: &mut u32, total_size: &mut u64) {
-        for entry in dir.entries() {
-            match entry {
-                DirEntry::File(file) => {
-                    *file_count += 1;
-                    *total_size += file.contents().len() as u64;
-                }
-                DirEntry::Dir(subdir) => {
-                    *dir_count += 1;
-                    walk(subdir, file_count, dir_count, total_size);
-                }
-            }
-        }
-    }
-
-    walk(
-        template_dir,
-        &mut file_count,
-        &mut dir_count,
-        &mut total_size,
-    );
-
-    println!("📦 Template : {}", name);
-    println!("📂 Content  : {file_count} file(s), {dir_count} folder(s)");
-    println!("💾 Size     : {}", format_file_size(total_size));
-}
-
-pub fn get_available_templates() -> Vec<String> {
-    TEMPLATES_DIR
-        .dirs()
-        .map(|dir| {
-            dir.path()
-                .file_name()
-                .unwrap()
-                .to_string_lossy()
-                .to_string()
-        })
-        .collect()
-}
+use devalang_utils::file::format_file_size;
+use include_dir::{Dir, DirEntry, include_dir};
+
+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();
+
+    println!("📦 Available templates ({}) :\n", available_templates.len());
+
+    for dir in available_templates {
+        println!("• {}", dir);
+    }
+
+    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);
+
+        std::process::exit(1);
+    });
+
+    let mut file_count = 0;
+    let mut dir_count = 0;
+    let mut total_size: u64 = 0;
+
+    fn walk(dir: &Dir, file_count: &mut u32, dir_count: &mut u32, total_size: &mut u64) {
+        for entry in dir.entries() {
+            match entry {
+                DirEntry::File(file) => {
+                    *file_count += 1;
+                    *total_size += file.contents().len() as u64;
+                }
+                DirEntry::Dir(subdir) => {
+                    *dir_count += 1;
+                    walk(subdir, file_count, dir_count, total_size);
+                }
+            }
+        }
+    }
+
+    walk(
+        template_dir,
+        &mut file_count,
+        &mut dir_count,
+        &mut total_size,
+    );
+
+    println!("📦 Template : {}", name);
+    println!("📂 Content  : {file_count} file(s), {dir_count} folder(s)");
+    println!("💾 Size     : {}", format_file_size(total_size));
+}
+
+pub fn get_available_templates() -> Vec<String> {
+    TEMPLATES_DIR
+        .dirs()
+        .map(|dir| {
+            dir.path()
+                .file_name()
+                .unwrap()
+                .to_string_lossy()
+                .to_string()
+        })
+        .collect()
+}