mini.py

#!/usr/bin/env python3
import os
import re
import json
import argparse
from pathlib import Path

class MudletBuilder:
    def __init__(self, project_root, output_file):
        self.project_root = Path(project_root)
        self.output_file = Path(output_file)
        self.scripts_config = None

    def load_scripts_config(self):
        """Load the scripts.json configuration file."""
        config_path = self.project_root / 'scripts.json'
        if not config_path.exists():
            raise FileNotFoundError(f"scripts.json not found in {self.project_root}")

        with open(config_path, 'r', encoding='utf-8') as f:
            self.scripts_config = json.load(f)

    def minify(self, content):
        """Basic Lua minification."""
        # Remove comments (but keep shebangs)
        lines = content.split('\n')
        processed_lines = []
        in_multiline_comment = False

        for line in lines:
            # Handle multiline comments
            if in_multiline_comment:
                if ']]' in line:
                    line = line[line.find(']]') + 2:]
                    in_multiline_comment = False
                else:
                    continue

            if '--[[' in line:
                if ']]' in line:
                    # Single-line multi-line comment
                    line = line[:line.find('--[[')] + line[line.find(']]') + 2:]
                else:
                    line = line[:line.find('--[[')]
                    in_multiline_comment = True

            # Handle single-line comments
            if not in_multiline_comment and '--' in line:
                line = line[:line.find('--')]

            if line.strip():
                processed_lines.append(line)

        content = '\n'.join(processed_lines)

        # Remove unnecessary whitespace
        content = re.sub(r'\s+', ' ', content)
        content = re.sub(r';\s+', ';', content)
        content = re.sub(r'\s*([=+\-*/<>()])\s*', r'\1', content)

        # Preserve some readability with newlines between statements
        content = re.sub(r'([\n;])\s*', r'\1\n', content)

        return content.strip()

    def process_scripts(self):
        """Process all scripts in the order specified by scripts.json."""
        if not self.scripts_config:
            self.load_scripts_config()

        processed_content = []
        total_size = 0

        # Add a header comment
        header = f"-- Generated by MudletBuilder\n"
        processed_content.append(header)

        # Process each script entry
        for script_entry in self.scripts_config:
            # Skip if not active
            if script_entry.get("isActive", "").lower() != "yes":
                print(f"Skipping inactive script: {script_entry['name']}")
                continue

            # Skip folders
            if script_entry.get("isFolder", "").lower() == "yes":
                print(f"Skipping folder: {script_entry['name']}")
                continue

            script_name = f"{script_entry['name']}.lua"
            script_path = self.project_root / script_name

            if not script_path.exists():
                print(f"Warning: Script not found: {script_path}")
                continue

            print(f"Processing: {script_name}")

            with open(script_path, 'r', encoding='utf-8') as f:
                content = f.read()
                total_size += len(content)

            # Add a comment to mark the start of each file
            processed_content.append(f"\n-- File: {script_name}")
            processed_content.append(content)

        return '\n'.join(processed_content), total_size

    def build(self, minify=True):
        """Build the final output."""
        print(f"Building Mudlet project from {self.project_root}")

        # Process all scripts
        content, original_size = self.process_scripts()

        # Minify if requested
        if minify:
            minified_content = self.minify(content)
        else:
            minified_content = content

        # Create output directory if it doesn't exist
        self.output_file.parent.mkdir(parents=True, exist_ok=True)

        # Write the output
        with open(self.output_file, 'w', encoding='utf-8') as f:
            f.write(minified_content)

        # Print build statistics
        print(f"\nBuild completed: {self.output_file}")
        print(f"Original size: {original_size:,} bytes")
        print(f"Final size: {len(minified_content):,} bytes")
        if minify:
            print(f"Reduction: {(1 - len(minified_content)/original_size)*100:.1f}%")

def main():
    parser = argparse.ArgumentParser(description='Build and minify Mudlet project')
    parser.add_argument('project_root', help='Root directory of the Mudlet project')
    parser.add_argument('output_file', help='Output file path')
    parser.add_argument('--no-minify', action='store_true', help='Skip minification')

    args = parser.parse_args()

    builder = MudletBuilder(
        project_root=args.project_root,
        output_file=args.output_file
    )

    builder.build(minify=not args.no_minify)

if __name__ == '__main__':
    main()