scrall 0.8.10__tar.gz → 0.9.1__tar.gz

{scrall-0.8.10/src/scrall.egg-info → scrall-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrall
-Version: 0.8.10
+Version: 0.9.1
 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.8.10 → scrall-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "scrall"
-version = "0.8.10"
+version = "0.9.1"
 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.9.1/src/scrall/__init__.py

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

{scrall-0.8.10 → scrall-0.9.1}/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
@@ -58,24 +58,23 @@ enum_value = '_' name // Scalar switch has enum value cases
 DECISION_OP = '?'
 
 // Signal action
-signal_action = signal_spec SP+ (signal_dest / ee_dest / SIGNAL_OP / ASYNCH)
+signal_action = signal_spec SP+ (signal_dest / external_dest / SIGNAL_OP)
 // SIGNAL_OP only destination means: copy dest from false result of decision action
 signal_spec = name supplied_params?
-signal_dest = SIGNAL_OP LINEWRAP? SP? (assigner / instance_set) (SP+ delay)?
+signal_dest = SIGNAL_OP '*'? LINEWRAP? SP? (assigner / instance_set) (SP+ delay)?
 assigner = rnum assigner_partition?
-ee_dest = ASYNCH LINEWRAP? SP? name
+external_dest = SIGNAL_OP LINEWRAP? SP? '~'
 delay = DELAY_OP SP* scalar_expr
 assigner_partition = '( ' instance_set ' )'
 DELAY_OP = '@'
 SIGNAL_OP = '->'
-ASYNCH = '=>'
 
 // Instance assignment action
 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
 supplied_params = '(' SP* (param (',' SP+ param)*)? SP* ')'

{scrall-0.8.10 → scrall-0.9.1}/src/scrall/parse/visitor.py

@@ -19,11 +19,11 @@ Attr_Access_a = namedtuple('Attr_Access_a', 'cname its attr')
 Rank_Selection_a = namedtuple('Rank_Selection_a', 'card rankr attr')
 Criteria_Selection_a = namedtuple('Criteria_Selection_a', 'card criteria')
 Inst_Assignment_a = namedtuple('Inst_Assignment_a', 'lhs card rhs X')
-EE_Signal_a = namedtuple('EE_Signal_a', 'event supplied_params ee')
+External_Signal_a = namedtuple('External_Signal_a', 'event supplied_params')
 Signal_a = namedtuple('Signal_a', 'event supplied_params dest')
 """Signal sent to trigger event at destination with optional supplied parameters"""
 Signal_Action_a = namedtuple('Signal_Action_a', 'event supplied_params dest delay')
-Signal_Dest_a = namedtuple('Signal_Dest_a', 'target_iset assigner_dest delay')
+Signal_Dest_a = namedtuple('Signal_Dest_a', 'target_iset assigner_dest delay cancel')
 Assigner_Dest_a = namedtuple('Assigner_Dest_a', 'rnum partition')
 Signal_Choice_a = namedtuple('Signal_Choice_a', 'decision true_signal false_signal')
 Sequence_Token_a = namedtuple('Sequence_Token_a', 'name')
@@ -647,13 +647,13 @@ class ScrallVisitor(PTNodeVisitor):
     def visit_signal_action(cls, node, children):
         """
         """
-        _logger.info("signal_action = signal_spec SP+ (signal_dest / ee_dest / SIGNAL_OP)")
+        _logger.info("signal_action = signal_spec SP+ (signal_dest / external_dest / SIGNAL_OP)")
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
         sdest = children.results.get('signal_dest')
-        eedest = children.results.get('ee_dest')
-        if not sdest and not eedest:
+        external_dest = bool(children.results.get('external_dest'))
+        if not sdest and not external_dest:
             # Dest should be supplied by false result in decision
             result = Signal_a(
                 event=children[0]['name'],
@@ -668,11 +668,10 @@ class ScrallVisitor(PTNodeVisitor):
                 dest=children[1]
             )
         else:
-            # Otherwise it must be an EE destination
-            result = EE_Signal_a(
+            # Otherwise it must be an external destination
+            result = External_Signal_a(
                 event=children[0]['name'],
                 supplied_params=children[0]['params'],
-                ee=children[1]
             )
 
         _logger.info(f"  > {result}")
@@ -692,14 +691,14 @@ class ScrallVisitor(PTNodeVisitor):
         return result
 
     @classmethod
-    def visit_ee_dest(cls, node, children):
+    def visit_external_dest(cls, node, children):
         """
         """
-        _logger.info("ee_dest = ASYNCH name")
+        _logger.info("external_dest = SIGNAL_OP LINEWRAP? SP? '~'")
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        result = children[0]
+        result = '~'
         _logger.info(f"  > {result}")
         return result
 
@@ -709,6 +708,7 @@ class ScrallVisitor(PTNodeVisitor):
         """
         _logger.info("signal_dest = SIGNAL_OP LINEWRAP? SP? (assigner / instance_set) (SP+ delay)?")
         _logger.info(f'  :: {node.value}')
+        cancel = bool(children[0] == '*')
 
         _logger.info(f"  < {children}")
         iset = children.results.get('instance_set')
@@ -717,7 +717,7 @@ class ScrallVisitor(PTNodeVisitor):
         assigner = assigner[0] if assigner else None
         delay = children.results.get('delay')
         delay = 0 if not delay else delay[0]
-        result = Signal_Dest_a(target_iset=iset, assigner_dest=assigner, delay=delay)
+        result = Signal_Dest_a(target_iset=iset, assigner_dest=assigner, delay=delay, cancel=cancel)
         _logger.info(f"  > {result}")
         return result
 
@@ -808,14 +808,14 @@ class ScrallVisitor(PTNodeVisitor):
         """
         Post-parse verify that last element is an operation, otherwise invalid call
         """
-        _logger.info("call = instance_set op_chain?")
+        _logger.info("call = ('~' / instance_set) op_chain?")
         _logger.info(f'  :: {node.value}')
 
         _logger.info(f"  < {children}")
-        iset = children.results['instance_set'][0]
+        iset = children.results.get('instance_set')
         opc = children.results.get('op_chain')
         result = Call_a(
-            call=iset,
+            call=iset[0] if iset else None,  # None means that we are calling a service mapped to a service domain
             op_chain=None if not opc else opc[0]
         )
         _logger.info(f"  > {result}")

{scrall-0.8.10 → scrall-0.9.1/src/scrall.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scrall
-Version: 0.8.10
+Version: 0.9.1
 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.8.10 → scrall-0.9.1}/src/scrall.egg-info/SOURCES.txt

@@ -16,6 +16,9 @@ src/scrall/parse/__init__.py
 src/scrall/parse/parser.py
 src/scrall/parse/scrall.peg
 src/scrall/parse/visitor.py
+tests/test_calls.py
+tests/test_decision_wrap.py
+tests/test_decision_wrap_false.py
 tests/test_delete.py
 tests/test_ping_actions.py
 tests/test_selection.py

scrall-0.9.1/tests/test_calls.py

@@ -0,0 +1,39 @@
+""" 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

scrall-0.9.1/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),
+                            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_signal_action(text):
+    parse = ScrallParser.parse_text(scrall_text=text, debug=False)[0]
+    print(parse)
+    assert parse[0] == expected_parse

scrall-0.9.1/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),
+                            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),
+                            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.8.10 → scrall-0.9.1}/tests/test_ping_actions.py

@@ -1,4 +1,4 @@
-# simple tests
+""" test_pint_actions.py - Example statements from the Elevator ping method """
 
 import pytest
 from scrall.parse.parser import ScrallParser
@@ -44,14 +44,18 @@ actions = [
                             projection=Projection_a(expand=None, attrs=[N_a(name='Floor')])),
             X=(0, 56)), block=None), output_token=None)),
     ("Try redirect( ^new dest ) -> /R53/Cabin",
-        Execution_Unit_a(statement_set=Seq_Statement_Set_a(input_tokens=[],
-            statement=Signal_a(event='Try redirect', supplied_params=[
-                [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')])]),
-                                       assigner_dest=None, delay=0)),
-            block=None), output_token=None)
-    ),
+     Execution_Unit_a(
+         statement_set=Seq_Statement_Set_a(
+             input_tokens=[],
+             statement=Signal_a(
+                 event='Try redirect', supplied_params=[
+                     [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')])]),
+                     assigner_dest=None, delay=0, cancel=False)), block=None),
+         output_token=None)
+     ),
     ("TRAN.Go to floor( Dest floor: ^new dest, Shaft )",
         Execution_Unit_a(statement_set=Seq_Statement_Set_a(input_tokens=[],
             statement=Call_a(call=INST_a(components=[Op_a(owner='TRAN', op_name='Go to floor',
@@ -60,12 +64,17 @@ actions = [
                                          ), op_chain=None),
             block=None), output_token=None)
     ),
-    ("Change requested -> ME",
-        Execution_Unit_a(statement_set=Seq_Statement_Set_a(input_tokens=[],
-            statement=Signal_a(event='Change requested', supplied_params=[],
-                               dest=Signal_Dest_a(target_iset=N_a(name='ME'),
-                               assigner_dest=None, delay=0)),
-            block=None), output_token=None)
+    ("Change requested -> me",
+        Execution_Unit_a(
+            statement_set=Seq_Statement_Set_a(
+                input_tokens=[],
+                statement=Signal_a(
+                    event='Change requested', supplied_params=[],
+                    dest=Signal_Dest_a(
+                        target_iset=N_a(name='me'), assigner_dest=None, delay=0, cancel=False
+                    )
+                ), block=None),
+            output_token=None)
      ),
     ("shaft aslevs ..= /R2/R28/Shaft Level/R3/Accessible Shaft Level",
         Execution_Unit_a(statement_set=Seq_Statement_Set_a(input_tokens=[],

scrall-0.9.1/tests/test_signals.py

@@ -0,0 +1,83 @@
+# simple tests
+
+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, Decision_a, Comp_Statement_Set_a)
+
+actions = [
+    ("Time to close ->* me",
+     Execution_Unit_a(
+         statement_set=Seq_Statement_Set_a(
+             input_tokens=[],
+             statement=Signal_a(
+                 event='Time to close',
+                 supplied_params=[],
+                 dest=Signal_Dest_a(target_iset=N_a(name='me'), assigner_dest=None, delay=0, cancel=True)),
+             block=None),
+         output_token=None)
+     ),
+    ("Goto floor( Dest floor: my level) -> ~",
+     Execution_Unit_a(
+         statement_set=Seq_Statement_Set_a(
+             input_tokens=[],
+             statement=External_Signal_a(
+                 event='Goto floor',
+                 supplied_params=[
+                     [Supplied_Parameter_a(pname='Dest floor', sval=N_a(name='my level'))]
+                 ]), block=None),
+         output_token=None)
+     ),
+    ("Change requested -> me",
+        Execution_Unit_a(
+            statement_set=Seq_Statement_Set_a(
+                input_tokens=[],
+                statement=Signal_a(
+                    event='Change requested',
+                    supplied_params=[],
+                    dest=Signal_Dest_a(target_iset=N_a(name='me'), assigner_dest=None, delay=0, cancel=False)),
+                block=None),
+            output_token=None)
+     ),
+    ("Ready to go -> /R53/Transfer",
+        Execution_Unit_a(
+            statement_set=Seq_Statement_Set_a(
+                input_tokens=[],
+                statement=Signal_a(
+                    event='Ready to go',
+                    supplied_params=[],
+                    dest=Signal_Dest_a(target_iset=INST_a(
+                        components=[PATH_a(hops=[R_a(rnum='R53'), N_a(name='Transfer')])]
+                    ), assigner_dest=None, delay=0, cancel=False)
+                ),
+                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)
+     ),
+]
+
+
+@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

{scrall-0.8.10 → scrall-0.9.1}/tests/test_state_actions.py

@@ -23,7 +23,7 @@ actions = [
             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'),
-                             assigner_dest=None, delay=0)), block=None),
+                             assigner_dest=None, delay=0, cancel=False)), block=None),
             false_result=None),
         block=None), output_token=None)
     ),
@@ -36,7 +36,7 @@ actions = [
              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'),
-                              assigner_dest=None, delay=0)), block=None),
+                              assigner_dest=None, delay=0, cancel=False)), block=None),
              false_result=None),
          block=None), output_token=None))]
 

scrall-0.8.10/src/scrall/__init__.py

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

scrall-0.8.10/tests/test_signals.py

@@ -1,31 +0,0 @@
-# simple tests
-
-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
-
-actions = [
-    ("Change requested -> ME",
-        Execution_Unit_a(statement_set=Seq_Statement_Set_a(input_tokens=[],
-           statement=Signal_a(event='Change requested', supplied_params=[],
-                              dest=Signal_Dest_a(target_iset=N_a(name='ME'),
-                              assigner_dest=None, delay=0)),
-           block=None), output_token=None)
-     ),
-    ("Ready to go -> /R53/Transfer",
-        Execution_Unit_a(statement_set=Seq_Statement_Set_a(input_tokens=[],
-           statement=Signal_a(event='Ready to go', supplied_params=[], dest=Signal_Dest_a(
-               target_iset=INST_a(
-                   components=[PATH_a(hops=[R_a(rnum='R53'), N_a(name='Transfer')])]),
-               assigner_dest=None, delay=0)),
-           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