shell-lite 0.5.3__tar.gz → 0.5.3.1__tar.gz

{shell_lite-0.5.3/shell_lite.egg-info → shell_lite-0.5.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shell-lite
-Version: 0.5.3
+Version: 0.5.3.1
 Summary: A lightweight, English-like scripting language.
 Home-page: https://github.com/Shrey-N/ShellDesk
 Author: Shrey Naithani

{shell_lite-0.5.3 → shell_lite-0.5.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "shell-lite"
-version = "0.5.3"
+version = "0.5.3.1"
 description = "A lightweight, English-like scripting language."
 readme = "README.md"
 requires-python = ">=3.8"

{shell_lite-0.5.3 → shell_lite-0.5.3.1}/shell_lite/interpreter.py

@@ -240,8 +240,10 @@ class Interpreter:
         for k, v in self.builtins.items():
             self.global_env.set(k, v)
     def _make_tag_fn(self, tag_name):
-        def tag_fn(*args):
+        def tag_fn(*args, **kwargs):
             attrs = {}
+            # Add kwargs directly as attributes
+            attrs.update(kwargs)
             content = []
             for arg in args:
                 if isinstance(arg, dict):
@@ -1502,7 +1504,7 @@ class Interpreter:
                             self.wfile.write(str(e).encode())
                     except: pass
         server = ReusableHTTPServer(('0.0.0.0', port_val), ShellLiteHandler)
-        print(f"\n  ShellLite Server v0.5.3 is running!")
+        print(f"\n  ShellLite Server v0.5.3.1 is running!")
         print(f"  \u001b[1;36m➜\u001b[0m  Local:   \u001b[1;4;36mhttp://localhost:{port_val}/\u001b[0m\n")
         try: server.serve_forever()
         except KeyboardInterrupt: 

{shell_lite-0.5.3 → shell_lite-0.5.3.1}/shell_lite/main.py

@@ -17,7 +17,6 @@ def execute_source(source: str, interpreter: Interpreter):
         lexer = Lexer(source)
         tokens = lexer.tokenize()
         if os.environ.get('USE_LEGACY_PARSER') == '1':
-            from .parser import Parser
             parser = Parser(tokens)
         else:
             from .parser_gbp import GeometricBindingParser

{shell_lite-0.5.3 → shell_lite-0.5.3.1}/shell_lite/parser_gbp.py

@@ -43,20 +43,24 @@ class GeometricBindingParser:
         node_stack: List[GeoNode] = [] # The active parents
         current_tokens_accumulator = []
         current_node: Optional[GeoNode] = None
+        last_line_node: Optional[GeoNode] = None  # Track the last completed line's node
         block_stack: List[GeoNode] = [] 
         for token in self.tokens:
             if token.type == 'EOF':
                 break
             if token.type == 'INDENT':
-                if current_node:
-                     block_stack.append(current_node)
-                     current_node = None # We are stepping "inside", so no current line active node yet
+                # Use last_line_node as parent if current_node is None (NEWLINE came before INDENT)
+                parent_to_push = current_node if current_node else last_line_node
+                if parent_to_push:
+                     block_stack.append(parent_to_push)
+                current_node = None
                 continue
             if token.type == 'DEDENT':
                  if block_stack:
                      block_stack.pop()
                  continue
             if token.type == 'NEWLINE':
+                last_line_node = current_node  # Save before resetting
                 current_node = None
                 continue
             if current_node is None:
@@ -83,7 +87,17 @@ class GeometricBindingParser:
             return self.bind_while(node)
         elif head_type == 'FOR' or head_type == 'LOOP':
             return self.bind_for(node)
-        elif head_type == 'FUNCTION' or head_type == 'TO' or (head_type == 'DEFINE' and self.peek_type(node, 1) == 'FUNCTION'):
+        elif head_type == 'USE':
+            return self.bind_use(node)
+        elif head_type == 'SERVE':
+            return self.bind_serve(node)
+        elif head_type == 'DEFINE':
+            return self.bind_define(node)
+        elif head_type == 'WHEN':
+            return self.bind_when(node)
+        elif head_type == 'ON':
+            return self.bind_on(node)
+        elif head_type == 'FUNCTION' or head_type == 'TO':
              return self.bind_func(node)
         elif head_type == 'PRINT' or head_type == 'SAY':
             return self.bind_print(node)
@@ -96,11 +110,13 @@ class GeometricBindingParser:
         elif head_type == 'LISTEN':
             return self.bind_listen(node)
         elif head_type == 'ID':
-            if any(t.type == 'ASSIGN' for t in node.tokens):
+            # Assignment: ID ASSIGN ... (second token must be ASSIGN)
+            # Function call with kwargs: ID ID ASSIGN ... (ASSIGN comes later)
+            if len(node.tokens) >= 2 and node.tokens[1].type == 'ASSIGN':
                 return self.bind_assignment(node)
-            return self.bind_expression_stmt(node)
+            return self.bind_call_or_expr(node)
         else:
-            return self.bind_expression_stmt(node)
+            return self.bind_call_or_expr(node)
     def peek_type(self, node: GeoNode, offset: int) -> str:
         if offset < len(node.tokens):
             return node.tokens[offset].type
@@ -159,12 +175,119 @@ class GeometricBindingParser:
         if node.tokens[0].type == 'DEFINE': start = 2
         name = node.tokens[start].value
         args = []
+        # Look for 'using' keyword (which is tokenized as ID)
+        collecting_args = False
         for t in node.tokens[start+1:]:
-             if t.type == 'ID':
-                 args.append((t.value, None, None))
-             elif t.type == 'COLON': break # End of signature
+            if t.type == 'USING':
+                collecting_args = True
+                continue
+            if t.type == 'ID' and collecting_args:
+                args.append((t.value, None, None))
+            elif t.type == 'COLON': break
+            elif t.type == 'COMMA': continue
+        body = [self.bind_node(child) for child in node.children]
+        return FunctionDef(name, args, body)
+    def bind_use(self, node: GeoNode) -> Import:
+        # 'use "filename.shl"'
+        for t in node.tokens:
+            if t.type == 'STRING':
+                return Import(t.value)
+        return Import(node.tokens[1].value if len(node.tokens) > 1 else '')
+    def bind_serve(self, node: GeoNode) -> ServeStatic:
+        # 'serve files from "public" at "/static"'
+        folder = String('public')
+        url = String('/static')
+        tokens = node.tokens
+        for i, t in enumerate(tokens):
+            if t.type == 'FROM' and i+1 < len(tokens):
+                folder = self.parse_expr_iterative([tokens[i+1]])
+            if t.type == 'AT' and i+1 < len(tokens):
+                url = self.parse_expr_iterative([tokens[i+1]])
+        return ServeStatic(folder, url)
+    def bind_define(self, node: GeoNode) -> FunctionDef:
+        # 'define page Name using arg1, arg2'
+        tokens = node.tokens
+        name = ''
+        args = []
+        i = 1
+        # Skip 'page' or 'component' if present
+        if i < len(tokens) and tokens[i].type == 'PAGE':
+            i += 1
+        if i < len(tokens) and tokens[i].type == 'ID':
+            name = tokens[i].value
+            i += 1
+        # Parse 'using' args
+        if i < len(tokens) and tokens[i].type == 'USING':
+            i += 1
+            while i < len(tokens):
+                if tokens[i].type == 'ID':
+                    args.append((tokens[i].value, None, None))
+                elif tokens[i].type == 'COMMA':
+                    pass
+                else:
+                    break
+                i += 1
         body = [self.bind_node(child) for child in node.children]
         return FunctionDef(name, args, body)
+    def bind_when(self, node: GeoNode) -> OnRequest:
+        # 'when someone visits "/path"'
+        tokens = node.tokens
+        path = String('/')
+        for i, t in enumerate(tokens):
+            if t.type == 'STRING':
+                path = String(t.value)
+                break
+        body = [self.bind_node(child) for child in node.children]
+        return OnRequest(path, body)
+    def bind_on(self, node: GeoNode) -> OnRequest:
+        # 'on request to "/path"'
+        tokens = node.tokens
+        path = String('/')
+        for t in tokens:
+            if t.type == 'STRING':
+                path = String(t.value)
+                break
+        body = [self.bind_node(child) for child in node.children]
+        return OnRequest(path, body)
+    def bind_call_or_expr(self, node: GeoNode) -> Any:
+        # Handle function calls like 'Head "title"' or 'Navbar'
+        tokens = node.tokens
+        if len(tokens) >= 1 and tokens[0].type == 'ID':
+            name = tokens[0].value
+            args = []
+            kwargs = []
+            # Parse remaining tokens as arguments, handling key=value for HTML attributes
+            i = 1
+            while i < len(tokens):
+                t = tokens[i]
+                # Check for key=value pattern (e.g. class="container", style="...", href="...")
+                # HTML attributes may be tokenized as various types: ID, STRUCTURE, HREF, REL, NAME, etc.
+                is_attr_key = t.type in ('ID', 'STRUCTURE', 'HREF', 'REL', 'NAME', 'STYLE', 'CONTENT', 'CHARSET', 'SRC', 'ALT', 'TYPE', 'VALUE', 'PLACEHOLDER', 'METHOD', 'ACTION')
+                is_kwarg = (is_attr_key and i + 2 < len(tokens) and tokens[i + 1].type == 'ASSIGN')
+                if is_kwarg:
+                    key = t.value
+                    val_token = tokens[i + 2]
+                    if val_token.type == 'STRING':
+                        kwargs.append((key, String(val_token.value)))
+                    elif val_token.type == 'NUMBER':
+                        kwargs.append((key, Number(int(val_token.value) if '.' not in val_token.value else float(val_token.value))))
+                    else:
+                        kwargs.append((key, VarAccess(val_token.value)))
+                    i += 3
+                    continue
+                elif t.type == 'STRING':
+                    args.append(String(t.value))
+                elif t.type == 'NUMBER':
+                    args.append(Number(int(t.value) if '.' not in t.value else float(t.value)))
+                elif t.type == 'ID':
+                    args.append(VarAccess(t.value))
+                i += 1
+            # Check for children (indented body)
+            body = None
+            if node.children:
+                body = [self.bind_node(child) for child in node.children]
+            return Call(name, args, kwargs=kwargs, body=body)
+        return self.parse_expr_iterative(tokens)
     def _extract_expr_tokens(self, tokens: List[Token], start: int = 0) -> List[Token]:
         end = len(tokens)
         if tokens[-1].type == 'COLON':

{shell_lite-0.5.3 → shell_lite-0.5.3.1/shell_lite.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shell-lite
-Version: 0.5.3
+Version: 0.5.3.1
 Summary: A lightweight, English-like scripting language.
 Home-page: https://github.com/Shrey-N/ShellDesk
 Author: Shrey Naithani