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

package/rust/cli/check.rs

@@ -1,124 +1,116 @@
-use std::{ thread, time::Duration };
-
 use crate::{
+    config::Config,
     core::{
-        debugger::Debugger,
-        preprocessor::module::load_all_modules,
-        types::{
-            statement::{
-                Statement,
-                StatementIterator,
-                StatementKind,
-                StatementResolved,
-                StatementResolvedValue,
-            },
-            variable::VariableValue,
-        },
+        preprocessor::loader::ModuleLoader,
+        store::global::GlobalStore,
+        utils::path::{ find_entry_file, normalize_path },
     },
-    runner::executer::execute_statements,
-    utils::{ loader::with_spinner, logger::log_message, 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(entry: String, output: String) -> () {
-    let entry_file = find_entry_file(&entry).unwrap_or_else(|| {
-        eprintln!("❌ index.deva not found in directory: {}", entry);
+pub fn handle_check_command(
+    config: Option<Config>,
+    entry: Option<String>,
+    output: Option<String>,
+    watch: bool
+) {
+    let fetched_entry = if entry.is_none() {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.entry.clone())
+            .unwrap_or_else(|| "".to_string())
+    } else {
+        entry.clone().unwrap_or_else(|| "".to_string())
+    };
+
+    let fetched_output = if output.is_none() {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.output.clone())
+            .unwrap_or_else(|| "".to_string())
+    } else {
+        output.clone().unwrap_or_else(|| "".to_string())
+    };
+
+    let fetched_watch = if watch {
+        watch
+    } else {
+        config
+            .as_ref()
+            .and_then(|c| c.defaults.watch)
+            .unwrap_or(false)
+    };
+
+    let logger = Logger::new();
+
+    if fetched_entry.is_empty() {
+        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() {
+        logger.log_message(
+            LogLevel::Error,
+            "Output directory is not specified. Please provide a valid output directory."
+        );
+        std::process::exit(1);
+    }
 
-    let spinner = with_spinner("Checking...", || {
-        thread::sleep(Duration::from_millis(800));
+    let entry_file = find_entry_file(&fetched_entry).unwrap_or_else(|| {
+        logger.log_message(
+            LogLevel::Error,
+            &format!("❌ index.deva not found in directory: {}", fetched_entry)
+        );
+        std::process::exit(1);
     });
 
-    let duration = std::time::Instant::now();
-
-    let normalized_entry_file = normalize_path(&entry_file);
-    let normalized_output_dir = normalize_path(&output);
-
-    let global_store = load_all_modules(&normalized_entry_file);
+    // SECTION Begin check
+    if fetched_watch {
+        begin_check(entry_file.clone(), fetched_output.clone());
 
-    if let Some(module) = global_store.modules.get(&normalized_entry_file) {
-        let mut module_clone = module.clone();
+        logger.log_message(
+            LogLevel::Watcher,
+            &format!("Watching for changes in '{}'...", fetched_entry)
+        );
 
-        let resolved_statements = execute_statements(&mut module_clone);
+        watch_directory(entry_file.clone(), move || {
+            logger.log_message(LogLevel::Watcher, "Detected changes, re-checking...");
 
-        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());
+            begin_check(entry_file.clone(), fetched_output.clone());
+        }).unwrap();
+    } else {
+        begin_check(entry_file.clone(), fetched_output.clone());
+    }
+}
 
-        let has_errors = resolved_statements.iter().any(|stmt| {
-            match_error_recursively_resolved(&stmt.clone())
-        });
+fn begin_check(entry: String, output: String) {
+    let spinner = with_spinner("Checking...", || {
+        thread::sleep(Duration::from_millis(800));
+    });
 
-        if has_errors {
-            let warning_message = format!(
-                "Check completed with errors in {:.2?}. Output files written to: '{}'",
-                duration.elapsed(),
-                normalized_output_dir
-            );
+    let duration = std::time::Instant::now();
 
-            log_message(&warning_message, "WARNING");
-        } else {
-            let success_message = format!(
-                "Check completed successfully in {:.2?}. Output files written to: '{}'",
-                duration.elapsed(),
-                normalized_output_dir
-            );
+    let normalized_entry_file = normalize_path(&entry);
+    let normalized_output_dir = normalize_path(&output);
 
-            log_message(&success_message, "SUCCESS");
-        }
-    }
-}
+    let mut global_store = GlobalStore::new();
+    let module_loader = ModuleLoader::new(&normalized_entry_file, &normalized_output_dir);
 
-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;
-            }
-        }
-    }
+    // 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);
 
-    false
-}
+    // TODO: Implement debugging
 
-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

@@ -0,0 +1,77 @@
+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 };
+
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+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/mod.rs

@@ -1,3 +1,176 @@
 pub mod check;
-pub mod new;
 pub mod build;
+pub mod init;
+pub mod template;
+
+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,
+    },
+}

package/rust/cli/template.rs

@@ -0,0 +1,56 @@
+use include_dir::{ include_dir, Dir, DirEntry };
+
+use crate::utils::file::format_file_size;
+
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+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>");
+}
+
+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,14 @@
+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,15 @@
+pub mod loader;
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct Config {
+    pub defaults: ConfigDefaults,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ConfigDefaults {
+    pub entry: Option<String>,
+    pub output: Option<String>,
+    pub watch: Option<bool>,
+}

package/rust/core/builder/mod.rs

@@ -1,37 +1,31 @@
-use crate::core::types::statement::{ StatementResolved };
-use std::fs::File;
+use crate::core::parser::statement::Statement;
+use std::{ collections::HashMap, fs::create_dir_all };
 use std::io::Write;
 
-pub fn build_ast(statements: &Vec<StatementResolved>) -> String {
-    let mut ast_string = String::new();
+pub struct Builder {}
 
-    serde_json
-        ::to_string_pretty(statements)
-        .map(|json| {
-            ast_string.push_str(&json);
-        })
-        .unwrap_or_else(|err| {
-            eprintln!("Error serializing AST: {}", err);
-            std::process::exit(1);
-        });
+impl Builder {
+    pub fn new() -> Self {
+        Builder {}
+    }
 
-    ast_string
-}
+    pub fn build_ast(&self, modules: &HashMap<String, Vec<Statement>>) {
+        let output_path = "./output";
 
-pub fn write_ast_to_file(ast: &str, file_path: &str) {
-    clear_json_directory(&file_path);
-    create_json_directory(&file_path);
+        for (name, statements) in modules {
+            let formatted_name = name.split("/").last().unwrap_or(name);
+            let formatted_name = formatted_name.replace(".deva", "");
 
-    let file_path = format!("{}/ast.json", file_path);
+            create_dir_all(format!("{}/ast", output_path)).expect("Failed to create AST directory");
 
-    let mut file = File::create(&file_path).expect("Unable to create AST file");
-    file.write_all(ast.as_bytes()).expect("Unable to write AST to file");
-}
+            let file_path = format!("{}/ast/{}.json", output_path, formatted_name);
+            let mut file = std::fs::File::create(file_path).expect("Failed to create AST file");
 
-fn clear_json_directory(path: &str) {
-    std::fs::remove_dir_all(path);
-}
+            let content = serde_json
+                ::to_string_pretty(&statements)
+                .expect("Failed to serialize AST");
 
-fn create_json_directory(path: &str) {
-    std::fs::create_dir_all(path);
+            file.write_all(content.as_bytes()).expect("Failed to write AST to file");
+        }
+    }
 }

package/rust/core/debugger/lexer.rs

@@ -0,0 +1,12 @@
+use crate::core::{ debugger::Debugger, lexer::token::Token };
+
+pub fn write_lexer_log_file(output_dir: &str, file_name: &str, tokens: Vec<Token>) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    for token in tokens {
+        content.push_str(&format!("{:?}\n", token));
+    }
+
+    debugger.write_log_file(output_dir, file_name, &content);
+}