@devaloop/devalang 0.0.1-alpha.2 → 0.0.1-alpha.4

package/rust/cli/check.rs

@@ -1,29 +1,20 @@
-use std::{ thread, time::Duration };
-
 use crate::{
+    config::Config,
     core::{
-        debugger::Debugger,
-        preprocessor::module::load_all_modules,
-        types::{
-            config::{ DevalangConfig },
-            statement::{ StatementKind, StatementResolved, StatementResolvedValue },
-        },
-    },
-    runner::executer::execute_statements,
-    utils::{
-        loader::with_spinner,
-        logger::log_message,
-        path::{ find_entry_file, normalize_path },
-        watcher::watch_directory,
+        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::{ thread, time::Duration };
 
 pub fn handle_check_command(
-    config: Option<DevalangConfig>,
+    config: Option<Config>,
     entry: Option<String>,
     output: Option<String>,
     watch: bool
-) -> () {
+) {
     let fetched_entry = if entry.is_none() {
         config
             .as_ref()
@@ -51,36 +42,51 @@ pub fn handle_check_command(
             .unwrap_or(false)
     };
 
+    let logger = Logger::new();
+
     if fetched_entry.is_empty() {
-        eprintln!("❌ Entry path is not specified. Please provide a valid entry path.");
+        logger.log_message(
+            LogLevel::Error,
+            "Entry path is not specified. Please provide a valid entry path."
+        );
         std::process::exit(1);
     }
-
     if fetched_output.is_empty() {
-        eprintln!("❌ Output directory is not specified. Please provide a valid output directory.");
+        logger.log_message(
+            LogLevel::Error,
+            "Output directory is not specified. Please provide a valid output directory."
+        );
         std::process::exit(1);
     }
 
     let entry_file = find_entry_file(&fetched_entry).unwrap_or_else(|| {
-        eprintln!("❌ index.deva not found in directory: {}", fetched_entry);
+        logger.log_message(
+            LogLevel::Error,
+            &format!("❌ index.deva not found in directory: {}", fetched_entry)
+        );
         std::process::exit(1);
     });
 
-    if fetched_watch.clone() == true {
-        log_message("Watch mode enabled, waiting for file changes...", "INFO");
+    // SECTION Begin check
+    if fetched_watch {
+        begin_check(entry_file.clone(), fetched_output.clone());
 
-        begin_check(entry_file.clone(), fetched_output.clone(), fetched_watch.clone());
+        logger.log_message(
+            LogLevel::Watcher,
+            &format!("Watching for changes in '{}'...", fetched_entry)
+        );
 
         watch_directory(entry_file.clone(), move || {
-            log_message("File change detected, rebuilding...", "INFO");
-            begin_check(entry_file.clone(), fetched_output.clone(), fetched_watch.clone());
+            logger.log_message(LogLevel::Watcher, "Detected changes, re-checking...");
+
+            begin_check(entry_file.clone(), fetched_output.clone());
         }).unwrap();
     } else {
-        begin_check(entry_file.clone(), fetched_output.clone(), fetched_watch.clone());
+        begin_check(entry_file.clone(), fetched_output.clone());
     }
 }
 
-fn begin_check(entry: String, output: String, watch: bool) {
+fn begin_check(entry: String, output: String) {
     let spinner = with_spinner("Checking...", || {
         thread::sleep(Duration::from_millis(800));
     });
@@ -90,91 +96,21 @@ fn begin_check(entry: String, output: String, watch: bool) {
     let normalized_entry_file = normalize_path(&entry);
     let normalized_output_dir = normalize_path(&output);
 
-    let global_store = load_all_modules(&normalized_entry_file);
-
-    if let Some(module) = global_store.modules.get(&normalized_entry_file) {
-        let mut module_clone = module.clone();
-
-        let resolved_statements = execute_statements(&mut module_clone);
-
-        let debugger = Debugger::new(&module_clone);
-        let debug_dir = format!("{}/debug/", normalized_output_dir.clone());
-        debugger.write_files(debug_dir.as_str(), resolved_statements.clone());
+    let mut global_store = GlobalStore::new();
+    let module_loader = ModuleLoader::new(&normalized_entry_file, &normalized_output_dir);
 
-        let has_errors = resolved_statements
-            .iter()
-            .any(|stmt| { match_error_recursively_resolved(&stmt.clone()) });
+    // SECTION Load
+    // NOTE: We don't use modules in the check command, but we still need to load them
+    let modules = module_loader.load_all(&mut global_store);
 
-        if has_errors {
-            let warning_message = format!(
-                "Check completed with errors in {:.2?}. Output files written to: '{}'",
-                duration.elapsed(),
-                normalized_output_dir
-            );
+    // TODO: Implement debugging
 
-            log_message(&warning_message, "WARNING");
-        } else {
-            let success_message = format!(
-                "Check completed successfully in {:.2?}. Output files written to: '{}'",
-                duration.elapsed(),
-                normalized_output_dir
-            );
-
-            log_message(&success_message, "SUCCESS");
-        }
-    }
-}
-
-fn match_error_recursively_resolved(stmt: &StatementResolved) -> bool {
-    match stmt.value.clone() {
-        // TODO Other statement value types here
-
-        StatementResolvedValue::Map(map) => {
-            for (key, value) in map {
-                if match_error_recursively_resolved_value(&value) {
-                    return true;
-                }
-            }
-        }
-
-        StatementResolvedValue::Array(array) => {
-            for item in array {
-                if match_error_recursively_resolved(&item) {
-                    return true;
-                }
-            }
-        }
-
-        _ => {
-            if let StatementKind::Error = stmt.kind {
-                eprintln!("❌ Error found in statement: {:?}", stmt);
-                return true;
-            }
-        }
-    }
-
-    false
-}
-
-fn match_error_recursively_resolved_value(value: &StatementResolvedValue) -> bool {
-    match value {
-        StatementResolvedValue::Map(map) => {
-            for (_, v) in map {
-                if match_error_recursively_resolved_value(v) {
-                    return true;
-                }
-            }
-        }
-
-        StatementResolvedValue::Array(array) => {
-            for item in array {
-                if match_error_recursively_resolved(item) {
-                    return true;
-                }
-            }
-        }
-        _ => {}
-    }
+    let success_message = format!(
+        "Check completed successfully in {:.2?}. Output files written to: '{}'",
+        duration.elapsed(),
+        normalized_output_dir
+    );
 
-    false
+    let logger = Logger::new();
+    logger.log_message(LogLevel::Success, &success_message);
 }

package/rust/cli/init.rs

@@ -2,7 +2,7 @@ use std::{ fs, path::Path };
 use include_dir::{ include_dir, Dir };
 use inquire::{ Select, Confirm };
 
-use crate::{ cli::template::{ get_available_templates }, utils::file::copy_dir_recursive };
+use crate::{ cli::template::get_available_templates, utils::file::copy_dir_recursive };
 
 static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
 

package/rust/cli/mod.rs

@@ -1,4 +1,205 @@
 pub mod check;
-pub mod init;
 pub mod build;
-pub mod template;
+pub mod init;
+pub mod template;
+pub mod play;
+
+use clap::{ Parser, Subcommand };
+use crate::utils::version::get_version;
+
+#[derive(Parser)]
+#[command(name = "devalang")]
+#[command(author = "Devaloop")]
+#[command(version = get_version())]
+#[command(about = "🦊 Devalang – A programming language for music and sound.")]
+pub struct Cli {
+    #[arg(long, global = true)]
+    /// Skips loading the configuration file.
+    pub no_config: bool,
+
+    #[command(subcommand)]
+    pub command: Commands,
+}
+
+#[derive(Subcommand)]
+pub enum TemplateCommand {
+    /// Lists all available templates for Devalang projects.
+    List,
+    /// Displays information about a specific template.
+    Info {
+        name: String,
+    },
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+    /// Create a new Devalang project.
+    ///
+    /// ### Arguments
+    /// - `name` - The name of the project to create.
+    /// - `template` - The template to use for the project. Defaults to "default".
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang init --name my_project --template default
+    ///
+    Init {
+        #[arg(short, long)]
+        /// The optional name (directory) of the project to create.
+        name: Option<String>,
+
+        #[arg(short, long)]
+        /// The template to use for the project.
+        ///
+        /// ### Default value
+        /// - `default`
+        ///
+        template: Option<String>,
+    },
+
+    Template {
+        #[command(subcommand)]
+        /// The template command to execute.
+        command: TemplateCommand,
+    },
+
+    /// Build the program and generate output files.
+    ///
+    /// ### Arguments
+    /// - `entry` - The entry point of the program to build. Defaults to "./src".
+    /// - `output` - The directory where the output files will be generated. Defaults to "./output".
+    /// - `watch` - Whether to watch for changes and rebuild. Defaults to "true".
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang build --entry ./src --output ./output --watch true
+    /// ```
+    ///
+    Build {
+        #[arg(short, long)]
+        /// The entry point of the program to build.
+        ///
+        entry: Option<String>,
+
+        #[arg(short, long)]
+        /// The directory where the output files will be generated.
+        ///
+        output: Option<String>,
+
+        #[arg(long, default_value_t = false)]
+        /// Whether to watch for changes and rebuild.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        watch: bool,
+
+        #[arg(long, default_value = "real-time")]
+        /// The mode of compilation.
+        ///
+        /// ### Default value
+        /// - `real-time`
+        ///
+        /// ### Possible values
+        /// - `real-time` - Compiles files as soon as possible.
+        /// - `batch` - Compiles files one by one.
+        /// - `check` - Analyzes the code without compiling it.
+        ///
+        compilation_mode: String,
+
+        #[arg(short, long, default_value_t = false)]
+        /// Whether to print debug information.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        debug: bool,
+
+        #[arg(short, long, default_value_t = false)]
+        /// Whether to compress the output files.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        compress: bool,
+    },
+
+    /// Analyze the program for errors and warnings.
+    ///
+    /// ### Arguments
+    /// - `entry` - The entry point of the program to analyze. Defaults to "./src".
+    /// - `watch` - Whether to watch for changes and re-analyze. Defaults to "true".
+    ///
+    /// ### Example
+    /// ```bash
+    /// devalang check --entry ./src --watch true --compilation-mode real-time
+    /// ```
+    Check {
+        #[arg(short, long)]
+        /// The entry point of the program to analyze.
+        ///
+        entry: Option<String>,
+
+        #[arg(short, long)]
+        /// The directory where the output files will be generated.
+        ///
+        output: Option<String>,
+
+        #[arg(long, default_value_t = false)]
+        /// Whether to watch for changes and re-analyze.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        watch: bool,
+
+        #[arg(short, long, default_value = "real-time")]
+        /// The mode of compilation.
+        ///
+        /// ### Default value
+        /// - `real-time`
+        ///
+        /// ### Possible values
+        /// - `real-time` - Analyzes files as soon as possible.
+        /// - `batch` - Analyzes files one by one.
+        /// - `check` - Analyzes the code without compiling it.
+        ///
+        compilation_mode: String,
+
+        #[arg(short, long, default_value_t = false)]
+        /// Whether to print debug information.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        debug: bool,
+    },
+
+    Play {
+        #[arg(short, long)]
+        /// The entry point of the program to play.
+        ///
+        entry: Option<String>,
+
+        #[arg(short, long)]
+        /// The directory where the output files will be generated.
+        ///
+        output: Option<String>,
+
+        #[arg(long, default_value_t = false)]
+        /// Whether to watch for changes and re-play.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        watch: bool,
+
+        #[arg(long, default_value_t = false)]
+        /// Whether to replay the program after it finishes.
+        ///
+        /// ### Default value
+        /// - `false`
+        ///
+        repeat: bool,
+    },
+}

package/rust/cli/play.rs

@@ -0,0 +1,191 @@
+use crate::{
+    audio::player::AudioPlayer,
+    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;
+
+pub fn handle_play_command(
+    config: Option<Config>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool,
+    repeat: bool
+) {
+    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(&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);
+    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/{utils/config.rs → config/loader.rs}

@@ -1,7 +1,8 @@
 use std::{ fs, path::Path };
-use crate::core::types::config::DevalangConfig;
 
-pub fn load_config(path: Option<&Path>) -> Option<DevalangConfig> {
+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() {

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>,
+}