minecraft-datapack-language 16.0.12__tar.gz → 16.0.14__tar.gz

{minecraft_datapack_language-16.0.12/minecraft_datapack_language.egg-info → minecraft_datapack_language-16.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.12
+Version: 16.0.14
 Summary: Compile MDL language with explicit scoping 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-16.0.14/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "16.0.13"
+tag: "v16.0.13"
+updated_at: "2025-09-09T06:19:59Z"

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/docs/downloads.md

@@ -350,17 +350,19 @@ MDL is open source software licensed under the MIT License. See the [LICENSE](ht
 }
 
 [data-theme="dark"] .install-code {
-  background: #21262d;
+  background: #191d23 !important;
   border-color: #30363d;
 }
 
 .install-code code {
   font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
   color: #24292e;
+  border: 0;
 }
 
 [data-theme="dark"] .install-code code {
   color: #e6edf3;
+  background: inherit !important;
 }
 
 .releases-section {

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '16.0.12'
-__version_tuple__ = version_tuple = (16, 0, 12)
+__version__ = version = '16.0.14'
+__version_tuple__ = version_tuple = (16, 0, 14)
 
-__commit_id__ = commit_id = 'gd830ed025'
+__commit_id__ = commit_id = 'g4a67b89f7'

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/minecraft_datapack_language/mdl_compiler.py

@@ -187,7 +187,10 @@ class MDLCompiler:
             if macro_re.search(line):
                 stripped = line.lstrip()
                 if not stripped.startswith('$'):
-                    return '$' + line
+                    # Insert '$' immediately after indentation so there is no space after '$'
+                    leading_ws_len = len(line) - len(stripped)
+                    leading_ws = line[:leading_ws_len]
+                    return f"{leading_ws}${stripped}"
             return line
         if '\n' in text:
             return '\n'.join(process_line(ln) for ln in text.split('\n'))
@@ -832,12 +835,49 @@ class MDLCompiler:
         # Default: generic expression string, no inversion
         invert_then = False
         
+        # Helpers local to this method to keep concerns contained
+        def unwrap(e: Any) -> Any:
+            while isinstance(e, ParenthesizedExpression):
+                e = e.expression
+            return e
+
+        def norm_op(op_in: Any) -> Optional[str]:
+            # Return one of: '>', '>=', '<', '<=', '==', '!=' or None
+            if op_in == TokenType.GREATER or op_in == ">":
+                return ">"
+            if op_in == TokenType.GREATER_EQUAL or op_in == ">=":
+                return ">="
+            if op_in == TokenType.LESS or op_in == "<":
+                return "<"
+            if op_in == TokenType.LESS_EQUAL or op_in == "<=":
+                return "<="
+            if op_in == TokenType.EQUAL or op_in == "==" or op_in == "EQUAL":
+                return "=="
+            if op_in == TokenType.NOT_EQUAL or op_in == "!=" or op_in == "NOT_EQUAL":
+                return "!="
+            # Accept python bindings string names as well
+            if isinstance(op_in, str):
+                upper = op_in.upper()
+                if upper == "GREATER":
+                    return ">"
+                if upper == "GREATER_EQUAL":
+                    return ">="
+                if upper == "LESS":
+                    return "<"
+                if upper == "LESS_EQUAL":
+                    return "<="
+                if upper == "EQUAL":
+                    return "=="
+                if upper == "NOT_EQUAL":
+                    return "!="
+            return None
+
         if isinstance(expression, BinaryExpression):
-            left = expression.left
-            right = expression.right
-            op = expression.operator
+            left = unwrap(expression.left)
+            right = unwrap(expression.right)
+            op_sym = norm_op(expression.operator)
             # Variable vs literal
-            if isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
+            if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, LiteralExpression) and isinstance(right.value, (int, float)):
                 objective = self.variables.get(left.name, left.name)
                 scope = left.scope.strip("<>")
                 # Normalize number
@@ -847,41 +887,47 @@ class MDLCompiler:
                     v = None
                 if v is not None:
                     n = int(v) if float(v).is_integer() else v
-                    if op == TokenType.GREATER:
+                    if op_sym == ">":
                         rng = f"{int(n)+1}.." if isinstance(n, int) else f"{v+1}.."
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.GREATER_EQUAL:
+                    if op_sym == ">=":
                         rng = f"{int(n)}.."
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.LESS:
+                    if op_sym == "<":
                         rng = f"..{int(n)-1}"
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.LESS_EQUAL:
+                    if op_sym == "<=":
                         rng = f"..{int(n)}"
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.EQUAL:
+                    if op_sym == "==":
                         rng = f"{int(n)}"
                         return (f"score {scope} {objective} matches {rng}", False)
-                    if op == TokenType.NOT_EQUAL:
+                    if op_sym == "!=":
                         rng = f"{int(n)}"
                         return (f"score {scope} {objective} matches {rng}", True)
+            # Literal vs variable (swap sides)
+            if op_sym and isinstance(left, LiteralExpression) and isinstance(left.value, (int, float)) and isinstance(right, VariableSubstitution):
+                # Swap by inverting the operator appropriately, then reuse logic
+                invert_map = {
+                    ">": "<",
+                    ">=": "<=",
+                    "<": ">",
+                    "<=": ">=",
+                    "==": "==",
+                    "!=": "!="
+                }
+                swapped = BinaryExpression(left=right, operator=invert_map.get(op_sym, op_sym), right=left)
+                return self._build_condition(swapped)
             # Variable vs variable
-            if isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
+            if op_sym and isinstance(left, VariableSubstitution) and isinstance(right, VariableSubstitution):
                 lobj = self.variables.get(left.name, left.name)
                 lscope = left.scope.strip("<>")
                 robj = self.variables.get(right.name, right.name)
                 rscope = right.scope.strip("<>")
-                if op in (TokenType.GREATER, TokenType.GREATER_EQUAL, TokenType.LESS, TokenType.LESS_EQUAL, TokenType.EQUAL):
-                    comp_map = {
-                        TokenType.GREATER: ">",
-                        TokenType.GREATER_EQUAL: ">=",
-                        TokenType.LESS: "<",
-                        TokenType.LESS_EQUAL: "<=",
-                        TokenType.EQUAL: "="
-                    }
-                    comp = comp_map[op]
+                if op_sym in (">", ">=", "<", "<=", "=="):
+                    comp = op_sym if op_sym != "==" else "="
                     return (f"score {lscope} {lobj} {comp} {rscope} {robj}", False)
-                if op == TokenType.NOT_EQUAL:
+                if op_sym == "!=":
                     # Use equals with inversion
                     return (f"score {lscope} {lobj} = {rscope} {robj}", True)
         

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/minecraft_datapack_language/mdl_lexer.py

@@ -357,6 +357,14 @@ class MDLLexer:
             if (self.source[self.current:self.current + 5] == 'raw!$'):
                 # Found the end marker - extract the content
                 raw_content = self.source[content_start:self.current]
+                # Trim leading/trailing whitespace on each line within the raw block
+                try:
+                    lines = raw_content.split('\n')
+                    trimmed_lines = [ln.strip() for ln in lines]
+                    raw_content = '\n'.join(trimmed_lines)
+                except Exception:
+                    # If anything goes wrong, fall back to original content
+                    pass
                 
                 # Generate a single RAW_CONTENT token with all the content
                 self.tokens.append(Token(TokenType.RAW_CONTENT, raw_content, self.line, self.column))

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14/minecraft_datapack_language.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 16.0.12
+Version: 16.0.14
 Summary: Compile MDL language with explicit scoping 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-16.0.12 → minecraft_datapack_language-16.0.14}/tests/run_all_tests.py

@@ -12,7 +12,11 @@ from pathlib import Path
 
 
 def run_test_suite(name, command, description=""):
-    """Run a test suite and return results."""
+    """Run a test suite and return results.
+
+    If command is a list, execute without a shell to avoid shell expansions.
+    If command is a string, execute via the shell (backward compatible).
+    """
     print(f"\n{'='*60}")
     print(f"Running {name}")
     if description:
@@ -22,7 +26,8 @@ def run_test_suite(name, command, description=""):
     start_time = time.time()
     
     try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True)
+        use_shell = isinstance(command, str)
+        result = subprocess.run(command, shell=use_shell, capture_output=True, text=True)
         duration = time.time() - start_time
         
         if result.returncode == 0:
@@ -64,11 +69,16 @@ def main():
         has_cov = importlib.util.find_spec("pytest_cov") is not None
     except Exception:
         has_cov = False
-    base_cmd = "python -m pytest tests/ -v"
-    cov_args = " --cov=minecraft_datapack_language --cov-report=term-missing --cov-report=html:htmlcov" if has_cov else ""
+    base_cmd = [sys.executable, "-m", "pytest", "tests/", "-v"]
+    if has_cov:
+        base_cmd += [
+            "--cov=minecraft_datapack_language",
+            "--cov-report=term-missing",
+            "--cov-report=html:htmlcov",
+        ]
     pytest_result = run_test_suite(
         "Pytest Suite",
-        f"{base_cmd}{cov_args}",
+        base_cmd,
         "Comprehensive pytest suite" + (" with coverage" if has_cov else "")
     )
     results.append(("Pytest", pytest_result))
@@ -87,7 +97,7 @@ def main():
         if test_path.exists():
             result = run_test_suite(
                 f"Pytest {test_file}",
-                f"python -m pytest -q tests/{test_file}",
+                [sys.executable, "-m", "pytest", "-q", f"tests/{test_file}"],
                 description
             )
             results.append((test_file, result))
@@ -100,7 +110,11 @@ def main():
     # Test complex scenarios
     complex_result = run_test_suite(
         "Complex Scenarios Compilation",
-        "python -c \"from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \\\"test\\\" \\\"Test pack\\\" 82; namespace \\\"test\\\"; var num counter<@s> = 0; var num health<@s> = 20; var num bonus<@s> = 5; function test:complex_math<@s> { counter<@s> = ($counter<@s>$ + $health<@s>$) * $bonus<@s>$; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Complex expressions compilation successful')\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \"test\" \"Test pack\" 82; namespace \"test\"; var num counter<@s> = 0; var num health<@s> = 20; var num bonus<@s> = 5; function test:complex_math<@s> { counter<@s> = ($counter<@s>$ + $health<@s>$) * $bonus<@s>$; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Complex expressions compilation successful')",
+        ],
         "Test complex mathematical expressions compilation"
     )
     results.append(("Complex Expressions", complex_result))
@@ -108,7 +122,11 @@ def main():
     # Test control flow
     control_result = run_test_suite(
         "Control Flow Compilation",
-        "python -c \"from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \\\"test\\\" \\\"Test pack\\\" 82; namespace \\\"test\\\"; var num health<@s> = 20; function test:health_check<@s> { if $health<@s>$ < 10 { say \\\"Health is low!\\\"; } else { say \\\"Health is good!\\\"; } }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Control flow compilation successful')\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \"test\" \"Test pack\" 82; namespace \"test\"; var num health<@s> = 20; function test:health_check<@s> { if $health<@s>$ < 10 { say \"Health is low!\"; } else { say \"Health is good!\"; } }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Control flow compilation successful')",
+        ],
         "Test if/else control flow compilation"
     )
     results.append(("Control Flow", control_result))
@@ -116,7 +134,11 @@ def main():
     # Test function execution
     function_result = run_test_suite(
         "Function Execution Compilation",
-        "python -c \"from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \\\"test\\\" \\\"Test pack\\\" 82; namespace \\\"test\\\"; function test:helper<@s> { say \\\"Helper function!\\\"; } function test:main<@s> { exec test:helper<@s>; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Function execution compilation successful')\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language.mdl_parser import MDLParser; from minecraft_datapack_language.mdl_compiler import MDLCompiler; import tempfile; from pathlib import Path; source = '''pack \"test\" \"Test pack\" 82; namespace \"test\"; function test:helper<@s> { say \"Helper function!\"; } function test:main<@s> { exec test:helper<@s>; }'''; parser = MDLParser(); ast = parser.parse(source); compiler = MDLCompiler('temp_output'); compiler.compile(ast); print('Function execution compilation successful')",
+        ],
         "Test function execution with scopes"
     )
     results.append(("Function Execution", function_result))
@@ -125,7 +147,11 @@ def main():
     print("\nTesting Python bindings...")
     api_result = run_test_suite(
         "Python Bindings Basic",
-        "python -c \"from minecraft_datapack_language import Pack; import tempfile, shutil; from pathlib import Path; td=tempfile.mkdtemp(); p=Pack('Test','Test pack',82); ns=p.namespace('test'); ns.function('hello','say Hello World!'); p.build(td); output=Path(td)/'data'/'test'/'function'/'hello.mcfunction'; assert output.exists(); print('Python API test successful'); shutil.rmtree(td)\"",
+        [
+            sys.executable,
+            "-c",
+            "from minecraft_datapack_language import Pack; import tempfile, shutil; from pathlib import Path; td=tempfile.mkdtemp(); p=Pack('Test','Test pack',82); ns=p.namespace('test'); ns.function('hello','say Hello World!'); p.build(td); output=Path(td)/'data'/'test'/'function'/'hello.mcfunction'; assert output.exists(); print('Python API test successful'); shutil.rmtree(td)",
+        ],
         "Test basic Python bindings functionality"
     )
     results.append(("Python Bindings", api_result))
@@ -134,7 +160,7 @@ def main():
     print("\nTesting CLI...")
     cli_result = run_test_suite(
         "CLI Help",
-        "python -m minecraft_datapack_language.cli --help",
+        [sys.executable, "-m", "minecraft_datapack_language.cli", "--help"],
         "Test CLI help command"
     )
     results.append(("CLI Help", cli_result))

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/tests/test_compiler_fixes.py

@@ -14,6 +14,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 from minecraft_datapack_language.mdl_compiler import MDLCompiler
 from minecraft_datapack_language.mdl_parser import MDLParser
+from minecraft_datapack_language.mdl_parser import MDLParser
 
 def test_complex_expressions():
     """Test that complex expressions compile correctly."""
@@ -34,7 +35,7 @@ function test:complex_math<@s> {
     
     with tempfile.TemporaryDirectory() as temp_dir:
         # Parse and compile
-        parser = MDLParser()
+        parser = MDLParser("<test>")
         ast = parser.parse(source)
         
         compiler = MDLCompiler(temp_dir)
@@ -77,6 +78,9 @@ function test:control_test<@s> {
     
     while $counter<@s>$ < 10 {
         counter<@s> = $counter<@s>$ + 1;
+        $!raw
+          say   Hello
+        raw!$
     }
 }
 """
@@ -92,15 +96,20 @@ function test:control_test<@s> {
         # Check output
         output_file = Path(temp_dir) / "data" / "test" / "function" / "control_test.mcfunction"
         assert output_file.exists(), "Output file should exist"
-        
+
         content = output_file.read_text()
         print(f"Generated content:\n{content}")
-        
+
         # Verify it contains proper control flow
         assert "execute if score" in content, "Should generate execute if commands"
         assert "execute unless score" in content, "Should generate execute unless commands"
         # While body is emitted as a generated function call with parent-name prefix
         assert "__while_" in content, "Should generate while loop functions"
+        # Raw block lines should be trimmed per line within generated function files
+        mcfuncs = list((Path(temp_dir) / "data" / "test").rglob("*.mcfunction"))
+        combined = "\n".join(p.read_text() for p in mcfuncs)
+        assert "\nsay   Hello" in combined
+        assert "\n  say" not in combined
         
         print("✅ Control flow test passed!")
 

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/tests/test_examples.py

@@ -34,8 +34,8 @@ def test_build_macros_example(tmp_path: Path):
     greeter = target_files[0].read_text()
     runner = runner_files[0].read_text()
 
-    # Macro line should be present as raw
-    assert '$say "Hello $(name)"' in greeter
+    # Macro line should be present as raw and no space after '$'
+    assert '$say "Hello $(name)"' in greeter and '$ say' not in greeter
     # Both exec forms should be emitted
     assert 'function macros_ex:greeter {name:"Casey"}' in runner
     assert 'function macros_ex:greeter with storage macros_ex:ctx player.profile' in runner

{minecraft_datapack_language-16.0.12 → minecraft_datapack_language-16.0.14}/tests/test_macros.py

@@ -50,6 +50,8 @@ def test_function_macros_exec_and_macro_lines():
 
         # Macro line should be preserved verbatim
         assert "$say \"Hello $(name)\"" in target_content
+        # Ensure there is no whitespace between '$' and the command token anywhere
+        assert "$ say" not in target_content
         # Exec with inline JSON compound
         assert "function macro:target {name:\"purple elephant\"}" in caller_content
         # Exec with data source 'with' clause

minecraft_datapack_language-16.0.12/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "16.0.11"
-tag: "v16.0.11"
-updated_at: "2025-09-09T03:58:29Z"