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

package/rust/cli/mod.rs

@@ -1,4 +1,176 @@
 pub mod check;
-pub mod init;
 pub mod build;
-pub mod template;
+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/{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/{core/types/config.rs → config/mod.rs}

@@ -1,15 +1,15 @@
+pub mod loader;
+
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
-pub struct DevalangConfig {
-    pub defaults: Defaults,
+pub struct Config {
+    pub defaults: ConfigDefaults,
 }
 
 #[derive(Debug, Deserialize)]
-pub struct Defaults {
+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);
+}

package/rust/core/debugger/mod.rs

@@ -1,57 +1,20 @@
-use crate::core::types::{ module::Module, statement::{ StatementResolved } };
+pub mod preprocessor;
+pub mod lexer;
 
-pub struct Debugger {
-    pub module: Module,
-}
+use std::io::Write;
+
+pub struct Debugger {}
 
 impl Debugger {
-    pub fn new(module: &Module) -> Self {
-        Debugger {
-            module: module.clone(),
-        }
+    pub fn new() -> Self {
+        Debugger {}
     }
 
-    pub fn write_files(&self, output_dir: &str, resolved_statements: Vec<StatementResolved>) {
-        const LEXER_FILENAME: &str = "debug_lexer.log";
-        const STATEMENTS_FILENAME: &str = "debug_statements.log";
-
-        let lexer_path = format!("{}{}", output_dir, LEXER_FILENAME);
-        let statements_path = format!("{}{}", output_dir, STATEMENTS_FILENAME);
-
-        // Collect debug information
-        let tokens = self.module.tokens
-            .iter()
-            .map(|token| format!("{:?}", token))
-            .collect::<Vec<String>>();
-        let statements = resolved_statements
-            .iter()
-            .map(|stmt| format!("{:?}", stmt))
-            .collect::<Vec<String>>();
+    pub fn write_log_file(&self, path: &str, filename: &str, content: &str) {
+        std::fs::create_dir_all(path).expect("Failed to create directory");
+        let file_path = format!("{}/{}", path, filename);
+        let mut file = std::fs::File::create(file_path).expect("Failed to create file");
 
-        // Ensure the debug directory exists and is cleared
-        clear_debug_directory(output_dir);
-        create_debug_directory(output_dir);
-
-        // Writing files
-        write_tokens_debug_to_file(&tokens, &lexer_path);
-        write_statements_debug_to_file(&statements, &statements_path);
+        file.write_all(content.as_bytes()).expect("Failed to write to file");
     }
 }
-
-fn clear_debug_directory(path: &str) {
-    std::fs::remove_dir_all(path);
-}
-
-fn create_debug_directory(path: &str) {
-    std::fs::create_dir_all(path);
-}
-
-fn write_statements_debug_to_file(statements: &Vec<String>, path: &str) {
-    let content = statements.join("\n");
-    std::fs::write(path, content).expect("Unable to write statements to file");
-}
-
-fn write_tokens_debug_to_file(tokens: &Vec<String>, path: &str) {
-    let content = tokens.join("\n");
-    std::fs::write(path, content).expect("Unable to write tokens to file");
-}

package/rust/core/debugger/preprocessor.rs

@@ -0,0 +1,23 @@
+use std::collections::HashMap;
+use crate::core::{ debugger::Debugger, parser::statement::Statement };
+
+pub fn write_preprocessor_log_file(
+    output_dir: &str,
+    file_name: &str,
+    statements: HashMap<String, Vec<Statement>>
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    for (path, stmts) in statements {
+        content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
+        
+        for stmt in stmts {
+            content.push_str(&format!("{:?}\n", stmt));
+        }
+
+        content.push_str("\n");
+    }
+
+    debugger.write_log_file(output_dir, file_name, &content);
+}

package/rust/core/error/mod.rs

@@ -0,0 +1,60 @@
+use crate::core::parser::{ statement::{ Statement, StatementKind }, Parser };
+
+pub struct ErrorHandler {
+    errors: Vec<Error>,
+}
+
+pub struct Error {
+    pub message: String,
+    pub line: usize,
+    pub column: usize,
+}
+
+impl ErrorHandler {
+    pub fn new() -> Self {
+        Self { errors: Vec::new() }
+    }
+
+    pub fn add_error(&mut self, message: String, line: usize, column: usize) {
+        let error_statement = Error {
+            message,
+            line,
+            column,
+        };
+        self.errors.push(error_statement);
+    }
+
+    pub fn has_errors(&self) -> bool {
+        !self.errors.is_empty()
+    }
+
+    pub fn get_errors(&self) -> &Vec<Error> {
+        &self.errors
+    }
+
+    pub fn clear_errors(&mut self) {
+        self.errors.clear();
+    }
+
+    pub fn detect_from_statements(&mut self, parser: &mut Parser, statements: &[Statement]) {
+        for stmt in statements {
+            match &stmt.kind {
+                StatementKind::Unknown => {
+                    self.add_error(
+                        "Unknown statement".to_string(),
+                        stmt.line,
+                        stmt.column
+                    );
+                }
+                StatementKind::Error { message } => {
+                    self.add_error(
+                        message.clone(),
+                        stmt.line,
+                        stmt.column
+                    );
+                }
+                _ => {}
+            }
+        }
+    }
+}

package/rust/core/lexer/{at.rs → handler/at.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_at_lexer(
     char: char,

package/rust/core/lexer/{brace.rs → handler/brace.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_rbrace_lexer(
     char: char,

package/rust/core/lexer/{colon.rs → handler/colon.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_colon_lexer(
     char: char,

package/rust/core/lexer/{comment.rs → handler/comment.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_comment_lexer(
     char: char,
@@ -21,8 +21,8 @@ pub fn handle_comment_lexer(
     }
 
     tokens.push(Token {
-        kind: TokenKind::Comment(comment.trim().to_string()),
-        lexeme: char.to_string(),
+        kind: TokenKind::Comment,
+        lexeme: comment.trim().to_string(),
         line: *line,
         column: *column,
         indent: *current_indent,

package/rust/core/lexer/{dot.rs → handler/dot.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_dot_lexer(
     char: char,

package/rust/core/lexer/{equal.rs → handler/equal.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{Token, TokenKind};
+use crate::core::lexer::token::{Token, TokenKind};
 
 pub fn handle_equal_lexer(
     char: char,

package/rust/core/lexer/{identifier.rs → handler/identifier.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_identifier_lexer(
     char: char,

package/rust/core/lexer/{indent.rs → handler/indent.rs}

@@ -1,4 +1,4 @@
-use crate::core::types::token::{ Token, TokenKind };
+use crate::core::lexer::token::{ Token, TokenKind };
 
 pub fn handle_indent_lexer(
     chars: &mut std::iter::Peekable<std::str::Chars>,
@@ -7,19 +7,26 @@ pub fn handle_indent_lexer(
     tokens: &mut Vec<Token>,
     line: &mut usize,
     column: &mut usize
-) -> (Vec<Token>, Vec<usize>, usize, usize) {
+) {
     *current_indent = 0;
+    let mut col = *column;
 
     while let Some(&c) = chars.peek() {
         if c == ' ' {
             *current_indent += 1;
             chars.next();
-            *column += 1;
+            col += 1;
+        } else if c == '\t' {
+            *current_indent += 4; // tabulation = 4 espaces
+            chars.next();
+            col += 4;
         } else {
             break;
         }
     }
 
+    *column = col;
+
     let last_indent = *indent_stack.last().unwrap();
     if *current_indent > last_indent {
         indent_stack.push(*current_indent);
@@ -42,6 +49,4 @@ pub fn handle_indent_lexer(
             });
         }
     }
-
-    (tokens.clone(), indent_stack.clone(), *line, *column)
 }