@devaloop/devalang 0.0.1-beta.1 → 0.0.1-beta.3

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

@@ -1,69 +1,69 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::{module::Module, resolver::driver::resolve_statement},
-    store::{function::FunctionDef, global::GlobalStore},
-};
-use devalang_types::Value;
-
-pub fn resolve_function(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    if let StatementKind::Function {
-        name,
-        parameters,
-        body,
-    } = &stmt.kind
-    {
-        let resolved_body = resolve_block_statements(body, module, path, global_store);
-
-        global_store.functions.add_function(FunctionDef {
-            name: name.clone(),
-            parameters: parameters.clone(),
-            body: resolved_body.clone(),
-        });
-
-        if let Some(current_mod) = global_store.modules.get_mut(path) {
-            current_mod.function_table.add_function(FunctionDef {
-                name: name.clone(),
-                parameters: parameters.clone(),
-                body: resolved_body.clone(),
-            });
-        } else {
-            eprintln!("[resolve_statement] ❌ Module path not found: {path}");
-        }
-
-        Statement {
-            kind: StatementKind::Function {
-                name: name.clone(),
-                parameters: parameters.clone(),
-                body: resolved_body,
-            },
-            value: Value::Null,
-            ..stmt.clone()
-        }
-    } else {
-        Statement {
-            kind: StatementKind::Error {
-                message: "Expected a function statement".to_string(),
-            },
-            value: Value::Null,
-            ..stmt.clone()
-        }
-    }
-}
-
-fn resolve_block_statements(
-    body: &[Statement],
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Vec<Statement> {
-    body.iter()
-        .map(|stmt| resolve_statement(stmt, module, path, global_store))
-        .collect()
-}
-
-// (removed unused helper type_error)
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+use devalang_types::{FunctionDef, Value};
+
+pub fn resolve_function(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    if let StatementKind::Function {
+        name,
+        parameters,
+        body,
+    } = &stmt.kind
+    {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+
+        global_store.functions.add_function(FunctionDef {
+            name: name.clone(),
+            parameters: parameters.clone(),
+            body: resolved_body.clone(),
+        });
+
+        if let Some(current_mod) = global_store.modules.get_mut(path) {
+            current_mod.function_table.add_function(FunctionDef {
+                name: name.clone(),
+                parameters: parameters.clone(),
+                body: resolved_body.clone(),
+            });
+        } else {
+            eprintln!("[resolve_statement] ❌ Module path not found: {path}");
+        }
+
+        Statement {
+            kind: StatementKind::Function {
+                name: name.clone(),
+                parameters: parameters.clone(),
+                body: resolved_body,
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    } else {
+        Statement {
+            kind: StatementKind::Error {
+                message: "Expected a function statement".to_string(),
+            },
+            value: Value::Null,
+            ..stmt.clone()
+        }
+    }
+}
+
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Vec<Statement> {
+    body.iter()
+        .map(|stmt| resolve_statement(stmt, module, path, global_store))
+        .collect()
+}
+
+// (removed unused helper type_error)

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

@@ -1,94 +1,122 @@
-use crate::core::{
-    parser::statement::{Statement, StatementKind},
-    preprocessor::{module::Module, resolver::driver::resolve_statement},
-    store::global::GlobalStore,
-};
-use devalang_types::Value;
-use devalang_utils::logger::{LogLevel, Logger};
-
-pub fn resolve_group(
-    stmt: &Statement,
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Statement {
-    let logger = Logger::new();
-
-    let Value::Map(group_map) = &stmt.value else {
-        return type_error(
-            &logger,
-            module,
-            stmt,
-            "Expected a map in group statement".to_string(),
-        );
-    };
-
-    // Check for the presence of the identifier field
-    let identifier = match group_map.get("identifier") {
-        Some(Value::String(id)) => id.clone(),
-        _ => {
-            return type_error(
-                &logger,
-                module,
-                stmt,
-                "Group statement must have an 'identifier' field".to_string(),
-            );
-        }
-    };
-
-    // Ensure the identifier does not already exist
-    if global_store.variables.variables.contains_key(&identifier) {
-        return type_error(
-            &logger,
-            module,
-            stmt,
-            format!("Group identifier '{}' already exists", identifier),
-        );
-    }
-
-    // Resolve statements in the body
-    let mut resolved_map = group_map.clone();
-    if let Some(Value::Block(body)) = group_map.get("body") {
-        let resolved_body = resolve_block_statements(body, module, path, global_store);
-        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
-    } else {
-        logger.log_message(LogLevel::Warning, "Group without a body");
-    }
-
-    // Build a complete Statement for the group
-    let resolved_group_stmt = Statement {
-        kind: StatementKind::Group,
-        value: Value::Map(resolved_map.clone()),
-        ..stmt.clone()
-    };
-
-    // Store the Statement directly in the global variable_table
-    global_store.variables.variables.insert(
-        identifier.clone(),
-        Value::Statement(Box::new(resolved_group_stmt.clone())),
-    );
-
-    resolved_group_stmt
-}
-
-fn resolve_block_statements(
-    body: &[Statement],
-    module: &Module,
-    path: &str,
-    global_store: &mut GlobalStore,
-) -> Vec<Statement> {
-    body.iter()
-        .map(|stmt| resolve_statement(stmt, module, path, global_store))
-        .collect()
-}
-
-fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
-    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
-    logger.log_error_with_stacktrace(&message, &stacktrace);
-
-    Statement {
-        kind: StatementKind::Error { message },
-        value: Value::Null,
-        ..stmt.clone()
-    }
-}
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module, resolver::driver::resolve_statement},
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+pub fn resolve_group(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    // Extract identifier from several allowed shapes (map.identifier, bare string, number -> to_string)
+    let identifier = match extract_group_identifier(stmt, &logger, module) {
+        Ok(id) => id,
+        Err(err_stmt) => return err_stmt,
+    };
+
+    // group_map: if the value is a map we clone it, otherwise create an empty map to hold body
+    let group_map = match &stmt.value {
+        Value::Map(m) => m.clone(),
+        _ => std::collections::HashMap::new(),
+    };
+
+    // Ensure the identifier does not already exist
+    if global_store.variables.variables.contains_key(&identifier) {
+        return type_error(
+            &logger,
+            module,
+            stmt,
+            format!("Group identifier '{}' already exists", identifier),
+        );
+    }
+
+    // Resolve statements in the body
+    let mut resolved_map = group_map.clone();
+    if let Some(Value::Block(body)) = group_map.get("body") {
+        let resolved_body = resolve_block_statements(body, module, path, global_store);
+        resolved_map.insert("body".to_string(), Value::Block(resolved_body));
+    } else {
+        logger.log_message(LogLevel::Warning, "Group without a body");
+    }
+
+    // Build a complete Statement for the group
+    let resolved_group_stmt = Statement {
+        kind: StatementKind::Group,
+        value: Value::Map(resolved_map.clone()),
+        ..stmt.clone()
+    };
+
+    // Store the Statement directly in the global variable_table
+    global_store.variables.variables.insert(
+        identifier.clone(),
+        Value::Statement(Box::new(resolved_group_stmt.clone())),
+    );
+
+    resolved_group_stmt
+}
+
+fn resolve_block_statements(
+    body: &[Statement],
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Vec<Statement> {
+    body.iter()
+        .map(|stmt| resolve_statement(stmt, module, path, global_store))
+        .collect()
+}
+
+fn type_error(logger: &Logger, module: &Module, stmt: &Statement, message: String) -> Statement {
+    let stacktrace = format!("{}:{}:{}", module.path, stmt.line, stmt.column);
+    logger.log_error_with_stacktrace(&message, &stacktrace);
+
+    Statement {
+        kind: StatementKind::Error { message },
+        value: Value::Null,
+        ..stmt.clone()
+    }
+}
+
+// Helper to extract a group identifier from multiple Value forms
+fn extract_group_identifier(
+    stmt: &Statement,
+    logger: &Logger,
+    module: &Module,
+) -> Result<String, Statement> {
+    match &stmt.value {
+        Value::Map(map) => match map.get("identifier") {
+            Some(Value::String(s)) => Ok(s.clone()),
+            Some(Value::Identifier(s)) => Ok(s.clone()),
+            Some(Value::Number(n)) => Ok(n.to_string()),
+            Some(other) => Err(type_error(
+                logger,
+                module,
+                stmt,
+                format!("Unsupported type for 'identifier': {:?}", other),
+            )),
+            None => Err(type_error(
+                logger,
+                module,
+                stmt,
+                "Group statement must have an 'identifier' field".to_string(),
+            )),
+        },
+        Value::String(s) => Ok(s.clone()),
+        Value::Identifier(s) => Ok(s.clone()),
+        other => Err(type_error(
+            logger,
+            module,
+            stmt,
+            format!(
+                "Expected a map or string for group statement, found {:?}",
+                other
+            ),
+        )),
+    }
+}

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

@@ -39,8 +39,20 @@ pub fn resolve_pattern(
         if let Some(t) = target {
             map.insert("target".to_string(), Value::String(t.clone()));
         }
-        // Keep raw pattern in 'pattern' key
-        map.insert("pattern".to_string(), resolved_value.clone());
+        // Keep raw pattern in 'pattern' key if it's a string, or merge options map
+        match resolved_value.clone() {
+            Value::String(s) => {
+                map.insert("pattern".to_string(), Value::String(s));
+            }
+            Value::Map(m) => {
+                for (k, v) in m {
+                    map.insert(k, v);
+                }
+            }
+            _ => {
+                map.insert("pattern".to_string(), resolved_value.clone());
+            }
+        }
 
         let resolved_stmt = Statement {
             kind: StatementKind::Pattern {

package/rust/core/store/global.rs

@@ -1,61 +1,57 @@
-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)
-    }
-}
+use crate::core::{parser::statement::Statement, preprocessor::module::Module};
+use devalang_types::{FunctionTable, VariableTable, plugin::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/mod.rs

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