@devaloop/devalang 0.0.1-alpha.9 → 0.0.1-beta.1

package/rust/core/store/global.rs

@@ -1,39 +1,61 @@
-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)
-    }
-}
+use crate::core::{
+    parser::statement::Statement,
+    preprocessor::module::Module,
+    store::{function::FunctionTable, variable::VariableTable},
+};
+use devalang_types::PluginInfo;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone)]
+pub struct GlobalStore {
+    pub modules: HashMap<String, Module>,
+    pub variables: VariableTable,
+    pub functions: FunctionTable,
+    pub events: HashMap<String, Vec<Statement>>,
+    pub plugins: HashMap<String, (PluginInfo, Vec<u8>)>,
+}
+
+impl Default for GlobalStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GlobalStore {
+    pub fn new() -> Self {
+        GlobalStore {
+            modules: HashMap::new(),
+            functions: FunctionTable::new(),
+            variables: VariableTable::new(),
+            events: HashMap::new(),
+            plugins: HashMap::new(),
+        }
+    }
+
+    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)
+    }
+
+    pub fn register_event_handler(&mut self, event: &str, handler: Statement) {
+        self.events
+            .entry(event.to_string())
+            .or_default()
+            .push(handler);
+    }
+
+    pub fn get_event_handlers(&self, event: &str) -> Option<&Vec<Statement>> {
+        self.events.get(event)
+    }
+}

package/rust/core/store/import.rs

@@ -1,28 +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)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::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

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

package/rust/core/store/variable.rs

@@ -1,28 +1,51 @@
-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)
-    }
-}
+use std::collections::HashMap;
+
+use devalang_types::Value;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct VariableTable {
+    pub variables: HashMap<String, Value>,
+    pub parent: Option<Box<VariableTable>>,
+}
+
+impl VariableTable {
+    pub fn new() -> Self {
+        VariableTable {
+            variables: HashMap::new(),
+            parent: None,
+        }
+    }
+
+    pub fn set(&mut self, name: String, value: Value) {
+        self.variables.insert(name, value);
+    }
+
+    pub fn with_parent(parent: VariableTable) -> Self {
+        Self {
+            variables: HashMap::new(),
+            parent: Some(Box::new(parent)),
+        }
+    }
+
+    pub fn get(&self, name: &str) -> Option<&Value> {
+        // First try the local table
+        if let Some(v) = self.variables.get(name) {
+            return Some(v);
+        }
+
+        // Then walk parent chain if present
+        let mut current = &self.parent;
+        while let Some(boxed) = current {
+            if let Some(v) = boxed.variables.get(name) {
+                return Some(v);
+            }
+            current = &boxed.parent;
+        }
+
+        None
+    }
+
+    pub fn remove(&mut self, name: &str) -> Option<Value> {
+        self.variables.remove(name)
+    }
+}

package/rust/core/utils/mod.rs

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

package/rust/core/utils/path.rs

@@ -1,31 +1,37 @@
-use std::path::{ Component, Path, PathBuf };
-
-pub fn find_entry_file(entry: &str) -> Option<String> {
-    let path = Path::new(entry);
-
-    if path.is_file() {
-        return Some(normalize_path(entry));
-    }
-
-    if path.is_dir() {
-        let candidate = path.join("index.deva");
-        if candidate.exists() {
-            return Some(normalize_path(&candidate));
-        }
-    }
-
-    None
-}
-
-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('\\', "/")
-}
-
-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("\\", "/")
-}
+use std::path::{Path, PathBuf};
+
+pub fn find_entry_file(entry: &str) -> Option<String> {
+    let path = Path::new(entry);
+
+    if path.is_file() {
+        return Some(normalize_path(entry));
+    }
+
+    if path.is_dir() {
+        let candidate = path.join("index.deva");
+        if candidate.exists() {
+            return Some(normalize_path(&candidate));
+        }
+    }
+
+    None
+}
+
+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('\\', "/")
+}
+
+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("\\", "/")
+}