zexus 1.6.2

package/src/zexus/stdlib/regex.py

@@ -0,0 +1,148 @@
+"""Regex module for Zexus standard library."""
+
+import re
+from typing import List, Dict, Any, Optional
+
+
+class RegexModule:
+    """Provides regular expression operations."""
+
+    @staticmethod
+    def match(pattern: str, text: str, flags: int = 0) -> Optional[Dict[str, Any]]:
+        """Match pattern at start of text."""
+        m = re.match(pattern, text, flags)
+        if m:
+            return {
+                'matched': True,
+                'groups': list(m.groups()),
+                'group_dict': m.groupdict(),
+                'span': m.span(),
+                'start': m.start(),
+                'end': m.end()
+            }
+        return None
+
+    @staticmethod
+    def search(pattern: str, text: str, flags: int = 0) -> Optional[Dict[str, Any]]:
+        """Search for pattern in text."""
+        m = re.search(pattern, text, flags)
+        if m:
+            return {
+                'matched': True,
+                'groups': list(m.groups()),
+                'group_dict': m.groupdict(),
+                'span': m.span(),
+                'start': m.start(),
+                'end': m.end()
+            }
+        return None
+
+    @staticmethod
+    def findall(pattern: str, text: str, flags: int = 0) -> List[str]:
+        """Find all occurrences of pattern."""
+        return re.findall(pattern, text, flags)
+
+    @staticmethod
+    def finditer(pattern: str, text: str, flags: int = 0) -> List[Dict[str, Any]]:
+        """Find all matches as iterator."""
+        matches = []
+        for m in re.finditer(pattern, text, flags):
+            matches.append({
+                'matched': True,
+                'groups': list(m.groups()),
+                'group_dict': m.groupdict(),
+                'span': m.span(),
+                'start': m.start(),
+                'end': m.end()
+            })
+        return matches
+
+    @staticmethod
+    def sub(pattern: str, replacement: str, text: str, count: int = 0, flags: int = 0) -> str:
+        """Replace pattern with replacement."""
+        return re.sub(pattern, replacement, text, count, flags)
+
+    @staticmethod
+    def subn(pattern: str, replacement: str, text: str, count: int = 0, flags: int = 0) -> tuple:
+        """Replace pattern and return (new_string, number_of_subs)."""
+        return re.subn(pattern, replacement, text, count, flags)
+
+    @staticmethod
+    def split(pattern: str, text: str, maxsplit: int = 0, flags: int = 0) -> List[str]:
+        """Split text by pattern."""
+        return re.split(pattern, text, maxsplit, flags)
+
+    @staticmethod
+    def escape(pattern: str) -> str:
+        """Escape special characters in pattern."""
+        return re.escape(pattern)
+
+    @staticmethod
+    def compile(pattern: str, flags: int = 0) -> str:
+        """Compile regex pattern (returns pattern string for Zexus)."""
+        # In Zexus, we can't return compiled pattern objects
+        # Just validate and return the pattern
+        re.compile(pattern, flags)  # Validate
+        return pattern
+
+    @staticmethod
+    def is_match(pattern: str, text: str, flags: int = 0) -> bool:
+        """Check if pattern matches text."""
+        return re.match(pattern, text, flags) is not None
+
+    @staticmethod
+    def is_search(pattern: str, text: str, flags: int = 0) -> bool:
+        """Check if pattern exists in text."""
+        return re.search(pattern, text, flags) is not None
+
+    @staticmethod
+    def count_matches(pattern: str, text: str, flags: int = 0) -> int:
+        """Count number of matches."""
+        return len(re.findall(pattern, text, flags))
+
+    @staticmethod
+    def extract_groups(pattern: str, text: str, flags: int = 0) -> List[str]:
+        """Extract all groups from first match."""
+        m = re.search(pattern, text, flags)
+        if m:
+            return list(m.groups())
+        return []
+
+    @staticmethod
+    def extract_all_groups(pattern: str, text: str, flags: int = 0) -> List[List[str]]:
+        """Extract groups from all matches."""
+        matches = []
+        for m in re.finditer(pattern, text, flags):
+            matches.append(list(m.groups()))
+        return matches
+
+    # Flag constants
+    IGNORECASE = re.IGNORECASE
+    MULTILINE = re.MULTILINE
+    DOTALL = re.DOTALL
+    VERBOSE = re.VERBOSE
+    ASCII = re.ASCII
+    UNICODE = re.UNICODE
+
+
+# Export functions for easy access
+match = RegexModule.match
+search = RegexModule.search
+findall = RegexModule.findall
+finditer = RegexModule.finditer
+sub = RegexModule.sub
+subn = RegexModule.subn
+split = RegexModule.split
+escape = RegexModule.escape
+compile = RegexModule.compile
+is_match = RegexModule.is_match
+is_search = RegexModule.is_search
+count_matches = RegexModule.count_matches
+extract_groups = RegexModule.extract_groups
+extract_all_groups = RegexModule.extract_all_groups
+IGNORECASE = RegexModule.IGNORECASE
+MULTILINE = RegexModule.MULTILINE
+DOTALL = RegexModule.DOTALL
+VERBOSE = RegexModule.VERBOSE
+ASCII = RegexModule.ASCII
+UNICODE = RegexModule.UNICODE

package/src/zexus/stdlib/sockets.py

@@ -0,0 +1,253 @@
+"""Socket/TCP primitives module for Zexus standard library."""
+
+import socket
+import threading
+import time
+from typing import Callable, Optional, Dict, Any
+
+
+class SocketModule:
+    """Provides socket and TCP operations."""
+    
+    @staticmethod
+    def create_server(host: str, port: int, handler: Callable, backlog: int = 5) -> 'TCPServer':
+        """Create a TCP server that listens for connections.
+        
+        Args:
+            host: Host address to bind to (e.g., '0.0.0.0', 'localhost')
+            port: Port number to listen on
+            handler: Callback function called for each connection
+            backlog: Maximum number of queued connections
+            
+        Returns:
+            TCPServer instance
+        """
+        return TCPServer(host, port, handler, backlog)
+    
+    @staticmethod
+    def create_connection(host: str, port: int, timeout: float = 5.0) -> 'TCPConnection':
+        """Create a TCP client connection.
+        
+        Args:
+            host: Remote host to connect to
+            port: Remote port to connect to
+            timeout: Connection timeout in seconds
+            
+        Returns:
+            TCPConnection instance
+        """
+        return TCPConnection(host, port, timeout)
+
+
+class TCPServer:
+    """TCP server that accepts connections and handles them with a callback."""
+    
+    def __init__(self, host: str, port: int, handler: Callable, backlog: int = 5):
+        self.host = host
+        self.port = port
+        self.handler = handler
+        self.backlog = backlog
+        self.socket: Optional[socket.socket] = None
+        self.running = False
+        self.thread: Optional[threading.Thread] = None
+    
+    def start(self) -> None:
+        """Start the server in a background thread."""
+        if self.running:
+            raise RuntimeError("Server is already running")
+        
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.socket.bind((self.host, self.port))
+        self.socket.listen(self.backlog)
+        self.running = True
+        
+        # Start accept loop in background thread
+        self.thread = threading.Thread(target=self._accept_loop, daemon=True)
+        self.thread.start()
+    
+    def _accept_loop(self):
+        """Accept connections and spawn handler threads."""
+        while self.running:
+            try:
+                self.socket.settimeout(1.0)  # Allow checking self.running
+                client_socket, address = self.socket.accept()
+                
+                # Spawn handler in new thread
+                handler_thread = threading.Thread(
+                    target=self._handle_connection,
+                    args=(client_socket, address),
+                    daemon=True
+                )
+                handler_thread.start()
+                
+            except socket.timeout:
+                continue
+            except Exception as e:
+                if self.running:  # Only log if we're not shutting down
+                    print(f"Server accept error: {e}")
+                break
+    
+    def _handle_connection(self, client_socket: socket.socket, address: tuple):
+        """Handle a single client connection."""
+        try:
+            connection = TCPConnection.from_socket(client_socket, address)
+            self.handler(connection)
+        except Exception as e:
+            print(f"Connection handler error: {e}")
+        finally:
+            try:
+                client_socket.close()
+            except:
+                pass
+    
+    def stop(self) -> None:
+        """Stop the server."""
+        self.running = False
+        if self.socket:
+            try:
+                self.socket.close()
+            except:
+                pass
+        if self.thread:
+            self.thread.join(timeout=2.0)
+    
+    def is_running(self) -> bool:
+        """Check if server is running."""
+        return self.running
+    
+    def get_address(self) -> Dict[str, Any]:
+        """Get server address info."""
+        return {
+            'host': self.host,
+            'port': self.port,
+            'running': self.running
+        }
+
+
+class TCPConnection:
+    """Represents a TCP connection (client or server-side)."""
+    
+    def __init__(self, host: str, port: int, timeout: float = 5.0):
+        """Create a new client connection."""
+        self.host = host
+        self.port = port
+        self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.socket.settimeout(timeout)
+        self.socket.connect((host, port))
+        self.connected = True
+    
+    @classmethod
+    def from_socket(cls, sock: socket.socket, address: tuple):
+        """Create TCPConnection from existing socket (for server-side)."""
+        conn = cls.__new__(cls)
+        conn.socket = sock
+        conn.host = address[0]
+        conn.port = address[1]
+        conn.connected = True
+        return conn
+    
+    def send(self, data: bytes) -> int:
+        """Send data over the connection.
+        
+        Args:
+            data: Bytes to send
+            
+        Returns:
+            Number of bytes sent
+        """
+        if not self.connected:
+            raise RuntimeError("Connection is closed")
+        return self.socket.sendall(data) or len(data)
+    
+    def send_string(self, text: str, encoding: str = 'utf-8') -> int:
+        """Send string over the connection.
+        
+        Args:
+            text: String to send
+            encoding: Text encoding
+            
+        Returns:
+            Number of bytes sent
+        """
+        return self.send(text.encode(encoding))
+    
+    def receive(self, buffer_size: int = 4096) -> bytes:
+        """Receive data from the connection.
+        
+        Args:
+            buffer_size: Maximum bytes to receive
+            
+        Returns:
+            Received bytes (empty if connection closed)
+        """
+        if not self.connected:
+            raise RuntimeError("Connection is closed")
+        
+        try:
+            data = self.socket.recv(buffer_size)
+            if not data:
+                self.connected = False
+            return data
+        except socket.timeout:
+            return b''
+    
+    def receive_string(self, buffer_size: int = 4096, encoding: str = 'utf-8') -> str:
+        """Receive string from the connection.
+        
+        Args:
+            buffer_size: Maximum bytes to receive
+            encoding: Text encoding
+            
+        Returns:
+            Received string
+        """
+        data = self.receive(buffer_size)
+        return data.decode(encoding) if data else ''
+    
+    def receive_all(self, timeout: float = 5.0) -> bytes:
+        """Receive all available data until connection closes or timeout.
+        
+        Args:
+            timeout: Maximum time to wait
+            
+        Returns:
+            All received bytes
+        """
+        chunks = []
+        start_time = time.time()
+        self.socket.settimeout(0.1)  # Small timeout for checking
+        
+        while time.time() - start_time < timeout:
+            try:
+                chunk = self.socket.recv(4096)
+                if not chunk:
+                    break
+                chunks.append(chunk)
+            except socket.timeout:
+                if chunks:  # If we got some data, we're done
+                    break
+                continue
+        
+        return b''.join(chunks)
+    
+    def close(self) -> None:
+        """Close the connection."""
+        if self.connected:
+            try:
+                self.socket.close()
+            except:
+                pass
+            self.connected = False
+    
+    def is_connected(self) -> bool:
+        """Check if connection is still open."""
+        return self.connected
+    
+    def get_address(self) -> Dict[str, Any]:
+        """Get connection address info."""
+        return {
+            'host': self.host,
+            'port': self.port,
+            'connected': self.connected
+        }

package/src/zexus/stdlib/test_framework.zx

@@ -0,0 +1,208 @@
+#!/usr/bin/env zexus
+# Zexus Testing Framework
+# Provides assertion functions and test utilities
+
+# Global test state - using individual variables instead of map
+let _total = 0
+let _passed = 0
+let _failed = 0
+let _current_suite = ""
+let _failures = []
+
+# Reset test statistics
+action reset_test_stats() {
+    _total = 0
+    _passed = 0
+    _failed = 0
+    _current_suite = ""
+    _failures = []
+}
+
+# Start a test suite
+action describe(suite_name) {
+    _current_suite = suite_name
+    print("\n" + suite_name)
+    print("=" + string_repeat("=", len(suite_name)))
+}
+
+# Helper to repeat string
+action string_repeat(str, count) {
+    let result = ""
+    let i = 0
+    while i < count {
+        result = result + str
+        i = i + 1
+    }
+    return result
+}
+
+# Individual test case
+action it(description, test_func) {
+    _total = _total + 1
+    
+    try {
+        test_func()
+        _passed = _passed + 1
+        print("  ✓ " + description)
+        return true
+    } catch (e) {
+        _failed = _failed + 1
+        let failure = {
+            "suite": _current_suite,
+            "test": description,
+            "error": string(e)
+        }
+        _failures = push(_failures, failure)
+        print("  ✗ " + description)
+        print("    Error: " + string(e))
+        return false
+    }
+}
+
+# Assertion: equality
+action assert_eq(actual, expected, message) {
+    if actual != expected {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected: " + string(expected)
+        error_msg = error_msg + "\n    Got: " + string(actual)
+        throw error_msg
+    }
+}
+
+# Assertion: not equal
+action assert_ne(actual, expected, message) {
+    if actual == expected {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected NOT to equal: " + string(expected)
+        error_msg = error_msg + "\n    But got: " + string(actual)
+        throw error_msg
+    }
+}
+
+# Assertion: true
+action assert_true(value, message) {
+    if !value {
+        throw "Assertion failed: " + message + " (expected true, got false)"
+    }
+}
+
+# Assertion: false
+action assert_false(value, message) {
+    if value {
+        throw "Assertion failed: " + message + " (expected false, got true)"
+    }
+}
+
+# Assertion: null
+action assert_null(value, message) {
+    if value != null {
+        throw "Assertion failed: " + message + " (expected null, got " + string(value) + ")"
+    }
+}
+
+# Assertion: not null
+action assert_not_null(value, message) {
+    if value == null {
+        throw "Assertion failed: " + message + " (expected non-null value)"
+    }
+}
+
+# Assertion: type check
+action assert_type(value, expected_type, message) {
+    let actual_type = type(value)
+    if actual_type != expected_type {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected type: " + expected_type
+        error_msg = error_msg + "\n    Got type: " + actual_type
+        throw error_msg
+    }
+}
+
+# Assertion: throws error
+action assert_throws(func, expected_error, message) {
+    let did_throw = false
+    let error_msg = ""
+    
+    try {
+        func()
+    } catch (e) {
+        did_throw = true
+        error_msg = string(e)
+    }
+    
+    if !did_throw {
+        throw "Assertion failed: " + message + " (expected function to throw)"
+    }
+}
+
+# Assertion: greater than
+action assert_gt(actual, expected, message) {
+    if actual <= expected {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected > " + string(expected)
+        error_msg = error_msg + "\n    Got: " + string(actual)
+        throw error_msg
+    }
+}
+
+# Assertion: greater than or equal
+action assert_gte(actual, expected, message) {
+    if actual < expected {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected >= " + string(expected)
+        error_msg = error_msg + "\n    Got: " + string(actual)
+        throw error_msg
+    }
+}
+
+# Assertion: less than
+action assert_lt(actual, expected, message) {
+    if actual >= expected {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected < " + string(expected)
+        error_msg = error_msg + "\n    Got: " + string(actual)
+        throw error_msg
+    }
+}
+
+# Assertion: less than or equal
+action assert_lte(actual, expected, message) {
+    if actual > expected {
+        let error_msg = "Assertion failed: " + message
+        error_msg = error_msg + "\n    Expected <= " + string(expected)
+        error_msg = error_msg + "\n    Got: " + string(actual)
+        throw error_msg
+    }
+}
+
+# Print test summary
+action print_test_summary() {
+    print("\n" + string_repeat("=", 50))
+    print("TEST SUMMARY")
+    print(string_repeat("=", 50))
+    print("Total tests: " + string(_total))
+    print("Passed: " + string(_passed) + " ✓")
+    print("Failed: " + string(_failed) + " ✗")
+    
+    if _failed > 0 {
+        print("\nFailed Tests:")
+        let i = 0
+        while i < len(_failures) {
+            let failure = _failures[i]
+            print("  " + string(i + 1) + ". " + failure["suite"] + " > " + failure["test"])
+            print("     " + failure["error"])
+            i = i + 1
+        }
+    }
+    
+    print(string_repeat("=", 50))
+    
+    if _failed == 0 {
+        print("🎉 ALL TESTS PASSED!")
+        return 0
+    } else {
+        print("❌ SOME TESTS FAILED")
+        return 1
+    }
+}
+