minecraft-datapack-language 15.4.7__py3-none-any.whl → 15.4.9__py3-none-any.whl

minecraft_datapack_language/mdl_errors.py

@@ -6,16 +6,6 @@ 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):
@@ -31,40 +21,78 @@ class MDLError(BaseException):
     
     def __str__(self) -> str:
         """Format error message with location information."""
-        parts = []
-        
-        if self.file_path:
-            # Show relative path if possible
-            try:
-                rel_path = os.path.relpath(self.file_path)
-                parts.append(f"{color.file_path('File:')} {color.file_path(rel_path)}")
-            except ValueError:
-                parts.append(f"{color.file_path('File:')} {color.file_path(self.file_path)}")
-        
-        if self.line is not None:
-            parts.append(f"{color.line_number('Line:')} {color.line_number(str(self.line))}")
-            if self.column is not None:
-                parts.append(f"{color.column_number('Column:')} {color.column_number(str(self.column))}")
-        
-        if self.line_content:
-            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}{color.error('^')}")
-        
-        parts.append(f"{color.error_type('Error:')} {color.error(self.message)}")
-        
-        if 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"\n{color.context('Context:')}\n{context}")
-        
-        return "\n".join(parts)
+        try:
+            from .cli_colors import color
+            parts = []
+            
+            if self.file_path:
+                # Show relative path if possible
+                try:
+                    rel_path = os.path.relpath(self.file_path)
+                    parts.append(f"{color.file_path('File:')} {color.file_path(rel_path)}")
+                except ValueError:
+                    parts.append(f"{color.file_path('File:')} {color.file_path(self.file_path)}")
+            
+            if self.line is not None:
+                parts.append(f"{color.line_number('Line:')} {color.line_number(str(self.line))}")
+                if self.column is not None:
+                    parts.append(f"{color.column_number('Column:')} {color.column_number(str(self.column))}")
+            
+            if self.line_content:
+                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}{color.error('^')}")
+            
+            parts.append(f"{color.error_type('Error:')} {color.error(self.message)}")
+            
+            if 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"\n{color.context('Context:')}\n{context}")
+            
+            return "\n".join(parts)
+        except ImportError:
+            # Fallback if colors aren't available
+            parts = []
+            
+            if self.file_path:
+                # Show relative path if possible
+                try:
+                    rel_path = os.path.relpath(self.file_path)
+                    parts.append(f"File: {rel_path}")
+                except ValueError:
+                    parts.append(f"File: {self.file_path}")
+            
+            if self.line is not None:
+                parts.append(f"Line: {self.line}")
+                if self.column is not None:
+                    parts.append(f"Column: {self.column}")
+            
+            if self.line_content:
+                parts.append(f"Code: {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"Error: {self.message}")
+            
+            if self.suggestion:
+                parts.append(f"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}")
+            
+            return "\n".join(parts)
     
     def to_dict(self) -> dict:
         """Convert error to dictionary for JSON output."""
@@ -85,7 +113,11 @@ class MDLSyntaxError(MDLError):
     error_type: str = "syntax_error"
     
     def __str__(self) -> str:
-        return f"{color.error_type('Syntax Error:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Syntax Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Syntax Error: {super().__str__()}"
 
 
 @dataclass
@@ -94,7 +126,11 @@ class MDLLexerError(MDLError):
     error_type: str = "lexer_error"
     
     def __str__(self) -> str:
-        return f"{color.error_type('Lexer Error:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Lexer Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Lexer Error: {super().__str__()}"
 
 
 @dataclass
@@ -103,43 +139,76 @@ class MDLParserError(MDLError):
     error_type: str = "parser_error"
     
     def __str__(self) -> str:
-        return f"{color.error_type('Parser Error:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Parser Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Parser Error: {super().__str__()}"
 
 
 @dataclass
 class MDLValidationError(MDLError):
-    """Validation error during semantic analysis."""
+    """Error during validation."""
     error_type: str = "validation_error"
     
     def __str__(self) -> str:
-        return f"{color.error_type('Validation Error:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Validation Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Validation Error: {super().__str__()}"
 
 
 @dataclass
-class MDLConfigurationError(MDLError):
-    """Configuration or setup error."""
-    error_type: str = "configuration_error"
+class MDLBuildError(MDLError):
+    """Error during build process."""
+    error_type: str = "build_error"
+    
+    def __str__(self) -> str:
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Build Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Build Error: {super().__str__()}"
+
+
+@dataclass
+class MDLCompilationError(MDLError):
+    """Error during compilation."""
+    error_type: str = "compilation_error"
     
     def __str__(self) -> str:
-        return f"{color.error_type('Configuration Error:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Compilation Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Compilation Error: {super().__str__()}"
 
 
 @dataclass
 class MDLFileError(MDLError):
-    """File I/O or access error."""
+    """Error related to file operations."""
     error_type: str = "file_error"
     
     def __str__(self) -> str:
-        return f"{color.error_type('File Error:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('File Error:')} {super().__str__()}"
+        except ImportError:
+            return f"File Error: {super().__str__()}"
 
 
 @dataclass
-class MDLWarning(MDLError):
-    """Warning message (non-fatal)."""
-    error_type: str = "warning"
+class MDLConfigurationError(MDLError):
+    """Error related to configuration."""
+    error_type: str = "configuration_error"
     
     def __str__(self) -> str:
-        return f"{color.warning('Warning:')} {super().__str__()}"
+        try:
+            from .cli_colors import color
+            return f"{color.error_type('Configuration Error:')} {super().__str__()}"
+        except ImportError:
+            return f"Configuration Error: {super().__str__()}"
 
 
 class MDLErrorCollector:
@@ -149,16 +218,12 @@ class MDLErrorCollector:
         self.errors: List[MDLError] = []
         self.warnings: List[MDLError] = []
     
-    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_error(self, error: MDLError) -> None:
+        """Add an error to the collection."""
+        self.errors.append(error)
     
-    def add_warning(self, message: str, **kwargs):
-        """Add a warning message."""
-        warning = create_error(MDLWarning, message, **kwargs)
+    def add_warning(self, warning: MDLError) -> None:
+        """Add a warning to the collection."""
         self.warnings.append(warning)
     
     def has_errors(self) -> bool:
@@ -169,104 +234,127 @@ class MDLErrorCollector:
         """Check if there are any warnings."""
         return len(self.warnings) > 0
     
-    def get_error_count(self) -> int:
-        """Get the total number of errors."""
-        return len(self.errors)
-    
-    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 get_all_issues(self) -> List[MDLError]:
+        """Get all errors and warnings."""
+        return self.errors + self.warnings
     
-    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"\n{color.error(f'❌ {len(self.errors)} Error(s):')}")
-            for error in self.errors:
-                print(f"\n{error}")
-        
+    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:
-            print(f"\n{color.success('✅ No errors or warnings found!')}")
+            return
+        
+        try:
+            from .cli_colors import color
+            if self.errors:
+                print(f"\n{color.error_type('ERROR:')} Found {color.error(str(len(self.errors)))} error(s):")
+                for i, error in enumerate(self.errors, 1):
+                    print(f"\n{color.highlight(str(i))}. {error}")
+            
+            if self.warnings and not ignore_warnings:
+                print(f"\n{color.warning('WARNING:')} Found {color.warning(str(len(self.warnings)))} warning(s):")
+                for i, warning in enumerate(self.warnings, 1):
+                    print(f"\n{color.highlight(str(i))}. {warning}")
+        except ImportError:
+            # Fallback if colors aren't available
+            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}")
+            
+            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}")
     
-    def raise_if_errors(self):
+    def raise_if_errors(self) -> None:
         """Raise an exception if there are any errors."""
         if self.has_errors():
-            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."
+            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"
             )
-            
-            # Add all errors as context
-            for error in self.errors:
-                summary_error.message += f"\n- {error.message}"
-            
-            raise summary_error
+    
+    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)
 
 
-def create_error(error_class: type, message: str, file_path: Optional[str] = None, 
+def create_error(error_type: str, message: str, file_path: Optional[str] = None, 
                 line: Optional[int] = None, column: Optional[int] = None, 
-                line_content: Optional[str] = None, suggestion: Optional[str] = None,
-                context_lines: int = 2) -> MDLError:
-    """Create an MDL error with the given information."""
+                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)
     return error_class(
         message=message,
         file_path=file_path,
         line=line,
         column=column,
         line_content=line_content,
-        suggestion=suggestion,
-        context_lines=context_lines
+        error_type=error_type,
+        suggestion=suggestion
     )
 
 
-def format_error_context(file_path: str, line: int, column: Optional[int], context_lines: int) -> str:
+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:
     """Format error context with surrounding lines."""
     try:
         with open(file_path, 'r', encoding='utf-8') as f:
             lines = f.readlines()
         
-        if not lines:
-            return ""
-        
-        # Calculate line range to show
-        start_line = max(0, line - context_lines - 1)
+        start_line = max(1, line - context_lines)
         end_line = min(len(lines), line + context_lines)
         
-        context_parts = []
-        for i in range(start_line, end_line):
-            line_num = i + 1
-            line_content = lines[i].rstrip('\n\r')
+        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}")
             
-            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)
+            if i == line and column is not None:
+                # Add caret to show exact position
+                indent = " " * (column - 1)
+                context.append(f"     {indent}^")
         
-    except Exception:
-        return "Unable to load file context"
+        return "\n".join(context)
+    except (FileNotFoundError, UnicodeDecodeError):
+        return f"Unable to read file: {file_path}"
 
 
 def create_syntax_error(message: str, file_path: Optional[str] = None, 

{minecraft_datapack_language-15.4.7.dist-info → minecraft_datapack_language-15.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.7
+Version: 15.4.9
 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.7.dist-info → minecraft_datapack_language-15.4.9.dist-info}/RECORD

@@ -1,25 +1,25 @@
 minecraft_datapack_language/__init__.py,sha256=i-qCchbe5b2Fshgc6yCU9mddOLs2UBt9SAcLqfUIrT0,606
-minecraft_datapack_language/_version.py,sha256=SIXKzGXg_ZDjpdiyLe3C99MU-0N6v8GJBEqcqIzfHEs,706
+minecraft_datapack_language/_version.py,sha256=kBS_aJPr-qhhnmfVNaDqUObyMzWJEMpsVQ-KXHKYm_8,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=HvrQdINx8EmF4OW6IZCx_S6Rs4NZQ-eB1PSlcDMnCmA,47939
 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=z7PTqkrRYOFhfqe7CLdaF68kEAO5R1iP0j45b_36bEw,13196
-minecraft_datapack_language/cli_new.py,sha256=3K6gHCYwmOTXysicSWJNsjU1YXyz2xa5IGjoOtj1CKc,6489
+minecraft_datapack_language/cli_help.py,sha256=jUTHUQBONAZKVTdQK9tNPXq4c_6xpsafNOvHDjkEldg,12243
+minecraft_datapack_language/cli_new.py,sha256=_pj5EeXESAG00C80_os9jONIXAMcsu2eoR8xVJWDw6g,9347
 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=O0lIem8C6GtOeYnbV0E0-ZGNVx9G7aD5X5LuzsvFCfs,11907
+minecraft_datapack_language/mdl_errors.py,sha256=mz6uyPkeBpbMHj4PiAyVecEVJ9_hdSfR45QAjG6oYf0,15690
 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.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-minecraft_datapack_language-15.4.7.dist-info/METADATA,sha256=Y1SE5p89bmmGEXZK674BS73GdhoYCCm9YAYtT0yYPdc,35229
-minecraft_datapack_language-15.4.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-minecraft_datapack_language-15.4.7.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
-minecraft_datapack_language-15.4.7.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
-minecraft_datapack_language-15.4.7.dist-info/RECORD,,
+minecraft_datapack_language-15.4.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+minecraft_datapack_language-15.4.9.dist-info/METADATA,sha256=OToHEbhvuer4uXbIRTJGD8DZzuiZ-aUqZAOINC5qcsM,35229
+minecraft_datapack_language-15.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+minecraft_datapack_language-15.4.9.dist-info/entry_points.txt,sha256=c6vjBeCiyQflvPHBRyBk2nJCSfYt3Oc7Sc9V87ySi_U,108
+minecraft_datapack_language-15.4.9.dist-info/top_level.txt,sha256=ADtFI476tbKLLxEAA-aJQAfg53MA3k_DOb0KTFiggfw,28
+minecraft_datapack_language-15.4.9.dist-info/RECORD,,