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

package/rust/core/debugger/logs.rs

@@ -1,52 +1,52 @@
-use devalang_types::{FunctionTable, VariableTable};
-use std::fs::create_dir_all;
-
-pub fn write_module_variable_log_file(
-    output_dir: &str,
-    module_path: &str,
-    variable_table: &VariableTable,
-) {
-    let debugger = crate::core::debugger::Debugger::new();
-    let mut content = String::new();
-    let module_name = module_path
-        .split('/')
-        .next_back()
-        .unwrap_or("index")
-        .replace(".deva", "");
-
-    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (var_name, var_data) in &variable_table.variables {
-        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, "variables.log", &content);
-}
-
-pub fn write_module_function_log_file(
-    output_dir: &str,
-    module_path: &str,
-    function_table: &FunctionTable,
-) {
-    let debugger = crate::core::debugger::Debugger::new();
-    let mut content = String::new();
-    let module_name = module_path
-        .split('/')
-        .next_back()
-        .unwrap_or("index")
-        .replace(".deva", "");
-
-    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (func_name, func_data) in &function_table.functions {
-        content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, "functions.log", &content);
-}
+use devalang_types::{FunctionTable, VariableTable};
+use std::fs::create_dir_all;
+
+pub fn write_module_variable_log_file(
+    output_dir: &str,
+    module_path: &str,
+    variable_table: &VariableTable,
+) {
+    let debugger = crate::core::debugger::Debugger::new();
+    let mut content = String::new();
+    let module_name = module_path
+        .split('/')
+        .next_back()
+        .unwrap_or("index")
+        .replace(".deva", "");
+
+    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (var_name, var_data) in &variable_table.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push('\n');
+
+    debugger.write_log_file(&log_directory, "variables.log", &content);
+}
+
+pub fn write_module_function_log_file(
+    output_dir: &str,
+    module_path: &str,
+    function_table: &FunctionTable,
+) {
+    let debugger = crate::core::debugger::Debugger::new();
+    let mut content = String::new();
+    let module_name = module_path
+        .split('/')
+        .next_back()
+        .unwrap_or("index")
+        .replace(".deva", "");
+
+    let log_directory = format!("{}/logs/modules/{}", output_dir, module_name);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (func_name, func_data) in &function_table.functions {
+        content.push_str(&format!("{:?} = {:?}\n", func_name, func_data));
+    }
+
+    content.push('\n');
+
+    debugger.write_log_file(&log_directory, "functions.log", &content);
+}

package/rust/core/debugger/preprocessor.rs

@@ -1,27 +1,27 @@
-use crate::core::{debugger::Debugger, parser::statement::Statement};
-use std::{collections::HashMap, fs::create_dir_all};
-
-pub fn write_preprocessor_log_file(
-    output_dir: &str,
-    file_name: &str,
-    modules: HashMap<String, Vec<Statement>>,
-) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (path, stmts) in modules {
-        content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
-
-        for stmt in stmts {
-            content.push_str(&format!("{:?}\n", stmt));
-        }
-
-        content.push('\n');
-    }
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::{debugger::Debugger, parser::statement::Statement};
+use std::{collections::HashMap, fs::create_dir_all};
+
+pub fn write_preprocessor_log_file(
+    output_dir: &str,
+    file_name: &str,
+    modules: HashMap<String, Vec<Statement>>,
+) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (path, stmts) in modules {
+        content.push_str(&format!("--- Resolved Statements for {} ---\n", path));
+
+        for stmt in stmts {
+            content.push_str(&format!("{:?}\n", stmt));
+        }
+
+        content.push('\n');
+    }
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/debugger/store.rs

@@ -1,38 +1,38 @@
-use crate::core::debugger::Debugger;
-use devalang_types::{FunctionTable, VariableTable};
-use std::fs::create_dir_all;
-
-pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (var_name, var_data) in variables.variables {
-        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
-
-pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
-    let debugger = Debugger::new();
-    let mut content = String::new();
-
-    let log_directory = format!("{}/logs", output_dir);
-    create_dir_all(&log_directory).expect("Failed to create log directory");
-
-    for (_index, function) in functions.functions {
-        content.push_str(&format!(
-            "'{}' = [{:?}] => {:?}\n",
-            function.name, function.parameters, function.body
-        ));
-    }
-
-    content.push('\n');
-
-    debugger.write_log_file(&log_directory, file_name, &content);
-}
+use crate::core::debugger::Debugger;
+use devalang_types::{FunctionTable, VariableTable};
+use std::fs::create_dir_all;
+
+pub fn write_variables_log_file(output_dir: &str, file_name: &str, variables: VariableTable) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (var_name, var_data) in variables.variables {
+        content.push_str(&format!("{:?} = {:?}\n", var_name, var_data));
+    }
+
+    content.push('\n');
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}
+
+pub fn write_function_log_file(output_dir: &str, file_name: &str, functions: FunctionTable) {
+    let debugger = Debugger::new();
+    let mut content = String::new();
+
+    let log_directory = format!("{}/logs", output_dir);
+    create_dir_all(&log_directory).expect("Failed to create log directory");
+
+    for (_index, function) in functions.functions {
+        content.push_str(&format!(
+            "'{}' = [{:?}] => {:?}\n",
+            function.name, function.parameters, function.body
+        ));
+    }
+
+    content.push('\n');
+
+    debugger.write_log_file(&log_directory, file_name, &content);
+}

package/rust/core/lexer/driver.rs

@@ -1,59 +1,59 @@
-use crate::core::lexer::{handler::driver::handle_content_lexing, token::Token};
-use devalang_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
-            ));
-        }
-    }
-}
+use crate::core::lexer::{handler::driver::handle_content_lexing, token::Token};
+use devalang_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
+            ));
+        }
+    }
+}

package/rust/core/lexer/handler/arrow.rs

@@ -1,82 +1,82 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_arrow_lexer(
-    ch: char,
-    chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    // If next char is '>', this is an arrow '->'.
-    if let Some(&c) = chars.peek() {
-        if c == '>' {
-            let mut arrow_call = ch.to_string();
-            chars.next();
-            arrow_call.push(c);
-            *column += 1;
-
-            tokens.push(Token {
-                kind: TokenKind::Arrow,
-                lexeme: arrow_call,
-                line: *line,
-                column: *column,
-                indent: *current_indent,
-            });
-            return;
-        }
-    }
-
-    // Otherwise, treat '-' as the start of a negative number if followed by digits.
-    let mut lexeme = String::from("-");
-    if let Some(&next) = chars.peek() {
-        if next.is_ascii_digit() {
-            // consume digits
-            while let Some(&d) = chars.peek() {
-                if d.is_ascii_digit() {
-                    chars.next();
-                    lexeme.push(d);
-                    *column += 1;
-                } else {
-                    break;
-                }
-            }
-            // optional decimal part
-            if let Some(&dot) = chars.peek() {
-                if dot == '.' {
-                    chars.next();
-                    lexeme.push(dot);
-                    *column += 1;
-                    while let Some(&d) = chars.peek() {
-                        if d.is_ascii_digit() {
-                            chars.next();
-                            lexeme.push(d);
-                            *column += 1;
-                        } else {
-                            break;
-                        }
-                    }
-                }
-            }
-
-            tokens.push(Token {
-                kind: TokenKind::Number,
-                lexeme,
-                line: *line,
-                column: *column,
-                indent: *current_indent,
-            });
-            return;
-        }
-    }
-
-    // Fallback: lone '-' not part of '->' or a number; emit Unknown to avoid mis-parsing as Arrow
-    tokens.push(Token {
-        kind: TokenKind::Unknown,
-        lexeme: "-".to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-}
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_arrow_lexer(
+    ch: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    _indent_stack: &mut [usize],
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+) {
+    // If next char is '>', this is an arrow '->'.
+    if let Some(&c) = chars.peek() {
+        if c == '>' {
+            let mut arrow_call = ch.to_string();
+            chars.next();
+            arrow_call.push(c);
+            *column += 1;
+
+            tokens.push(Token {
+                kind: TokenKind::Arrow,
+                lexeme: arrow_call,
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+            return;
+        }
+    }
+
+    // Otherwise, treat '-' as the start of a negative number if followed by digits.
+    let mut lexeme = String::from("-");
+    if let Some(&next) = chars.peek() {
+        if next.is_ascii_digit() {
+            // consume digits
+            while let Some(&d) = chars.peek() {
+                if d.is_ascii_digit() {
+                    chars.next();
+                    lexeme.push(d);
+                    *column += 1;
+                } else {
+                    break;
+                }
+            }
+            // optional decimal part
+            if let Some(&dot) = chars.peek() {
+                if dot == '.' {
+                    chars.next();
+                    lexeme.push(dot);
+                    *column += 1;
+                    while let Some(&d) = chars.peek() {
+                        if d.is_ascii_digit() {
+                            chars.next();
+                            lexeme.push(d);
+                            *column += 1;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+
+            tokens.push(Token {
+                kind: TokenKind::Number,
+                lexeme,
+                line: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+            return;
+        }
+    }
+
+    // Fallback: lone '-' not part of '->' or a number; emit Unknown to avoid mis-parsing as Arrow
+    tokens.push(Token {
+        kind: TokenKind::Unknown,
+        lexeme: "-".to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/handler/at.rs

@@ -1,21 +1,21 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_at_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    tokens.push(Token {
-        kind: TokenKind::At,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_at_lexer(
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    _indent_stack: &mut [usize],
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+) {
+    tokens.push(Token {
+        kind: TokenKind::At,
+        lexeme: ch.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/handler/brace.rs

@@ -1,41 +1,41 @@
-use crate::core::lexer::token::{Token, TokenKind};
-
-pub fn handle_rbrace_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    tokens.push(Token {
-        kind: TokenKind::RBrace,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}
-
-pub fn handle_lbrace_lexer(
-    ch: char,
-    _chars: &mut std::iter::Peekable<std::str::Chars>,
-    current_indent: &mut usize,
-    _indent_stack: &mut [usize],
-    tokens: &mut Vec<Token>,
-    line: &mut usize,
-    column: &mut usize,
-) {
-    tokens.push(Token {
-        kind: TokenKind::LBrace,
-        lexeme: ch.to_string(),
-        line: *line,
-        column: *column,
-        indent: *current_indent,
-    });
-
-    *column += 1;
-}
+use crate::core::lexer::token::{Token, TokenKind};
+
+pub fn handle_rbrace_lexer(
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    _indent_stack: &mut [usize],
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+) {
+    tokens.push(Token {
+        kind: TokenKind::RBrace,
+        lexeme: ch.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lbrace_lexer(
+    ch: char,
+    _chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    _indent_stack: &mut [usize],
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+) {
+    tokens.push(Token {
+        kind: TokenKind::LBrace,
+        lexeme: ch.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}