onelaraveljs 1.0.0 → 1.1.1

package/scripts/compiler/test_compiler.py

@@ -0,0 +1,69 @@
+"""
+Test cases cho Blade Compiler
+"""
+
+from main_compiler import BladeCompiler
+
+def test_basic_compilation():
+    """Test basic blade compilation"""
+    compiler = BladeCompiler()
+    
+    blade_code = """@vars($users = [], $title = 'Test')
+<h1>{{ $title }}</h1>
+<ul>
+    @foreach($users as $user)
+        <li>{{ $user->name }}</li>
+    @endforeach
+</ul>"""
+    
+    result = compiler.compile_blade_to_js(blade_code, 'test')
+    print("=== BASIC COMPILATION TEST ===")
+    print(result)
+    print()
+
+def test_extends_compilation():
+    """Test extends compilation"""
+    compiler = BladeCompiler()
+    
+    blade_code = """@extends('layouts.app')
+
+@section('title', 'Home Page')
+
+@section('content')
+    <h1>Welcome!</h1>
+    <p>{{ $message }}</p>
+@endsection"""
+    
+    result = compiler.compile_blade_to_js(blade_code, 'home')
+    print("=== EXTENDS COMPILATION TEST ===")
+    print(result)
+    print()
+
+def test_async_compilation():
+    """Test async directives compilation"""
+    compiler = BladeCompiler()
+    
+    blade_code = """@vars($users)
+@fetch('/api/users')
+@await($users)
+
+<div>
+    <h1>Users</h1>
+    @foreach($users as $user)
+        <div>{{ $user->name }}</div>
+    @endforeach
+</div>"""
+    
+    result = compiler.compile_blade_to_js(blade_code, 'users')
+    print("=== ASYNC COMPILATION TEST ===")
+    print(result)
+    print()
+
+def run_all_tests():
+    """Run all test cases"""
+    test_basic_compilation()
+    test_extends_compilation()
+    test_async_compilation()
+
+if __name__ == "__main__":
+    run_all_tests()

package/scripts/compiler/utils.py

@@ -0,0 +1,54 @@
+"""
+Các hàm tiện ích chung cho compiler
+"""
+
+import re
+import json
+
+def extract_balanced_parentheses(text, start_pos):
+    """Extract content inside balanced parentheses starting from start_pos"""
+    if start_pos >= len(text) or text[start_pos] != '(':
+        return None, start_pos
+    
+    paren_count = 0
+    content_start = start_pos + 1
+    i = start_pos
+    
+    while i < len(text):
+        if text[i] == '(':
+            paren_count += 1
+        elif text[i] == ')':
+            paren_count -= 1
+            if paren_count == 0:
+                content = text[content_start:i]
+                return content, i + 1
+        i += 1
+    
+    # Unbalanced parentheses
+    return text[content_start:], len(text)
+
+def format_attrs(attrs_dict):
+    """Format attributes dictionary to JavaScript object string"""
+    return json.dumps(attrs_dict, separators=(',', ':'))
+
+def normalize_quotes(expr):
+    """Normalize single quotes to double quotes in JSON"""
+    if not expr:
+        return expr
+    
+    # Replace single quotes with double quotes, but be careful with nested quotes
+    expr = re.sub(r"'([^']*)'", r'"\1"', expr)
+    return expr
+
+def format_js_output(content, indent_level=0):
+    """Format JavaScript output with proper indentation"""
+    lines = content.split('\n')
+    formatted_lines = []
+    
+    for line in lines:
+        if line.strip():
+            formatted_lines.append('    ' * indent_level + line.strip())
+        else:
+            formatted_lines.append('')
+    
+    return '\n'.join(formatted_lines)

package/scripts/compiler/variables_analyzer.py

@@ -0,0 +1,135 @@
+"""
+Phân tích việc sử dụng biến trong template
+"""
+
+import re
+from config import JS_FUNCTION_PREFIX
+
+def analyze_section_variables(section_content, vars_declaration):
+    """Analyze if a section uses variables from @vars directive"""
+    if not vars_declaration:
+        return False
+    
+    # Extract variable names from vars_declaration
+    vars_match = re.search(r'let\s*\{\s*([^}]+)\s*\}', vars_declaration)
+    if not vars_match:
+        return False
+    
+    vars_content = vars_match.group(1)
+    var_names = []
+    for var_part in vars_content.split(','):
+        var_name = var_part.split('=')[0].strip()
+        var_names.append(var_name)
+    
+    # Check if section content uses any of these variables
+    for var_name in var_names:
+        patterns = [
+            f'${{{var_name}}}',
+            f'${{{JS_FUNCTION_PREFIX}.escString({var_name})}}',
+            f'${{{JS_FUNCTION_PREFIX}.foreach({var_name}',
+            f', {var_name})',
+            f'({var_name})',
+            f', {var_name}',
+            f' {var_name}',
+        ]
+        
+        for pattern in patterns:
+            if pattern in section_content:
+                return True
+    
+    return False
+
+def analyze_render_uses_vars(sections_code, template_content, vars_declaration):
+    """Analyze if render function uses variables from @vars directive"""
+    if not vars_declaration:
+        return False
+    
+    # Extract variable names from vars_declaration
+    vars_match = re.search(r'let\s*\{\s*([^}]+)\s*\}', vars_declaration)
+    if not vars_match:
+        return False
+    
+    vars_content = vars_match.group(1)
+    var_names = []
+    for var_part in vars_content.split(','):
+        var_name = var_part.split('=')[0].strip()
+        var_names.append(var_name)
+    
+    # Combine all render content
+    render_content = sections_code + template_content
+    
+    # Check if any variable is used in render content
+    for var_name in var_names:
+        patterns = [
+            f'${{{var_name}}}',
+            f'${{{JS_FUNCTION_PREFIX}.escString({var_name})}}',
+            f'${{{JS_FUNCTION_PREFIX}.foreach({var_name}',
+            f', {var_name})',
+            f'({var_name})',
+            f', {var_name}',
+            f' {var_name}',
+        ]
+        
+        for pattern in patterns:
+            if pattern in render_content:
+                return True
+    
+    return False
+
+def analyze_sections_info(sections_code, vars_declaration, has_await=False, has_fetch=False):
+    """Analyze sections and return detailed information about each section"""
+    sections_info = {}
+    
+    if not sections_code:
+        return sections_info
+    
+    # Extract variable names from vars_declaration
+    var_names = []
+    if vars_declaration:
+        vars_match = re.search(r'let\s*\{\s*([^}]+)\s*\}', vars_declaration)
+        if vars_match:
+            vars_content = vars_match.group(1)
+            for var_part in vars_content.split(','):
+                var_name = var_part.split('=')[0].strip()
+                var_names.append(var_name)
+    
+    # Find all APP.View.section() calls in the sections_code
+    section_matches = re.findall(fr'{JS_FUNCTION_PREFIX}\.section\([^)]+\)', sections_code, re.DOTALL)
+    
+    for section_call in section_matches:
+        # Extract section name and content
+        if ',' in section_call:
+            name_match = re.search(fr"{JS_FUNCTION_PREFIX}\.section\(['\"]([^'\"]+)['\"]", section_call)
+            if name_match:
+                section_name = name_match.group(1)
+                
+                # Find the content part after the first comma
+                comma_pos = section_call.find(',')
+                section_content = section_call[comma_pos + 1:].strip()
+                section_content = section_content.rstrip(');').strip()
+                
+                # Check if this is a long section
+                is_long_section = False
+                if section_content.startswith('`') and section_content.endswith('`'):
+                    inner_content = section_content[1:-1]
+                    is_long_section = ('\n' in inner_content or 
+                                     '<' in inner_content or 
+                                     len(inner_content.strip()) > 50)
+                elif section_content.startswith('`') and not section_content.endswith('`'):
+                    is_long_section = True
+                
+                # Check if section uses variables
+                has_variables = analyze_section_variables(section_content, vars_declaration)
+                
+                # Determine section type and preload status
+                section_type = "long" if is_long_section else "short"
+                use_vars = has_variables
+                preloader = has_variables and (has_await or has_fetch)
+                
+                sections_info[section_name] = {
+                    "type": section_type,
+                    "preloader": preloader,
+                    "useVars": use_vars
+                }
+    
+    return sections_info

package/scripts/compiler/view_identifier_generator.py

@@ -0,0 +1,278 @@
+"""
+View Identifier Generator for Blade Compiler
+Generates view identification attributes for server-rendered content
+"""
+
+import re
+from utils import extract_balanced_parentheses
+
+class ViewIdentifierGenerator:
+    def __init__(self):
+        self.view_id_counter = 0
+        self.view_hierarchy = {}
+    
+    def generate_view_attributes(self, view_name, view_type='view', parent_view=None):
+        """Generate view identification attributes"""
+        view_id = self.generate_view_id(view_name)
+        
+        attributes = {
+            'data-spa-view': self.extract_view_scope(view_name),
+            'data-spa-view-name': view_name,
+            'data-spa-view-path': view_name,
+            'data-spa-view-id': view_id,
+            'data-spa-view-type': view_type
+        }
+        
+        if parent_view:
+            attributes['data-spa-view-parent'] = parent_view
+        
+        return attributes
+    
+    def generate_view_id(self, view_name):
+        """Generate unique view ID"""
+        self.view_id_counter += 1
+        # Convert view name to ID format
+        clean_name = re.sub(r'[^a-zA-Z0-9]', '-', view_name)
+        return f"{clean_name}-{self.view_id_counter}"
+    
+    def extract_view_scope(self, view_name):
+        """Extract view scope from view name"""
+        parts = view_name.split('.')
+        if len(parts) > 1:
+            return parts[-1]  # Last part as scope
+        return 'main'
+    
+    def process_template_with_identifiers(self, blade_code, view_name, view_type='view'):
+        """Process template and add view identification attributes"""
+        
+        # Generate attributes for main container
+        main_attributes = self.generate_view_attributes(view_name, view_type)
+        
+        # Add attributes to main container elements
+        blade_code = self.add_attributes_to_containers(blade_code, main_attributes)
+        
+        # Process sections with identifiers
+        blade_code = self.process_sections_with_identifiers(blade_code, view_name)
+        
+        # Process conditional blocks with identifiers
+        blade_code = self.process_conditionals_with_identifiers(blade_code, view_name)
+        
+        return blade_code
+    
+    def add_attributes_to_containers(self, blade_code, attributes):
+        """Add view identification attributes to container elements"""
+        
+        # Find main container elements (div, section, main, article, etc.)
+        container_patterns = [
+            r'<div([^>]*)>',
+            r'<section([^>]*)>',
+            r'<main([^>]*)>',
+            r'<article([^>]*)>',
+            r'<aside([^>]*)>',
+            r'<header([^>]*)>',
+            r'<footer([^>]*)>'
+        ]
+        
+        for pattern in container_patterns:
+            def add_attributes(match):
+                existing_attrs = match.group(1)
+                new_attrs = ' '.join([f'{k}="{v}"' for k, v in attributes.items()])
+                
+                if existing_attrs.strip():
+                    return f'<{match.group(0)[1:-1]} {new_attrs}>'
+                else:
+                    return f'<{match.group(0)[1:-1]} {new_attrs}>'
+            
+            blade_code = re.sub(pattern, add_attributes, blade_code)
+        
+        return blade_code
+    
+    def process_sections_with_identifiers(self, blade_code, view_name):
+        """Process @section directives with view identifiers"""
+        
+        # Find @section directives
+        section_pattern = r'@section\s*\(\s*[\'"]([^\'"]+)[\'"]\s*\)'
+        
+        def process_section(match):
+            section_name = match.group(1)
+            section_id = f"{view_name}.{section_name}"
+            section_attributes = self.generate_view_attributes(section_id, 'section', view_name)
+            
+            # Add attributes to the section content
+            attrs_str = ' '.join([f'{k}="{v}"' for k, v in section_attributes.items()])
+            
+            return f'@section(\'{section_name}\')\n<div {attrs_str}>'
+        
+        blade_code = re.sub(section_pattern, process_section, blade_code)
+        
+        # Find @endsection directives
+        endsection_pattern = r'@endsection'
+        blade_code = re.sub(endsection_pattern, '</div>\n@endsection', blade_code)
+        
+        return blade_code
+    
+    def process_conditionals_with_identifiers(self, blade_code, view_name):
+        """Process conditional blocks with view identifiers"""
+        
+        # Find @if directives
+        if_pattern = r'@if\s*\([^)]+\)'
+        
+        def process_if(match):
+            if_content = match.group(0)
+            if_id = f"{view_name}.if-{self.view_id_counter}"
+            if_attributes = self.generate_view_attributes(if_id, 'conditional', view_name)
+            
+            attrs_str = ' '.join([f'{k}="{v}"' for k, v in if_attributes.items()])
+            
+            return f'{if_content}\n<div {attrs_str}>'
+        
+        blade_code = re.sub(if_pattern, process_if, blade_code)
+        
+        # Find @endif directives
+        endif_pattern = r'@endif'
+        blade_code = re.sub(endif_pattern, '</div>\n@endif', blade_code)
+        
+        return blade_code
+    
+    def generate_server_side_attributes(self, view_name, view_type='view'):
+        """Generate attributes for server-side rendering"""
+        
+        attributes = self.generate_view_attributes(view_name, view_type)
+        
+        # Add server-side specific attributes
+        attributes.update({
+            'data-server-rendered': 'true',
+            'data-hydration-ready': 'false'
+        })
+        
+        return attributes
+    
+    def generate_meta_tags(self, view_name, view_type='view'):
+        """Generate meta tags for view identification"""
+        
+        view_id = self.generate_view_id(view_name)
+        
+        meta_tags = f"""
+    <!-- View Identification Meta Tags -->
+    <meta name="spa-view-name" content="{view_name}">
+    <meta name="spa-view-path" content="{view_name}">
+    <meta name="spa-view-id" content="{view_id}">
+    <meta name="spa-view-type" content="{view_type}">
+"""
+        
+        return meta_tags
+    
+    def process_yield_directives(self, blade_code, view_name):
+        """Process @yield directives with view identifiers"""
+        
+        # Find @yield directives
+        yield_pattern = r'@yield\s*\(\s*[\'"]([^\'"]+)[\'"]\s*\)'
+        
+        def process_yield(match):
+            yield_name = match.group(1)
+            yield_id = f"{view_name}.yield-{yield_name}"
+            yield_attributes = self.generate_view_attributes(yield_id, 'yield', view_name)
+            
+            attrs_str = ' '.join([f'{k}="{v}"' for k, v in yield_attributes.items()])
+            
+            return f'<div {attrs_str}>@yield(\'{yield_name}\')</div>'
+        
+        blade_code = re.sub(yield_pattern, process_yield, blade_code)
+        
+        return blade_code
+    
+    def generate_view_boundary_comments(self, view_name, view_type='view'):
+        """Generate HTML comments for view boundaries"""
+        
+        view_id = self.generate_view_id(view_name)
+        
+        start_comment = f"<!-- SPA VIEW START: {view_name} (ID: {view_id}, Type: {view_type}) -->"
+        end_comment = f"<!-- SPA VIEW END: {view_name} -->"
+        
+        return start_comment, end_comment
+    
+    def process_loop_directives(self, blade_code, view_name):
+        """Process loop directives with view identifiers"""
+        
+        # Find @foreach directives
+        foreach_pattern = r'@foreach\s*\([^)]+\)'
+        
+        def process_foreach(match):
+            foreach_content = match.group(0)
+            loop_id = f"{view_name}.loop-{self.view_id_counter}"
+            loop_attributes = self.generate_view_attributes(loop_id, 'loop', view_name)
+            
+            attrs_str = ' '.join([f'{k}="{v}"' for k, v in loop_attributes.items()])
+            
+            return f'{foreach_content}\n<div {attrs_str}>'
+        
+        blade_code = re.sub(foreach_pattern, process_foreach, blade_code)
+        
+        # Find @endforeach directives
+        endforeach_pattern = r'@endforeach'
+        blade_code = re.sub(endforeach_pattern, '</div>\n@endforeach', blade_code)
+        
+        return blade_code
+    
+    def generate_debug_attributes(self, view_name, debug_mode=False):
+        """Generate debug attributes for development"""
+        
+        if not debug_mode:
+            return {}
+        
+        return {
+            'data-debug-view': view_name,
+            'data-debug-timestamp': str(int(__import__('time').time())),
+            'data-debug-version': '1.0.0'
+        }
+    
+    def process_complete_template(self, blade_code, view_name, view_type='view', debug_mode=False):
+        """Process complete template with all view identifiers"""
+        
+        # Add meta tags
+        meta_tags = self.generate_meta_tags(view_name, view_type)
+        blade_code = self.insert_meta_tags(blade_code, meta_tags)
+        
+        # Process template with identifiers
+        blade_code = self.process_template_with_identifiers(blade_code, view_name, view_type)
+        
+        # Process yield directives
+        blade_code = self.process_yield_directives(blade_code, view_name)
+        
+        # Process loop directives
+        blade_code = self.process_loop_directives(blade_code, view_name)
+        
+        # Add debug attributes if enabled
+        if debug_mode:
+            debug_attrs = self.generate_debug_attributes(view_name, debug_mode)
+            blade_code = self.add_debug_attributes(blade_code, debug_attrs)
+        
+        return blade_code
+    
+    def insert_meta_tags(self, blade_code, meta_tags):
+        """Insert meta tags into head section"""
+        
+        # Find head tag
+        head_pattern = r'(<head[^>]*>)'
+        
+        def insert_meta(match):
+            return f"{match.group(1)}\n{meta_tags}"
+        
+        blade_code = re.sub(head_pattern, insert_meta, blade_code, flags=re.IGNORECASE)
+        
+        return blade_code
+    
+    def add_debug_attributes(self, blade_code, debug_attrs):
+        """Add debug attributes to elements"""
+        
+        # Add debug attributes to main containers
+        container_pattern = r'<div([^>]*data-spa-view[^>]*)>'
+        
+        def add_debug(match):
+            existing_attrs = match.group(1)
+            debug_str = ' '.join([f'{k}="{v}"' for k, v in debug_attrs.items()])
+            return f'<div {existing_attrs} {debug_str}>'
+        
+        blade_code = re.sub(container_pattern, add_debug, blade_code)
+        
+        return blade_code

package/scripts/compiler/wrapper_parser.py

@@ -0,0 +1,78 @@
+"""
+Parser để đọc file wraper.js và extract nội dung
+"""
+
+import re
+import os
+
+class WrapperParser:
+    def __init__(self):
+        self.wrapper_function_content = ""
+        self.wrapper_config_content = ""
+    
+    def parse_wrapper_file(self, file_path="resources/js/templates/wraper.js"):
+        """Parse file wraper.js và extract nội dung theo comment đánh dấu"""
+        # Reset state trước khi parse
+        self.wrapper_function_content = ""
+        self.wrapper_config_content = ""
+
+        # Convert to absolute path if relative
+        if not os.path.isabs(file_path):
+            # Try path relative to current working directory
+            if not os.path.exists(file_path):
+                # Try path relative to script directory
+                script_dir = os.path.dirname(os.path.abspath(__file__))
+                alt_path = os.path.join(script_dir, "..", "..", file_path)
+                if os.path.exists(alt_path):
+                    file_path = alt_path
+
+        if not os.path.exists(file_path):
+            print(f"Warning: Wrapper file not found: {file_path}")
+            return "", ""
+
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+        except Exception as e:
+            print(f"Error reading wrapper file: {e}")
+            return "", ""
+
+        # Extract function wraper content - từ "// start wrapper" đến "// end wrapper"
+        start_marker = "// start wrapper"
+        end_marker = "// end wrapper"
+        
+        start_pos = content.find(start_marker)
+        if start_pos != -1:
+            start_pos = content.find('\n', start_pos) + 1  # Bỏ qua dòng comment
+            end_pos = content.find(end_marker)
+            if end_pos != -1:
+                self.wrapper_function_content = content[start_pos:end_pos].strip()
+            else:
+                print("Warning: End wrapper marker not found")
+        else:
+            print("Warning: Start wrapper marker not found")
+
+        # Extract WRAPPER_CONFIG content - từ "// start wrapper config" đến "// end wrapper config"
+        start_config_marker = "// start wrapper config"
+        end_config_marker = "// end wrapper config"
+        
+        start_config_pos = content.find(start_config_marker)
+        if start_config_pos != -1:
+            start_config_pos = content.find('\n', start_config_pos) + 1  # Bỏ qua dòng comment
+            end_config_pos = content.find(end_config_marker)
+            if end_config_pos != -1:
+                self.wrapper_config_content = content[start_config_pos:end_config_pos].strip()
+            else:
+                print("Warning: End wrapper config marker not found")
+        else:
+            print("Warning: Start wrapper config marker not found")
+
+        return self.wrapper_function_content, self.wrapper_config_content
+    
+    def get_wrapper_function_content(self):
+        """Lấy nội dung function wraper"""
+        return self.wrapper_function_content
+    
+    def get_wrapper_config_content(self):
+        """Lấy nội dung WRAPPER_CONFIG"""
+        return self.wrapper_config_content