scrall 0.9.0__tar.gz → 0.12.2__tar.gz

{scrall-0.9.0/src/scrall.egg-info → scrall-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrall
-Version: 0.9.0
+Version: 0.12.2
 Summary: Starr's Concise Relational Action Language - For Shlaer-Mellor Executable UML
 Author-email: Leon Starr <leon_starr@modelint.com>
 License: MIT License

{scrall-0.9.0 → scrall-0.12.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrall"
-version = "0.9.0"
+version = "0.12.2"
 description = "Starr's Concise Relational Action Language - For Shlaer-Mellor Executable UML"
 readme = "README.md"
 authors = [{ name = "Leon Starr", email = "leon_starr@modelint.com" }]

scrall-0.12.2/src/scrall/__init__.py

@@ -0,0 +1 @@
+version = "0.12.2"

{scrall-0.9.0 → scrall-0.12.2}/src/scrall/parse/scrall.peg

@@ -1,5 +1,5 @@
 activity = LINEWRAP* execution_unit* EOF
-execution_unit = LINEWRAP* statement_set sequence_token? LINEWRAP+
+execution_unit = LINEWRAP* statement_set sequence_token? (SP+ / LINEWRAP*)
 statement_set = SP* sequenced_statement_set / component_statement_set
 sequenced_statement_set = sequence_token* (block / statement)
 component_statement_set = block / LINEWRAP* statement
@@ -44,15 +44,15 @@ RENAME = '>>'
 
 // Decision action
 decision = scalar_expr true_result false_result?
-true_result = DECISION_OP LINEWRAP? SP? component_statement_set
-false_result = SP FALSE_RESULT_OP LINEWRAP? SP? component_statement_set // Else
+true_result = DECISION_OP LINEWRAP? SP? component_statement_set SP*
+false_result = FALSE_RESULT_OP LINEWRAP? SP? component_statement_set // Else
 FALSE_RESULT_OP = ':'
 
 // Switch action
 switch = switch_input DECISION_OP SP* case_block // Boolean expr triggers case_block
 switch_input = rnum / scalar_expr
 case_block = '{' LINEWRAP* case+ LINEWRAP*'}'
-case = LINEWRAP* trigger_set? ':' LINEWRAP* component_statement_set
+case = LINEWRAP* trigger_set? ':' (SP+ / LINEWRAP*) component_statement_set
 trigger_set = enum_value (',' SP+ enum_value)* SP*
 enum_value = '_' name // Scalar switch has enum value cases
 DECISION_OP = '?'
@@ -74,9 +74,9 @@ inst_assignment = flow_output SP+ INST_ASSIGN SP+ instance_set
 INST_ASSIGN = '.=' / '..='
 
 // Synchronous call action (method or ee operation or type operation)
-call = ('~' / instance_set) op_chain? // Post-parse verify that last element is an operation, otherwise invalid call
+call = instance_set op_chain? // Post-parse verify that last element is an operation, otherwise invalid call
 operation = owner? '.' name supplied_params
-owner = name
+owner = '~' / name
 supplied_params = '(' SP* (param (',' SP+ param)*)? SP* ')'
 param = (name SP* ':' SP*)? scalar_expr // Comma above keeps scalar_expr from grabbing next param
 
@@ -105,7 +105,8 @@ ITS = 'ITS'
 // Creation, deletion and references
 new_instance = '*' new_inst_init // create an instance of a class as an action
 new_lineage = '*[' SP* new_inst_init (';' SP+ new_inst_init)+ SP* ']' // create all instances of a lineage
-new_inst_init = name attr_init? (SP+ to_ref)* // specify class, attr inits, and any required references
+new_inst_init = name attr_init? (SP+ to_ref)* (SP+ to_state)? // specify class, attr inits, and any required references
+to_state = '>' SP* name
 attr_init = '(' SP* (attr_value_init (',' SP+ attr_value_init)* SP*)? ')' // all attrs to init for a new instance
 attr_value_init = (name SP? ':' SP+ scalar_expr )*
 update_ref = (instance_set SP+)? to_ref // relate or unrelated to me or explicit instance_set
@@ -118,7 +119,7 @@ delete = '!*' SP* instance_set (',' SP+ instance_set)* // supports multi-delete
 // Scalar assignment
 scalar_assignment = scalar_output_set SP* SCALAR_ASSIGN SP* scalar_expr projection? (',' SP* scalar_expr projection?)*
 scalar_output_set = qualified_name / flow_output (',' SP+ flow_output)*
-qualified_name = name '.' name
+qualified_name = (name / instance_set) '.' name
 flow_output = name (TYPE_ASSIGN name)?
 projection = '.' (name / '(' ( (ALL / (name (',' SP+ name)*) )? ')')) // TODO: Why is empty () ok in projection?
 ALL = '*'

{scrall-0.9.0 → scrall-0.12.2}/src/scrall/parse/visitor.py

@@ -42,11 +42,11 @@ BOOL_a = namedtuple('BOOL_a', 'op operands')
 Scalar_Assignment_a = namedtuple('Scalar_Assignment_a', 'lhs rhs')
 Table_Assignment_a = namedtuple('Table_Assignment_a', 'type assign_tuple lhs rhs X')
 Scalar_RHS_a = namedtuple('Scalar_RHS_a', 'expr attrs')
-Qualified_Name_a = namedtuple('Qualified_Name_a', 'cname aname')
+Qualified_Name_a = namedtuple('Qualified_Name_a', 'iset cname aname')
 Flow_Output_a = namedtuple('Flow_Output_a', 'name exp_type')
 PATH_a = namedtuple('PATH_a', 'hops')
 INST_a = namedtuple('INST_a', 'components')
-INST_PROJ_a = namedtuple('INST_PROJ_a', 'iset projection')
+INST_PROJ_a = namedtuple('INST_PROJ_a', 'iset projection op_chain')
 TEXPR_a = namedtuple('TEXPR_a', 'table hexpr selection projection')
 R_a = namedtuple('R_a', 'rnum')
 IN_a = namedtuple('IN_a', 'name')
@@ -60,7 +60,7 @@ Type_expr_a = namedtuple('Type_expr_a', 'type selector')
 Attr_value_init_a = namedtuple('Attr_value_init_a', 'attr scalar_expr')
 To_ref_a = namedtuple('To_ref_a', 'rnum iset1 iset2')
 Update_ref_a = namedtuple('Update_ref_a', 'iset to_ref')
-New_inst_a = namedtuple('New_inst_a', 'cname attrs rels')
+New_inst_a = namedtuple('New_inst_a', 'cname attrs rels state')
 New_lineage_a = namedtuple('New_lineage_a', 'inits')
 Output_Flow_a = namedtuple('Output_Flow_a', 'output')
 Projection_a = namedtuple('Projection_a', 'expand attrs')
@@ -157,7 +157,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"< {children}")
-        result = [c for c in children if c]
+        result = children[:]
         _logger.info(f"  -> {result}")
         return result
 
@@ -239,7 +239,7 @@ class ScrallVisitor(PTNodeVisitor):
 
         _logger.info(f"  < {children}")
         _logger.info(f"  > pass")
-        return children
+        return children[:]  # Removes the result component
 
     @classmethod
     def visit_statement(cls, node, children):
@@ -333,7 +333,7 @@ class ScrallVisitor(PTNodeVisitor):
 
         _logger.info(f"  < {children}")
         _logger.info("  > pass")
-        return children
+        return children[:]
 
     @classmethod
     def visit_attr_type_def(cls, node, children):
@@ -354,7 +354,7 @@ class ScrallVisitor(PTNodeVisitor):
 
         _logger.info(f"  < {children}")
         _logger.info(f"  > pass")
-        return children
+        return children[:]
 
     @classmethod
     def visit_row(cls, node, children):
@@ -376,7 +376,7 @@ class ScrallVisitor(PTNodeVisitor):
 
         _logger.info(f"  < {children}")
         _logger.info(f"  > pass")
-        return children
+        return children[:]
 
     # Implicit table assignment
     @classmethod
@@ -483,7 +483,7 @@ class ScrallVisitor(PTNodeVisitor):
 
         _logger.info(f"  < {children}")
         _logger.info(f"  > pass")
-        return children
+        return children[:]
 
     @classmethod
     def visit_column_op(cls, node, children):
@@ -592,7 +592,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = children
+        result = children[:]
         _logger.info(f"  > {result}")
         return result
 
@@ -635,14 +635,6 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f"  > {result}")
         return result
 
-    # # Asynch service
-    # @classmethod
-    # def visit_asynch_service(cls, node, children):
-    #     """
-    #     name '.' signal_spec ASYNCH ee
-    #     """
-    #     result = Asynch_a(*children)
-
     @classmethod
     def visit_signal_action(cls, node, children):
         """
@@ -685,7 +677,8 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        params = children.results.get('supplied_params', [])
+        params = children.results.get('supplied_params')
+        params = params[0] if params else []
         result = {'name': children[0].name, 'params': params}
         _logger.info(f"  > {result}")
         return result
@@ -789,7 +782,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = children
+        result = children[:]
         _logger.info(f"  > {result}")
         return result
 
@@ -840,13 +833,23 @@ class ScrallVisitor(PTNodeVisitor):
         owner = children.results.get('owner')
         p = children.results.get('supplied_params')
         result = Op_a(
-            owner='implicit' if not owner else owner[0],
+            owner='_implicit' if not owner else owner[0],
             op_name=children.results['name'][0].name,
             supplied_params=[] if not p else p[0]
         )
         _logger.info(f"  > {result}")
         return result
 
+    @classmethod
+    def visit_owner(cls, node, children):
+        """
+        '~' / name
+        """
+        name = children.results.get('name')
+        # This is either ~ signifying an external service or a single instance flow (instance set)
+        result = name[0].name if name else '_external'
+        return result
+
     @classmethod
     def visit_supplied_params(cls, node, children):
         """
@@ -856,7 +859,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = children if children else []
+        result = children[:]
         _logger.info(f"  > {result}")
         return result
 
@@ -906,7 +909,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = Iteration_a(*children)
+        result = Iteration_a(*children)  # TODO: Check this for inclusion of results member
         _logger.info(f"  > {result}")
         return result
 
@@ -947,7 +950,7 @@ class ScrallVisitor(PTNodeVisitor):
                 # Just like above case, but returning an IN_a (parameter name)
                 result = p[0]
             else:
-                result = INST_a(children)
+                result = INST_a(children[:])
         _logger.info(f"  > {result}")
         return result
 
@@ -1015,7 +1018,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = New_lineage_a(children)
+        result = New_lineage_a(children[:])
         _logger.info(f"  > {result}")
         return result
 
@@ -1030,10 +1033,25 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f"  < {children}")
         a = children.results.get('attr_init')
         r = children.results.get('to_ref')
-        result = New_inst_a(cname=children[0], attrs=a[0] if a else [], rels=None if not r else r)
+        s = children.results.get('to_state')
+        result = New_inst_a(cname=children[0], attrs=a[0] if a else [], rels=None if not r else r,
+                            state=s[0].name if s else None)
         _logger.info(f"  > {result}")
         return result
 
+    @classmethod
+    def visit_to_state(cls, node, children):
+        """
+        '>' SP* name
+        """
+        _logger.info("to_state = '>' SP* name")
+        _logger.info(f'  :: {node.value}')
+
+        _logger.info(f"  < {children}")
+        result = children[0]
+        return result
+
+
     @classmethod
     def visit_attr_init(cls, node, children):
         """
@@ -1112,7 +1130,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = Scalar_Call_a(children)
+        result = Scalar_Call_a(children[:])
         _logger.info(f"  > {result}")
         return result
 
@@ -1136,10 +1154,21 @@ class ScrallVisitor(PTNodeVisitor):
     @classmethod
     def visit_qualified_name(cls, node, children):
         """
+        (name / instance_set) '.' name
         """
         _logger.info("qualified_name = name '.' name")
         _logger.info(f'  :: {node.value}')
-        return Qualified_Name_a(cname=children[0].name, aname=children[1].name)
+        iset = children.results.get('instance_set')
+        names = children.results.get('name')
+        if iset:
+            # iset takes the place of cname
+            # iset.attribute -- /R4/Door.Lock request
+            aname = names[0].name
+            cname = None
+        else:
+            # class.attribute -- Door.Lock request
+            cname, aname = names[0].name, names[1].name
+        return Qualified_Name_a(iset=iset, cname=cname, aname=aname)
 
     @classmethod
     def visit_scalar_output_set(cls, node, children):
@@ -1149,7 +1178,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = children
+        result = children[:]
         _logger.info(f"  > {result}")
         return result
 
@@ -1417,7 +1446,8 @@ class ScrallVisitor(PTNodeVisitor):
             _logger.info(f"  > {result}")
             return result
 
-        if len(children) == 1 and (isinstance(children[0], N_a) or (isinstance(children[0], IN_a))):
+        if len(children) == 1 and (isinstance(children[0], N_a) or (isinstance(children[0], IN_a)) or
+                                   isinstance(children[0], Type_expr_a)):
             result = children[0]
             _logger.info(f"  > {result}")
             return result
@@ -1426,12 +1456,13 @@ class ScrallVisitor(PTNodeVisitor):
         iset = children.results.get('instance_set')
         if iset:
             p = children.results.get('projection')
-            result = INST_PROJ_a(iset=iset[0], projection=None if not p else p[0])
+            o = children.results.get('op_chain')
+            op_chain = None if not o else o[0]
+            result = INST_PROJ_a(iset=iset[0], projection=None if not p else p[0], op_chain=op_chain)
             _logger.info(f"  > {result}")
             return result
-            # TODO: include opchain if supplied
 
-        result = children
+        result = children[:]
         _logger.info(f"  > {result}")
         return result
 
@@ -1462,7 +1493,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = Op_chain_a(children)
+        result = Op_chain_a(children[:])
         _logger.info(f"  > {result}")
         return result
 
@@ -1571,7 +1602,7 @@ class ScrallVisitor(PTNodeVisitor):
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = PATH_a(children)
+        result = PATH_a(children[:])
         _logger.info(f"  > {result}")
         return result
 

{scrall-0.9.0 → scrall-0.12.2/src/scrall.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrall
-Version: 0.9.0
+Version: 0.12.2
 Summary: Starr's Concise Relational Action Language - For Shlaer-Mellor Executable UML
 Author-email: Leon Starr <leon_starr@modelint.com>
 License: MIT License

{scrall-0.9.0 → scrall-0.12.2}/src/scrall.egg-info/SOURCES.txt

@@ -17,7 +17,11 @@ src/scrall/parse/parser.py
 src/scrall/parse/scrall.peg
 src/scrall/parse/visitor.py
 tests/test_calls.py
+tests/test_decision_scalar_expr.py
+tests/test_decision_wrap.py
+tests/test_decision_wrap_false.py
 tests/test_delete.py
+tests/test_operation.py
 tests/test_ping_actions.py
 tests/test_selection.py
 tests/test_signals.py

scrall-0.12.2/tests/test_calls.py

@@ -0,0 +1,78 @@
+""" test_calls.py - Test method calls and calls to an external service """
+
+import pytest
+from scrall.parse.parser import ScrallParser
+from scrall.parse.visitor import *
+
+actions = [
+    ("~.Goto floor( Dest floor: ^new dest )",
+    Execution_Unit_a(
+        statement_set=Seq_Statement_Set_a(
+            input_tokens=[],
+            statement=Call_a(
+                call=INST_a(
+                    components=[
+                        Op_a(owner='_external', op_name='Goto floor',
+                             supplied_params=[
+                                 Supplied_Parameter_a(
+                                     pname='Dest floor', sval=IN_a(name='new dest')
+                                 )
+                             ])]), op_chain=None), block=None), output_token=None)
+     ),
+    #  Execution_Unit_a(
+    #      statement_set=Seq_Statement_Set_a(
+    #          input_tokens=[],
+    #          statement=Call_a(
+    #              call=None,
+    #              op_chain=Op_chain_a(
+    #                  components=[
+    #                      Scalar_op_a(
+    #                          name=N_a(name='Goto floor'),
+    #                          supplied_params=[
+    #                              Supplied_Parameter_a(
+    #                                  pname='Dest floor',
+    #                                  sval=IN_a(name='new dest')
+    #                              )
+    #                          ]
+    #                      )
+    #                  ]
+    #              )
+    #          ), block=None),
+    #      output_token=None)
+    #  ),
+    (".Ping( dir: Travel direction.opposite )",
+    Execution_Unit_a(
+        statement_set=Seq_Statement_Set_a(
+            input_tokens=[],
+            statement=Call_a(
+                call=INST_a(
+                    components=[
+                        Op_a(
+                            owner='_implicit',
+                            op_name='Ping',
+                            supplied_params=[
+                                Supplied_Parameter_a(
+                                    pname='dir',
+                                    sval=INST_PROJ_a(
+                                        iset=N_a(name='Travel direction'),
+                                        projection=Projection_a(
+                                            expand=None, attrs=[N_a(name='opposite')]
+                                        ),
+                                        op_chain=None
+                                    )
+                                )
+                            ]
+                        )
+                    ]
+                ),
+                op_chain=None),
+            block=None),
+        output_token=None)
+     ),
+]
+
+@pytest.mark.parametrize("text, expected", actions)
+def test_call_action(text, expected):
+    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
+    print(parse)
+    assert parse[0] == expected

scrall-0.12.2/tests/test_decision_scalar_expr.py

@@ -0,0 +1,66 @@
+""" test_decision_scalar_expr.py -- Ensure scalar expression works as true result in a decision"""
+
+# This verifies that we don't have a regression on a bug fix where scalar_expr true results were eating the colon
+# and failing the parse
+
+import pytest
+from scrall.parse.parser import ScrallParser
+from scrall.parse.visitor import *
+
+actions = [
+    ("fwd dest? =>> fwd dest : {\n"
+     "    rev dest .= Ping( dir: Travel direction.opposite )\n"
+     "    !rev dest? Travel direction.toggle : =>> rev dest\n"
+     "}",
+        Execution_Unit_a(
+            statement_set=Seq_Statement_Set_a(
+                input_tokens=[],
+                statement=Decision_a(
+                    input=N_a(name='fwd dest'),
+                    true_result=Comp_Statement_Set_a(
+                        statement=Output_Flow_a(output=N_a(name='fwd dest')), block=None),
+                    false_result=Comp_Statement_Set_a(
+                        statement=None, block=[
+                            Execution_Unit_a(
+                                statement_set=Seq_Statement_Set_a(
+                                    input_tokens=[],
+                                    statement=Inst_Assignment_a(
+                                    lhs=Flow_Output_a(name=N_a(name='rev dest'), exp_type=None), card='1',
+                                    rhs=INST_a(components=
+                                        [N_a(name='Ping'),
+                                        Criteria_Selection_a(
+                                        card='ALL',
+                                        criteria=BOOL_a(op='==',
+                                        operands=[N_a(name='dir'),
+                                            INST_PROJ_a(
+                                                iset=N_a(name='Travel direction'),
+                                                projection=Projection_a(
+                                                expand=None,
+                                                attrs=[N_a(name='opposite')]), op_chain=None)
+                                                  ]))]), X=(31, 81)), block=None),
+                                output_token=None),
+                            Execution_Unit_a(
+                                statement_set=Seq_Statement_Set_a(
+                                    input_tokens=[],
+                                    statement=Decision_a(
+                                        input=BOOL_a(op='NOT', operands=N_a(name='rev dest')),
+                                        true_result=Comp_Statement_Set_a(
+                                            statement=Call_a(
+                                                call=N_a(name='Travel direction'),
+                                                op_chain=Op_chain_a(components=[N_a(name='toggle')])), block=None),
+                                        false_result=Comp_Statement_Set_a(
+                                            statement=Output_Flow_a(
+                                                output=N_a(name='rev dest')), block=None)), block=None),
+                                output_token=None)
+                        ]
+                    )
+                ), block=None
+            ), output_token=None),
+     )
+]
+
+@pytest.mark.parametrize("text, expected", actions)
+def test_decision_scalar_true_result(text, expected):
+    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
+    print(parse)
+    assert parse[0] == expected

scrall-0.12.2/tests/test_decision_wrap.py

@@ -0,0 +1,39 @@
+""" test_decision_wrap.py -- Test line wrapping """
+
+import pytest
+from scrall.parse.parser import ScrallParser
+from scrall.parse.visitor import *
+
+# The expected result is teh same for each input case
+expected_parse = Execution_Unit_a(
+    statement_set=Seq_Statement_Set_a(
+        input_tokens=[],
+        statement=Decision_a(
+            input=N_a(name='choice'),
+            true_result=Comp_Statement_Set_a(
+                statement=None,
+                block=[
+                    Execution_Unit_a(
+                        statement_set=Seq_Statement_Set_a(
+                            input_tokens=[],
+                            statement=New_inst_a(
+                                cname=N_a(name='cat'), attrs=[], rels=None, state=None),
+                            block=None
+                        ),
+                        output_token=None
+                    )
+                ]), false_result=None), block=None
+    ), output_token=None
+)
+
+# Different line wrapping of the same content
+@pytest.mark.parametrize("text", [
+    "choice? { *cat }",
+    "choice? {\n*cat }",
+    "choice? {\n    *cat\n}",
+    "choice?\n    { *cat }",
+])
+def test_decision_wrap(text):
+    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
+    print(parse)
+    assert parse[0] == expected_parse

scrall-0.12.2/tests/test_decision_wrap_false.py

@@ -0,0 +1,47 @@
+""" test_decision_wrap_false.py -- Test line wrapping with true false decision cases """
+
+import pytest
+from scrall.parse.parser import ScrallParser
+from scrall.parse.visitor import *
+
+# The expected result is teh same for each input case
+expected_parse = Execution_Unit_a(
+    statement_set=Seq_Statement_Set_a(
+        input_tokens=[],
+        statement=Decision_a(
+            input=N_a(name='choice'),
+            true_result=Comp_Statement_Set_a(
+                statement=None,
+                block=[
+                    Execution_Unit_a(
+                        statement_set=Seq_Statement_Set_a(
+                            input_tokens=[],
+                            statement=New_inst_a(
+                                cname=N_a(name='cat'), attrs=[], rels=None, state=None),
+                            block=None), output_token=None
+                    )
+                ]),
+            false_result=Comp_Statement_Set_a(
+                statement=None,
+                block=[
+                    Execution_Unit_a(
+                        statement_set=Seq_Statement_Set_a(
+                            input_tokens=[],
+                            statement=New_inst_a(
+                                cname=N_a(name='dog'), attrs=[], rels=None, state=None),
+                            block=None), output_token=None
+                    )
+                ])
+        ), block=None), output_token=None)
+
+# Different line wrapping of the same content
+@pytest.mark.parametrize("text", [
+    "choice? { *cat } : { *dog }",
+    "choice? { *cat } : {\n        *dog\n    }",
+    "choice? { *cat } : {\n    *dog }",
+    "choice? { *cat } :\n    {\n        *dog\n    }",
+])
+def test_signal_action(text):
+    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
+    print(parse)
+    assert parse[0] == expected_parse

scrall-0.12.2/tests/test_operation.py

@@ -0,0 +1,30 @@
+""" test_operation.py - Test the invocation of an operation"""
+
+import pytest
+from scrall.parse.parser import ScrallParser
+from scrall.parse.visitor import *
+
+actions = [
+    ("dest aslev .= cabin in shaft.Ping both ways()",
+        Execution_Unit_a(statement_set=Seq_Statement_Set_a(
+            input_tokens=[],
+            statement=Inst_Assignment_a(
+                lhs=Flow_Output_a(name=N_a(name='dest aslev'), exp_type=None), card='1',
+                rhs=INST_a(
+                    components=[
+                        Op_a(
+                            owner='cabin in shaft',
+                            op_name='Ping both ways',
+                            supplied_params=[])]
+                ), X=(0, 45)
+            ),
+            block=None), output_token=None)
+     ),
+]
+
+
+@pytest.mark.parametrize("text, expected", actions)
+def test_operation(text, expected):
+    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
+    print(parse)
+    assert parse[0] == expected

{scrall-0.9.0 → scrall-0.12.2}/tests/test_ping_actions.py

@@ -49,7 +49,7 @@ actions = [
              input_tokens=[],
              statement=Signal_a(
                  event='Try redirect', supplied_params=[
-                     [Supplied_Parameter_a(pname='new dest', sval=IN_a(name='new dest'))]],
+                     Supplied_Parameter_a(pname='new dest', sval=IN_a(name='new dest'))],
                  dest=Signal_Dest_a(
                      target_iset=INST_a(
                          components=[PATH_a(hops=[R_a(rnum='R53'), N_a(name='Cabin')])]),
@@ -99,8 +99,9 @@ actions = [
                  Criteria_Selection_a(card='ALL', criteria=BOOL_a(op='AND', operands=[
                      BOOL_a(op='==', operands=[N_a(name='Floor'),
                            INST_PROJ_a(iset=N_a(name='nearest dest'),
-                                 projection=Projection_a(expand=None, attrs=[N_a(name='Floor')]))]),
-                                 N_a(name='Shaft')]))]), projection=None)), block=None), output_token=None
+                                 projection=Projection_a(expand=None, attrs=[N_a(name='Floor')]), op_chain=None)]),
+                                 N_a(name='Shaft')]))]), projection=None, op_chain=None)), block=None),
+                         output_token=None
                          )
     ),
 ]

{scrall-0.9.0 → scrall-0.12.2}/tests/test_signals.py

@@ -2,8 +2,8 @@
 
 import pytest
 from scrall.parse.parser import ScrallParser
-from scrall.parse.visitor import Execution_Unit_a, Signal_a, Signal_Dest_a, N_a, INST_a, PATH_a, R_a, \
-    Seq_Statement_Set_a, Supplied_Parameter_a, External_Signal_a
+from scrall.parse.visitor import (Execution_Unit_a, Signal_a, Signal_Dest_a, N_a, INST_a, PATH_a, R_a,
+    Seq_Statement_Set_a, Supplied_Parameter_a, External_Signal_a, Decision_a, Comp_Statement_Set_a)
 
 actions = [
     ("Time to close ->* me",
@@ -24,7 +24,7 @@ actions = [
              statement=External_Signal_a(
                  event='Goto floor',
                  supplied_params=[
-                     [Supplied_Parameter_a(pname='Dest floor', sval=N_a(name='my level'))]
+                     Supplied_Parameter_a(pname='Dest floor', sval=N_a(name='my level'))
                  ]), block=None),
          output_token=None)
      ),
@@ -53,6 +53,26 @@ actions = [
                 block=None),
             output_token=None)
      ),
+    ("destination aslev?\n"
+     "    Transfer created -> : No destination -> me",
+     Execution_Unit_a(
+         statement_set=Seq_Statement_Set_a(
+             input_tokens=[],
+             statement=Decision_a(
+                 input=N_a(name='destination aslev'),
+                 true_result=Comp_Statement_Set_a(
+                     statement=Signal_a(
+                         event='Transfer created',
+                         supplied_params=[], dest=None), block=None),
+                 false_result=Comp_Statement_Set_a(
+                     statement=Signal_a(
+                         event='No destination',
+                         supplied_params=[],
+                         dest=Signal_Dest_a(
+                             target_iset=N_a(name='me'), assigner_dest=None, delay=0, cancel=False
+                         )), block=None
+                 )), block=None), output_token=None)
+     ),
 ]
 
 

{scrall-0.9.0 → scrall-0.12.2}/tests/test_state_actions.py

@@ -19,7 +19,7 @@ actions = [
         statement=Decision_a(input=BOOL_a(
             op='NOT', operands=INST_PROJ_a(iset=INST_a(
                 components=[PATH_a(hops=[R_a(rnum='R2'), N_a(name='Shaft')])]),
-                projection=Projection_a(expand=None, attrs=[N_a(name='In service')]))),
+                projection=Projection_a(expand=None, attrs=[N_a(name='In service')]), op_chain=None)),
             true_result=Comp_Statement_Set_a(statement=
                     Signal_a(event='Take out of service', supplied_params=[],
                              dest=Signal_Dest_a(target_iset=N_a(name='ME'),
@@ -32,7 +32,7 @@ actions = [
          statement=Decision_a(input=BOOL_a(
              op='NOT', operands=INST_PROJ_a(iset=INST_a(
                  components=[PATH_a(hops=[R_a(rnum='R2'), N_a(name='Shaft')])]),
-                 projection=Projection_a(expand=None, attrs=[N_a(name='In service')]))),
+                 projection=Projection_a(expand=None, attrs=[N_a(name='In service')]), op_chain=None)),
              true_result=Comp_Statement_Set_a(statement=
                      Signal_a(event='Take out of service', supplied_params=[],
                               dest=Signal_Dest_a(target_iset=N_a(name='ME'),

scrall-0.9.0/src/scrall/__init__.py

@@ -1 +0,0 @@
-version = "0.9.0"

scrall-0.9.0/tests/test_calls.py

@@ -1,39 +0,0 @@
-""" test_calls.py - Test method calls and calls to an external service """
-
-import pytest
-from scrall.parse.parser import ScrallParser
-from scrall.parse.visitor import (
-    Execution_Unit_a, Seq_Statement_Set_a, Call_a, Op_chain_a, Scalar_op_a,
-    Supplied_Parameter_a, N_a, IN_a,
-)
-
-actions = [
-    ("~.Goto floor( Dest floor: ^new dest )",
-     Execution_Unit_a(
-         statement_set=Seq_Statement_Set_a(
-             input_tokens=[],
-             statement=Call_a(
-                 call=None,
-                 op_chain=Op_chain_a(
-                     components=[
-                         Scalar_op_a(
-                             name=N_a(name='Goto floor'),
-                             supplied_params=[
-                                 Supplied_Parameter_a(
-                                     pname='Dest floor',
-                                     sval=IN_a(name='new dest')
-                                 )
-                             ]
-                         )
-                     ]
-                 )
-             ), block=None),
-         output_token=None)
-     ),
-]
-
-@pytest.mark.parametrize("text, expected", actions)
-def test_signal_action(text, expected):
-    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
-    print(parse)
-    assert parse[0] == expected