@devaloop/devalang 0.0.1-alpha.1 → 0.0.1-alpha.2

package/rust/core/lexer/mod.rs

@@ -1,333 +1,14 @@
-use crate::core::types::token::{ Token, TokenKind };
-
-pub fn lex(input: String) -> Vec<Token> {
-    let mut tokens = Vec::new();
-
-    let mut line = 1;
-    let mut column = 1;
-
-    let mut indent_stack: Vec<usize> = vec![0];
-    let mut current_indent = 0;
-    let mut at_line_start = true;
-
-    let mut chars = input.chars().peekable();
-
-    while let Some(_) = chars.peek() {
-        if at_line_start {
-            current_indent = 0;
-
-            while let Some(&c) = chars.peek() {
-                if c == ' ' {
-                    current_indent += 1;
-                    chars.next();
-                    column += 1;
-                } else {
-                    break;
-                }
-            }
-
-            let last_indent = *indent_stack.last().unwrap();
-            if current_indent > last_indent {
-                indent_stack.push(current_indent);
-                tokens.push(Token {
-                    kind: TokenKind::Indent,
-                    lexeme: String::new(),
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-            } else {
-                while current_indent < *indent_stack.last().unwrap() {
-                    indent_stack.pop();
-                    tokens.push(Token {
-                        kind: TokenKind::Dedent,
-                        lexeme: String::new(),
-                        line,
-                        column,
-                        indent: current_indent,
-                    });
-                }
-            }
-
-            at_line_start = false;
-        }
-
-        let Some(ch) = chars.next() else {
-            break;
-        };
-
-        if ch == '\n' {
-            tokens.push(Token {
-                kind: TokenKind::Newline,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-
-            line += 1;
-            column = 1;
-            at_line_start = true;
-
-            continue;
-        }
-
-        if ch == ' ' || ch == '\t' {
-            column += if ch == '\t' { 4 } else { 1 };
-            continue;
-        }
-
-        if ch == '#' {
-            let mut comment = String::new();
-            while let Some(&c) = chars.peek() {
-                if c == '\n' {
-                    break;
-                }
-                comment.push(c);
-                chars.next();
-                column += 1;
-            }
-            tokens.push(Token {
-                kind: TokenKind::Comment(comment.trim().to_string()),
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            continue;
-        }
-
-        if ch == ':' {
-            tokens.push(Token {
-                kind: TokenKind::Colon,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch == '=' {
-            if let Some('=') = chars.peek() {
-                chars.next();
-                tokens.push(Token {
-                    kind: TokenKind::DoubleEquals,
-                    lexeme: ch.to_string(),
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-                column += 2;
-            } else {
-                tokens.push(Token {
-                    kind: TokenKind::Equals,
-                    lexeme: ch.to_string(),
-                    line,
-                    column,
-                    indent: current_indent,
-                });
-                column += 1;
-            }
-            continue;
-        }
-
-        if ch == '[' {
-            tokens.push(Token {
-                kind: TokenKind::LBracket,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch == ']' {
-            tokens.push(Token {
-                kind: TokenKind::RBracket,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch == '{' {
-            tokens.push(Token {
-                kind: TokenKind::LBrace,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch == '}' {
-            tokens.push(Token {
-                kind: TokenKind::RBrace,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch == '"' {
-            let mut string_content = String::new();
-            column += 1; // skip the opening quote
-
-            while let Some(next_ch) = chars.next() {
-                column += 1;
-                if next_ch == '"' {
-                    break; // closing quote reached
-                } else {
-                    string_content.push(next_ch);
-                }
-            }
-
-            tokens.push(Token {
-                kind: TokenKind::String,
-                lexeme: string_content,
-                line,
-                column,
-                indent: current_indent,
-            });
-
-            continue;
-        }
-
-        if ch == '\'' {
-            let mut string_content = String::new();
-            column += 1;
-
-            while let Some(next_ch) = chars.next() {
-                column += 1;
-                if next_ch == '\'' {
-                    break;
-                } else {
-                    string_content.push(next_ch);
-                }
-            }
-
-            tokens.push(Token {
-                kind: TokenKind::String,
-                lexeme: string_content,
-                line,
-                column,
-                indent: current_indent,
-            });
-
-            continue;
-        }
-
-        if ch == '.' {
-            tokens.push(Token {
-                kind: TokenKind::Dot,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch == '@' {
-            tokens.push(Token {
-                kind: TokenKind::At,
-                lexeme: ch.to_string(),
-                line,
-                column,
-                indent: current_indent,
-            });
-            column += 1;
-            continue;
-        }
-
-        if ch.is_ascii_digit() {
-            let mut number = ch.to_string();
-            while let Some(&c) = chars.peek() {
-                if c.is_ascii_digit() {
-                    number.push(c);
-                    chars.next();
-                    column += 1;
-                } else {
-                    break;
-                }
-            }
-
-            // let value = number.parse::<f32>().unwrap();
-            tokens.push(Token {
-                kind: TokenKind::Number,
-                lexeme: number,
-                line,
-                column,
-                indent: current_indent,
-            });
-            continue;
-        }
-
-        if ch.is_ascii_alphabetic() {
-            let mut ident = ch.to_string();
-            while let Some(&c) = chars.peek() {
-                if c.is_ascii_alphanumeric() || c == '_' {
-                    ident.push(c);
-                    chars.next();
-                    column += 1;
-                } else {
-                    break;
-                }
-            }
-
-            let kind = match ident.as_str() {
-                "bank" => TokenKind::Bank,
-                "bpm" => TokenKind::Tempo,
-                "loop" => TokenKind::Loop,
-                _ => TokenKind::Identifier,
-            };
-
-            tokens.push(Token {
-                kind,
-                lexeme: ident,
-                line,
-                column,
-                indent: current_indent,
-            });
-            continue;
-        }
-
-        // Skip unknown char
-        column += 1;
-    }
-
-    while indent_stack.len() > 1 {
-        indent_stack.pop();
-        current_indent = *indent_stack.last().unwrap();
-        tokens.push(Token {
-            kind: TokenKind::Dedent,
-            lexeme: String::new(),
-            line,
-            column,
-            indent: current_indent,
-        });
-    }
-
-    tokens.push(Token {
-        kind: TokenKind::EOF,
-        lexeme: String::new(),
-        line: line + 1, // EOF is considered to be on the next line
-        column: 0, // EOF has no column
-        indent: 0, // EOF has no indent
-    });
-
-    tokens
-}
+pub mod indent;
+pub mod identifier;
+pub mod number;
+pub mod at;
+pub mod dot;
+pub mod quote;
+pub mod brace;
+pub mod newline;
+pub mod comment;
+pub mod bracket;
+pub mod colon;
+pub mod equal;
+
+pub mod driver;

package/rust/core/lexer/newline.rs

@@ -0,0 +1,23 @@
+use crate::core::types::token::{Token, TokenKind};
+
+pub fn handle_newline_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize,
+    at_line_start: &mut bool,
+    current_indent: &mut usize,
+) {
+    tokens.push(Token {
+        kind: TokenKind::Newline,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *line += 1;
+    *column = 1;
+    *at_line_start = true;
+}

package/rust/core/lexer/number.rs

@@ -0,0 +1,31 @@
+use crate::core::types::token::{Token, TokenKind};
+
+pub fn handle_number_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    let mut number = char.to_string();
+
+    while let Some(&c) = chars.peek() {
+        if c.is_ascii_digit() {
+            number.push(c);
+            chars.next();
+            *column += 1;
+        } else {
+            break;
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::Number,
+        lexeme: number,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/quote.rs

@@ -0,0 +1,61 @@
+use crate::core::types::token::{Token, TokenKind};
+
+pub fn handle_single_quote_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    let mut string_content = String::new();
+    *column += 1;
+
+    while let Some(next_ch) = chars.next() {
+        *column += 1;
+        if next_ch == '\'' {
+            break;
+        } else {
+            string_content.push(next_ch);
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::String,
+        lexeme: string_content,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}
+
+pub fn handle_double_quote_lexer(
+    char: char,
+    chars: &mut std::iter::Peekable<std::str::Chars>,
+    current_indent: &mut usize,
+    indent_stack: &mut Vec<usize>,
+    tokens: &mut Vec<Token>,
+    line: &mut usize,
+    column: &mut usize
+) {
+    let mut string_content = String::new();
+    *column += 1; // skip the opening quote
+
+    while let Some(next_ch) = chars.next() {
+        *column += 1;
+        if next_ch == '"' {
+            break; // closing quote reached
+        } else {
+            string_content.push(next_ch);
+        }
+    }
+
+    tokens.push(Token {
+        kind: TokenKind::String,
+        lexeme: string_content,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/parser/dot.rs

@@ -1,9 +1,12 @@
 use std::{ collections::HashMap, hash::Hash };
 
-use crate::core::types::{
-    statement::{ Statement, StatementKind },
-    token::{ Token, TokenDuration, TokenKind, TokenParamValue },
-    variable::{ Variable, VariableValue },
+use crate::{
+    core::types::{
+        statement::{ Statement, StatementKind },
+        token::{ Token, TokenDuration, TokenKind, TokenParamValue },
+        variable::{ Variable, VariableValue },
+    },
+    utils::logger::log_message,
 };
 
 pub fn parse_dot(
@@ -19,12 +22,43 @@ pub fn parse_dot(
 
     parser.next();
 
-    let next_token = parser.peek().ok_or("Expected identifier after dot")?.clone();
-    if next_token.kind != crate::core::types::token::TokenKind::Identifier {
-        return Err(format!("Expected Identifier after Dot, found {:?}", next_token.kind));
+    let identifier_token = parser.peek().ok_or("Expected identifier after dot")?.clone();
+    if identifier_token.kind != crate::core::types::token::TokenKind::Identifier {
+        return Err(format!("Expected Identifier after Dot, found {:?}", identifier_token.kind));
     }
 
-    parser.next(); 
+    match identifier_token.lexeme.as_str() {
+        // TODO Execute each trigger logic
+
+        "kick" => {
+            trigger_value = String::from("Kick");
+        }
+        "snare" => {
+            trigger_value = String::from("Snare");
+        }
+        "hihat" => {
+            trigger_value = String::from("HiHat");
+        }
+        "tom" => {
+            trigger_value = String::from("Tom");
+        }
+        "clap" => {
+            trigger_value = String::from("Clap");
+        }
+        "crash" => {
+            trigger_value = String::from("Crash");
+        }
+        "ride" => {
+            trigger_value = String::from("Ride");
+        }
+
+        _ => {
+            log_message("Custom triggers are experimental", "WARNING");
+            trigger_value = identifier_token.lexeme.clone();
+        }
+    }
+
+    parser.next();
 
     let duration_token = parser.peek().ok_or("Expected duration after identifier")?.clone();
     let mut duration = TokenDuration::Unknown;
@@ -50,10 +84,8 @@ pub fn parse_dot(
     }
 
     parser.next();
-   
-    let dot_params: Vec<Token> = parser.collect_until(|t| {
-        t.kind == TokenKind::Newline
-    });
+
+    let dot_params: Vec<Token> = parser.collect_until(|t| { t.kind == TokenKind::Newline });
 
     let mut params_value: VariableValue = VariableValue::Null;
 
@@ -79,24 +111,22 @@ pub fn parse_dot(
                 }
                 VariableValue::Map(map)
             }
-            TokenKind::Identifier => {
-                VariableValue::Text(param.lexeme.clone())
-            }
+            TokenKind::Identifier => { VariableValue::Text(param.lexeme.clone()) }
             TokenKind::Unknown => {
                 Err(format!("Unsupported token type in dot parameters: {:?}", param.kind))?;
                 VariableValue::Null
-            },
+            }
             _ => {
                 Err(format!("Unsupported token type in dot parameters: {:?}", param.kind))?;
                 VariableValue::Unknown
-            },
+            }
         };
         params_value = token_value;
     }
 
     Ok(Statement {
         kind: StatementKind::Trigger {
-            entity: next_token.lexeme.clone(),
+            entity: identifier_token.lexeme.clone(),
             duration: duration.clone(),
         },
         value: params_value,

package/rust/core/preprocessor/module.rs

@@ -1,5 +1,5 @@
 use crate::core::{
-    lexer::lex,
+    lexer::driver::lex,
     parser::{ parse_without_resolving },
     preprocessor::{
         collect_dependencies_recursively,