machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_action_statements.py

@@ -0,0 +1,334 @@
+"""Tests for Action statements (private methods) in Machine Dialect™."""
+
+from machine_dialect.ast import ActionStatement, BlockStatement, EmptyLiteral, Output, SetStatement
+from machine_dialect.parser import Parser
+
+
+class TestActionStatements:
+    """Test parsing of Action statements (private methods)."""
+
+    def test_simple_action_without_parameters(self) -> None:
+        """Test parsing a simple action without parameters."""
+        source = """### **Action**: `make noise`
+
+<details>
+<summary>Emits the sound of the alarm.</summary>
+
+> Define `noise` as Text.
+> Set `noise` to _"WEE-OO WEE-OO WEE-OO"_.
+> Say `noise`.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "make noise"
+        assert len(action_stmt.inputs) == 0
+        assert len(action_stmt.outputs) == 0
+        assert isinstance(action_stmt.body, BlockStatement)
+        assert len(action_stmt.body.statements) == 3
+
+        # Check first statement: Define `noise` as Text.
+        from machine_dialect.ast import DefineStatement
+
+        define_stmt = action_stmt.body.statements[0]
+        assert isinstance(define_stmt, DefineStatement)
+        assert define_stmt.name.value == "noise"
+
+        # Check second statement: Set `noise` to _"WEE-OO WEE-OO WEE-OO"_.
+        set_stmt = action_stmt.body.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+        assert set_stmt.name and set_stmt.name.value == "noise"
+
+        # Check third statement: Say `noise`.
+        say_stmt = action_stmt.body.statements[2]
+        from machine_dialect.ast import SayStatement
+
+        assert isinstance(say_stmt, SayStatement)
+
+    def test_action_with_heading_level(self) -> None:
+        """Test that action heading level (###) is parsed correctly."""
+        source = """### **Action**: `calculate`
+
+<details>
+<summary>Performs a calculation.</summary>
+
+> Define `result` as Whole Number.
+> Set `result` to _42_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "calculate"
+
+    def test_action_with_multi_word_name(self) -> None:
+        """Test action with multi-word name in backticks."""
+        source = """### **Action**: `send alert message`
+
+<details>
+<summary>Sends an alert.</summary>
+
+> Say _"Alert!"_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "send alert message"
+
+    def test_action_plural_form(self) -> None:
+        """Test that 'Actions' keyword also works."""
+        source = """### **Actions**: `make noise`
+
+<details>
+<summary>Emits sound.</summary>
+
+> Say _"Noise"_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "make noise"
+
+    def test_action_with_empty_body(self) -> None:
+        """Test action with no statements in body."""
+        source = """### **Action**: `do nothing`
+
+<details>
+<summary>Does nothing.</summary>
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "do nothing"
+        assert len(action_stmt.body.statements) == 0
+
+    def test_multiple_actions(self) -> None:
+        """Test parsing multiple actions in one program."""
+        source = """### **Action**: `first action`
+
+<details>
+<summary>First action.</summary>
+
+> Define `x` as Whole Number.
+> Set `x` to _1_.
+
+</details>
+
+### **Action**: `second action`
+
+<details>
+<summary>Second action.</summary>
+
+> Define `y` as Whole Number.
+> Set `y` to _2_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 2
+
+        first_action = program.statements[0]
+        assert isinstance(first_action, ActionStatement)
+        assert first_action.name.value == "first action"
+
+        second_action = program.statements[1]
+        assert isinstance(second_action, ActionStatement)
+        assert second_action.name.value == "second action"
+
+    def test_action_with_input_parameters(self) -> None:
+        """Test parsing an action with input parameters."""
+        source = """### **Action**: `make noise`
+
+<details>
+<summary>Emits the sound of the alarm.</summary>
+
+> Define `noise` as Text.
+> Set `noise` to `sound`.
+> Say `noise`.
+
+</details>
+
+#### Inputs:
+- `sound` **as** Text (required)
+- `volume` **as** Whole Number (optional, default: _60_)"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "make noise"
+
+        # Check inputs
+        assert len(action_stmt.inputs) == 2
+
+        # First input: sound (required)
+        sound_param = action_stmt.inputs[0]
+        assert sound_param.name.value == "sound"
+        assert sound_param.type_name == "Text"
+        assert sound_param.is_required is True
+        assert sound_param.default_value is None
+
+        # Second input: volume (optional with default)
+        volume_param = action_stmt.inputs[1]
+        assert volume_param.name.value == "volume"
+        assert volume_param.type_name == "Whole Number"
+        assert volume_param.is_required is False
+        assert volume_param.default_value is not None
+        from machine_dialect.ast import WholeNumberLiteral
+
+        assert isinstance(volume_param.default_value, WholeNumberLiteral)
+        assert volume_param.default_value.value == 60
+
+        # No outputs
+        assert len(action_stmt.outputs) == 0
+
+    def test_action_with_output_parameters(self) -> None:
+        """Test parsing an action with output parameters."""
+        source = """### **Action**: `calculate`
+
+<details>
+<summary>Performs a calculation.</summary>
+
+> Define `result` as Number.
+> Set `result` to _42_.
+> Give back `result`.
+
+</details>
+
+#### Outputs:
+- `result` **as** Number
+- `success` **as** Yes/No"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "calculate"
+
+        # No inputs
+        assert len(action_stmt.inputs) == 0
+
+        # Check outputs
+        assert len(action_stmt.outputs) == 2
+
+        # First output: result
+        result_param = action_stmt.outputs[0]
+        assert isinstance(result_param, Output)
+        assert result_param.name.value == "result"
+        assert result_param.type_name == "Number"
+
+        # Second output: success
+        success_param = action_stmt.outputs[1]
+        assert isinstance(success_param, Output)
+        assert success_param.name.value == "success"
+        assert success_param.type_name == "Yes/No"
+
+    def test_action_with_both_inputs_and_outputs(self) -> None:
+        """Test parsing an action with both input and output parameters."""
+        source = """### **Action**: `process data`
+
+<details>
+<summary>Processes input data.</summary>
+
+> Define `result` as Text.
+> Set `result` to `input`.
+> Give back `result`.
+
+</details>
+
+#### Inputs:
+- `input` **as** Text (required)
+- `format` **as** Text (optional, default: _"json"_)
+
+#### Outputs:
+- `result` **as** Text
+- `error` **as** Text"""
+
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        action_stmt = program.statements[0]
+        assert isinstance(action_stmt, ActionStatement)
+        assert action_stmt.name.value == "process data"
+
+        # Check inputs
+        assert len(action_stmt.inputs) == 2
+
+        input_param = action_stmt.inputs[0]
+        assert input_param.name.value == "input"
+        assert input_param.type_name == "Text"
+        assert input_param.is_required is True
+
+        format_param = action_stmt.inputs[1]
+        assert format_param.name.value == "format"
+        assert format_param.type_name == "Text"
+        assert format_param.is_required is False
+        assert format_param.default_value is not None
+        from machine_dialect.ast import StringLiteral
+
+        assert isinstance(format_param.default_value, StringLiteral)
+        assert format_param.default_value.value == "json"
+
+        # Check outputs
+        assert len(action_stmt.outputs) == 2
+
+        result_param = action_stmt.outputs[0]
+        assert isinstance(result_param, Output)
+        assert result_param.name.value == "result"
+        assert result_param.type_name == "Text"
+
+        error_param = action_stmt.outputs[1]
+        assert isinstance(error_param, Output)
+        assert error_param.name.value == "error"
+        assert error_param.type_name == "Text"
+        # Outputs without explicit defaults should have Empty as default
+        assert error_param.default_value is not None
+        assert isinstance(error_param.default_value, EmptyLiteral)

machine_dialect/parser/tests/test_boolean_literal_expressions.py

@@ -0,0 +1,152 @@
+"""Tests for parsing boolean literal expressions.
+
+This module tests the parser's ability to handle boolean literal expressions
+including Yes and No in both regular and underscore-wrapped forms.
+"""
+
+import pytest
+
+from machine_dialect.ast import ExpressionStatement
+from machine_dialect.parser import Parser
+from machine_dialect.parser.tests.helper_functions import (
+    assert_literal_expression,
+    assert_program_statements,
+)
+
+
+class TestBooleanLiteralExpressions:
+    """Test parsing of boolean literal expressions."""
+
+    @pytest.mark.parametrize(
+        "source,expected_value",
+        [
+            # Simple boolean literals
+            ("Yes", True),
+            ("No", False),
+            # Underscore-wrapped boolean literals
+            ("_Yes_", True),
+            ("_No_", False),
+        ],
+    )
+    def test_boolean_literal_expression(self, source: str, expected_value: bool) -> None:
+        """Test parsing various boolean literal expressions.
+
+        Args:
+            source: The source code containing a boolean literal.
+            expected_value: The expected boolean value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, expected_value)
+
+    def test_boolean_with_period(self) -> None:
+        """Test parsing boolean literal with explicit statement terminator."""
+        source = "Yes."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, True)
+
+    def test_multiple_boolean_statements(self) -> None:
+        """Test parsing multiple boolean literal statements."""
+        source = "Yes. No. Yes. No."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 4
+
+        # Check each statement
+        expected_values = [True, False, True, False]
+        for i, expected_value in enumerate(expected_values):
+            statement = program.statements[i]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+            assert_literal_expression(statement.expression, expected_value)
+
+    def test_mixed_literals_with_booleans(self) -> None:
+        """Test parsing mixed literal types including booleans."""
+        source = "Yes. 42. No. 3.14. _Yes_."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 5
+
+        # Check boolean statements
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert_literal_expression(statement.expression, True)
+
+        statement = program.statements[2]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert_literal_expression(statement.expression, False)
+
+        statement = program.statements[4]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+        assert_literal_expression(statement.expression, True)
+
+    @pytest.mark.parametrize(
+        "source,expected_value",
+        [
+            # Case insensitive variations should all parse as True
+            ("yes", True),
+            ("YES", True),
+            ("YeS", True),
+            ("yEs", True),
+            # Case insensitive variations should all parse as False
+            ("no", False),
+            ("NO", False),
+            ("No", False),
+            ("nO", False),
+            # Underscore-wrapped case variations
+            ("_yes_", True),
+            ("_YES_", True),
+            ("_no_", False),
+            ("_NO_", False),
+        ],
+    )
+    def test_case_insensitive_boolean_literals(self, source: str, expected_value: bool) -> None:
+        """Test that boolean literals are case-insensitive.
+
+        Boolean literals should be recognized regardless of case and stored
+        in their canonical form as defined in tokens.py.
+
+        Args:
+            source: The source code with various case boolean literals.
+            expected_value: The expected boolean value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, expected_value)

machine_dialect/parser/tests/test_call_statements.py

@@ -0,0 +1,154 @@
+"""Tests for use statements in Machine Dialect™."""
+
+from machine_dialect.ast import (
+    Arguments,
+    CallStatement,
+    Identifier,
+    StringLiteral,
+    WholeNumberLiteral,
+)
+from machine_dialect.parser import Parser
+
+
+class TestCallStatements:
+    """Test parsing of use statements."""
+
+    def test_call_without_parameters(self) -> None:
+        """Test parsing a use statement without parameters."""
+        source = "use `turn alarm off`."
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        assert isinstance(call_stmt.function_name, Identifier)
+        assert call_stmt.function_name.value == "turn alarm off"
+        assert call_stmt.arguments is None
+
+    def test_call_with_positional_arguments(self) -> None:
+        """Test parsing a use statement with positional arguments."""
+        source = "use `add numbers` with _5_, _10_."
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        assert isinstance(call_stmt.function_name, Identifier)
+        assert call_stmt.function_name.value == "add numbers"
+
+        assert call_stmt.arguments is not None
+        assert isinstance(call_stmt.arguments, Arguments)
+        # Should have 2 positional arguments
+        assert len(call_stmt.arguments.positional) == 2
+        assert len(call_stmt.arguments.named) == 0
+
+        # First argument
+        assert isinstance(call_stmt.arguments.positional[0], WholeNumberLiteral)
+        assert call_stmt.arguments.positional[0].value == 5
+
+        # Second argument
+        assert isinstance(call_stmt.arguments.positional[1], WholeNumberLiteral)
+        assert call_stmt.arguments.positional[1].value == 10
+
+    def test_call_with_named_arguments(self) -> None:
+        """Test parsing a use statement with named arguments."""
+        source = 'use `make noise` where `sound` is _"WEE-OO WEE-OO WEE-OO"_, `volume` is _80_.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        assert isinstance(call_stmt.function_name, Identifier)
+        assert call_stmt.function_name.value == "make noise"
+
+        assert call_stmt.arguments is not None
+        assert isinstance(call_stmt.arguments, Arguments)
+        # Should have 2 named arguments
+        assert len(call_stmt.arguments.positional) == 0
+        assert len(call_stmt.arguments.named) == 2
+
+        # First named argument: sound
+        name0, val0 = call_stmt.arguments.named[0]
+        assert isinstance(name0, Identifier)
+        assert name0.value == "sound"
+        assert isinstance(val0, StringLiteral)
+        assert val0.value == "WEE-OO WEE-OO WEE-OO"
+
+        # Second named argument: volume
+        name1, val1 = call_stmt.arguments.named[1]
+        assert isinstance(name1, Identifier)
+        assert name1.value == "volume"
+        assert isinstance(val1, WholeNumberLiteral)
+        assert val1.value == 80
+
+    def test_call_with_identifier_as_function_name(self) -> None:
+        """Test parsing a use statement with an identifier as the function name."""
+        source = 'use `my_function` with _"test"_.'
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        call_stmt = program.statements[0]
+        assert isinstance(call_stmt, CallStatement)
+        assert isinstance(call_stmt.function_name, Identifier)
+        assert call_stmt.function_name.value == "my_function"
+
+    def test_call_without_period(self) -> None:
+        """Test that use statement without period fails."""
+        source = "use `my_function`"
+
+        parser = Parser()
+        parser.parse(source)
+
+        # Should have an error about missing period
+        assert len(parser.errors) > 0
+        assert any("period" in str(err).lower() for err in parser.errors)
+
+    def test_multiple_call_statements(self) -> None:
+        """Test parsing multiple use statements."""
+        source = """use `start process`.
+use `log message` with _"Process started"_.
+use `stop process`.
+"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 3
+
+        # First call
+        call1 = program.statements[0]
+        assert isinstance(call1, CallStatement)
+        assert isinstance(call1.function_name, Identifier)
+        assert call1.function_name.value == "start process"
+        assert call1.arguments is None
+
+        # Second call
+        call2 = program.statements[1]
+        assert isinstance(call2, CallStatement)
+        assert isinstance(call2.function_name, Identifier)
+        assert call2.function_name.value == "log message"
+        assert call2.arguments is not None
+
+        # Third call
+        call3 = program.statements[2]
+        assert isinstance(call3, CallStatement)
+        assert isinstance(call3.function_name, Identifier)
+        assert call3.function_name.value == "stop process"
+        assert call3.arguments is None