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

package/rust/core/utils/mod.rs

@@ -0,0 +1,2 @@
+pub mod path;
+pub mod validation;

package/rust/core/utils/validation.rs

@@ -0,0 +1,35 @@
+use crate::core::{ preprocessor::module::Module, shared::value::Value, store::global::GlobalStore };
+
+pub fn is_valid_entity(entity: &str, module: &Module, global_store: &GlobalStore) -> bool {
+    let built_ins = ["kick", "snare", "hat", "clap"];
+
+    if built_ins.contains(&entity) {
+        return true;
+    }
+
+    if let Some(val) = module.variable_table.get(entity) {
+        match val {
+            Value::Sample(_) => true,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}
+
+pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
+    let built_ins = ["auto"];
+
+    if built_ins.contains(&ident) {
+        return true;
+    }
+
+    if let Some(val) = module.variable_table.get(ident) {
+        match val {
+            Value::Identifier(_) => true,
+            _ => false,
+        }
+    } else {
+        false
+    }
+}

package/rust/lib.rs

@@ -1 +0,0 @@
-// TODO WebAssembly support

package/rust/main.rs

@@ -1,10 +1,10 @@
 pub mod core;
 pub mod cli;
-pub mod runner;
-pub mod audio;
 pub mod utils;
+pub mod config;
 
-use std::{ io };
+use std::io;
+use cli::{ Cli };
 use clap::Parser;
 use crate::{
     cli::{
@@ -12,48 +12,46 @@ use crate::{
         check::handle_check_command,
         init::handle_init_command,
         template::{ handle_template_info_command, handle_template_list_command },
+        Commands,
+        TemplateCommand,
     },
-    core::types::{ cli::{ Cli, CliCommands, CliTemplateCommand }, config::DevalangConfig },
-    utils::{ config::load_config, logger::log_message },
+    config::{ loader::load_config, Config },
 };
 
 fn main() -> io::Result<()> {
     let cli: Cli = Cli::parse();
-    let mut config: Option<DevalangConfig> = None;
+    let mut config: Option<Config> = None;
 
     if !cli.no_config {
         config = load_config(None);
     } else {
-        log_message("Configuration file loading is skipped.", "WARNING");
+        println!("No configuration file loaded. Running with arguments only.");
     }
 
     match cli.command {
-        CliCommands::Init { name, template } => {
+        Commands::Init { name, template } => {
             handle_init_command(name, template);
         }
 
-        CliCommands::Template { command } =>
+        Commands::Template { command } =>
             match command {
-                CliTemplateCommand::List => {
+                TemplateCommand::List => {
                     handle_template_list_command();
                 }
-                CliTemplateCommand::Info { name } => {
+                TemplateCommand::Info { name } => {
                     handle_template_info_command(name);
                 }
             }
 
-        CliCommands::Build { entry, output, watch, compilation_mode, debug, compress } => {
-            handle_build_command(config, entry, output, watch);
+        Commands::Check { entry, output, watch, compilation_mode, debug } => {
+            handle_check_command(config, entry, output, watch);
         }
 
-        CliCommands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(config, entry, output, watch);
+        Commands::Build { entry, output, watch, compilation_mode, debug, compress } => {
+            handle_build_command(config, entry, output, watch);
         }
 
-        // TODO - Implement the play command
-        // CliCommands::Play {} => {
-        //     log_message("Command 'play' is not implemented yet.", "WARNING");
-        // }
+        _ => {}
     }
 
     Ok(())

package/rust/utils/logger.rs

@@ -1,49 +1,84 @@
-use crossterm::style::{Attribute, Color, ResetColor, SetAttribute, SetForegroundColor};
+use crossterm::style::{ Attribute, Color, ResetColor, SetAttribute, SetForegroundColor };
 use std::{ fmt::Write };
 
-pub fn log_message(message: &str, status: &str) {
-    let formatted_status = format_status(status);
-    println!("🦊 {} {} {}", language_signature(), formatted_status, message);
+#[derive(Debug, Clone, PartialEq)]
+pub enum LogLevel {
+    Success,
+    Error,
+    Info,
+    Warning,
+    Watcher,
+    Debug,
 }
 
-fn language_signature() -> String {
-    let mut s = String::new();
+#[derive(Debug, Clone)]
+pub struct Logger {}
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-    s.push('[');
+impl Logger {
+    pub fn new() -> Self {
+        Logger {}
+    }
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Rgb { r: 29, g: 211, b: 176 })).unwrap();
-    write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-    s.push_str("Devalang");
-    write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+    pub fn log_message(&self, level: LogLevel, message: &str) {
+        let formatted_status = self.format_status(level);
+        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
+    }
 
-    write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
-    s.push(']');
+    pub fn log_error_with_stacktrace(&self, message: &str, stacktrace: &str) {
+        let formatted_status = self.format_status(LogLevel::Error);
+        println!("🦊 {} {} {}", self.language_signature(), formatted_status, message);
+        println!("     ↳ {}", stacktrace);
+    }
 
-    write!(&mut s, "{}", ResetColor).unwrap();
+    fn language_signature(&self) -> String {
+        let mut s = String::new();
 
-    s
-}
+        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
+        s.push('[');
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Rgb { r: 29, g: 211, b: 176 })).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str("Devalang");
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+
+        write!(&mut s, "{}", SetForegroundColor(Color::Grey)).unwrap();
+        s.push(']');
+
+        write!(&mut s, "{}", ResetColor).unwrap();
+
+        s
+    }
+
+    fn format_status(&self, level: LogLevel) -> String {
+        let mut s = String::new();
 
-fn format_status(status: &str) -> String {
-    let mut s = String::new();
+        let color = match level {
+            LogLevel::Success => Color::Rgb { r: 76, g: 175, b: 80 },
+            LogLevel::Error => Color::Rgb { r: 244, g: 67, b: 54 },
+            LogLevel::Info => Color::Rgb { r: 33, g: 150, b: 243 },
+            LogLevel::Warning => Color::Rgb { r: 255, g: 152, b: 0 },
+            LogLevel::Watcher => Color::Rgb { r: 156, g: 39, b: 176 },
+            LogLevel::Debug => Color::Rgb { r: 103, g: 58, b: 183 },
+        };
 
-    let color = match status {
-        "SUCCESS" => Color::Rgb { r: 76, g: 175, b: 80 },
-        "ERROR" => Color::Rgb { r: 244, g: 67, b: 54 },
-        "INFO" => Color::Rgb { r: 33, g: 150, b: 243 },
-        "WARNING" => Color::Rgb { r: 255, g: 152, b: 0 },
-        _ => Color::Grey,
-    };
+        let status = match level {
+            LogLevel::Success => "SUCCESS",
+            LogLevel::Error => "ERROR",
+            LogLevel::Info => "INFO",
+            LogLevel::Warning => "WARNING",
+            LogLevel::Watcher => "WATCHER",
+            LogLevel::Debug => "DEBUG",
+        };
 
-    s.push('[');
-    write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
-    write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
-    s.push_str(status);
-    write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
-    s.push(']');
+        s.push('[');
+        write!(&mut s, "{}", SetForegroundColor(color)).unwrap();
+        write!(&mut s, "{}", SetAttribute(Attribute::Bold)).unwrap();
+        s.push_str(status);
+        write!(&mut s, "{}", SetAttribute(Attribute::Reset)).unwrap();
+        s.push(']');
 
-    write!(&mut s, "{}", ResetColor).unwrap();
+        write!(&mut s, "{}", ResetColor).unwrap();
 
-    s
+        s
+    }
 }

package/rust/utils/mod.rs

@@ -1,8 +1,6 @@
 pub mod version;
 pub mod signature;
-pub mod path;
-pub mod loader;
-pub mod logger;
-pub mod file;
+pub mod spinner;
 pub mod watcher;
-pub mod config;
+pub mod file;
+pub mod logger;

package/templates/minimal/.devalang

@@ -1,4 +1,4 @@
 [defaults]
 entry = "./src"
 output = "./output"
-watch = true
+watch = false

package/templates/welcome/.devalang

@@ -1,4 +1,4 @@
 [defaults]
 entry = "./src"
 output = "./output"
-watch = true
+watch = false

package/rust/audio/mod.rs

@@ -1 +0,0 @@
-// TODO Audio engine

package/rust/core/lexer/bracket.rs

@@ -1,41 +0,0 @@
-use crate::core::types::token::{ Token, TokenKind };
-
-pub fn handle_rbracket_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize
-) {
-    tokens.push(Token {
-        kind: TokenKind::RBracket,
-        lexeme: char.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}
-
-pub fn handle_lbracket_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize
-) {
-    tokens.push(Token {
-        kind: TokenKind::LBracket,
-        lexeme: char.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}

package/rust/core/lexer/driver.rs

@@ -1,286 +0,0 @@
-
-
-use crate::core::{
-    lexer::{
-        at::handle_at_lexer,
-        brace::{ handle_lbrace_lexer, handle_rbrace_lexer },
-        colon::handle_colon_lexer,
-        comment::handle_comment_lexer,
-        equal::handle_equal_lexer,
-        newline::handle_newline_lexer,
-        bracket::{ handle_lbracket_lexer, handle_rbracket_lexer },
-        dot::handle_dot_lexer,
-        identifier::handle_identifier_lexer,
-        indent::handle_indent_lexer,
-        number::handle_number_lexer,
-        quote::{ handle_double_quote_lexer, handle_single_quote_lexer },
-    },
-    types::token::{ Token, TokenKind },
-};
-
-pub fn lex(input: String) -> Vec<Token> {
-    let mut tokens = Vec::new();
-
-    let mut line = 1;
-    let mut column = 1;
-
-    let mut indent_stack: Vec<usize> = vec![0];
-    let mut current_indent = 0;
-    let mut at_line_start = true;
-
-    let mut chars = input.chars().peekable();
-
-    while let Some(_) = chars.peek() {
-        if at_line_start {
-            let (new_tokens, new_indent_stack, new_line, new_column) = handle_indent_lexer(
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            // Update the main tokens vector and indent stack
-            tokens = new_tokens;
-            indent_stack = new_indent_stack;
-            line = new_line;
-            column = new_column;
-
-            // Reset at_line_start flag
-            at_line_start = false;
-        }
-
-        // Read the next character
-        let Some(ch) = chars.next() else {
-            break;
-        };
-
-        // Newline handling
-        if ch == '\n' {
-            handle_newline_lexer(
-                ch,
-                &mut chars,
-                &mut tokens,
-                &mut line,
-                &mut column,
-                &mut at_line_start,
-                &mut current_indent
-            );
-
-            continue;
-        }
-
-        if ch == ' ' || ch == '\t' {
-            column += if ch == '\t' { 4 } else { 1 };
-            continue;
-        }
-
-        if ch == '#' {
-            handle_comment_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == ':' {
-            handle_colon_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '=' {
-            handle_equal_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '[' {
-            handle_lbracket_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == ']' {
-            handle_rbracket_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '{' {
-            handle_lbrace_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '}' {
-            handle_rbrace_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '"' {
-            handle_double_quote_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '\'' {
-            handle_single_quote_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '.' {
-            handle_dot_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch == '@' {
-            handle_at_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch.is_ascii_digit() {
-            handle_number_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        if ch.is_ascii_alphabetic() {
-            handle_identifier_lexer(
-                ch,
-                &mut chars,
-                &mut current_indent,
-                &mut indent_stack,
-                &mut tokens,
-                &mut line,
-                &mut column
-            );
-
-            continue;
-        }
-
-        // Skip unknown char
-        column += 1;
-    }
-
-    while indent_stack.len() > 1 {
-        indent_stack.pop();
-        current_indent = *indent_stack.last().unwrap();
-        tokens.push(Token {
-            kind: TokenKind::Dedent,
-            lexeme: String::new(),
-            line,
-            column,
-            indent: current_indent,
-        });
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::EOF,
-        lexeme: String::new(),
-        line: line + 1, // EOF is considered to be on the next line
-        column: 0, // EOF has no column
-        indent: 0, // EOF has no indent
-    });
-
-    tokens
-}

package/rust/core/lexer/quote.rs

@@ -1,61 +0,0 @@
-use crate::core::types::token::{Token, TokenKind};
-
-pub fn handle_single_quote_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize
-) {
-    let mut string_content = String::new();
-    *column += 1;
-
-    while let Some(next_ch) = chars.next() {
-        *column += 1;
-        if next_ch == '\'' {
-            break;
-        } else {
-            string_content.push(next_ch);
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::String,
-        lexeme: string_content,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}
-
-pub fn handle_double_quote_lexer(
-    char: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    indent_stack: &mut Vec<usize>,
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize
-) {
-    let mut string_content = String::new();
-    *column += 1; // skip the opening quote
-
-    while let Some(next_ch) = chars.next() {
-        *column += 1;
-        if next_ch == '"' {
-            break; // closing quote reached
-        } else {
-            string_content.push(next_ch);
-        }
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::String,
-        lexeme: string_content,
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}