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

package/rust/cli/template.rs

@@ -0,0 +1,56 @@
+use include_dir::{ include_dir, Dir, DirEntry };
+
+use crate::utils::file::format_file_size;
+
+static TEMPLATES_DIR: Dir = include_dir!("$CARGO_MANIFEST_DIR/templates");
+
+pub fn handle_template_list_command() {
+    let available_templates = get_available_templates();
+
+    println!("📦 Available templates ({}) :\n", available_templates.len());
+
+    for dir in available_templates {
+        println!("• {}", dir);
+    }
+
+    println!("\nUsage : devalang init --name <project-name> --template <template-name>");
+}
+
+pub fn handle_template_info_command(name: String) {
+    let template_dir = TEMPLATES_DIR.get_dir(name.clone()).unwrap_or_else(|| {
+        println!("❌ The template '{}' is not found.", name);
+
+        std::process::exit(1);
+    });
+
+    let mut file_count = 0;
+    let mut dir_count = 0;
+    let mut total_size: u64 = 0;
+
+    fn walk(dir: &Dir, file_count: &mut u32, dir_count: &mut u32, total_size: &mut u64) {
+        for entry in dir.entries() {
+            match entry {
+                DirEntry::File(file) => {
+                    *file_count += 1;
+                    *total_size += file.contents().len() as u64;
+                }
+                DirEntry::Dir(subdir) => {
+                    *dir_count += 1;
+                    walk(subdir, file_count, dir_count, total_size);
+                }
+            }
+        }
+    }
+
+    walk(template_dir, &mut file_count, &mut dir_count, &mut total_size);
+
+    println!("📦 Template : {}", name);
+    println!("📂 Content  : {file_count} file(s), {dir_count} folder(s)");
+    println!("💾 Size     : {}", format_file_size(total_size));
+}
+
+pub fn get_available_templates() -> Vec<String> {
+    TEMPLATES_DIR.dirs()
+        .map(|dir| dir.path().file_name().unwrap().to_string_lossy().to_string())
+        .collect()
+}

package/rust/core/lexer/at.rs

@@ -0,0 +1,21 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn handle_at_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::At,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/brace.rs

@@ -0,0 +1,41 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn handle_rbrace_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::RBrace,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lbrace_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::LBrace,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/bracket.rs

@@ -0,0 +1,41 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn handle_rbracket_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::RBracket,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}
+
+pub fn handle_lbracket_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::LBracket,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/colon.rs

@@ -0,0 +1,21 @@
+use crate::core::types::token::{Token, TokenKind};
+
+pub fn handle_colon_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::Colon,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/comment.rs

@@ -0,0 +1,30 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn handle_comment_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 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: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/dot.rs

@@ -0,0 +1,21 @@
+use crate::core::types::token::{Token, TokenKind};
+
+pub fn handle_dot_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
+) {
+    tokens.push(Token {
+        kind: TokenKind::Dot,
+        lexeme: char.to_string(),
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+
+    *column += 1;
+}

package/rust/core/lexer/driver.rs

@@ -0,0 +1,286 @@
+
+
+use crate::core::{
+    lexer::{
+        at::handle_at_lexer,
+        brace::{ handle_lbrace_lexer, handle_rbrace_lexer },
+        colon::handle_colon_lexer,
+        comment::handle_comment_lexer,
+        equal::handle_equal_lexer,
+        newline::handle_newline_lexer,
+        bracket::{ handle_lbracket_lexer, handle_rbracket_lexer },
+        dot::handle_dot_lexer,
+        identifier::handle_identifier_lexer,
+        indent::handle_indent_lexer,
+        number::handle_number_lexer,
+        quote::{ handle_double_quote_lexer, handle_single_quote_lexer },
+    },
+    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 {
+            let (new_tokens, new_indent_stack, new_line, new_column) = handle_indent_lexer(
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            // Update the main tokens vector and indent stack
+            tokens = new_tokens;
+            indent_stack = new_indent_stack;
+            line = new_line;
+            column = new_column;
+
+            // Reset at_line_start flag
+            at_line_start = false;
+        }
+
+        // Read the next character
+        let Some(ch) = chars.next() else {
+            break;
+        };
+
+        // Newline handling
+        if ch == '\n' {
+            handle_newline_lexer(
+                ch,
+                &mut chars,
+                &mut tokens,
+                &mut line,
+                &mut column,
+                &mut at_line_start,
+                &mut current_indent
+            );
+
+            continue;
+        }
+
+        if ch == ' ' || ch == '\t' {
+            column += if ch == '\t' { 4 } else { 1 };
+            continue;
+        }
+
+        if ch == '#' {
+            handle_comment_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == ':' {
+            handle_colon_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '=' {
+            handle_equal_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '[' {
+            handle_lbracket_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == ']' {
+            handle_rbracket_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '{' {
+            handle_lbrace_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '}' {
+            handle_rbrace_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '"' {
+            handle_double_quote_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '\'' {
+            handle_single_quote_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '.' {
+            handle_dot_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch == '@' {
+            handle_at_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch.is_ascii_digit() {
+            handle_number_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            continue;
+        }
+
+        if ch.is_ascii_alphabetic() {
+            handle_identifier_lexer(
+                ch,
+                &mut chars,
+                &mut current_indent,
+                &mut indent_stack,
+                &mut tokens,
+                &mut line,
+                &mut column
+            );
+
+            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
+}

package/rust/core/lexer/equal.rs

@@ -0,0 +1,32 @@
+use crate::core::types::token::{Token, TokenKind};
+
+pub fn handle_equal_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
+) {
+    if let Some('=') = chars.peek() {
+        chars.next();
+        tokens.push(Token {
+            kind: TokenKind::DoubleEquals,
+            lexeme: char.to_string(),
+            line: *line,
+            column: *column,
+            indent: *current_indent,
+        });
+        *column += 2;
+    } else {
+        tokens.push(Token {
+            kind: TokenKind::Equals,
+            lexeme: char.to_string(),
+            line: *line,
+            column: *column,
+            indent: *current_indent,
+        });
+        *column += 1;
+    }
+}

package/rust/core/lexer/identifier.rs

@@ -0,0 +1,38 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn handle_identifier_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 ident = char.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: kind.clone(),
+        lexeme: ident,
+        line: *line,
+        column: *column,
+        indent: *current_indent,
+    });
+}

package/rust/core/lexer/indent.rs

@@ -0,0 +1,47 @@
+use crate::core::types::token::{ Token, TokenKind };
+
+pub fn handle_indent_lexer(
+    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
+) -> (Vec<Token>, Vec<usize>, usize, usize) {
+    *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: *line,
+            column: *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: *line,
+                column: *column,
+                indent: *current_indent,
+            });
+        }
+    }
+
+    (tokens.clone(), indent_stack.clone(), *line, *column)
+}