minecraft-datapack-language 15.4.1__py3-none-any.whl → 15.4.2__py3-none-any.whl

minecraft_datapack_language/mdl_errors.py

@@ -6,6 +6,16 @@ from dataclasses import dataclass
 from typing import Optional, List, Any
 import os
 
+# Import color utilities
+try:
+    from .cli_colors import color
+except ImportError:
+    # Fallback if colors aren't available
+    class DummyColor:
+        def __getattr__(self, name):
+            return lambda text: text
+    color = DummyColor()
+
 
 @dataclass
 class MDLError(BaseException):
@@ -27,32 +37,32 @@ class MDLError(BaseException):
             # Show relative path if possible
             try:
                 rel_path = os.path.relpath(self.file_path)
-                parts.append(f"File: {rel_path}")
+                parts.append(f"{color.file_path('File:')} {color.file_path(rel_path)}")
             except ValueError:
-                parts.append(f"File: {self.file_path}")
+                parts.append(f"{color.file_path('File:')} {color.file_path(self.file_path)}")
         
         if self.line is not None:
-            parts.append(f"Line: {self.line}")
+            parts.append(f"{color.line_number('Line:')} {color.line_number(str(self.line))}")
             if self.column is not None:
-                parts.append(f"Column: {self.column}")
+                parts.append(f"{color.column_number('Column:')} {color.column_number(str(self.column))}")
         
         if self.line_content:
-            parts.append(f"Code: {self.line_content.strip()}")
+            parts.append(f"{color.context('Code:')} {color.context(self.line_content.strip())}")
             if self.column is not None:
                 # Add a caret to show the exact position
                 indent = " " * (self.column - 1)
-                parts.append(f"      {indent}^")
+                parts.append(f"      {indent}{color.error('^')}")
         
-        parts.append(f"Error: {self.message}")
+        parts.append(f"{color.error_type('Error:')} {color.error(self.message)}")
         
         if self.suggestion:
-            parts.append(f"Suggestion: {self.suggestion}")
+            parts.append(f"{color.suggestion('Suggestion:')} {color.suggestion(self.suggestion)}")
         
         # Add context if we have file and line information
         if self.file_path and self.line is not None:
             context = format_error_context(self.file_path, self.line, self.column, self.context_lines)
             if context:
-                parts.append(f"\nContext:\n{context}")
+                parts.append(f"\n{color.context('Context:')}\n{context}")
         
         return "\n".join(parts)
     
@@ -75,7 +85,7 @@ class MDLSyntaxError(MDLError):
     error_type: str = "syntax_error"
     
     def __str__(self) -> str:
-        return f"Syntax Error: {super().__str__()}"
+        return f"{color.error_type('Syntax Error:')} {super().__str__()}"
 
 
 @dataclass
@@ -84,7 +94,7 @@ class MDLLexerError(MDLError):
     error_type: str = "lexer_error"
     
     def __str__(self) -> str:
-        return f"Lexer Error: {super().__str__()}"
+        return f"{color.error_type('Lexer Error:')} {super().__str__()}"
 
 
 @dataclass
@@ -93,52 +103,43 @@ class MDLParserError(MDLError):
     error_type: str = "parser_error"
     
     def __str__(self) -> str:
-        return f"Parser Error: {super().__str__()}"
+        return f"{color.error_type('Parser Error:')} {super().__str__()}"
 
 
 @dataclass
 class MDLValidationError(MDLError):
-    """Error during validation."""
+    """Validation error during semantic analysis."""
     error_type: str = "validation_error"
     
     def __str__(self) -> str:
-        return f"Validation Error: {super().__str__()}"
-
-
-@dataclass
-class MDLBuildError(MDLError):
-    """Error during build process."""
-    error_type: str = "build_error"
-    
-    def __str__(self) -> str:
-        return f"Build Error: {super().__str__()}"
+        return f"{color.error_type('Validation Error:')} {super().__str__()}"
 
 
 @dataclass
-class MDLCompilationError(MDLError):
-    """Error during compilation."""
-    error_type: str = "compilation_error"
+class MDLConfigurationError(MDLError):
+    """Configuration or setup error."""
+    error_type: str = "configuration_error"
     
     def __str__(self) -> str:
-        return f"Compilation Error: {super().__str__()}"
+        return f"{color.error_type('Configuration Error:')} {super().__str__()}"
 
 
 @dataclass
 class MDLFileError(MDLError):
-    """Error related to file operations."""
+    """File I/O or access error."""
     error_type: str = "file_error"
     
     def __str__(self) -> str:
-        return f"File Error: {super().__str__()}"
+        return f"{color.error_type('File Error:')} {super().__str__()}"
 
 
 @dataclass
-class MDLConfigurationError(MDLError):
-    """Error related to configuration."""
-    error_type: str = "configuration_error"
+class MDLWarning(MDLError):
+    """Warning message (non-fatal)."""
+    error_type: str = "warning"
     
     def __str__(self) -> str:
-        return f"Configuration Error: {super().__str__()}"
+        return f"{color.warning('Warning:')} {super().__str__()}"
 
 
 class MDLErrorCollector:
@@ -148,12 +149,16 @@ class MDLErrorCollector:
         self.errors: List[MDLError] = []
         self.warnings: List[MDLError] = []
     
-    def add_error(self, error: MDLError) -> None:
-        """Add an error to the collection."""
-        self.errors.append(error)
+    def add_error(self, error: MDLError):
+        """Add an error to the collector."""
+        if isinstance(error, MDLWarning):
+            self.warnings.append(error)
+        else:
+            self.errors.append(error)
     
-    def add_warning(self, warning: MDLError) -> None:
-        """Add a warning to the collection."""
+    def add_warning(self, message: str, **kwargs):
+        """Add a warning message."""
+        warning = create_error(MDLWarning, message, **kwargs)
         self.warnings.append(warning)
     
     def has_errors(self) -> bool:
@@ -164,114 +169,104 @@ class MDLErrorCollector:
         """Check if there are any warnings."""
         return len(self.warnings) > 0
     
-    def get_all_issues(self) -> List[MDLError]:
-        """Get all errors and warnings."""
-        return self.errors + self.warnings
+    def get_error_count(self) -> int:
+        """Get the total number of errors."""
+        return len(self.errors)
     
-    def print_errors(self, verbose: bool = False, ignore_warnings: bool = False) -> None:
-        """Print all errors and warnings."""
-        if not self.errors and not self.warnings:
-            return
+    def get_warning_count(self) -> int:
+        """Get the total number of warnings."""
+        return len(self.warnings)
+    
+    def clear(self):
+        """Clear all errors and warnings."""
+        self.errors.clear()
+        self.warnings.clear()
+    
+    def print_errors(self, verbose: bool = True, ignore_warnings: bool = False):
+        """Print all collected errors and warnings."""
+        if not ignore_warnings and self.warnings:
+            print(f"\n{color.warning(f'⚠️  {len(self.warnings)} Warning(s):')}")
+            for warning in self.warnings:
+                print(f"\n{warning}")
         
         if self.errors:
-            print(f"\nERROR: Found {len(self.errors)} error(s):")
-            for i, error in enumerate(self.errors, 1):
-                print(f"\n{i}. {error}")
+            print(f"\n{color.error(f'❌ {len(self.errors)} Error(s):')}")
+            for error in self.errors:
+                print(f"\n{error}")
         
-        if self.warnings and not ignore_warnings:
-            print(f"\nWARNING: Found {len(self.warnings)} warning(s):")
-            for i, warning in enumerate(self.warnings, 1):
-                print(f"\n{i}. {warning}")
+        if not self.errors and not self.warnings:
+            print(f"\n{color.success('✅ No errors or warnings found!')}")
     
-    def raise_if_errors(self) -> None:
+    def raise_if_errors(self):
         """Raise an exception if there are any errors."""
         if self.has_errors():
-            error_messages = [str(error) for error in self.errors]
-            raise MDLBuildError(
-                message=f"Build failed with {len(self.errors)} error(s):\n" + "\n".join(error_messages),
-                error_type="build_error"
+            error_summary = f"Compilation failed with {len(self.errors)} error(s)"
+            if self.warnings:
+                error_summary += f" and {len(self.warnings)} warning(s)"
+            
+            # Create a summary error
+            summary_error = create_error(
+                MDLConfigurationError,
+                error_summary,
+                suggestion="Fix the errors above and try again."
             )
-    
-    def get_summary(self) -> str:
-        """Get a summary of errors and warnings."""
-        summary_parts = []
-        
-        if self.errors:
-            summary_parts.append(f"{len(self.errors)} error(s)")
-        
-        if self.warnings:
-            summary_parts.append(f"{len(self.warnings)} warning(s)")
-        
-        if not summary_parts:
-            return "No issues found"
-        
-        return ", ".join(summary_parts)
+            
+            # Add all errors as context
+            for error in self.errors:
+                summary_error.message += f"\n- {error.message}"
+            
+            raise summary_error
 
 
-def create_error(error_type: str, message: str, file_path: Optional[str] = None, 
+def create_error(error_class: type, message: str, file_path: Optional[str] = None, 
                 line: Optional[int] = None, column: Optional[int] = None, 
-                line_content: Optional[str] = None, suggestion: Optional[str] = None) -> MDLError:
-    """Factory function to create appropriate error type."""
-    error_classes = {
-        "syntax": MDLSyntaxError,
-        "lexer": MDLLexerError,
-        "parser": MDLParserError,
-        "validation": MDLValidationError,
-        "build": MDLBuildError,
-        "compilation": MDLCompilationError,
-        "file": MDLFileError,
-        "configuration": MDLConfigurationError
-    }
-    
-    error_class = error_classes.get(error_type, MDLError)
+                line_content: Optional[str] = None, suggestion: Optional[str] = None,
+                context_lines: int = 2) -> MDLError:
+    """Create an MDL error with the given information."""
     return error_class(
         message=message,
         file_path=file_path,
         line=line,
         column=column,
         line_content=line_content,
-        error_type=error_type,
-        suggestion=suggestion
+        suggestion=suggestion,
+        context_lines=context_lines
     )
 
 
-def get_line_content(file_path: str, line_number: int) -> Optional[str]:
-    """Get the content of a specific line from a file."""
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            lines = f.readlines()
-            if 1 <= line_number <= len(lines):
-                return lines[line_number - 1]
-    except (FileNotFoundError, UnicodeDecodeError):
-        pass
-    return None
-
-
-def format_error_context(file_path: str, line: int, column: int, 
-                        context_lines: int = 2) -> str:
+def format_error_context(file_path: str, line: int, column: Optional[int], context_lines: int) -> str:
     """Format error context with surrounding lines."""
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
             lines = f.readlines()
         
-        start_line = max(1, line - context_lines)
+        if not lines:
+            return ""
+        
+        # Calculate line range to show
+        start_line = max(0, line - context_lines - 1)
         end_line = min(len(lines), line + context_lines)
         
-        context = []
-        for i in range(start_line, end_line + 1):
-            prefix = ">>> " if i == line else "    "
-            line_num = f"{i:4d}"
-            content = lines[i - 1].rstrip('\n')
-            context.append(f"{prefix}{line_num}: {content}")
+        context_parts = []
+        for i in range(start_line, end_line):
+            line_num = i + 1
+            line_content = lines[i].rstrip('\n\r')
             
-            if i == line and column is not None:
-                # Add caret to show exact position
-                indent = " " * (column - 1)
-                context.append(f"     {indent}^")
+            if line_num == line:
+                # Highlight the error line
+                prefix = f"{color.line_number(f'{line_num:3d}:')} "
+                content = color.error(line_content)
+                context_parts.append(f"{prefix}{content}")
+            else:
+                # Show context lines
+                prefix = f"{color.context(f'{line_num:3d}:')} "
+                content = color.context(line_content)
+                context_parts.append(f"{prefix}{content}")
+        
+        return "\n".join(context_parts)
         
-        return "\n".join(context)
-    except (FileNotFoundError, UnicodeDecodeError):
-        return f"Unable to read file: {file_path}"
+    except Exception:
+        return "Unable to load file context"
 
 
 def create_syntax_error(message: str, file_path: Optional[str] = None, 

{minecraft_datapack_language-15.4.1.dist-info → minecraft_datapack_language-15.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.1
+Version: 15.4.2
 Summary: Compile JavaScript-style MDL language or Python API into a Minecraft datapack (1.21+ ready). Features variables, control flow, error handling, and VS Code extension.
 Project-URL: Homepage, https://www.mcmdl.com
 Project-URL: Documentation, https://www.mcmdl.com/docs

{minecraft_datapack_language-15.4.1.dist-info → minecraft_datapack_language-15.4.2.dist-info}/RECORD

@@ -1,25 +1,25 @@
 minecraft_datapack_language/__init__.py,sha256=i-qCchbe5b2Fshgc6yCU9mddOLs2UBt9SAcLqfUIrT0,606
-minecraft_datapack_language/_version.py,sha256=Ohcg9Yyw2RsH29peJV8QS4k6ROTO-G8se_Vhy3xGc3M,706
+minecraft_datapack_language/_version.py,sha256=ryxn9HWHc1n3aIKcrjY9Y_8_9ek9rdgANmjmrldYgYI,706
 minecraft_datapack_language/ast_nodes.py,sha256=pgjI2Nlap3ixFPgWqGSkqncG9zB91h5BKgRjtcJqMew,2118
 minecraft_datapack_language/cli.py,sha256=p5A_tEEXugN2NhQFbbgfwi4FxbWYD91RWeKR_A3Vuec,6263
-minecraft_datapack_language/cli_build.py,sha256=YEEStmQfZg4uZqbhDQc3z8jExCNJ08dAuP632wOBC7M,47610
+minecraft_datapack_language/cli_build.py,sha256=8G0YtPd9hoG2s5aJwKM5HOtz6nDAVRj90XzxhvhlOy0,8213
 minecraft_datapack_language/cli_check.py,sha256=bPq9gHsxQ1CIiftkrAtRCifWkVAyjp5c8Oay2NNQ1qs,6277
 minecraft_datapack_language/cli_colors.py,sha256=Ims0KbdYpsiwoqv96Y_g89uOB5l1qdETm_P51rkljfk,7884
-minecraft_datapack_language/cli_help.py,sha256=jUTHUQBONAZKVTdQK9tNPXq4c_6xpsafNOvHDjkEldg,12243
+minecraft_datapack_language/cli_help.py,sha256=n2cJLYlKRz0umCgWuKrZm2Il0qEAkOloSUOcZvPa4Qk,13186
 minecraft_datapack_language/cli_new.py,sha256=Uw-xuW6KTTRTeOsnS3wgoZnna7xA203SM8qvUUDFHTk,8112
 minecraft_datapack_language/cli_utils.py,sha256=nl22j96vpCW0XRMpD_zjwamnMU4e4LXEjACsnwiFGzs,9931
 minecraft_datapack_language/dir_map.py,sha256=HmxFkuvWGkzHF8o_GFb4BpuMCRc6QMw8UbmcAI8JVdY,1788
 minecraft_datapack_language/expression_processor.py,sha256=GN6cuRNvgI8TrV6YnEHrA9P0X-ACTT7rCBh4WlOPjSI,20140
 minecraft_datapack_language/linter.py,sha256=7UqbygC5JPCGg-BSOq65NB2xEJBu_OUOYIIgmHItO2M,16567
-minecraft_datapack_language/mdl_errors.py,sha256=a_-683gjF3gfGRpDMbRgCXmXD9_aYYBmLodNH6fe29A,11596
+minecraft_datapack_language/mdl_errors.py,sha256=O0lIem8C6GtOeYnbV0E0-ZGNVx9G7aD5X5LuzsvFCfs,11907
 minecraft_datapack_language/mdl_lexer_js.py,sha256=VvbhKm727khdSAABxa03hoIIA7H3hWi3RLp9BSXbhY0,28277
 minecraft_datapack_language/mdl_linter.py,sha256=z85xoAglENurCh30bR7kEHZ_JeMxcYaLDcGNRAl-RAI,17253
 minecraft_datapack_language/mdl_parser_js.py,sha256=SQzc67pKls3NVnQaT0xIILGqpZYAmcZn78TQ0KIM4TE,40216
 minecraft_datapack_language/pack.py,sha256=nYiXQ3jgJlDfc4m-65f7C2LFhDRioaUU_XVy6Na4SJI,34625
 minecraft_datapack_language/utils.py,sha256=Aq0HAGlXqj9BUTEjaEilpvzEW0EtZYYMMwOqG9db6dE,684
-minecraft_datapack_language-15.4.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.1.dist-info/METADATA,sha256=GKfvUfLEIW3Jpbllp2U8_kuvrCWb0m8We9yBNF7Q3_M,35229
-minecraft_datapack_language-15.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.1.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.1.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.1.dist-info/RECORD,,
+minecraft_datapack_language-15.4.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.2.dist-info/METADATA,sha256=U4e9OFniRONfR61-P6gGWyO5a2xLevPGxR9bGS0ZzdQ,35229
+minecraft_datapack_language-15.4.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.2.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.2.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.2.dist-info/RECORD,,