@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.10

package/rust/cli/template.rs

@@ -0,0 +1,57 @@
+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();
+
+    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()
+}

package/rust/config/loader.rs

@@ -0,0 +1,13 @@
+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/config/mod.rs

@@ -0,0 +1,16 @@
+pub mod loader;
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Config {
+    pub defaults: ConfigDefaults,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct ConfigDefaults {
+    pub entry: Option<String>,
+    pub output: Option<String>,
+    pub watch: Option<bool>,
+    pub repeat: Option<bool>,
+}

package/rust/core/audio/engine.rs

@@ -0,0 +1,214 @@
+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 get_buffer(&self) -> &[i16] {
+        &self.buffer
+    }
+
+    pub fn get_normalized_buffer(&self) -> Vec<f32> {
+        self.buffer
+            .iter()
+            .map(|&s| (s as f32) / 32768.0)
+            .collect()
+    }
+
+    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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,129 @@
+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

@@ -0,0 +1,70 @@
+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,
+    all_statements: &Vec<Statement>
+) -> (AudioEngine, f32, f32, f32) {
+    match &stmt.value {
+        Value::String(identifier) | Value::Identifier(identifier) => {
+            if
+                let Some(group_stmt) = all_statements
+                    .iter()
+                    .find(|s| {
+                        matches!(s.kind, StatementKind::Group) &&
+                            s.value.get("identifier") == Some(&Value::String(identifier.clone()))
+                    })
+            {
+                if let Some(Value::Block(block)) = group_stmt.value.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, cursor_time);
+                } else {
+                    eprintln!("❌ Group '{}' found but no valid body block", identifier);
+                }
+            } else {
+                eprintln!("❌ Group '{}' not found in statements", 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, cursor_time);
+            } else {
+                eprintln!("❌ Call map has no 'body' block");
+            }
+        }
+
+        other => {
+            eprintln!("❌ Invalid call statement: expected identifier or map, found {:?}", other);
+        }
+    }
+
+    (audio_engine, base_bpm, max_end_time, cursor_time)
+}

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

@@ -0,0 +1,69 @@
+use crate::core::{
+    audio::{
+        engine::AudioEngine,
+        evaluator::evaluate_condition_string,
+        interpreter::driver::execute_audio_block,
+    },
+    parser::statement::Statement,
+    shared::value::Value,
+    store::variable::VariableTable,
+};
+
+pub fn interprete_condition_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) {
+    let mut engine = audio_engine.clone();
+    let mut vars = variable_table.clone();
+    let mut cur_time = cursor_time;
+    let mut max_time = max_end_time;
+
+    let mut current = stmt.value.clone();
+
+    loop {
+        let Value::Map(map) = current else {
+            break;
+        };
+
+        let should_execute = match map.get("condition") {
+            Some(Value::Boolean(b)) => *b,
+            Some(Value::String(expr)) => evaluate_condition_string(expr, &vars),
+            Some(_) => false,
+            None => true,
+        };
+
+        if should_execute {
+            if let Some(Value::Block(block)) = map.get("body") {
+                let (new_engine, _, new_max) = execute_audio_block(
+                    engine,
+                    vars,
+                    block.clone(),
+                    base_bpm,
+                    base_duration,
+                    max_time,
+                    cur_time
+                );
+                return (new_engine, new_max, new_max);
+            } else {
+                break;
+            }
+        }
+
+        // Advance to the next condition
+        match map.get("next") {
+            Some(Value::Map(next_map)) => {
+                current = Value::Map(next_map.clone());
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+
+    (audio_engine, max_end_time, cursor_time)
+}