@devaloop/devalang 0.0.1-alpha.17 → 0.0.1-alpha.18

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

@@ -0,0 +1,75 @@
+use crate::core::{
+    parser::statement::{Statement, StatementKind},
+    preprocessor::{module::Module},
+    store::global::GlobalStore,
+};
+use devalang_types::Value;
+use devalang_utils::logger::{LogLevel, Logger};
+
+pub fn resolve_pattern(
+    stmt: &Statement,
+    module: &Module,
+    path: &str,
+    global_store: &mut GlobalStore,
+) -> Statement {
+    let logger = Logger::new();
+
+    // Expecting pattern name stored on the Statement.kind; value may contain the string
+    if let StatementKind::Pattern { name, target } = &stmt.kind {
+        // Ensure name doesn't already exist
+        if global_store.variables.variables.contains_key(name) {
+            logger.log_error_with_stacktrace(&format!("Pattern identifier '{}' already exists", name), path);
+            return Statement {
+                kind: StatementKind::Error { message: format!("Pattern '{}' already exists", name) },
+                ..stmt.clone()
+            };
+        }
+
+        // Resolve potential target and pattern string value
+        let resolved_value = resolve_value(&stmt.value, module, global_store);
+
+        // Build a map to store the pattern definition
+        let mut map = std::collections::HashMap::new();
+        map.insert("identifier".to_string(), Value::String(name.clone()));
+        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());
+
+        let resolved_stmt = Statement {
+            kind: StatementKind::Pattern {
+                name: name.clone(),
+                target: target.clone(),
+            },
+            value: resolved_value,
+            ..stmt.clone()
+        };
+
+        // Store into global variables as a Statement
+        global_store.variables.variables.insert(
+            name.clone(),
+            Value::Statement(Box::new(resolved_stmt.clone())),
+        );
+
+        return resolved_stmt;
+    }
+
+    logger.log_message(LogLevel::Warning, "resolve_pattern called on non-pattern statement");
+    stmt.clone()
+}
+
+fn resolve_value(value: &Value, module: &Module, global_store: &mut GlobalStore) -> Value {
+    // reuse driver::resolve_value logic; simple local resolution for pattern value
+    match value {
+        Value::String(s) => Value::String(s.clone()),
+        Value::Map(m) => {
+            let mut resolved = std::collections::HashMap::new();
+            for (k, v) in m {
+                resolved.insert(k.clone(), resolve_value(v, module, global_store));
+            }
+            Value::Map(resolved)
+        }
+        other => other.clone(),
+    }
+}

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

@@ -48,6 +48,33 @@ pub fn resolve_spawn(
                 }
             }
         }
+        // Pattern case (make spawn accept patterns stored as variables)
+        if let StatementKind::Pattern { .. } = stmt_box.kind {
+            let mut resolved_map = std::collections::HashMap::new();
+            resolved_map.insert("identifier".to_string(), Value::String(name.clone()));
+            // pattern value may be a string or a map stored on the statement
+            match &stmt_box.value {
+                Value::String(s) => {
+                    resolved_map.insert("pattern".to_string(), Value::String(s.clone()));
+                }
+                Value::Map(m) => {
+                    if let Some(val) = m.get("pattern") {
+                        resolved_map.insert("pattern".to_string(), val.clone());
+                    }
+                    if let Some(val) = m.get("target") {
+                        resolved_map.insert("target".to_string(), val.clone());
+                    }
+                }
+                _ => {}
+            }
+            resolved_map.insert("args".to_string(), Value::Array(args.clone()));
+
+            return Statement {
+                kind: StatementKind::Spawn { name, args },
+                value: Value::Map(resolved_map),
+                ..stmt.clone()
+            };
+        }
     }
 
     // Otherwise, log an error

package/rust/core/store/variable.rs

@@ -28,7 +28,21 @@ impl VariableTable {
     }
 
     pub fn get(&self, name: &str) -> Option<&Value> {
-        self.variables.get(name)
+        // 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> {

package/rust/main.rs

@@ -4,6 +4,7 @@ pub mod cli;
 pub mod config;
 pub mod core;
 pub mod web;
+use devalang_utils::path::ensure_deva_dir;
 pub use devalang_utils as utils;
 
 use crate::cli::telemetry::send::send_telemetry_event;
@@ -50,7 +51,7 @@ async fn main() -> io::Result<()> {
     cmd = cmd.version(version_static).before_help(signature_static);
 
     let raw_args: Vec<String> = std::env::args().collect();
-    if raw_args.iter().any(|a| (a == "--version" || a == "-V")) {
+    if raw_args.iter().any(|a| a == "--version" || a == "-V") {
         println!("{}", signature_static);
         return Ok(());
     }
@@ -66,6 +67,8 @@ async fn main() -> io::Result<()> {
     let mut last_error_message: Option<String> = None;
     let mut exit_code: Option<i32> = None;
 
+    let _ = ensure_deva_dir();
+
     if check_is_first_usage() == true {
         write_user_config_file();
     } else {

package/rust/types/Cargo.toml

@@ -1,6 +1,9 @@
 [package]
 name = "devalang_types"
 version = "0.0.1"
+description = "Types and traits for Devalang"
+license = "MIT"
+authors = ["Devaloop <contact@devaloop.com>"]
 edition = "2024"
 
 [dependencies]

package/rust/types/src/ast.rs

@@ -87,6 +87,10 @@ pub enum StatementKind {
 
     // ───── Structure & Logic ─────
     Group,
+    Pattern {
+        name: String,
+        target: Option<String>,
+    },
 
     // ───── Module System ─────
     Include(String),

package/rust/utils/Cargo.toml

@@ -1,10 +1,13 @@
 [package]
 name = "devalang_utils"
 version = "0.0.1"
+description = "Utility functions and types for Devalang"
+license = "MIT"
+authors = ["Devaloop <contact@devaloop.com>"]
 edition = "2024"
 
 [dependencies]
-devalang_types = { path = "../types" }
+devalang_types = { path = "../types", version = "0.0.1" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 include_dir = "0.7"

package/rust/web/api.rs

@@ -1,5 +1,5 @@
 pub fn get_api_url() -> String {
-    // let api_url = "https://api.devalang.com";
-    let api_url = "http://127.0.0.1:8989";
+    let api_url = "https://api.devalang.com";
+    // let api_url = "http://127.0.0.1:8989";
     api_url.to_string()
 }