shell-lite 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

shell_lite/js_compiler.py

@@ -1,38 +1,28 @@
 import random
 from typing import List
 from .ast_nodes import *
-
 class JSCompiler:
     def __init__(self):
         self.indentation = 0
-        
     def indent(self):
         return "    " * self.indentation
-        
     def visit(self, node: Node) -> str:
         method_name = f'visit_{type(node).__name__}'
         visitor = getattr(self, method_name, self.generic_visit)
         return visitor(node)
-        
     def generic_visit(self, node: Node):
         raise Exception(f"JSCompiler does not support {type(node).__name__}")
-        
     def compile_block(self, statements: List[Node]) -> str:
         if not statements:
             return ""
-            
         code = ""
         for stmt in statements:
             stmt_code = self.visit(stmt)
             if not stmt_code: continue
-            
-            # Formatting
             indented_stmt = "\n".join([f"{self.indent()}{line}" for line in stmt_code.split('\n')])
             code += indented_stmt + "\n"
         return code.rstrip()
-
     def compile(self, statements: List[Node]) -> str:
-        # Preamble / Runtime
         code = [
             "// ShellLite Runtime (JS)",
             "const fs = require('fs');",
@@ -55,91 +45,59 @@ class JSCompiler:
             "// --- User Code ---",
             ""
         ]
-        
         code.append(self.compile_block(statements))
         return "\n".join(code)
-
-    # --- Visitor Methods ---
-
     def visit_Number(self, node: Number):
         return str(node.value)
-
     def visit_String(self, node: String):
-        return repr(node.value) # 'string' or "string" is valid JS too
-
+        return repr(node.value) 
     def visit_Boolean(self, node: Boolean):
         return "true" if node.value else "false"
-        
     def visit_Regex(self, node: Regex):
         return f"/{node.pattern}/"
-
     def visit_ListVal(self, node: ListVal):
         elements = [self.visit(e) for e in node.elements]
         return f"[{', '.join(elements)}]"
-
     def visit_Dictionary(self, node: Dictionary):
-        # JS Objects for Dicts
         pairs = [f"{self.visit(k)}: {self.visit(v)}" for k, v in node.pairs]
         return f"{{{', '.join(pairs)}}}"
-        
     def visit_SetVal(self, node: SetVal):
         elements = [self.visit(e) for e in node.elements]
         return f"new Set([{', '.join(elements)}])"
-
     def visit_VarAccess(self, node: VarAccess):
         return node.name
-
     def visit_Assign(self, node: Assign):
-        # We assume 'let' or 'const' isn't strictly needed if we reuse vars,
-        # but in strict mode we might need it. 
-        # For simplicity, we'll try to use assignments directly.
-        # Ideally we track scope to emit 'let' on first use?
-        # ShellLite is dynamic. Let's assume Global/Function scope and just emit `name = value`.
-        # However, in strict JS, undeclared vars are errors.
-        # We might need a "let name;" preamble or just use `var`?
         return f"var {node.name} = {self.visit(node.value)};"
-
     def visit_ConstAssign(self, node: ConstAssign):
         return f"const {node.name} = {self.visit(node.value)};"
-    
     def visit_PropertyAssign(self, node: PropertyAssign):
         return f"{node.instance_name}.{node.property_name} = {self.visit(node.value)};"
-
     def visit_BinOp(self, node: BinOp):
         left = self.visit(node.left)
         right = self.visit(node.right)
         op = node.op
-        
         js_ops = {
-            'matches': None, # Special
+            'matches': None, 
             'and': '&&',
             'or': '||',
             '==': '==='
         }
-        
         if op == 'matches':
             return f"new RegExp({right}).test({left})"
-            
         real_op = js_ops.get(op, op)
         return f"({left} {real_op} {right})"
-
     def visit_UnaryOp(self, node: UnaryOp):
         return f"({node.op} {self.visit(node.right)})"
-
     def visit_Print(self, node: Print):
         return f"console.log({self.visit(node.expression)});"
-        
     def visit_Input(self, node: Input):
-        # JS doesn't have synchronous input easily in Node without libs.
         return f"require('readline-sync').question({repr(node.prompt) if node.prompt else '\"\"'})"
-
     def visit_If(self, node: If):
         code = f"if ({self.visit(node.condition)}) {{\n"
         self.indentation += 1
         code += self.compile_block(node.body)
         self.indentation -= 1
         code += f"\n{self.indent()}}}"
-        
         if node.else_body:
             code += f" else {{\n"
             self.indentation += 1
@@ -147,7 +105,6 @@ class JSCompiler:
             self.indentation -= 1
             code += f"\n{self.indent()}}}"
         return code
-
     def visit_While(self, node: While):
         code = f"while ({self.visit(node.condition)}) {{\n"
         self.indentation += 1
@@ -155,10 +112,7 @@ class JSCompiler:
         self.indentation -= 1
         code += f"\n{self.indent()}}}"
         return code
-
     def visit_For(self, node: For):
-        # range loop
-        # for (let i = 0; i < count; i++)
         count = self.visit(node.count)
         var = f"_i_{random.randint(0,1000)}"
         code = f"for (let {var} = 0; {var} < {count}; {var}++) {{\n"
@@ -167,7 +121,6 @@ class JSCompiler:
         self.indentation -= 1
         code += f"\n{self.indent()}}}"
         return code
-
     def visit_ForIn(self, node: ForIn):
         code = f"for (let {node.var_name} of {self.visit(node.iterable)}) {{\n"
         self.indentation += 1
@@ -175,35 +128,26 @@ class JSCompiler:
         self.indentation -= 1
         code += f"\n{self.indent()}}}"
         return code
-        
     def visit_Repeat(self, node: Repeat):
         return self.visit_For(For(node.count, node.body))
-
     def visit_FunctionDef(self, node: FunctionDef):
-        args = [arg[0] for arg in node.args] # Ignore defaults/types for now in basic JS
-        
+        args = [arg[0] for arg in node.args] 
         code = f"function {node.name}({', '.join(args)}) {{\n"
         self.indentation += 1
         code += self.compile_block(node.body)
         self.indentation -= 1
         code += f"\n{self.indent()}}}"
         return code
-
     def visit_Return(self, node: Return):
         return f"return {self.visit(node.value)};"
-
     def visit_Call(self, node: Call):
         args = [self.visit(a) for a in node.args]
         return f"{node.name}({', '.join(args)})"
-
     def visit_ClassDef(self, node: ClassDef):
         parent = node.parent if node.parent else ""
         extends = f" extends {parent}" if parent else ""
-        
         code = f"class {node.name}{extends} {{\n"
         self.indentation += 1
-        
-        # Constructor
         if node.properties:
             props = node.properties
             code += f"{self.indent()}constructor({', '.join(props)}) {{\n"
@@ -213,8 +157,6 @@ class JSCompiler:
                 code += f"{self.indent()}self.{p} = {p};\n"
             self.indentation -= 1
             code += f"{self.indent()}}}\n"
-            
-        # Methods
         for m in node.methods:
              args = [arg[0] for arg in m.args]
              code += f"\n{self.indent()}{m.name}({', '.join(args)}) {{\n"
@@ -222,33 +164,25 @@ class JSCompiler:
              code += self.compile_block(m.body)
              self.indentation -= 1
              code += f"\n{self.indent()}}}"
-             
         self.indentation -= 1
         code += f"\n{self.indent()}}}"
         return code
-
     def visit_Instantiation(self, node: Instantiation):
         args = [self.visit(a) for a in node.args]
         return f"var {node.var_name} = new {node.class_name}({', '.join(args)});"
-
     def visit_MethodCall(self, node: MethodCall):
         args = [self.visit(a) for a in node.args]
         return f"{node.instance_name}.{node.method_name}({', '.join(args)})"
-
     def visit_PropertyAccess(self, node: PropertyAccess):
         return f"{node.instance_name}.{node.property_name}"
-
     def visit_Import(self, node: Import):
-        # require
         base = node.path
         if base == 'vscode': return 'const vscode = require("vscode");'
         return f"const {base} = require('./{base}');"
-
     def visit_ImportAs(self, node: ImportAs):
         path = node.path
         if path == 'vscode': return f"const {node.alias} = require('vscode');"
         return f"const {node.alias} = require('./{path}');"
-
     def visit_Try(self, node: Try):
         code = f"try {{\n"
         self.indentation += 1
@@ -262,21 +196,11 @@ class JSCompiler:
         return code
     def visit_Throw(self, node: Throw):
         return f"throw new Error({self.visit(node.message)});"
-        
     def visit_Skip(self, node: Skip):
         return "continue;"
-        
     def visit_Stop(self, node: Stop):
         return "break;"
-        
     def visit_Lambda(self, node: Lambda):
         return f"({', '.join(node.params)}) => {self.visit(node.body)}"
-        
     def visit_Execute(self, node: Execute):
-         # on execute command "id"
-         # This is specific for VS Code extension logic usually?
-         # Or just generic event listener mechanism?
-         # "on request to" was OnRequest.
-         # This needs a new generic "on event" node or handled via Call?
-         # Assuming user writes standard shl: `vscode.commands.registerCommand(...)`
          pass

shell_lite/lexer.py

@@ -1,13 +1,13 @@
 import re
 from dataclasses import dataclass
 from typing import List, Optional
-
+@dataclass
 @dataclass
 class Token:
     type: str
     value: str
     line: int
-
+    column: int = 1
 class Lexer:
     def __init__(self, source_code: str):
         self.source_code = source_code
@@ -15,39 +15,35 @@ class Lexer:
         self.current_char_index = 0
         self.line_number = 1
         self.indent_stack = [0]
-
     def tokenize(self) -> List[Token]:
         source = self._remove_multiline_comments(self.source_code)
         lines = source.split('\n')
-        
         for line_num, line in enumerate(lines, 1):
             self.line_number = line_num
             stripped_line = line.strip()
-            
-            if not stripped_line or stripped_line.startswith('#'):
+            if not stripped_line:
                 continue
-
             indent_level = len(line) - len(line.lstrip())
+            if stripped_line.startswith('#'):
+                self.tokens.append(Token('COMMENT', stripped_line, self.line_number, indent_level + 1))
+                self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
+                continue
             if indent_level > self.indent_stack[-1]:
                 self.indent_stack.append(indent_level)
-                self.tokens.append(Token('INDENT', '', self.line_number))
+                self.tokens.append(Token('INDENT', '', self.line_number, indent_level + 1))
             elif indent_level < self.indent_stack[-1]:
                 while indent_level < self.indent_stack[-1]:
                     self.indent_stack.pop()
-                    self.tokens.append(Token('DEDENT', '', self.line_number))
+                    self.tokens.append(Token('DEDENT', '', self.line_number, indent_level + 1))
                 if indent_level != self.indent_stack[-1]:
                     raise IndentationError(f"Unindent does not match any outer indentation level on line {self.line_number}")
-
-            self.tokenize_line(stripped_line)
-            self.tokens.append(Token('NEWLINE', '', self.line_number))
-
+            self.tokenize_line(stripped_line, indent_level + 1)
+            self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
         while len(self.indent_stack) > 1:
             self.indent_stack.pop()
-            self.tokens.append(Token('DEDENT', '', self.line_number))
-            
-        self.tokens.append(Token('EOF', '', self.line_number))
+            self.tokens.append(Token('DEDENT', '', self.line_number, 1))
+        self.tokens.append(Token('EOF', '', self.line_number, 1))
         return self.tokens
-
     def _remove_multiline_comments(self, source: str) -> str:
         result = []
         i = 0
@@ -63,75 +59,41 @@ class Lexer:
                 result.append(source[i])
                 i += 1
         return ''.join(result)
-
-    def tokenize_line(self, line: str):
+    def tokenize_line(self, line: str, start_col: int = 1):
         pos = 0
         while pos < len(line):
             match = None
-            
-
+            current_col = start_col + pos
             if line[pos] == '#':
+                self.tokens.append(Token('COMMENT', line[pos:], self.line_number, current_col))
                 break
-            
             if line[pos].isspace():
                 pos += 1
                 continue
-
             if line[pos].isdigit():
                 match = re.match(r'^\d+(\.\d+)?', line[pos:])
                 if match:
                     value = match.group(0)
-                    self.tokens.append(Token('NUMBER', value, self.line_number))
+                    self.tokens.append(Token('NUMBER', value, self.line_number, current_col))
                     pos += len(value)
                     continue
-
-            # Check for Triple Quotes first
             if line[pos:pos+3] in ('"""', "'''"):
                  quote_char = line[pos:pos+3]
-                 # For multiline, we need to scan ahead across lines?
-                 # Lexer tokenizes line by line.
-                 # If we want multiline strings, we need to look ahead in lines or store state.
-                 # Current Lexer iterates lines.
-                 # We can switch to "in_multiline_string" state?
-                 # Or we can consume remaining lines here?
-                 # Since tokenize() loop iterates lines, we can't easily consume from 'lines' list inside tokenize_line.
-                 # But we can raise SyntaxError or support it limited to one line (useless).
-                 
-                 # Simpler logic: Lexer state machine.
-                 # But refactoring tokenize() loop is risky.
-                 
-                 # Alternative: "css" tag takes a BLOCK?
-                 # css:
-                 #    ... content ...
-                 # But css takes expression.
-                 
-                 # Let's support triple quotes ONLY if they end on same line? No.
-                 # Let's change website/main.shl to use single line strings concatenated?
-                 # Or use a separate file for CSS? serve static is already there.
-                 # I used get_styles() returning css string.
-                 
-                 # User asked for "CSS Bundling: A way to define styles directly".
-                 # I'll stick to single quotes for now to save time and reliability.
-                 # I'll update website/main.shl to use "string" + "string".
                  pass
-
             if line[pos] in ('"', "'"):
                 quote_char = line[pos]
                 end_quote = line.find(quote_char, pos + 1)
                 if end_quote == -1:
                     raise SyntaxError(f"Unterminated string on line {self.line_number}")
                 value = line[pos+1:end_quote]
-                # Simple escape handling
                 value = value.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r").replace("\\\"", "\"").replace("\\\'", "\'")
-                self.tokens.append(Token('STRING', value, self.line_number))
+                self.tokens.append(Token('STRING', value, self.line_number, current_col))
                 pos = end_quote + 1
                 continue
-
             if line[pos:pos+3] == '...':
-                self.tokens.append(Token('DOTDOTDOT', '...', self.line_number))
+                self.tokens.append(Token('DOTDOTDOT', '...', self.line_number, current_col))
                 pos += 3
                 continue
-
             two_char = line[pos:pos+2]
             two_char_tokens = {
                 '=>': 'ARROW', '==': 'EQ', '!=': 'NEQ',
@@ -140,65 +102,47 @@ class Lexer:
                 '%=': 'MODEQ'
             }
             if two_char in two_char_tokens:
-                self.tokens.append(Token(two_char_tokens[two_char], two_char, self.line_number))
+                self.tokens.append(Token(two_char_tokens[two_char], two_char, self.line_number, current_col))
                 pos += 2
                 continue
-            
             char = line[pos]
-
-            # Natural Language Comparisons: 'is at least', 'is exactly', 'is less than', 'is more than'
-            # We check this before single chars to catch 'is' phrases.
-            # Using simple Lookahead
             rest_of_line = line[pos:]
-            
             if rest_of_line.startswith('is at least '):
-                self.tokens.append(Token('GE', '>=', self.line_number))
-                pos += 12 # len('is at least ')
+                self.tokens.append(Token('GE', '>=', self.line_number, current_col))
+                pos += 12 
                 continue
             elif rest_of_line.startswith('is exactly '):
-                self.tokens.append(Token('EQ', '==', self.line_number))
+                self.tokens.append(Token('EQ', '==', self.line_number, current_col))
                 pos += 11
                 continue
             elif rest_of_line.startswith('is less than '):
-                self.tokens.append(Token('LT', '<', self.line_number))
+                self.tokens.append(Token('LT', '<', self.line_number, current_col))
                 pos += 13
                 continue
             elif rest_of_line.startswith('is more than '):
-                self.tokens.append(Token('GT', '>', self.line_number))
+                self.tokens.append(Token('GT', '>', self.line_number, current_col))
                 pos += 13
                 continue
-
-            # Filler Words: 'the'
-            # Check if next chars are 'the' plus a non-alphanum bound (e.g. space, newline, symbol)
             if rest_of_line.startswith('the') and (len(rest_of_line) == 3 or not rest_of_line[3].isalnum()):
-                 # Only skip if it's a standalone word 'the'
                  pos += 3
                  continue
-
             if char == '/':
-                # Check for Regex /regex/
-                # We assume regex if the PREVIOUS token is not something that implies division (Number, ID, RBracket, RParen)
                 last_type = self.tokens[-1].type if self.tokens else None
                 is_division = False
                 if last_type in ('NUMBER', 'STRING', 'ID', 'RPAREN', 'RBRACKET'):
                      is_division = True
-                
                 if not is_division:
-                    # Parse Regex
                     end_slash = line.find('/', pos + 1)
                     if end_slash != -1:
                         pattern = line[pos+1:end_slash]
-                        # Check for flags after slash
                         flags = ""
                         k = end_slash + 1
                         while k < len(line) and line[k].isalpha():
                             flags += line[k]
                             k += 1
-                        
-                        self.tokens.append(Token('REGEX', pattern, self.line_number))
+                        self.tokens.append(Token('REGEX', pattern, self.line_number, current_col))
                         pos = k
                         continue
-
             single_char_tokens = {
                 '+': 'PLUS', '-': 'MINUS', '*': 'MUL', '/': 'DIV',
                 '%': 'MOD', '=': 'ASSIGN', '>': 'GT', '<': 'LT',
@@ -207,10 +151,9 @@ class Lexer:
                 '{': 'LBRACE', '}': 'RBRACE', ',': 'COMMA', '.': 'DOT'
             }
             if char in single_char_tokens:
-                self.tokens.append(Token(single_char_tokens[char], char, self.line_number))
+                self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
                 pos += 1
                 continue
-
             if char.isalpha() or char == '_':
                 match = re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*', line[pos:])
                 if match:
@@ -264,50 +207,29 @@ class Lexer:
                         'red': 'RED', 'green': 'GREEN', 'blue': 'BLUE', 
                         'yellow': 'YELLOW', 'cyan': 'CYAN', 'magenta': 'MAGENTA',
                         'serve': 'SERVE', 'static': 'STATIC',
-                        
-                        # === NATURAL ENGLISH WEB DSL ===
-                        # Routing
-                        # File System Mastery (v0.03.3)
                         'write': 'WRITE', 'append': 'APPEND', 'read': 'READ', 'file': 'FILE',
-                        
-                        # File System Mastery (v0.03.3)
                         'write': 'WRITE', 'append': 'APPEND', 'read': 'READ', 'file': 'FILE',
                         'db': 'DB', 'database': 'DB',
                         'query': 'QUERY', 'open': 'OPEN', 'close': 'CLOSE', 'exec': 'EXEC',
                         'middleware': 'MIDDLEWARE', 'before': 'BEFORE',
-                         
-                        
                         'when': 'WHEN', 'someone': 'SOMEONE', 'visits': 'VISITS', 
                         'submits': 'SUBMITS', 'start': 'START', 'server': 'SERVER',
                         'files': 'FILES',
-                        
-                        # Page/Component creation
                         'define': 'DEFINE', 'page': 'PAGE', 'called': 'CALLED',
                         'using': 'USING', 'component': 'PAGE',
-                        
-                        # HTML aliases (natural names)
                         'heading': 'HEADING', 'paragraph': 'PARAGRAPH',
-                        # 'link' removed - conflicts with HTML <link> tag
                         'image': 'IMAGE',
-                        
-                        # List operations  
                         'add': 'ADD', 'put': 'ADD', 'into': 'INTO',
                         'count': 'COUNT', 'many': 'MANY', 'how': 'HOW',
-                        
-                        # Forms
                         'field': 'FIELD', 'submit': 'SUBMIT', 'named': 'NAMED',
                         'placeholder': 'PLACEHOLDER',
                     }
                     token_type = keywords.get(value, 'ID')
-                    self.tokens.append(Token(token_type, value, self.line_number))
+                    self.tokens.append(Token(token_type, value, self.line_number, current_col))
                     pos += len(value)
                     continue
-            
-
-            
             if char in single_char_tokens:
-                self.tokens.append(Token(single_char_tokens[char], char, self.line_number))
+                self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
                 pos += 1
                 continue
-
             raise SyntaxError(f"Illegal character '{char}' at line {self.line_number}")