@devaloop/devalang 0.0.1-alpha.8 → 0.0.1-alpha.9

package/rust/core/preprocessor/resolver/value.rs

@@ -0,0 +1,78 @@
+use std::collections::HashMap;
+
+use crate::{
+    core::{
+        parser::statement::{ Statement, StatementKind },
+        preprocessor::{ module::Module, resolver::driver::resolve_statement },
+        shared::value::Value,
+        store::{ global::GlobalStore, variable::VariableTable },
+    },
+    utils::logger::{ LogLevel, Logger },
+};
+
+fn find_export_value(name: &str, global_store: &GlobalStore) -> Option<Value> {
+    for (_path, module) in &global_store.modules {
+        if let Some(val) = module.export_table.get_export(name) {
+            return Some(val.clone());
+        }
+    }
+    None
+}
+
+pub fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    match value {
+        Value::Identifier(name) => {
+            if let Some(original_val) = module.variable_table.get(name) {
+                return resolve_value(original_val, module, global_store);
+            }
+
+            if let Some(export_val) = find_export_value(name, global_store) {
+                return resolve_value(&export_val, module, global_store);
+            }
+
+            eprintln!("⚠️ Unresolved identifier '{}'", name);
+            Value::Null
+        }
+
+        Value::Map(map) => {
+            if let Some(Value::Identifier(entity)) = map.get("entity") {
+                // SECTION Synth
+                if entity == "synth" {
+                    if let Some(Value::Map(synth_data)) = map.get("value") {
+                        let resolved_waveform = synth_data
+                            .get("waveform")
+                            .map(|wf| resolve_value(wf, module, global_store))
+                            .unwrap_or(Value::Null);
+
+                        let resolved_params = synth_data
+                            .get("parameters")
+                            .map(|p| resolve_value(p, module, global_store))
+                            .unwrap_or(Value::Map(HashMap::new()));
+
+                        let mut result = HashMap::new();
+                        result.insert("waveform".to_string(), resolved_waveform);
+                        result.insert("parameters".to_string(), resolved_params);
+
+                        return Value::Map(result);
+                    }
+                }
+            }
+
+            let mut resolved = HashMap::new();
+            for (k, v) in map {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+            Value::Map(resolved)
+        }
+
+        Value::Block(stmts) => {
+            let resolved_stmts = stmts
+                .iter()
+                .map(|stmt| resolve_statement(stmt, module, &module.path, global_store))
+                .collect();
+            Value::Block(resolved_stmts)
+        }
+
+        other => other.clone(),
+    }
+}

package/rust/core/utils/path.rs

@@ -1,46 +1,31 @@
-use std::path::{ Component, Path };
+use std::path::{ Component, Path, PathBuf };
 
-pub fn find_entry_file(path: &str) -> Option<String> {
-    let path = Path::new(path);
+pub fn find_entry_file(entry: &str) -> Option<String> {
+    let path = Path::new(entry);
 
-    // Check if the path is a file
     if path.is_file() {
-        return Some(path.to_string_lossy().to_string());
+        return Some(normalize_path(entry));
     }
 
-    // Check if the path is a directory
     if path.is_dir() {
-        // Look for an index.deva file in the directory
-        let index_path = path.join("index.deva");
-        if index_path.is_file() {
-            return Some(index_path.to_string_lossy().to_string());
+        let candidate = path.join("index.deva");
+        if candidate.exists() {
+            return Some(normalize_path(&candidate));
         }
     }
 
     None
 }
 
-pub fn normalize_path(path: &str) -> String {
-    let mut components = Vec::new();
-
-    // Iterate through the components of the path
-    for comp in Path::new(path).components() {
-        match comp {
-            Component::CurDir => {
-                continue;
-            }
-            Component::Normal(c) => components.push(c),
-            Component::RootDir => components.clear(),
-            _ => {}
-        }
-    }
-
-    // Join the components into a normalized path
-    let normalized = components
-        .iter()
-        .map(|c| c.to_string_lossy())
-        .collect::<Vec<_>>()
-        .join("/");
+pub fn normalize_path<P: AsRef<Path>>(path: P) -> String {
+    let path_buf = PathBuf::from(path.as_ref());
+    path_buf.components().collect::<PathBuf>().to_string_lossy().replace('\\', "/")
+}
 
-    format!("./{}", normalized)
+pub fn resolve_relative_path(base: &str, import: &str) -> String {
+    let base_path = Path::new(base)
+        .parent()
+        .unwrap_or_else(|| Path::new(""));
+    let full_path = base_path.join(import);
+    full_path.components().collect::<PathBuf>().to_string_lossy().replace("\\", "/")
 }

package/rust/core/utils/validation.rs

@@ -1,35 +1,37 @@
 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"];
+// NOTE: Deprecated functions, kept for reference
 
-    if built_ins.contains(&entity) {
-        return true;
-    }
+// pub fn is_valid_entity(entity: &str, module: &Module, global_store: &GlobalStore) -> bool {
+//     let built_ins = ["kick", "snare", "hat", "clap"];
 
-    if let Some(val) = module.variable_table.get(entity) {
-        match val {
-            Value::Sample(_) => true,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}
+//     if built_ins.contains(&entity) {
+//         return true;
+//     }
 
-pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
-    let built_ins = ["auto"];
+//     if let Some(val) = module.variable_table.get(entity) {
+//         match val {
+//             Value::Sample(_) => true,
+//             _ => false,
+//         }
+//     } else {
+//         false
+//     }
+// }
 
-    if built_ins.contains(&ident) {
-        return true;
-    }
+// pub fn is_valid_identifier(ident: &str, module: &Module) -> bool {
+//     let built_ins = ["auto"];
 
-    if let Some(val) = module.variable_table.get(ident) {
-        match val {
-            Value::Identifier(_) => true,
-            _ => false,
-        }
-    } else {
-        false
-    }
-}
+//     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/typescript/scripts/version/fetch.ts

@@ -1,23 +1,18 @@
 import fs from "fs";
-import path from "path";
 import { execSync } from "child_process";
 
 export const fetchVersion = async (projectVersionPath: string) => {
-    // Lire le fichier
     const data = JSON.parse(fs.readFileSync(projectVersionPath, "utf-8"));
 
-    // Incrémenter le numéro de build
     data.build = (data.build || 0) + 1;
 
-    // Récupérer le dernier hash git
     try {
         const commit = execSync("git rev-parse HEAD").toString().trim();
         data.lastCommit = commit;
     } catch (err) {
-        console.warn("⚠️ Impossible de récupérer le hash git.");
+        console.warn("⚠️ Unable to fetch git commit hash. Ensure you are in a git repository.");
     }
 
-    // Écrire la mise à jour
     fs.writeFileSync(projectVersionPath, JSON.stringify(data, null, 2));
 }
 

package/rust/core/parser/handler/identifier.rs

@@ -1,262 +0,0 @@
-use crate::core::{
-    lexer::token::{ Token, TokenKind },
-    parser::{ statement::{ Statement, StatementKind }, driver::Parser },
-    shared::value::Value,
-    store::global::GlobalStore,
-};
-use std::collections::HashMap;
-
-pub fn parse_identifier_token(parser: &mut Parser, global_store: &mut GlobalStore) -> Statement {
-    let Some(current_token) = parser.peek_clone() else {
-        return Statement::unknown();
-    };
-
-    if current_token.lexeme == "let" {
-        parser.advance(); // consume "let"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'let'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'let'".to_string());
-        };
-
-        if !parser.match_token(TokenKind::Equals) {
-            return Statement::error(current_token, "Expected '=' after identifier".to_string());
-        }
-
-        let value = match parser.peek_clone() {
-            Some(token) if token.kind == TokenKind::Identifier => {
-                parser.advance();
-                Value::Identifier(token.lexeme.clone())
-            }
-            Some(token) if token.kind == TokenKind::String => {
-                parser.advance();
-                Value::String(token.lexeme.clone())
-            }
-            Some(token) if token.kind == TokenKind::Number => {
-                parser.advance();
-                Value::Number(token.lexeme.parse().unwrap_or(0.0))
-            }
-            Some(token) if token.kind == TokenKind::LBrace => {
-                parser.advance(); // consume '{'
-                let mut map = HashMap::new();
-
-                while let Some(key_token) = parser.peek_clone() {
-                    if key_token.kind == TokenKind::RBrace {
-                        parser.advance(); // consume '}'
-                        break;
-                    }
-
-                    if key_token.kind != TokenKind::Identifier {
-                        return Statement::error(
-                            token,
-                            "Expected key identifier in map".to_string()
-                        );
-                    }
-                    parser.advance();
-                    let key = key_token.lexeme.clone();
-
-                    if !parser.match_token(TokenKind::Colon) {
-                        let message = format!("Expected ':' after key '{}'", key);
-                        return Statement::error(token, message);
-                    }
-
-                    let val = match parser.peek_clone() {
-                        Some(t) if t.kind == TokenKind::Number => {
-                            parser.advance();
-                            Value::Number(t.lexeme.parse().unwrap_or(0.0))
-                        }
-                        Some(t) if t.kind == TokenKind::String => {
-                            parser.advance();
-                            Value::String(t.lexeme.clone())
-                        }
-                        Some(t) if t.kind == TokenKind::Identifier => {
-                            parser.advance();
-                            Value::Identifier(t.lexeme.clone())
-                        }
-                        _ => { Value::Null }
-                    };
-
-                    if val == Value::Null {
-                        let message = format!("Invalid value for key '{}'", key);
-                        return Statement::error(token, message);
-                    }
-
-                    map.insert(key, val);
-
-                    if let Some(t) = parser.peek() {
-                        if t.kind == TokenKind::Comma {
-                            parser.advance(); // skip comma
-                        }
-                    }
-                }
-
-                Value::Map(map)
-            }
-            other => {
-                let message = format!("Unexpected value token in let: {:?}", other);
-                return Statement::error(current_token, message);
-            }
-        };
-
-        return Statement {
-            kind: StatementKind::Let { name: identifier },
-            value,
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "group" {
-        parser.advance(); // consume "group"
-
-        let Some(identifier_token) = parser.peek_clone() else {
-            return Statement::error(current_token, "Expected identifier after 'group'".to_string());
-        };
-
-        if
-            identifier_token.kind != TokenKind::Identifier &&
-            identifier_token.kind != TokenKind::String
-        {
-            return Statement::error(identifier_token, "Expected valid identifier".to_string());
-        }
-
-        parser.advance(); // consume identifier
-
-        let Some(colon_token) = parser.peek_clone() else {
-            return Statement::error(
-                identifier_token,
-                "Expected ':' after group identifier".to_string()
-            );
-        };
-
-        if colon_token.kind != TokenKind::Colon {
-            return Statement::error(
-                colon_token.clone(),
-                "Expected ':' after group identifier".to_string()
-            );
-        }
-
-        parser.advance(); // consume ':'
-
-        let base_indent = current_token.indent;
-
-        // Clone without consuming tokens
-        let mut index = parser.token_index;
-        let mut tokens_inside_group = Vec::new();
-
-        while index < parser.tokens.len() {
-            let token = parser.tokens[index].clone();
-
-            if token.indent <= base_indent && token.kind != TokenKind::Newline {
-                break;
-            }
-
-            tokens_inside_group.push(token);
-            index += 1;
-        }
-
-        // Advance index once to skip the processed tokens
-        parser.token_index = index;
-
-        let body = parser.parse_block(tokens_inside_group, global_store);
-
-        let mut value_map = HashMap::new();
-        value_map.insert("identifier".to_string(), Value::String(identifier_token.lexeme.clone()));
-        value_map.insert("body".to_string(), Value::Block(body));
-
-        return Statement {
-            kind: StatementKind::Group,
-            value: Value::Map(value_map),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "call" {
-        parser.advance(); // consume "call"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'call'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'call'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Call,
-            value: Value::String(identifier),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "spawn" {
-        parser.advance(); // consume "spawn"
-
-        let identifier = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Identifier {
-                parser.advance();
-                token.lexeme.clone()
-            } else {
-                return Statement::error(token, "Expected identifier after 'spawn'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected identifier after 'spawn'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Spawn,
-            value: Value::String(identifier),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else if current_token.lexeme == "sleep" {
-        parser.advance(); // consume "sleep"
-
-        let duration = if let Some(token) = parser.peek_clone() {
-            if token.kind == TokenKind::Number {
-                parser.advance();
-                token.lexeme.parse().unwrap_or(0.0)
-            } else {
-                return Statement::error(token, "Expected number after 'sleep'".to_string());
-            }
-        } else {
-            return Statement::error(current_token, "Expected number after 'sleep'".to_string());
-        };
-
-        return Statement {
-            kind: StatementKind::Sleep,
-            value: Value::Number(duration),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    } else {
-        // Unknown identifier handling
-        Statement {
-            kind: StatementKind::Unknown,
-            value: Value::String(current_token.lexeme.clone()),
-            indent: current_token.indent,
-            line: current_token.line,
-            column: current_token.column,
-        };
-    }
-
-    parser.advance(); // unknown identifier fallback
-
-    Statement {
-        kind: StatementKind::Unknown,
-        value: Value::String(current_token.lexeme.clone()),
-        indent: current_token.indent,
-        line: current_token.line,
-        column: current_token.column,
-    }
-}