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

package/rust/core/store/export.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ExportTable {
+    pub exports: HashMap<String, Value>,
+}
+
+impl ExportTable {
+    pub fn new() -> Self {
+        ExportTable {
+            exports: HashMap::new(),
+        }
+    }
+
+    pub fn add_export(&mut self, name: String, value: Value) {
+        self.exports.insert(name, value);
+    }
+
+    pub fn get_export(&self, name: &str) -> Option<&Value> {
+        self.exports.get(name)
+    }
+
+    pub fn remove_export(&mut self, name: &str) -> Option<Value> {
+        self.exports.remove(name)
+    }
+}

package/rust/core/store/global.rs

@@ -0,0 +1,39 @@
+use std::collections::HashMap;
+use crate::core::preprocessor::module::Module;
+
+#[derive(Debug, Default, Clone)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+        }
+    }
+
+    pub fn resolve_all_imports(&mut self) {
+        for module in self.modules.values_mut() {
+            for (name, source_path) in &module.import_table.imports {
+                println!("Resolving import: {} from {:?}", name, source_path);
+            }
+        }
+    }
+
+    pub fn insert_module(&mut self, path: String, module: Module) {
+        self.modules.insert(path, module);
+    }
+
+    pub fn modules_mut(&mut self) -> &mut HashMap<String, Module> {
+        &mut self.modules
+    }
+
+    pub fn get_module(&self, path: &str) -> Option<&Module> {
+        self.modules.get(path)
+    }
+
+    pub fn remove_module(&mut self, path: &str) -> Option<Module> {
+        self.modules.remove(path)
+    }
+}

package/rust/core/store/import.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct ImportTable {
+    pub imports: HashMap<String, Value>,
+}
+
+impl ImportTable {
+    pub fn new() -> Self {
+        ImportTable {
+            imports: HashMap::new(),
+        }
+    }
+
+    pub fn add_import(&mut self, name: String, value: Value) {
+        self.imports.insert(name, value);
+    }
+
+    pub fn get_import(&self, name: &str) -> Option<&Value> {
+        self.imports.get(name)
+    }
+
+    pub fn remove_import(&mut self, name: &str) -> Option<Value> {
+        self.imports.remove(name)
+    }
+}

package/rust/core/store/mod.rs

@@ -0,0 +1,4 @@
+pub mod global;
+pub mod export;
+pub mod import;
+pub mod variable;

package/rust/core/store/variable.rs

@@ -0,0 +1,28 @@
+use std::collections::HashMap;
+
+use crate::core::shared::value::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct VariableTable {
+    pub variables: HashMap<String, Value>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        self.variables.get(name)
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<Value> {
+        self.variables.remove(name)
+    }
+}

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,59 +1,63 @@
 pub mod core;
 pub mod cli;
-pub mod runner;
-pub mod audio;
 pub mod utils;
+pub mod config;
+pub mod audio;
 
-use std::{ io };
+use std::io;
+use cli::{ Cli };
 use clap::Parser;
 use crate::{
     cli::{
         build::handle_build_command,
         check::handle_check_command,
         init::handle_init_command,
+        play::handle_play_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 } => {
+        Commands::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);
         }
 
-        CliCommands::Check { entry, output, watch, compilation_mode, debug } => {
-            handle_check_command(config, entry, output, watch);
+        Commands::Play { entry, output, watch, repeat } => {
+            handle_play_command(config, entry, output, watch, repeat);
         }
 
-        // 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/rust/utils/watcher.rs

@@ -1,6 +1,8 @@
 use notify::{ Watcher, RecursiveMode, Config, RecommendedWatcher };
 use std::sync::mpsc::channel;
 
+use std::time::{ Duration, Instant };
+
 pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
     where F: Fn() + Send + 'static
 {
@@ -9,13 +11,19 @@ pub fn watch_directory<F>(entry: String, callback: F) -> notify::Result<()>
     let mut watcher: RecommendedWatcher = Watcher::new(tx, Config::default())?;
     watcher.watch(&entry.as_ref(), RecursiveMode::Recursive)?;
 
+    let mut last_trigger = Instant::now();
+
     loop {
         match rx.recv() {
             Ok(_) => {
-                callback();
+                let now = Instant::now();
+                if now.duration_since(last_trigger) > Duration::from_millis(200) {
+                    callback();
+                    last_trigger = now;
+                }
             }
             Err(e) => {
-                eprintln!("Channel error : {:?}", e);
+                eprintln!("Channel error: {:?}", e);
                 break;
             }
         }

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/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;
-}