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

package/rust/core/lexer/mod.rs

@@ -1,64 +1,3 @@
 pub mod handler;
 pub mod token;
-
-use crate::core::{
-    lexer::{handler::driver::handle_content_lexing, token::Token},
-    utils::path::normalize_path,
-};
-use std::fs;
-use std::path::Path;
-
-pub struct Lexer {}
-
-impl Default for Lexer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Lexer {
-    pub fn new() -> Self {
-        Lexer {}
-    }
-
-    pub fn lex_from_source(&self, source: &str) -> Result<Vec<Token>, String> {
-        handle_content_lexing(source.to_string())
-    }
-
-    pub fn lex_tokens(&self, entrypoint: &str) -> Result<Vec<Token>, String> {
-        let path = normalize_path(entrypoint);
-        let resolved_path = Self::resolve_entry_path(&path)?;
-
-        let file_content = fs::read_to_string(&resolved_path).map_err(|e| {
-            format!(
-                "Failed to read the entrypoint file '{}': {}",
-                resolved_path, e
-            )
-        })?;
-
-        handle_content_lexing(file_content).map_err(|e| format!("Failed to lex the content: {}", e))
-    }
-
-    fn resolve_entry_path(path: &str) -> Result<String, String> {
-        let candidate = Path::new(path);
-
-        if candidate.is_dir() {
-            let index_path = candidate.join("index.deva");
-            if index_path.exists() {
-                Ok(index_path.to_string_lossy().replace("\\", "/"))
-            } else {
-                Err(format!(
-                    "Expected 'index.deva' in directory '{}', but it was not found",
-                    path
-                ))
-            }
-        } else if candidate.is_file() {
-            return Ok(path.to_string());
-        } else {
-            return Err(format!(
-                "Provided entrypoint '{}' is not a valid file or directory",
-                path
-            ));
-        }
-    }
-}
+pub mod driver;

package/rust/core/lexer/token.rs

@@ -21,6 +21,7 @@ pub enum TokenKind {
     At,
     Tempo,
     Bank,
+    Pattern,
     Loop,
     Function,
     As,

package/rust/core/parser/driver.rs

@@ -9,6 +9,7 @@ use crate::core::{
             bank::parse_bank_token,
             condition::parse_condition_token,
             dot::parse_dot_token,
+            pattern::parse_pattern_token,
             identifier::{
                 emit::parse_emit_token, function::parse_function_token, on::parse_on_token,
                 parse_identifier_token,
@@ -156,6 +157,7 @@ impl Parser {
                 TokenKind::Dot => parse_dot_token(self, global_store),
                 TokenKind::Tempo => parse_tempo_token(self, global_store),
                 TokenKind::Bank => parse_bank_token(self, global_store),
+                TokenKind::Pattern => parse_pattern_token(self, global_store),
                 TokenKind::Loop => parse_loop_token(self, global_store),
                 TokenKind::If => parse_condition_token(self, global_store),
                 TokenKind::Function => parse_function_token(self, global_store),
@@ -202,6 +204,8 @@ impl Parser {
     }
 
     pub fn parse_map_value(&mut self) -> Option<Value> {
+    let logger = devalang_utils::logger::Logger::new();
+    use devalang_utils::logger::LogLevel;
         if !self.match_token(TokenKind::LBrace) {
             return None;
         }
@@ -244,7 +248,7 @@ impl Parser {
             }
 
             if !self.match_token(TokenKind::Colon) {
-                println!("Expected ':' after map key '{}'", key);
+                logger.log_message(LogLevel::Error, &format!("Expected ':' after map key '{}'", key));
                 break;
             }
 
@@ -278,14 +282,11 @@ impl Parser {
                                         number_str.push('.');
                                         number_str.push_str(&decimal_token.lexeme);
                                     } else {
-                                        println!(
-                                            "Expected number after dot, got {:?}",
-                                            decimal_token
-                                        );
+                                        logger.log_message(LogLevel::Error, &format!("Expected number after dot, got {:?}", decimal_token));
                                         return Some(Value::Null);
                                     }
                                 } else {
-                                    println!("Expected number after dot, but reached EOF");
+                                    logger.log_message(LogLevel::Error, "Expected number after dot, but reached EOF");
                                     return Some(Value::Null);
                                 }
                             }
@@ -325,7 +326,7 @@ impl Parser {
                         Value::Identifier(parts.join("."))
                     }
                     _ => {
-                        println!("Unexpected token in map value: {:?}", token);
+                        logger.log_message(LogLevel::Error, &format!("Unexpected token in map value: {:?}", token));
                         Value::Null
                     }
                 }
@@ -345,7 +346,7 @@ impl Parser {
         }
 
         if !self.match_token(TokenKind::RBrace) {
-            println!("Expected '}}' at end of map");
+            logger.log_message(LogLevel::Error, "Expected '}' at end of map");
         }
 
         Some(Value::Map(map))
@@ -353,6 +354,8 @@ impl Parser {
 
     // Parse an array value like [1, 2, 3] or ["a", b]
     pub fn parse_array_value(&mut self) -> Option<Value> {
+    let logger = devalang_utils::logger::Logger::new();
+    use devalang_utils::logger::LogLevel;
         if !self.match_token(TokenKind::LBracket) {
             return None;
         }
@@ -436,7 +439,7 @@ impl Parser {
         }
 
         if !self.match_token(TokenKind::RBracket) {
-            println!("Expected ']' at end of array");
+            logger.log_message(LogLevel::Error, "Expected ']' at end of array");
         }
 
         Some(Value::Array(arr))

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

@@ -13,7 +13,8 @@ pub fn parse_dot_token(
     _global_store: &mut crate::core::store::global::GlobalStore,
 ) -> Statement {
     parser.advance(); // consume '.'
-
+    let logger = devalang_utils::logger::Logger::new();
+    use devalang_utils::logger::LogLevel;
     let Some(dot_token) = parser.previous_clone() else {
         return Statement::unknown();
     };
@@ -56,7 +57,7 @@ pub fn parse_dot_token(
     let entity = if !parts.is_empty() {
         parts.join(".") // only join within the same line
     } else {
-        eprintln!("⚠️ Empty entity after '.' at line {}", dot_token.line);
+        logger.log_message(LogLevel::Warning, &format!("Empty entity after '.' at line {}", dot_token.line));
         String::new()
     };
 

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

@@ -100,7 +100,7 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
         }
 
         let tokens =
-            parser.collect_until(|t| (t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF));
+            parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
         let loop_body = parser.parse_block(tokens.clone(), global_store);
         if let Some(token) = parser.peek() {
             if token.kind == TokenKind::Dedent {
@@ -173,7 +173,7 @@ pub fn parse_loop_token(parser: &mut Parser, global_store: &mut GlobalStore) ->
     }
 
     let tokens =
-        parser.collect_until(|t| (t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF));
+        parser.collect_until(|t| t.kind == TokenKind::Dedent || t.kind == TokenKind::EOF);
     let loop_body = parser.parse_block(tokens.clone(), global_store);
     if let Some(token) = parser.peek() {
         if token.kind == TokenKind::Dedent {

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

@@ -1,6 +1,7 @@
 pub mod arrow_call;
 pub mod at;
 pub mod bank;
+pub mod pattern;
 pub mod condition;
 pub mod dot;
 pub mod identifier;

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

@@ -0,0 +1,74 @@
+use devalang_types::Value;
+
+use crate::core::{
+    lexer::token::TokenKind,
+    parser::{
+        driver::Parser,
+        statement::{Statement, StatementKind},
+    },
+    store::global::GlobalStore,
+};
+
+pub fn parse_pattern_token(parser: &mut Parser, _global_store: &mut GlobalStore) -> Statement {
+    // consume 'pattern'
+    parser.advance();
+
+    let Some(tok) = parser.previous_clone() else {
+        return Statement::unknown();
+    };
+
+    // Parse pattern name
+    let mut name = String::new();
+    if let Some(next) = parser.peek_clone() {
+        if next.kind == TokenKind::Identifier {
+            parser.advance();
+            name = next.lexeme.clone();
+        }
+    }
+
+    // optional 'with <target>' sequence
+    let mut target: Option<String> = None;
+    if parser.peek_is("with") {
+        parser.advance(); // consume 'with'
+        if let Some(tok2) = parser.peek_clone() {
+            // target can be identifier or dotted identifier
+            if tok2.kind == TokenKind::Identifier {
+                parser.advance();
+                let mut base = tok2.lexeme.clone();
+                if let Some(dot) = parser.peek_clone() {
+                    if dot.kind == TokenKind::Dot {
+                        parser.advance();
+                        if let Some(suf) = parser.peek_clone() {
+                            if suf.kind == TokenKind::Identifier || suf.kind == TokenKind::Number {
+                                parser.advance();
+                                base.push('.');
+                                base.push_str(&suf.lexeme);
+                            }
+                        }
+                    }
+                }
+                target = Some(base);
+            }
+        }
+    }
+
+    // optional '=' and pattern string
+    let mut value: Value = Value::Null;
+    if parser.peek_is("=") {
+        parser.advance();
+        if let Some(tok3) = parser.peek_clone() {
+            if tok3.kind == TokenKind::String {
+                parser.advance();
+                value = Value::String(tok3.lexeme.clone());
+            }
+        }
+    }
+
+    Statement {
+        kind: StatementKind::Pattern { name, target },
+        value,
+        indent: tok.indent,
+        line: tok.line,
+        column: tok.column,
+    }
+}