@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.2

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,203 +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, resolve_relative_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>,
-    pub module_name: String,
-}
-
-impl AudioEngine {
-    pub fn new(module_name: String) -> Self {
-        AudioEngine {
-            volume: 1.0,
-            buffer: vec![],
-            variables: VariableTable::new(),
-            module_name,
-        }
-    }
-
-    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 merge_with(&mut self, other: AudioEngine) {
-        if other.buffer.iter().all(|&s| s == 0) {
-            eprintln!("⚠️ Skipping merge: other buffer is silent");
-            return;
-        }
-
-        if self.buffer.iter().all(|&s| s == 0) {
-            self.buffer = other.buffer;
-            self.variables.variables.extend(other.variables.variables);
-            return;
-        }
-
-        self.mix(&other);
-        self.variables.variables.extend(other.variables.variables);
-    }
-
-    pub fn set_duration(&mut self, duration_secs: f32) {
-        let total_samples = (duration_secs * (SAMPLE_RATE as f32) * (CHANNELS as f32)) as usize;
-
-        if self.buffer.len() < total_samples {
-            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_note(
-        &mut self,
-        waveform: String,
-        freq: f32,
-        amp: f32,
-        start_time_ms: f32,
-        duration_ms: f32
-    ) {
-        let sample_rate = SAMPLE_RATE as f32;
-        let channels = CHANNELS as usize;
-
-        let total_samples = ((duration_ms / 1000.0) * sample_rate) as usize;
-        let start_sample = ((start_time_ms / 1000.0) * sample_rate) as usize;
-        let amplitude = (i16::MAX as f32) * amp.clamp(0.0, 1.0);
-
-        let mut samples = Vec::with_capacity(total_samples);
-        let fade_len = (sample_rate * 0.01) as usize; // 10 ms fade
-
-        for i in 0..total_samples {
-            let t = ((start_sample + i) as f32) / sample_rate;
-            let phase = 2.0 * std::f32::consts::PI * freq * t;
-
-            let mut value = match waveform.as_str() {
-                "sine" => phase.sin(),
-                "square" => if phase.sin() >= 0.0 { 1.0 } else { -1.0 }
-                "saw" => 2.0 * (freq * t - (freq * t + 0.5).floor()),
-                "triangle" => (2.0 * (2.0 * (freq * t).fract() - 1.0)).abs() * 2.0 - 1.0,
-                _ => 0.0,
-            };
-
-            // Fade in/out
-            if i < fade_len {
-                value *= (i as f32) / (fade_len as f32);
-            } else if i >= total_samples - fade_len {
-                value *= ((total_samples - i) as f32) / (fade_len as f32);
-            }
-
-            samples.push((value * amplitude) as i16);
-        }
-
-        // Convert to stereo
-        let stereo_samples: Vec<i16> = samples
-            .iter()
-            .flat_map(|s| vec![*s, *s])
-            .collect();
-
-        let offset = start_sample * channels;
-        let required_len = offset + stereo_samples.len();
-
-        if self.buffer.len() < required_len {
-            self.buffer.resize(required_len, 0);
-        }
-
-        for (i, sample) in stereo_samples.iter().enumerate() {
-            if *sample != 0 {
-            }
-            self.buffer[offset + i] = self.buffer[offset + i].saturating_add(*sample);
-        }
-    }
-
-    pub fn insert_sample(
-        &mut self,
-        filepath: &str,
-        time_secs: f32,
-        dur_sec: f32,
-        effects: Option<HashMap<String, f32>>
-    ) {
-        let resolved = resolve_relative_path(&self.module_name.clone(), filepath);
-
-        let file = BufReader::new(File::open(resolved).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/audio/evaluator.rs

@@ -1,31 +0,0 @@
-use crate::core::{ shared::value::Value, store::variable::VariableTable };
-
-pub fn evaluate_condition_string(expr: &str, vars: &VariableTable) -> bool {
-    let tokens: Vec<&str> = expr.split_whitespace().collect();
-    if tokens.len() != 3 {
-        return false;
-    }
-
-    let left = tokens[0];
-    let op = tokens[1];
-    let right = tokens[2];
-
-    let left_val = match vars.get(left) {
-        Some(Value::Number(n)) => *n,
-        _ => {
-            return false;
-        }
-    };
-
-    let right_val: f32 = right.parse().unwrap_or(0.0);
-
-    match op {
-        ">" => left_val > right_val,
-        "<" => left_val < right_val,
-        ">=" => left_val >= right_val,
-        "<=" => left_val <= right_val,
-        "==" => (left_val - right_val).abs() < f32::EPSILON,
-        "!=" => (left_val - right_val).abs() > f32::EPSILON,
-        _ => false,
-    }
-}

package/rust/core/audio/interpreter/arrow_call.rs

@@ -1,129 +0,0 @@
-use crate::core::{
-    audio::engine::AudioEngine,
-    parser::statement::{ Statement, StatementKind },
-    shared::value::Value,
-    store::variable::VariableTable,
-};
-
-use std::collections::HashMap;
-
-pub fn interprete_call_arrow_statement(
-    stmt: &Statement,
-    audio_engine: &mut AudioEngine,
-    variable_table: &VariableTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: &mut f32,
-    mut cursor_time: Option<&mut f32>,
-    update_cursor: bool
-) -> (f32, f32) {
-    let cursor_copy = cursor_time
-        .as_ref()
-        .map(|c| **c)
-        .unwrap_or(0.0);
-
-    if let StatementKind::ArrowCall { target, method, args } = &stmt.kind {
-        let Some(Value::Map(synth_map)) = variable_table.get(target) else {
-            println!("❌ Synth '{}' not found in variable table", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::String(entity)) = synth_map.get("entity") else {
-            println!("❌ Missing 'entity' key in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        if entity != "synth" {
-            println!("❌ '{}' is not a synth, entity is '{}'.", target, entity);
-            return (*max_end_time, cursor_copy);
-        }
-
-        let Some(Value::Map(value_map)) = synth_map.get("value") else {
-            println!("❌ Missing 'value' map in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::String(waveform)) = value_map.get("waveform") else {
-            println!("❌ Missing or invalid 'waveform' in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let Some(Value::Map(params)) = value_map.get("parameters") else {
-            println!("❌ Missing or invalid 'parameters' in synth '{}'.", target);
-            return (*max_end_time, cursor_copy);
-        };
-
-        let freq = extract_f32(params, "freq").unwrap_or(440.0);
-        let amp = extract_f32(params, "amp").unwrap_or(1.0);
-
-        if method == "note" {
-            let Some(Value::Identifier(note_name)) = args.get(0) else {
-                println!("❌ Invalid or missing argument for 'note' method on '{}'.", target);
-                return (*max_end_time, cursor_copy);
-            };
-
-            let mut final_note_params = HashMap::new();
-            if let Some(Value::Map(note_params)) = args.get(1) {
-                for (key, value) in note_params {
-                    final_note_params.insert(key.clone(), value.clone());
-                }
-            }
-
-            let duration_ms = extract_f32(&final_note_params, "duration").unwrap_or(base_duration);
-            let duration_secs = duration_ms / 1000.0;
-
-            let final_freq = note_to_freq(note_name);
-            let start_time = cursor_copy;
-            let end_time = start_time + duration_secs;
-
-            audio_engine.insert_note(
-                waveform.clone(),
-                final_freq,
-                amp,
-                start_time * 1000.0,
-                duration_ms
-            );
-
-            *max_end_time = (*max_end_time).max(end_time);
-
-            if update_cursor {
-                if let Some(c) = cursor_time.as_mut() {
-                    **c = end_time;
-                }
-            }
-
-            return (*max_end_time, end_time);
-        } else {
-            println!("❌ Unknown method '{}' on synth '{}'.", method, target);
-        }
-    }
-
-    (*max_end_time, cursor_copy)
-}
-
-fn extract_f32(map: &HashMap<String, Value>, key: &str) -> Option<f32> {
-    map.get(key).and_then(|v| {
-        match v {
-            Value::Number(n) => Some(*n),
-            _ => None,
-        }
-    })
-}
-
-fn note_to_freq(note: &str) -> f32 {
-    let notes = vec!["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
-
-    if note.len() < 2 || note.len() > 3 {
-        return 440.0;
-    }
-
-    let (name, octave_str) = note.split_at(note.len() - 1);
-    let semitone = notes
-        .iter()
-        .position(|&n| n == name)
-        .unwrap_or(9) as i32;
-    let octave = octave_str.parse::<i32>().unwrap_or(4);
-    let midi_note = (octave + 1) * 12 + semitone;
-
-    440.0 * (2.0_f32).powf(((midi_note as f32) - 69.0) / 12.0)
-}

package/rust/core/audio/interpreter/call.rs

@@ -1,64 +0,0 @@
-use crate::core::{
-    audio::{ engine::AudioEngine, interpreter::{ driver::execute_audio_block } },
-    parser::statement::{ Statement, StatementKind },
-    shared::{ duration::Duration, value::Value },
-    store::variable::VariableTable,
-};
-
-pub fn interprete_call_statement(
-    stmt: &Statement,
-    audio_engine: AudioEngine,
-    variable_table: VariableTable,
-    base_bpm: f32,
-    base_duration: f32,
-    max_end_time: f32,
-    cursor_time: f32
-) -> (AudioEngine, f32, f32) {
-    match &stmt.value {
-        Value::String(identifier) | Value::Identifier(identifier) => {
-            if let Some(Value::Map(map)) = variable_table.clone().get(identifier) {
-                if let Some(Value::Block(block)) = map.get("body") {
-                    let (eng, _, end_time) = execute_audio_block(
-                        audio_engine,
-                        variable_table,
-                        block.clone(),
-                        base_bpm,
-                        base_duration,
-                        max_end_time,
-                        cursor_time
-                    );
-
-                    return (eng, max_end_time.max(end_time), end_time);
-                } else {
-                    eprintln!("❌ Group '{}' has no 'body' block", identifier);
-                }
-            } else {
-                eprintln!("❌ Group '{}' not found or not a map", identifier);
-            }
-        }
-
-        Value::Map(map) => {
-            if let Some(Value::Block(block)) = map.get("body") {
-                let (eng, _, end_time) = execute_audio_block(
-                    audio_engine,
-                    variable_table,
-                    block.clone(),
-                    base_bpm,
-                    base_duration,
-                    max_end_time,
-                    cursor_time
-                );
-
-                return (eng, max_end_time.max(end_time), end_time);
-            } else {
-                eprintln!("❌ Call map has no 'body' block");
-            }
-        }
-
-        other => {
-            eprintln!("❌ Invalid call statement: expected identifier or map, found {:?}", other);
-        }
-    }
-
-    (audio_engine, max_end_time, cursor_time)
-}

package/rust/core/audio/interpreter/let_.rs

@@ -1,19 +0,0 @@
-use crate::core::{
-    audio::engine::AudioEngine,
-    parser::statement::{ Statement, StatementKind },
-    shared::value::Value,
-    store::variable::VariableTable,
-};
-
-pub fn interprete_let_statement(
-    stmt: &Statement,
-    variable_table: &mut VariableTable
-) -> Option<VariableTable> {
-    if let StatementKind::Let { name } = &stmt.kind {
-        variable_table.set(name.to_string(), stmt.value.clone());
-
-        return Some(variable_table.clone())
-    } 
-    
-    None
-}

package/rust/core/audio/interpreter/load.rs

@@ -1,18 +0,0 @@
-use crate::core::{
-    parser::statement::{ Statement, StatementKind },
-    shared::value::Value,
-    store::variable::VariableTable,
-};
-
-pub fn interprete_load_statement(
-    stmt: &Statement,
-    variable_table: &mut VariableTable
-) -> Option<VariableTable> {
-    if let StatementKind::Load { source, alias } = &stmt.kind {
-        variable_table.set(alias.to_string(), Value::String(source.clone()));
-
-        return Some(variable_table.clone());
-    }
-
-    None
-}