machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/parser/tests/test_integer_literal_expressions.py

@@ -0,0 +1,137 @@
+"""Tests for parsing integer literal expressions."""
+
+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 TestWholeNumberLiteralExpressions:
+    """Test cases for parsing integer literal expressions."""
+
+    @pytest.mark.parametrize(
+        "source,expected_value",
+        [
+            # Single digit integers
+            ("0", 0),
+            ("1", 1),
+            ("5", 5),
+            ("9", 9),
+            # Multi-digit integers
+            ("10", 10),
+            ("42", 42),
+            ("123", 123),
+            ("999", 999),
+            # Large integers
+            ("1000", 1000),
+            ("12345", 12345),
+            ("99999", 99999),
+            ("1000000", 1000000),
+            # Edge cases
+            ("2147483647", 2147483647),  # Max 32-bit signed int
+            ("9223372036854775807", 9223372036854775807),  # Max 64-bit signed int
+            # Integers with underscores (one on each side)
+            ("_42_", 42),
+            ("_123_", 123),
+            ("_1_", 1),
+            ("_999_", 999),
+            ("_12345_", 12345),
+            ("_0_", 0),
+        ],
+    )
+    def test_integer_literal_expression(self, source: str, expected_value: int) -> None:
+        """Test parsing various integer literal expressions.
+
+        Args:
+            source: The source code to parse.
+            expected_value: The expected integer value.
+        """
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        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_integer_with_period(self) -> None:
+        """Test parsing integer literal followed by period."""
+        source = "42."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert_program_statements(parser, program)
+
+        statement = program.statements[0]
+        assert isinstance(statement, ExpressionStatement)
+        assert statement.expression is not None
+
+        assert_literal_expression(statement.expression, 42)
+
+    def test_multiple_integer_statements(self) -> None:
+        """Test parsing multiple integer literal statements."""
+        source = "1. 2. 3."
+        parser = Parser()
+
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 3
+
+        # Check each statement
+        for i, expected_value in enumerate([1, 2, 3]):
+            statement = program.statements[i]
+            assert isinstance(statement, ExpressionStatement)
+            assert statement.expression is not None
+            assert_literal_expression(statement.expression, expected_value)
+
+    @pytest.mark.parametrize(
+        "source,error_substring",
+        [
+            # Underscore only on left side
+            ("_42", "_42"),
+            ("_123", "_123"),
+            ("_1", "_1"),
+            # Underscore only on right side
+            ("42_", "42_"),
+            ("123_", "123_"),
+            ("1_", "1_"),
+            # Multiple underscores
+            ("__42__", "__42__"),
+            ("___123___", "___123___"),
+            ("__1__", "__1__"),
+            # Mixed multiple and single
+            ("__42_", "__42_"),
+            ("_42__", "_42__"),
+        ],
+    )
+    def test_invalid_underscore_formats_produce_errors(self, source: str, error_substring: str) -> None:
+        """Test that invalid underscore formats produce lexer errors.
+
+        Args:
+            source: The source code with invalid underscore format.
+            error_substring: Expected substring in the error message.
+        """
+        # Lexer instantiation moved to Parser.parse()
+        parser = Parser()
+
+        # Parse the program (parser collects lexer errors)
+        _ = parser.parse(source)
+
+        # Should have at least one error
+        assert len(parser.errors) >= 1, f"Expected error for invalid format: {source}"
+
+        # Check that the error mentions the invalid token
+        error_messages = [str(error) for error in parser.errors]
+        assert any(error_substring in msg for msg in error_messages), (
+            f"Expected error to mention '{error_substring}', got errors: {error_messages}"
+        )

machine_dialect/parser/tests/test_interaction_statements.py

@@ -0,0 +1,269 @@
+"""Tests for Interaction statements (public methods) in Machine Dialect™."""
+
+from machine_dialect.ast import (
+    BlockStatement,
+    EmptyLiteral,
+    IfStatement,
+    InteractionStatement,
+    Output,
+)
+from machine_dialect.parser import Parser
+
+
+class TestInteractionStatements:
+    """Test parsing of Interaction statements (public methods)."""
+
+    def test_simple_interaction_without_parameters(self) -> None:
+        """Test parsing a simple interaction without parameters."""
+        source = """### **Interaction**: `turn alarm off`
+
+<details>
+<summary>Turns off the alarm when it is on.</summary>
+
+> Define `alarm is on` as Yes/No.
+> Set `alarm is on` to _Yes_.
+> **if** `alarm is on` **then**:
+> >
+> > **Set** `alarm is on` **to** _No_.
+> > Say _"Alarm has been turned off"_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        interaction_stmt = program.statements[0]
+        assert isinstance(interaction_stmt, InteractionStatement)
+        assert interaction_stmt.name.value == "turn alarm off"
+        assert len(interaction_stmt.inputs) == 0
+        assert len(interaction_stmt.outputs) == 0
+        assert isinstance(interaction_stmt.body, BlockStatement)
+
+        # The body should contain define + set + if statement
+        assert len(interaction_stmt.body.statements) == 3
+        if_stmt = interaction_stmt.body.statements[2]
+        assert isinstance(if_stmt, IfStatement)
+
+        # The if statement should have a consequence block with 2 statements
+        assert isinstance(if_stmt.consequence, BlockStatement)
+        assert len(if_stmt.consequence.statements) == 2
+
+    def test_interaction_with_heading_level(self) -> None:
+        """Test that interaction heading level (###) is parsed correctly."""
+        source = """### **Interaction**: `get status`
+
+<details>
+<summary>Returns the current status.</summary>
+
+> Say _"Status: OK"_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        interaction_stmt = program.statements[0]
+        assert isinstance(interaction_stmt, InteractionStatement)
+        assert interaction_stmt.name.value == "get status"
+
+    def test_interaction_with_multi_word_name(self) -> None:
+        """Test interaction with multi-word name in backticks."""
+        source = """### **Interaction**: `check system health`
+
+<details>
+<summary>Checks if the system is healthy.</summary>
+
+> Define `health` as Text.
+> Set `health` to _"Good"_.
+> Say `health`.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        interaction_stmt = program.statements[0]
+        assert isinstance(interaction_stmt, InteractionStatement)
+        assert interaction_stmt.name.value == "check system health"
+
+    def test_interaction_plural_form(self) -> None:
+        """Test that 'Interactions' keyword also works."""
+        source = """### **Interactions**: `say hello`
+
+<details>
+<summary>Greets the user.</summary>
+
+> Say _"Hello!"_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        interaction_stmt = program.statements[0]
+        assert isinstance(interaction_stmt, InteractionStatement)
+        assert interaction_stmt.name.value == "say hello"
+
+    def test_interaction_with_empty_body(self) -> None:
+        """Test interaction with no statements in body."""
+        source = """### **Interaction**: `noop`
+
+<details>
+<summary>No operation.</summary>
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 1
+
+        interaction_stmt = program.statements[0]
+        assert isinstance(interaction_stmt, InteractionStatement)
+        assert interaction_stmt.name.value == "noop"
+        assert len(interaction_stmt.body.statements) == 0
+
+    def test_multiple_interactions(self) -> None:
+        """Test parsing multiple interactions in one program."""
+        source = """### **Interaction**: `start process`
+
+<details>
+<summary>Starts the process.</summary>
+
+> Define `running` as Yes/No.
+> Set `running` to _Yes_.
+
+</details>
+
+### **Interaction**: `stop process`
+
+<details>
+<summary>Stops the process.</summary>
+
+> Define `is_running` as Yes/No.
+> Set `is_running` to _No_.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 2
+
+        first_interaction = program.statements[0]
+        assert isinstance(first_interaction, InteractionStatement)
+        assert first_interaction.name.value == "start process"
+
+        second_interaction = program.statements[1]
+        assert isinstance(second_interaction, InteractionStatement)
+        assert second_interaction.name.value == "stop process"
+
+    def test_interaction_with_parameters(self) -> None:
+        """Test parsing an interaction with input and output parameters."""
+        source = """### **Interaction**: `get user info`
+
+<details>
+<summary>Gets user information.</summary>
+
+> Define `user` as Text.
+> Define `age` as Number.
+> Set `user` to _"John Doe"_.
+> Set `age` to _25_.
+> Give back `user`.
+
+</details>
+
+#### Inputs:
+- `userId` **as** Text (required)
+
+#### Outputs:
+- `user` **as** Text
+- `age` **as** Number"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 1
+
+        interaction_stmt = program.statements[0]
+        assert isinstance(interaction_stmt, InteractionStatement)
+        assert interaction_stmt.name.value == "get user info"
+
+        # Check inputs
+        assert len(interaction_stmt.inputs) == 1
+        input_param = interaction_stmt.inputs[0]
+        assert input_param.name.value == "userId"
+        assert input_param.type_name == "Text"
+        assert input_param.is_required is True
+
+        # Check outputs
+        assert len(interaction_stmt.outputs) == 2
+
+        user_param = interaction_stmt.outputs[0]
+        assert isinstance(user_param, Output)
+        assert user_param.name.value == "user"
+        assert user_param.type_name == "Text"
+        # All outputs have Empty as default when not specified
+        assert isinstance(user_param.default_value, EmptyLiteral)
+
+        age_param = interaction_stmt.outputs[1]
+        assert isinstance(age_param, Output)
+        assert age_param.name.value == "age"
+        assert age_param.type_name == "Number"
+        # All outputs have Empty as default when not specified
+        assert isinstance(age_param.default_value, EmptyLiteral)
+
+    def test_mixed_actions_and_interactions(self) -> None:
+        """Test parsing both actions and interactions in same program."""
+        source = """### **Action**: `internal process`
+
+<details>
+<summary>Internal processing.</summary>
+
+> Define `data` as Text.
+> Set `data` to _"processed"_.
+
+</details>
+
+### **Interaction**: `get data`
+
+<details>
+<summary>Returns processed data.</summary>
+
+> Define `current_data` as Text.
+> Say `current_data`.
+
+</details>"""
+
+        parser = Parser()
+        program = parser.parse(source, check_semantics=False)
+
+        assert len(parser.errors) == 0
+        assert len(program.statements) == 2
+
+        # First should be an Action
+        from machine_dialect.ast import ActionStatement
+
+        action = program.statements[0]
+        assert isinstance(action, ActionStatement)
+        assert action.name.value == "internal process"
+
+        # Second should be an Interaction
+        interaction = program.statements[1]
+        assert isinstance(interaction, InteractionStatement)
+        assert interaction.name.value == "get data"

machine_dialect/parser/tests/test_list_literals.py

@@ -0,0 +1,277 @@
+"""Test parsing of list literals (unordered, ordered, and named)."""
+
+import pytest
+
+from machine_dialect.ast import (
+    FloatLiteral,
+    NamedListLiteral,
+    OrderedListLiteral,
+    SetStatement,
+    StringLiteral,
+    UnorderedListLiteral,
+    WholeNumberLiteral,
+)
+from machine_dialect.parser import Parser
+
+
+class TestUnorderedLists:
+    """Test parsing of unordered lists (dash-prefixed)."""
+
+    def test_simple_unordered_list(self) -> None:
+        """Test parsing a simple unordered list."""
+        source = """
+Define `fruits` as an unordered list.
+Set `fruits` to:
+- _"apple"_.
+- _"banana"_.
+- _"cherry"_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2  # Define and Set statements
+
+        set_stmt = program.statements[1]  # Second statement is the Set
+        assert isinstance(set_stmt, SetStatement)
+        assert set_stmt.name and set_stmt.name.value == "fruits"
+
+        # Check the list literal
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, UnorderedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.elements) == 3
+
+        # Check elements
+        assert isinstance(list_literal.elements[0], StringLiteral)
+        assert list_literal.elements[0].value == "apple"
+        assert isinstance(list_literal.elements[1], StringLiteral)
+        assert list_literal.elements[1].value == "banana"
+        assert isinstance(list_literal.elements[2], StringLiteral)
+        assert list_literal.elements[2].value == "cherry"
+
+    def test_mixed_type_unordered_list(self) -> None:
+        """Test parsing an unordered list with mixed types."""
+        source = """
+Define `mixed` as unordered list.
+Set `mixed` to:
+- _"text"_.
+- _42_.
+- _3.14_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        set_stmt = program.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+
+        # Check the list literal
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, UnorderedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.elements) == 3
+
+        # Check mixed types
+        assert isinstance(list_literal.elements[0], StringLiteral)
+        assert list_literal.elements[0].value == "text"
+        assert isinstance(list_literal.elements[1], WholeNumberLiteral)
+        assert list_literal.elements[1].value == 42
+        assert isinstance(list_literal.elements[2], FloatLiteral)
+        assert list_literal.elements[2].value == 3.14
+
+    def test_list_with_negative_numbers(self) -> None:
+        """Test that lists can contain negative numbers."""
+        source = """
+Define `numbers` as unordered list.
+Set `numbers` to:
+- _-5_.
+- _10_.
+- _-3.14_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        set_stmt = program.statements[1]
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, UnorderedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.elements) == 3
+
+        # Check negative numbers
+        assert isinstance(list_literal.elements[0], WholeNumberLiteral)
+        assert list_literal.elements[0].value == -5
+        assert isinstance(list_literal.elements[1], WholeNumberLiteral)
+        assert list_literal.elements[1].value == 10
+        assert isinstance(list_literal.elements[2], FloatLiteral)
+        assert list_literal.elements[2].value == -3.14
+
+
+class TestOrderedLists:
+    """Test parsing of ordered lists (numbered)."""
+
+    def test_simple_ordered_list(self) -> None:
+        """Test parsing a simple ordered list."""
+        source = """
+Define `steps` as ordered list.
+Set `steps` to:
+1. _"First step"_.
+2. _"Second step"_.
+3. _"Third step"_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        set_stmt = program.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+        assert set_stmt.name and set_stmt.name.value == "steps"
+
+        # Check the list literal
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, OrderedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.elements) == 3
+
+        # Check elements
+        assert isinstance(list_literal.elements[0], StringLiteral)
+        assert list_literal.elements[0].value == "First step"
+        assert isinstance(list_literal.elements[1], StringLiteral)
+        assert list_literal.elements[1].value == "Second step"
+        assert isinstance(list_literal.elements[2], StringLiteral)
+        assert list_literal.elements[2].value == "Third step"
+
+    def test_non_sequential_ordered_list(self) -> None:
+        """Test that ordered lists can have non-sequential numbers."""
+        source = """
+Define `priorities` as ordered list.
+Set `priorities` to:
+1. _"High priority"_.
+5. _"Medium priority"_.
+10. _"Low priority"_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        set_stmt = program.statements[1]
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, OrderedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.elements) == 3
+
+
+class TestNamedLists:
+    """Test parsing of named lists (dictionaries)."""
+
+    def test_simple_named_list(self) -> None:
+        """Test parsing a simple named list."""
+        source = """
+Define `person` as named list.
+Set `person` to:
+- _"name"_: _"Alice"_.
+- _"profession"_: _"Software Engineer"_.
+- _"age"_: _30_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        assert len(parser.errors) == 0, f"Parser errors: {parser.errors}"
+        assert len(program.statements) == 2
+
+        set_stmt = program.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+        assert set_stmt.name and set_stmt.name.value == "person"
+
+        # Check the list literal
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, NamedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.entries) == 3
+
+        # Check name-value pairs
+        assert list_literal.entries[0][0] == "name"
+        assert isinstance(list_literal.entries[0][1], StringLiteral)
+        assert list_literal.entries[0][1].value == "Alice"
+
+        assert list_literal.entries[1][0] == "profession"
+        assert isinstance(list_literal.entries[1][1], StringLiteral)
+        assert list_literal.entries[1][1].value == "Software Engineer"
+
+        assert list_literal.entries[2][0] == "age"
+        assert isinstance(list_literal.entries[2][1], WholeNumberLiteral)
+        assert list_literal.entries[2][1].value == 30
+
+
+class TestListParsingErrors:
+    """Test error handling in list parsing."""
+
+    @pytest.mark.parametrize(
+        "source",
+        [
+            """
+            Define `mixed` as list.
+            Set `mixed` to:
+            - _"unordered item"_.
+            1. _"ordered item"_.
+            """,
+            """
+            Define `mixed` as list.
+            Set `mixed` to:
+            1. _"unordered item"_.
+            - _"ordered item"_.
+            """,
+        ],
+    )
+    def test_mixed_list_types_not_allowed(self, source: str) -> None:
+        """Test that mixing list types is not allowed."""
+        parser = Parser()
+        program = parser.parse(source)
+
+        # The parser should handle mixed list types gracefully
+        # It may produce an error expression or a partial list
+        assert len(program.statements) >= 2  # At least Define and Set
+
+        set_stmt = program.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+
+        # Check what the parser produced
+        if hasattr(set_stmt, "value"):
+            # If it's an ErrorExpression, that's acceptable
+            from machine_dialect.ast import ErrorExpression
+
+            if isinstance(set_stmt.value, ErrorExpression):
+                # Parser correctly identified an error
+                pass
+            elif isinstance(set_stmt.value, UnorderedListLiteral | OrderedListLiteral):
+                # Parser created a list with only the consistent items
+                list_literal = set_stmt.value
+                # Should have at most the first type's items
+                assert len(list_literal.elements) <= 1
+
+        # The main requirement is that the parser doesn't crash
+        # and produces some reasonable output
+        assert program is not None
+
+    def test_incomplete_named_list(self) -> None:
+        """Test parsing incomplete named list elements."""
+        source = """
+Define `incomplete` as named list.
+Set `incomplete` to:
+- "name": _"test"_.
+"""
+        parser = Parser()
+        program = parser.parse(source)
+
+        # Should still create a named list
+        assert len(program.statements) == 2
+        set_stmt = program.statements[1]
+        assert isinstance(set_stmt, SetStatement)
+
+        # Should be a named list with error for missing content
+        assert hasattr(set_stmt, "value") and isinstance(set_stmt.value, NamedListLiteral)
+        list_literal = set_stmt.value
+        assert len(list_literal.entries) == 1