minecraft-datapack-language 15.4.41__tar.gz → 15.4.42__tar.gz

{minecraft_datapack_language-15.4.41/minecraft_datapack_language.egg-info → minecraft_datapack_language-15.4.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.41
+Version: 15.4.42
 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-15.4.42/docs/_data/version.yml

@@ -0,0 +1,3 @@
+current: "15.4.41"
+tag: "v15.4.41"
+updated_at: "2025-09-06T17:22:18Z"

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/docs/_docs/examples.md

@@ -86,6 +86,32 @@ function raw:custom {
 on_load raw:custom;
 ```
 
+## Function Macros
+
+Demonstrates macro lines and passing macro data to functions:
+
+```mdl
+pack "macros" "Function macro examples" 82;
+namespace "macros";
+
+// Target function using a macro line with $(name)
+function macros:greeter {
+    $say "Hello $(name)"
+    say "Done";
+}
+
+// Callers using inline JSON and with-clause
+function macros:callers {
+    // Inline JSON compound (prefer single quotes outside)
+    exec macros:greeter '{name:"Alex"}';
+
+    // Pull compound from a data source via with-clause
+    exec macros:greeter with storage macros:ctx player.info;
+}
+
+on_load macros:callers;
+```
+
 ## Complete Game Example
 
 A complete game with scoring, levels, and timers:

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/docs/_docs/language-reference.md

@@ -131,6 +131,12 @@ exec game:start_game;                            // Execute any function
 exec utils:calculator;                           // Execute from different namespace
 exec game:reset_player<@s>;                      // Execute function with scope
 exec game:reset_player<@a>;                      // Execute function with different scope
+
+// Function Macros (Minecraft snapshot): pass macro arguments
+// Inline JSON compound as a single-quoted string to minimize escapes
+exec game:spawn_mob '{id:"minecraft:cow",name:"Betsy"}';
+// With-clause to pull a compound from a data source
+exec game:spawn_mob with storage mymod:ctx path.to.compound;
 ```
 
 ### Control Structures
@@ -200,6 +206,14 @@ execute as @a[team=blue] at @s run playsound minecraft:entity.player.levelup pla
 raw!$
 ```
 
+### Macro Lines
+```mdl
+// Lines starting with $ are emitted as-is into the generated .mcfunction and
+// can contain $(variable) placeholders that Minecraft will substitute when the
+// function is called with a macro compound.
+$summon minecraft:cow ~ ~ ~ {CustomName:'{"text":"$(name)"}'}
+```
+
 **Important:** Raw blocks are completely ignored by the MDL parser. They get copied directly to the output `.mcfunction` files without any processing. This means you can use any valid Minecraft command syntax inside raw blocks.
 
 ## Scope System

minecraft_datapack_language-15.4.42/examples/macros_example.mdl

@@ -0,0 +1,20 @@
+// MDL Macros Example - macro lines and exec macro arguments
+pack "macros_example" "Function macro demo" 82;
+namespace "macros_ex";
+
+function macros_ex:greeter {
+    $say "Hello $(name)"
+    say "Greeting complete.";
+}
+
+function macros_ex:runner {
+    // Inline JSON compound (prefer single quotes around the JSON)
+    exec macros_ex:greeter '{name:"Casey"}';
+
+    // With-clause using a storage data source
+    exec macros_ex:greeter with storage macros_ex:ctx player.profile;
+}
+
+on_load macros_ex:runner;
+
+

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/minecraft_datapack_language/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '15.4.41'
-__version_tuple__ = version_tuple = (15, 4, 41)
+__version__ = version = '15.4.42'
+__version_tuple__ = version_tuple = (15, 4, 42)
 
-__commit_id__ = commit_id = 'gb4437b04f'
+__commit_id__ = commit_id = 'g00d85a082'

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/minecraft_datapack_language/ast_nodes.py

@@ -74,6 +74,9 @@ class FunctionCall(ASTNode):
     namespace: str
     name: str
     scope: Optional[str]  # Optional scope for the function call
+    # Macro invocation support (Minecraft function macros)
+    macro_json: Optional[str] = None  # Inline compound JSON string (including braces)
+    with_clause: Optional[str] = None  # Raw "with <data source> [path]" clause (without leading 'with')
 
 
 @dataclass
@@ -132,6 +135,12 @@ class ScoreboardCommand(ASTNode):
     command: str
 
 
+@dataclass
+class MacroLine(ASTNode):
+    """A raw macro line for mcfunction starting with '$' and containing $(vars)."""
+    content: str
+
+
 # Expression nodes
 @dataclass
 class BinaryExpression(ASTNode):

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/minecraft_datapack_language/mdl_compiler.py

@@ -11,7 +11,7 @@ from typing import Dict, List, Any, Optional
 from .ast_nodes import (
     Program, PackDeclaration, NamespaceDeclaration, TagDeclaration,
     VariableDeclaration, VariableAssignment, VariableSubstitution, FunctionDeclaration,
-    FunctionCall, IfStatement, WhileLoop, HookDeclaration, RawBlock,
+    FunctionCall, IfStatement, WhileLoop, HookDeclaration, RawBlock, MacroLine,
     SayCommand, BinaryExpression, LiteralExpression, ParenthesizedExpression
 )
 from .dir_map import get_dir_map, DirMap
@@ -325,6 +325,8 @@ class MDLCompiler:
             return self._say_command_to_command(statement)
         elif isinstance(statement, RawBlock):
             return statement.content
+        elif isinstance(statement, MacroLine):
+            return statement.content
         elif isinstance(statement, IfStatement):
             return self._if_statement_to_command(statement)
         elif isinstance(statement, WhileLoop):
@@ -616,10 +618,17 @@ class MDLCompiler:
     
     def _function_call_to_command(self, func_call: FunctionCall) -> str:
         """Convert function call to execute command."""
+        # Build base function invocation, possibly with macro args
+        suffix = ""
+        if func_call.macro_json:
+            suffix = f" {func_call.macro_json}"
+        elif func_call.with_clause:
+            suffix = f" with {func_call.with_clause}"
+
+        base = f"function {func_call.namespace}:{func_call.name}{suffix}"
         if func_call.scope:
-            return f"execute as {func_call.scope.strip('<>')} run function {func_call.namespace}:{func_call.name}"
-        else:
-            return f"function {func_call.namespace}:{func_call.name}"
+            return f"execute as {func_call.scope.strip('<>')} run {base}"
+        return base
     
     def _expression_to_value(self, expression: Any) -> str:
         """Convert expression to a value string."""

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/minecraft_datapack_language/mdl_lexer.py

@@ -79,6 +79,7 @@ class TokenType:
     QUOTE = "QUOTE"                  # " (string literal delimiter)
     EXCLAMATION = "EXCLAMATION"      # ! (for raw blocks)
     RANGE = "RANGE"                  # .. (range operator)
+    DOT = "DOT"                      # . (for paths in with-clause)
     
     # Literals
     IDENTIFIER = "IDENTIFIER"        # Variable names, function names, etc.
@@ -89,6 +90,7 @@ class TokenType:
     EOF = "EOF"
     COMMENT = "COMMENT"              # Comments (ignored during parsing)
     RAW_CONTENT = "RAW_CONTENT"      # Raw content inside raw blocks
+    MACRO_LINE = "MACRO_LINE"        # Entire macro line starting with '$' at line-begin
 
 
 class MDLLexer:
@@ -167,9 +169,9 @@ class MDLLexer:
             self._scan_multi_line_comment()
             return
         
-        # Handle strings (quotes)
-        if char == '"':
-            self._scan_string()
+        # Handle strings (quotes) - support both ' and "
+        if char == '"' or char == "'":
+            self._scan_string(quote_char=char)
             return
         
         # Handle raw block markers
@@ -180,6 +182,11 @@ class MDLLexer:
         
 
         
+        # Handle macro line: '$' as first non-space on the line (not $!raw)
+        if char == '$' and self._is_line_start_nonspace():
+            self._scan_macro_line()
+            return
+
         # Handle variable substitution
         if char == '$':
             self._scan_variable_substitution()
@@ -264,7 +271,7 @@ class MDLLexer:
         # Unterminated comment
         self._error("Unterminated multi-line comment", "Add */ to close the comment")
     
-    def _scan_string(self):
+    def _scan_string(self, quote_char='"'):
         """Scan a string literal (quoted text)."""
         # Skip opening quote
         self.current += 1
@@ -275,7 +282,7 @@ class MDLLexer:
         
         # Scan until closing quote
         while (self.current < len(self.source) and 
-               self.source[self.current] != '"'):
+               self.source[self.current] != quote_char):
             if self.source[self.current] == '\n':
                 self._error("Unterminated string literal", "Add a closing quote")
             
@@ -295,14 +302,34 @@ class MDLLexer:
         self.column += 1
         
         # Generate QUOTE token for the opening quote
-        self.tokens.append(Token(TokenType.QUOTE, '"', start_line, start_column))
+        self.tokens.append(Token(TokenType.QUOTE, quote_char, start_line, start_column))
         
         # Generate IDENTIFIER token for the string content
         string_content = self.source[self.start + 1:self.current - 1]
         self.tokens.append(Token(TokenType.IDENTIFIER, string_content, start_line, start_column + 1))
         
         # Generate QUOTE token for the closing quote
-        self.tokens.append(Token(TokenType.QUOTE, '"', self.line, self.column - 1))
+        self.tokens.append(Token(TokenType.QUOTE, quote_char, self.line, self.column - 1))
+
+    def _is_line_start_nonspace(self) -> bool:
+        """Return True if current position is at the first non-space character in the line."""
+        # Find beginning of current line
+        idx = self.current - 1
+        while idx >= 0 and self.source[idx] != '\n':
+            if not self.source[idx].isspace():
+                return False
+            idx -= 1
+        return True
+
+    def _scan_macro_line(self):
+        """Scan a full macro line starting with '$' as first non-space char."""
+        # Capture from current to end of line (excluding trailing newline)
+        line_start = self.current
+        while self.current < len(self.source) and self.source[self.current] != '\n':
+            self.current += 1
+            self.column += 1
+        content = self.source[line_start:self.current]
+        self.tokens.append(Token(TokenType.MACRO_LINE, content, self.line, 1))
     
     def _scan_raw_block_start(self):
         """Scan the start of a raw block ($!raw)."""
@@ -548,7 +575,8 @@ class MDLLexer:
             '{': TokenType.LBRACE,
             '}': TokenType.RBRACE,
             '[': TokenType.LBRACKET,
-            ']': TokenType.RBRACKET
+            ']': TokenType.RBRACKET,
+            '.': TokenType.DOT
         }
         
         if char in token_map:

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/minecraft_datapack_language/mdl_parser.py

@@ -9,7 +9,7 @@ from .mdl_errors import MDLParserError
 from .ast_nodes import (
     ASTNode, Program, PackDeclaration, NamespaceDeclaration, TagDeclaration,
     VariableDeclaration, VariableAssignment, VariableSubstitution, FunctionDeclaration,
-    FunctionCall, IfStatement, WhileLoop, HookDeclaration, RawBlock,
+    FunctionCall, IfStatement, WhileLoop, HookDeclaration, RawBlock, MacroLine,
     SayCommand, TellrawCommand, ExecuteCommand, ScoreboardCommand,
     BinaryExpression, UnaryExpression, ParenthesizedExpression, LiteralExpression,
     ScopeSelector
@@ -257,7 +257,7 @@ class MDLParser:
         )
     
     def _parse_function_call(self) -> FunctionCall:
-        """Parse function call: exec namespace:name<scope>;"""
+        """Parse function call: exec namespace:name<scope>? [ '{json}' | with <data source> [path] ] ;"""
         self._expect(TokenType.EXEC, "Expected 'exec' keyword")
         
         # Parse namespace:name
@@ -269,13 +269,41 @@ class MDLParser:
         scope = None
         if self._peek().type == TokenType.LANGLE:
             scope = self._parse_scope_selector()
-        
+
+        # Optional macro arguments (inline JSON in a quoted string)
+        macro_json = None
+        with_clause = None
+        if self._peek().type == TokenType.QUOTE:
+            self._advance()  # opening quote
+            if self._peek().type == TokenType.IDENTIFIER:
+                macro_json = self._peek().value
+                self._advance()
+            self._expect(TokenType.QUOTE, "Expected closing quote for macro JSON")
+        elif self._peek().type == TokenType.IDENTIFIER and self._peek().value == 'with':
+            # Capture everything after 'with' up to the semicolon as raw clause
+            self._advance()  # consume 'with'
+            # Expect a data source spec like: storage <identifier> <path-with-dots>
+            # Accumulate tokens until semicolon, inserting spaces only between identifiers/numbers
+            built: List[str] = []
+            prev_type = None
+            while not self._is_at_end() and self._peek().type != TokenType.SEMICOLON:
+                t = self._advance()
+                # Insert a space between adjacent identifiers/numbers
+                if built and (prev_type in (TokenType.IDENTIFIER, TokenType.NUMBER, TokenType.RBRACE, TokenType.RBRACKET)
+                              and t.type in (TokenType.IDENTIFIER, TokenType.NUMBER)):
+                    built.append(" ")
+                built.append(t.value)
+                prev_type = t.type
+            with_clause = "".join(built).strip()
+
         self._expect(TokenType.SEMICOLON, "Expected semicolon after function call")
         
         return FunctionCall(
             namespace=namespace,
             name=name,
-            scope=scope
+            scope=scope,
+            macro_json=macro_json,
+            with_clause=with_clause
         )
     
     def _parse_if_statement(self) -> IfStatement:
@@ -498,6 +526,10 @@ class MDLParser:
                 statements.append(self._parse_while_loop())
             elif self._peek().type == TokenType.EXEC:
                 statements.append(self._parse_function_call())
+            elif self._peek().type == TokenType.MACRO_LINE:
+                # Preserve macro line exactly as-is
+                statements.append(MacroLine(content=self._peek().value))
+                self._advance()
             elif self._peek().type == TokenType.DOLLAR and self._peek(1).type == TokenType.EXCLAMATION:
                 statements.append(self._parse_raw_block())
             elif self._peek().type == TokenType.IDENTIFIER:

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42/minecraft_datapack_language.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: minecraft-datapack-language
-Version: 15.4.41
+Version: 15.4.42
 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-15.4.41 → minecraft_datapack_language-15.4.42}/minecraft_datapack_language.egg-info/SOURCES.txt

@@ -290,6 +290,7 @@ docs/icons/icon-256.png
 docs/icons/icon-512.png
 docs/icons/icon-64.png
 examples/hello_world.mdl
+examples/macros_example.mdl
 examples/scope_examples.mdl
 examples/simple_counter.mdl
 icons/favicon-16.png
@@ -376,6 +377,8 @@ tests/test_codegen_naming_and_logic.py
 tests/test_compiler_fixes.py
 tests/test_complex_scenarios.py
 tests/test_comprehensive_end_to_end.py
+tests/test_examples.py
+tests/test_macros.py
 tests/test_python_api.py
 tests/test_python_bindings.py
 tests/test_user_regression_test1.py

{minecraft_datapack_language-15.4.41 → minecraft_datapack_language-15.4.42}/tests/test_cli.py

@@ -292,6 +292,9 @@ class TestCLIComplexFeatures:
             function test:main<@s> {
                 exec test:helper;
                 exec test:helper<@s>;
+                // Macro calls (inline JSON and with-clause)
+                exec test:helper '{foo:"bar"}';
+                exec test:helper with storage test:ctx args;
             }
             ''')
             

minecraft_datapack_language-15.4.42/tests/test_examples.py

@@ -0,0 +1,43 @@
+import subprocess
+import sys
+from pathlib import Path
+
+
+def test_build_macros_example(tmp_path: Path):
+    # Build the macros example shipped in the repo
+    proj_root = Path(__file__).resolve().parents[1]
+    example = proj_root / "examples" / "macros_example.mdl"
+    assert example.exists()
+
+    out_dir = tmp_path / "out"
+    result = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "minecraft_datapack_language.cli",
+            "build",
+            "--mdl",
+            str(example),
+            "-o",
+            str(out_dir),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stderr
+
+    target_files = list(out_dir.glob("data/macros_ex/**/greeter.mcfunction"))
+    runner_files = list(out_dir.glob("data/macros_ex/**/runner.mcfunction"))
+    assert target_files, "greeter.mcfunction not found"
+    assert runner_files, "runner.mcfunction not found"
+
+    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
+    # 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-15.4.42/tests/test_macros.py

@@ -0,0 +1,58 @@
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+def test_function_macros_exec_and_macro_lines():
+    with tempfile.TemporaryDirectory() as temp_dir:
+        mdl = Path(temp_dir) / "macro_test.mdl"
+        mdl.write_text(
+            (
+                'pack "macrotest" "Macro test" 82;\n'
+                'namespace "macro";\n\n'
+                'function macro:target {\n'
+                '    $say "Hello $(name)"\n'
+                '    say "Done";\n'
+                '}\n\n'
+                'function macro:caller {\n'
+                "    exec macro:target '{name:\"purple elephant\"}';\n"
+                '    exec macro:target with storage macro:ctx data.args;\n'
+                '}\n'
+            )
+        )
+
+        out_dir = Path(temp_dir) / "out"
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "minecraft_datapack_language.cli",
+                "build",
+                "--mdl",
+                str(mdl),
+                "-o",
+                str(out_dir),
+            ],
+            capture_output=True,
+            text=True,
+        )
+        assert result.returncode == 0, result.stderr
+
+        # Find target and caller mcfunction files regardless of singular/plural folder name
+        target_files = list(out_dir.glob("data/macro/**/target.mcfunction"))
+        caller_files = list(out_dir.glob("data/macro/**/caller.mcfunction"))
+        assert target_files, f"target.mcfunction not found in {out_dir!s}"
+        assert caller_files, f"caller.mcfunction not found in {out_dir!s}"
+
+        target_content = target_files[0].read_text()
+        caller_content = caller_files[0].read_text()
+
+        # Macro line should be preserved verbatim
+        assert "$say \"Hello $(name)\"" in target_content
+        # Exec with inline JSON compound
+        assert "function macro:target {name:\"purple elephant\"}" in caller_content
+        # Exec with data source 'with' clause
+        assert "function macro:target with storage macro:ctx data.args" in caller_content
+
+

minecraft_datapack_language-15.4.41/docs/_data/version.yml

@@ -1,3 +0,0 @@
-current: "15.4.40"
-tag: "v15.4.40"
-updated_at: "2025-09-06T06:16:43Z"