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

package/rust/cli/init.rs

@@ -0,0 +1,79 @@
+use std::{ fs, path::Path };
+use include_dir::{ include_dir, Dir };
+use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
+
+#[cfg(feature = "cli")]
+use inquire::{ Select, Confirm };
+
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+#[cfg(feature = "cli")]
+pub fn handle_init_command(name: Option<String>, template: Option<String>) {
+    let current_dir = std::env::current_dir().unwrap();
+    let project_name = name
+        .clone()
+        .unwrap_or_else(|| {
+            current_dir.file_name().unwrap_or_default().to_string_lossy().to_string()
+        });
+
+    // Select a template if not provided
+    let selected_template = template.unwrap_or_else(|| {
+        Select::new("Select a template for your project:", get_available_templates())
+            .prompt()
+            .unwrap_or_else(|_| {
+                eprintln!("No template selected. Exiting...");
+                std::process::exit(1);
+            })
+    });
+
+    if selected_template.is_empty() {
+        eprintln!("Template cannot be empty.");
+        std::process::exit(1);
+    }
+
+    if name.is_none() {
+        // Case of initialization in the current directory
+        if fs::read_dir(&current_dir).unwrap().next().is_some() {
+            let confirm = Confirm::new(
+                "The current directory is not empty. Do you want to continue?"
+            )
+                .with_default(false)
+                .prompt()
+                .unwrap_or(false);
+
+            if !confirm {
+                eprintln!("Operation cancelled by the user.");
+                std::process::exit(0);
+            }
+        }
+
+        scaffold_project_current_dir(current_dir.as_path(), selected_template);
+        println!(
+            "✅ Initialized '{}' project in current directory: {}",
+            project_name,
+            current_dir.display()
+        );
+    } else {
+        // Case of initialization in a new directory
+        let target_path = current_dir.join(&project_name);
+
+        if target_path.exists() {
+            eprintln!("❌ A folder named '{}' already exists.", project_name);
+            std::process::exit(1);
+        }
+
+        fs::create_dir_all(&target_path).expect("Error creating project directory");
+
+        scaffold_project_current_dir(&target_path, selected_template);
+        println!("✅ Initialized '{}' project in: {}", project_name, target_path.display());
+    }
+}
+
+fn scaffold_project_current_dir(path: &Path, template: String) {
+    let template_dir = TEMPLATES_DIR.get_dir(&template).unwrap_or_else(|| {
+        eprintln!("❌ The template '{}' doesn't exist.", template);
+        std::process::exit(1);
+    });
+
+    copy_dir_recursive(template_dir, path, &template_dir.path());
+}

package/rust/cli/install.rs

@@ -0,0 +1,17 @@
+use crate::installer::bank::install_bank;
+
+#[cfg(feature = "cli")]
+pub async fn handle_install_bank_command(name: String) -> Result<(), String> {
+    let deva_dir = std::path::Path::new("./.deva/");
+
+    println!("⬇️  Installing bank '{}'...", name);
+    println!("📂 Target directory: {}", deva_dir.display());
+
+    if let Err(e) = install_bank(name.as_str(), deva_dir).await {
+        eprintln!("❌ Error installing bank '{}': {}", name, e);
+    } else {
+        println!("✅ Bank '{}' installed successfully!", name);
+    }
+
+    Ok(())
+}

package/rust/cli/mod.rs

@@ -1,3 +1,10 @@
+pub mod driver;
+
 pub mod check;
-pub mod new;
 pub mod build;
+pub mod init;
+pub mod template;
+pub mod play;
+pub mod install;
+pub mod bank;
+pub mod update;

package/rust/cli/play.rs

@@ -0,0 +1,193 @@
+use crate::{
+    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 },
+    },
+    config::driver::Config,
+    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/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/cli/update.rs

@@ -0,0 +1,4 @@
+pub async fn handle_update_command(only: Option<String>) -> Result<(), Box<dyn std::error::Error>> {
+    println!("Updates are not yet implemented. This is a placeholder function.");
+    Ok(())
+}

package/rust/common/cdn.rs

@@ -0,0 +1,11 @@
+pub fn get_cdn_url() -> String {
+    let cdn_url = std::env
+        ::var("CDN_URL")
+        .unwrap_or_else(|_| "https://cdn.devalang.com".to_string());
+
+    if !cdn_url.ends_with('/') {
+        format!("{}/", cdn_url)
+    } else {
+        cdn_url
+    }
+}

package/rust/common/mod.rs

@@ -0,0 +1 @@
+pub mod cdn;

package/rust/config/driver.rs

@@ -0,0 +1,76 @@
+use serde::{ Deserialize, Serialize };
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct Config {
+    pub defaults: ConfigDefaults,
+    pub banks: Option<Vec<BankEntry>>,
+}
+
+#[derive(Debug, Deserialize, Clone, Serialize)]
+pub struct ConfigDefaults {
+    pub entry: Option<String>,
+    pub output: Option<String>,
+    pub watch: Option<bool>,
+    pub repeat: Option<bool>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
+pub struct BankEntry {
+    pub path: String,
+    pub version: Option<String>,
+    pub author: Option<String>,
+}
+
+impl Config {
+    pub fn new() -> Self {
+        Config {
+            defaults: ConfigDefaults {
+                entry: None,
+                output: None,
+                watch: None,
+                repeat: None,
+            },
+            banks: Some(Vec::new()),
+        }
+    }
+
+    pub fn with_defaults(
+        entry: Option<String>,
+        output: Option<String>,
+        watch: Option<bool>,
+        repeat: Option<bool>
+    ) -> Self {
+        Config {
+            defaults: ConfigDefaults {
+                entry,
+                output,
+                watch,
+                repeat,
+            },
+            banks: Some(Vec::new()),
+        }
+    }
+
+    pub fn from_string(config_string: &str) -> Result<(Self, String), String> {
+        let config: Config = toml
+            ::from_str(config_string)
+            .map_err(|e| format!("Failed to parse config string: {}", e))?;
+        let config_path = ".devalang".to_string();
+
+        Ok((config, config_path))
+    }
+
+    pub fn write(&self, new_config: &Config) -> Result<(), String> {
+        let config_path = ".devalang";
+
+        let content = toml
+            ::to_string(new_config)
+            .map_err(|e| format!("Failed to serialize config: {}", e))?;
+
+        std::fs
+            ::write(config_path, content)
+            .map_err(|e| format!("Failed to write config to file '{}': {}", config_path, e))?;
+
+        Ok(())
+    }
+}

package/rust/config/loader.rs

@@ -0,0 +1,110 @@
+use std::{ fs, path::Path };
+use std::collections::HashMap;
+use crate::config::driver::{ BankEntry, 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
+    }
+}
+
+pub fn update_bank_version_in_config(config: &mut Config, dependency: &str, new_version: &str) {
+    // Si le vecteur banks n'existe pas, on ne fait rien
+    if config.banks.is_none() {
+        println!("No banks configured.");
+        return;
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    if let Some(bank) = banks.iter_mut().find(|b| b.path.contains(dependency)) {
+        bank.version = Some(new_version.to_string());
+
+        if let Err(e) = config.write(config) {
+            eprintln!("❌ Failed to write config: {}", e);
+        } else {
+            println!("✅ Bank '{}' updated to version '{}'", dependency, new_version);
+        }
+    } else {
+        println!("Bank '{}' not found in config", dependency);
+    }
+}
+
+pub fn remove_bank_from_config(config: &mut Config, dependency: &str) {
+    if config.banks.is_none() {
+        println!("No banks configured.");
+        return;
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    if let Some(index) = banks.iter().position(|b| b.path.contains(dependency)) {
+        banks.remove(index);
+
+        if let Err(e) = config.write(config) {
+            eprintln!("❌ Failed to write config: {}", e);
+        } else {
+            println!("✅ Bank '{}' removed from config", dependency);
+        }
+    } else {
+        println!("Bank '{}' not found in config", dependency);
+    }
+}
+
+pub fn add_bank_to_config(config: &mut Config, real_path: &Path, dependency: &str) {
+    if config.banks.is_none() {
+        config.banks = Some(Vec::new());
+    }
+
+    let banks = config.banks.as_mut().unwrap();
+
+    let exists = banks.iter().any(|b| b.path == dependency);
+    if exists {
+        println!("Bank '{}' already in config", dependency);
+        return;
+    }
+
+    let metadata_path = Path::new(real_path).join("bank.toml");
+
+    if !metadata_path.exists() {
+        eprintln!("❌ Bank metadata file '{}' does not exist", metadata_path.display());
+        return;
+    }
+
+    let metadata_content = fs
+        ::read_to_string(&metadata_path)
+        .expect("Failed to read bank metadata file");
+
+    let metadata: HashMap<String, String> = toml
+        ::from_str(&metadata_content)
+        .expect("Failed to parse bank metadata file");
+
+    let bank_to_insert = BankEntry {
+        path: dependency.to_string(),
+        version: Some(
+            metadata
+                .get("version")
+                .cloned()
+                .unwrap_or_else(|| "0.0.1".to_string())
+        ),
+        author: Some(
+            metadata
+                .get("author")
+                .cloned()
+                .unwrap_or_else(|| "unknown".to_string())
+        ),
+    };
+
+    banks.push(bank_to_insert);
+
+    if let Err(e) = config.write(config) {
+        eprintln!("❌ Failed to write config: {}", e);
+    } else {
+        println!("✅ Bank '{}' added to config", dependency);
+    }
+}

package/rust/config/mod.rs

@@ -0,0 +1,2 @@
+pub mod loader;
+pub mod driver;