@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-beta.1

package/rust/cli/play.rs

@@ -1,193 +0,0 @@
-use crate::{
-    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
-) {
-    use crate::core::audio::player::AudioPlayer;
-
-    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/config/loader.rs

@@ -1,13 +0,0 @@
-use std::{ fs, path::Path };
-use crate::config::Config;
-
-pub fn load_config(path: Option<&Path>) -> Option<Config> {
-    let config_path = path.unwrap_or_else(|| Path::new(".devalang"));
-
-    if config_path.exists() {
-        let content = fs::read_to_string(config_path).ok()?;
-        toml::from_str(&content).ok()
-    } else {
-        None
-    }
-}

package/rust/core/audio/engine.rs

@@ -1,126 +0,0 @@
-use std::{ collections::HashMap, fs::File, io::BufReader };
-use hound::{ SampleFormat, WavSpec, WavWriter };
-use rodio::{ Decoder, Source };
-
-use crate::core::{ store::variable::VariableTable, utils::path::normalize_path };
-
-const SAMPLE_RATE: u32 = 44100;
-const CHANNELS: u16 = 2;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct AudioEngine {
-    pub volume: f32,
-    pub variables: VariableTable,
-    pub buffer: Vec<i16>,
-}
-
-impl AudioEngine {
-    pub fn new() -> Self {
-        AudioEngine {
-            volume: 1.0,
-            buffer: vec![],
-            variables: VariableTable::new(),
-        }
-    }
-
-    pub fn mix(&mut self, other: &AudioEngine) {
-        let max_len = self.buffer.len().max(other.buffer.len());
-        self.buffer.resize(max_len, 0);
-
-        for (i, &sample) in other.buffer.iter().enumerate() {
-            self.buffer[i] = self.buffer[i].saturating_add(sample);
-        }
-    }
-
-    pub fn set_duration(&mut self, duration_secs: f32) {
-        let mut total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-
-        if total_samples % (CHANNELS as usize) != 0 {
-            total_samples += 1;
-        }
-
-        self.buffer.resize(total_samples, 0);
-    }
-
-    pub fn set_variables(&mut self, variables: VariableTable) {
-        self.variables = variables;
-    }
-
-    pub fn generate_wav_file(&mut self, output_dir: &String) -> Result<(), String> {
-        if self.buffer.len() % (CHANNELS as usize) != 0 {
-            self.buffer.push(0);
-            println!("Completed buffer to respect stereo format.");
-        }
-
-        let spec = WavSpec {
-            channels: CHANNELS,
-            sample_rate: SAMPLE_RATE,
-            bits_per_sample: 16,
-            sample_format: SampleFormat::Int,
-        };
-
-        let mut writer = WavWriter::create(output_dir, spec).map_err(|e|
-            format!("Error creating WAV file: {}", e)
-        )?;
-
-        for sample in &self.buffer {
-            writer.write_sample(*sample).map_err(|e| format!("Error writing sample: {:?}", e))?;
-        }
-
-        writer.finalize().map_err(|e| format!("Error finalizing WAV: {:?}", e))?;
-
-        Ok(())
-    }
-
-    pub fn insert(
-        &mut self,
-        filepath: &str,
-        time_secs: f32,
-        dur_sec: f32,
-        effects: Option<HashMap<String, f32>>
-    ) {
-        let normalized_filepath = normalize_path(filepath);
-
-        let file = BufReader::new(
-            File::open(normalized_filepath).expect("Failed to open audio file")
-        );
-        let decoder = Decoder::new(file).expect("Failed to decode audio file");
-
-        // Mono or stereo reading possible here, we will duplicate in L/R
-        let max_mono_samples = (dur_sec * (SAMPLE_RATE as f32)) as usize;
-        let samples: Vec<i16> = decoder.convert_samples().take(max_mono_samples).collect();
-
-        if samples.is_empty() {
-            eprintln!("No samples found in the audio file: {}", filepath);
-            return;
-        }
-
-        // TODO Apply effects here if needed
-        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-        let required_len = offset + samples.len() * (CHANNELS as usize);
-        let padded_required_len = if required_len % 2 == 1 {
-            required_len + 1
-        } else {
-            required_len
-        };
-
-        self.buffer.resize(padded_required_len, 0);
-        self.pad_samples(&samples, time_secs);
-    }
-
-    fn pad_samples(&mut self, samples: &[i16], time_secs: f32) {
-        let offset = (time_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-
-        for (i, &sample) in samples.iter().enumerate() {
-            let adjusted_sample = ((sample as f32) * self.volume).round() as i16;
-
-            let left_pos = offset + i * 2;
-            let right_pos = left_pos + 1;
-
-            if right_pos < self.buffer.len() {
-                self.buffer[left_pos] = self.buffer[left_pos].saturating_add(adjusted_sample); // gauche
-                self.buffer[right_pos] = self.buffer[right_pos].saturating_add(adjusted_sample); // droite
-            }
-        }
-    }
-}

package/rust/core/parser/handler/identifier.rs

@@ -1,262 +0,0 @@
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-use std::collections::HashMap;
-
-pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    let Some(current_token) = parser.peek_clone() else {
-        return Statement::unknown();
-    };
-
-    if current_token.lexeme == "let" {
-        parser.advance(); // consume "let"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'let'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'let'".to_string());
-        };
-
-        if !parser.match_token(TokenKind::Equals) {
-            return Statement::error(current_token, "Expected '=' after identifier".to_string());
-        }
-
-        let value = match parser.peek_clone() {
-            Some(token) if token.kind == TokenKind::Identifier => {
-                parser.advance();
-                Value::Identifier(token.lexeme.clone())
-            }
-            Some(token) if token.kind == TokenKind::String => {
-                parser.advance();
-                Value::String(token.lexeme.clone())
-            }
-            Some(token) if token.kind == TokenKind::Number => {
-                parser.advance();
-                Value::Number(token.lexeme.parse().unwrap_or(0.0))
-            }
-            Some(token) if token.kind == TokenKind::LBrace => {
-                parser.advance(); // consume '{'
-                let mut map = HashMap::new();
-
-                while let Some(key_token) = parser.peek_clone() {
-                    if key_token.kind == TokenKind::RBrace {
-                        parser.advance(); // consume '}'
-                        break;
-                    }
-
-                    if key_token.kind != TokenKind::Identifier {
-                        return Statement::error(
-                            token,
-                            "Expected key identifier in map".to_string()
-                        );
-                    }
-                    parser.advance();
-                    let key = key_token.lexeme.clone();
-
-                    if !parser.match_token(TokenKind::Colon) {
-                        let message = format!("Expected ':' after key '{}'", key);
-                        return Statement::error(token, message);
-                    }
-
-                    let val = match parser.peek_clone() {
-                        Some(t) if t.kind == TokenKind::Number => {
-                            parser.advance();
-                            Value::Number(t.lexeme.parse().unwrap_or(0.0))
-                        }
-                        Some(t) if t.kind == TokenKind::String => {
-                            parser.advance();
-                            Value::String(t.lexeme.clone())
-                        }
-                        Some(t) if t.kind == TokenKind::Identifier => {
-                            parser.advance();
-                            Value::Identifier(t.lexeme.clone())
-                        }
-                        _ => { Value::Null }
-                    };
-
-                    if val == Value::Null {
-                        let message = format!("Invalid value for key '{}'", key);
-                        return Statement::error(token, message);
-                    }
-
-                    map.insert(key, val);
-
-                    if let Some(t) = parser.peek() {
-                        if t.kind == TokenKind::Comma {
-                            parser.advance(); // skip comma
-                        }
-                    }
-                }
-
-                Value::Map(map)
-            }
-            other => {
-                let message = format!("Unexpected value token in let: {:?}", other);
-                return Statement::error(current_token, message);
-            }
-        };
-
-        return Statement {
-            kind: StatementKind::Let { name: identifier },
-            value,
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "group" {
-        parser.advance(); // consume "group"
-
-        let Some(identifier_token) = parser.peek_clone() else {
-            return Statement::error(current_token, "Expected identifier after 'group'".to_string());
-        };
-
-        if
-            identifier_token.kind != TokenKind::Identifier &&
-            identifier_token.kind != TokenKind::String
-        {
-            return Statement::error(identifier_token, "Expected valid identifier".to_string());
-        }
-
-        parser.advance(); // consume identifier
-
-        let Some(colon_token) = parser.peek_clone() else {
-            return Statement::error(
-                identifier_token,
-                "Expected ':' after group identifier".to_string()
-            );
-        };
-
-        if colon_token.kind != TokenKind::Colon {
-            return Statement::error(
-                colon_token.clone(),
-                "Expected ':' after group identifier".to_string()
-            );
-        }
-
-        parser.advance(); // consume ':'
-
-        let base_indent = current_token.indent;
-
-        // Clone without consuming tokens
-        let mut index = parser.token_index;
-        let mut tokens_inside_group = Vec::new();
-
-        while index < parser.tokens.len() {
-            let token = parser.tokens[index].clone();
-
-            if token.indent <= base_indent && token.kind != TokenKind::Newline {
-                break;
-            }
-
-            tokens_inside_group.push(token);
-            index += 1;
-        }
-
-        // Advance index once to skip the processed tokens
-        parser.token_index = index;
-
-        let body = parser.parse_block(tokens_inside_group, global_store);
-
-        let mut value_map = HashMap::new();
-        value_map.insert("identifier".to_string(), Value::String(identifier_token.lexeme.clone()));
-        value_map.insert("body".to_string(), Value::Block(body));
-
-        return Statement {
-            kind: StatementKind::Group,
-            value: Value::Map(value_map),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "call" {
-        parser.advance(); // consume "call"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'call'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'call'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Call,
-            value: Value::String(identifier),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "spawn" {
-        parser.advance(); // consume "spawn"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'spawn'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'spawn'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Spawn,
-            value: Value::String(identifier),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "sleep" {
-        parser.advance(); // consume "sleep"
-
-        let duration = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Number {
-                parser.advance();
-                token.lexeme.parse().unwrap_or(0.0)
-            } else {
-                return Statement::error(token, "Expected number after 'sleep'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected number after 'sleep'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Sleep,
-            value: Value::Number(duration),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else {
-        // Unknown identifier handling
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::String(current_token.lexeme.clone()),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    }
-
-    parser.advance(); // unknown identifier fallback
-
-    Statement {
-        kind: StatementKind::Unknown,
-        value: Value::String(current_token.lexeme.clone()),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}

package/rust/core/shared/duration.rs

@@ -1,8 +0,0 @@
-use serde::{ Deserialize, Serialize };
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum Duration {
-    Number(f32),
-    Identifier(String),
-    Auto,
-}

package/rust/core/shared/mod.rs

@@ -1,2 +0,0 @@
-pub mod value;
-pub mod duration;

package/rust/core/shared/value.rs

@@ -1,18 +0,0 @@
-use std::collections::HashMap;
-use serde::{ Deserialize, Serialize };
-
-use crate::core::parser::statement::Statement;
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub enum Value {
-    Boolean(bool),
-    Number(f32),
-    Identifier(String),
-    String(String),
-    Array(Vec<Value>),
-    Map(HashMap<String, Value>),
-    Block(Vec<Statement>),
-    Sample(String),
-    Unknown,
-    Null,
-}

package/rust/core/utils/validation.rs

@@ -1,35 +0,0 @@
-use crate::core::{ preprocessor::module::Module, shared::value::Value, store::global::GlobalStore };
-
-pub fn is_valid_entity(entity: &str, module: &Module, global_store: &GlobalStore) -> bool {
-    let built_ins = ["kick", "snare", "hat", "clap"];
-
-    if built_ins.contains(&entity) {
-        return true;
-    }
-
-    if let Some(val) = module.variable_table.get(entity) {
-        match val {
-            Value::Sample(_) => true,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}
-
-pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
-    let built_ins = ["auto"];
-
-    if built_ins.contains(&ident) {
-        return true;
-    }
-
-    if let Some(val) = module.variable_table.get(ident) {
-        match val {
-            Value::Identifier(_) => true,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}

package/rust/utils/file.rs

@@ -1,35 +0,0 @@
-use std::{ fs::{ self }, path::Path };
-use include_dir::{ Dir, DirEntry };
-
-pub fn copy_dir_recursive(dir: &Dir, target_root: &Path, base_path: &Path) {
-    for entry in dir.entries() {
-        match entry {
-            DirEntry::Dir(subdir) => {
-                copy_dir_recursive(subdir, target_root, base_path);
-            }
-            DirEntry::File(file) => {
-                let rel_path = file.path().strip_prefix(base_path).unwrap();
-                let dest_path = target_root.join(rel_path);
-
-                if let Some(parent) = dest_path.parent() {
-                    fs::create_dir_all(parent).unwrap();
-                }
-
-                fs::write(&dest_path, file.contents()).expect("Error writing file");
-            }
-        }
-    }
-}
-
-pub fn format_file_size(bytes: u64) -> String {
-    const KB: u64 = 1024;
-    const MB: u64 = 1024 * 1024;
-
-    if bytes >= MB {
-        format!("{:.2} Mb", (bytes as f64) / (MB as f64))
-    } else if bytes >= KB {
-        format!("{:.2} Kb", (bytes as f64) / (KB as f64))
-    } else {
-        format!("{} bytes", bytes)
-    }
-}