Commit: ddd4d080d1e246c71c9da2b101ada74d9369d230 - CCastle2 (hg)

Castle: The best Real-Time/Embedded/HighTech language EVER. Attempt 2

Commit MetaInfo

• Révision: ddd4d080d1e246c71c9da2b101ada74d9369d230 (tree)
• l'heure: 2022-01-04 07:33:12
• Auteur: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Message de Log

Refactored, added some extra test

Change Summary

• modified: AST/castle/peg.py
• modified: AST/pytst/test_1_Rules.py
• modified: Arpeggio/pytst/d2_ast/test_3_rule.py
• modified: Arpeggio/pytst/d2_ast/test_4_quantity.py
• modified: Arpeggio/pytst/d2_ast/test_5_group.py
• modified: Arpeggio/visitor.py
• add: Arpeggio/pytst/d2_ast/test_3_Seq.py

Modification

diff -r 9480be959415 -r ddd4d080d1e2 AST/castle/peg.py
--- a/AST/castle/peg.py	Mon Jan 03 00:01:50 2022 +0100
+++ b/AST/castle/peg.py	Mon Jan 03 23:33:12 2022 +0100
@@ -1,3 +1,5 @@
+import logging; logger = logging.getLogger(__name__)
+
 from ._base import AST_BASE, ID, IDError
 
 class PEG (AST_BASE):                                                   # abstract
@@ -6,26 +8,45 @@
         super().__init__(**kwargs)
 
 
+class MixIn_value_attribute:
+    """With this MixIn PEG-classes get the ``.value`` property"""
+
+    def __init__(self, *, value=None, **kwargs):
+        super().__init__(**kwargs)
+        logger.debug(f'{type(self).__name__}:: value:={value}:{type(value)}')
+        self._value=value
+
+    @property
+    def value(self):
+        logger.debug(f'{type(self).__name__}:: @property={self._value}')
+        return self._value
+
+
+class MixIn_expr_attribute:
+    """With this MixIn PEG-classes get the ``.expr`` property"""
+
+    def __init__(self, *, expr=None, **kwargs):
+        super().__init__(**kwargs)
+        self._expr = expr
+
+    @property
+    def expr(self):
+        return self._expr
+
 ##
 ## Note: When using TypeHints with PEG-classes; the clases
 ##       should be defined "above" the typehints uses them
 ##       This defines (largely/partly) the order of classes.
 ##
 
-class Terminal(PEG):                                                    # abstract
-    def __init__(self, *, value=None, **kwargs):
-        super().__init__(**kwargs)
-        self.value=value
-
-
-class NonTerminal(PEG): pass                                            # abstract
-class Markers(PEG): pass                                                # abstract
-
+class Terminal(MixIn_value_attribute, PEG): pass                        # abstract
 class StrTerm(Terminal): pass
 class RegExpTerm(Terminal): pass
 
-class EOF(Markers): pass                                               # singleton?
+class Markers(PEG): pass                                                # abstract
+class EOF(Markers): pass                                                # XXX Todo ## singleton?
 
+class NonTerminal(PEG): pass                                            # abstract
 class Expression(NonTerminal): pass                                     # abstract
 
 
@@ -42,14 +63,14 @@
 
 class Rule(NonTerminal):
     def __init__(self, *,
-                 name: ID,
-                 expr :Expression=None,
+                 name: ID, expr:Expression=None,
                  **kwargs):
         ID.validate_or_raise(name)
         super().__init__(**kwargs)
         self.name = name
         self.expr = expr
-
+        logger.debug(f'{type(self).__name__}:: expr:={expr}:{type(expr)}')
+        logger.debug("\t" + "; ".join(f'{c}:{type(c)}' for c in expr))
 
 class Grammar(NonTerminal):
     def __init__(self, *,
@@ -61,29 +82,22 @@
         self.settings = settings
 
 
-class Group(Expression):pass                                            # abstract --  Do not use for a '(' ...')' group, that's a Sequence!!
-class UnorderedGroup(Group):                                            # It looks like a Quantity, but is a group
-    def __init__(self, *, expr=None, **kwargs):
-        super().__init__(**kwargs)
-        self.expr = expr
+class Group(Expression): pass                                           # abstract --  Note: Do not Group for  '(' ...')';  that's a Sequence!!
+class UnorderedGroup(MixIn_expr_attribute, Group):                      # It looks like a Quantity, but is a group
+    """See a set (aka "group") of expressions that **all** have to be matched, but the **order** is a don't care.
+
+       Possible an extension of Arpeggio (see: https://textx.github.io/Arpeggio/stable/grammars/), possible a generic one."""
+
+class Quantity(MixIn_expr_attribute, Expression):                                             # abstract
+    """An expression with Quantification; like optional, or repetition. The subclasses defines which Quantification"""
 
 
-class Quantity(Expression):                                             # abstract
-    """An expression with Quantification; like optional, or repetition. The subclasses defines which Quantification"""
-    def __init__(self, *, expr=None, **kwargs):
-        super().__init__(**kwargs)
-        self.expr = expr
-
+class Sequence(MixIn_value_attribute, Expression):
+    """A _list_ of expressions; can be of length=1"""
+    # __init__ (see MixIn) sets self._value; assuming it is a list
 
-class Sequence(Expression):
-    """A _list_ of expressions; can be of length=1"""
-    def __init__(self, *, value=None, **kwargs):
-        super().__init__(**kwargs)
-        self.value=value
-    def __len__(self):
-        return len(self.value)
-    def __getitem__(self, n):
-        return self.value[n]
+    def __len__(self):       	return len(self._value)
+    def __getitem__(self, n):	return self._value[n]
 
 
 class OrderedChoice(Expression):pass                                    # It a an set of alternatives

diff -r 9480be959415 -r ddd4d080d1e2 AST/pytst/test_1_Rules.py
--- a/AST/pytst/test_1_Rules.py	Mon Jan 03 00:01:50 2022 +0100
+++ b/AST/pytst/test_1_Rules.py	Mon Jan 03 23:33:12 2022 +0100
@@ -2,6 +2,7 @@
 
 from castle.peg import Rule
 
[e-mail]("This test is wrong: (1) An ID is not string, (2) a int is not an Expression")
 def test_a_ID():
     a_name, a_val = 'aName', 42
     s=Rule(name=a_name, expr=a_val)

diff -r 9480be959415 -r ddd4d080d1e2 Arpeggio/pytst/d2_ast/test_3_Seq.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Arpeggio/pytst/d2_ast/test_3_Seq.py	Mon Jan 03 23:33:12 2022 +0100
@@ -0,0 +1,53 @@
+"""Test that a sequence of expressions is an Expression()
+
+   Note: the value of Expression() is a list-subclass; which is fine. But use it as list!!"""
+
+import pytest
+import logging; logger = logging.getLogger(__name__)
+
+import grammar
+from castle import peg # has the AST classes
+
+from . import parse, assert_ID
+
+def test_seq_of_one_as_single_expr():
+    txt = "A"
+    ast = parse(txt, grammar.single_expr)
+
+    assert_ID(ast, 'A'), "An Id as single_expr results in an ID()"
+
+def test_seq_of_two_is_NOT_a_single_expression():
+    txt = "A B"
+    with pytest.raises(AssertionError):
+        ast = parse(txt, grammar.single_expr)
+
+
+def test_seq_of_two_as_expressions():
+    txt = "A B"
+    ast = parse(txt, grammar.expressions)
+
+    assert isinstance(ast, peg.Expression),	"Two sequence of two expr is an Expression()"
+    assert isinstance(ast, peg.Sequence),	" ... and a Sequence()"
+    assert len(ast) == 2,			" ... of length==2"
+
+    assert isinstance(ast.value, list),		"It will be an `arpeggio.SemanticActionResult` which is a subclass of list"
+    assert_ID(ast[0], 'A'),			" ... the first one is ID('A')"
+    assert_ID(ast[1], 'B'),			"... and the 2nd: ID('B')"
+
+
+def test_seq_of_thre_with_quantification():
+    txt = "A? B+ C*"
+    ast = parse(txt, grammar.expressions)
+
+    assert isinstance(ast, peg.Expression), "Two sequence of two expr is an Expression()"
+    assert isinstance(ast, peg.Sequence),   " ... and a Sequence()"
+    assert len(ast) == 3,                   " ... of length==3"
+
+    assert isinstance(ast[0], peg.Optional)
+    assert isinstance(ast[1], peg.OneOrMore)
+    assert isinstance(ast[2], peg.ZeroOrMore)
+
+    assert_ID(ast[0].expr, 'A'),	"The first ID is an 'A'"
+    assert_ID(ast[1].expr, 'B'),	"The 2nd ID is a 'B'"
+    assert_ID(ast[2].expr, 'C'),	"The 3th one is a 'C'"
+

diff -r 9480be959415 -r ddd4d080d1e2 Arpeggio/pytst/d2_ast/test_3_rule.py
--- a/Arpeggio/pytst/d2_ast/test_3_rule.py	Mon Jan 03 00:01:50 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/test_3_rule.py	Mon Jan 03 23:33:12 2022 +0100
@@ -1,4 +1,5 @@
 import pytest
+import logging; logger = logging.getLogger(__name__)
 
 import grammar
 from castle import peg # has the AST classes
@@ -17,7 +18,7 @@
     expr = ast.expr;
     assert isinstance(expr, peg.Expression), 	"The expression is an Expression ..."
     assert isinstance(expr, peg.Sequence),	" .. and a Sequence .."
-    assert len(expr) ==1, 			" .. of length==1"
+    assert len(expr) == 1, 			" .. of length==1"
     assert_ID(expr[0], txt.split()[2], "The single element of the expression is an ID (the 2nd) --  which name is the 3 part of the txt")
 
 

diff -r 9480be959415 -r ddd4d080d1e2 Arpeggio/pytst/d2_ast/test_4_quantity.py
--- a/Arpeggio/pytst/d2_ast/test_4_quantity.py	Mon Jan 03 00:01:50 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/test_4_quantity.py	Mon Jan 03 23:33:12 2022 +0100
@@ -1,7 +1,7 @@
 """  Test several optional parts of an expression -- mosty quantity suffixes like '?' '*' and '+' -- also '#' although is different"""
 
 import pytest
-import logging;logger = logging.getLogger(__name__)
+import logging; logger = logging.getLogger(__name__)
 
 import grammar
 from castle import peg # has the AST classes

diff -r 9480be959415 -r ddd4d080d1e2 Arpeggio/pytst/d2_ast/test_5_group.py
--- a/Arpeggio/pytst/d2_ast/test_5_group.py	Mon Jan 03 00:01:50 2022 +0100
+++ b/Arpeggio/pytst/d2_ast/test_5_group.py	Mon Jan 03 23:33:12 2022 +0100
@@ -1,5 +1,5 @@
 import pytest
-import logging;logger = logging.getLogger(__name__)
+import logging; logger = logging.getLogger(__name__)
 
 import grammar
 from castle import peg # has the AST classes

diff -r 9480be959415 -r ddd4d080d1e2 Arpeggio/visitor.py
--- a/Arpeggio/visitor.py	Mon Jan 03 00:01:50 2022 +0100
+++ b/Arpeggio/visitor.py	Mon Jan 03 23:33:12 2022 +0100
@@ -31,19 +31,19 @@
     def visit_single_expr(self, node, children):                        #  [ rule_crossref, term, group, predicate ],  expr_quantity
         if len(children) == 1: #  No Optional part
             try:
-                n = children[0].name
+                n = f'name={children[0].name}'
             except AttributeError:
-                n = str(children[0])
+                n = f'name:{children[0]}'
             logger.debug(f'visit_single_expr==1:: {n}:{type(children[0])}')
             return children[0]
         elif len(children) == 2: #  Optional part
-            logger.debug(f'visit_single_expr==2:: {children[0]}, {children[1]}')
+            logger.debug(f'visit_single_expr==2::Got: {children[0]}, {children[1]}')
             expr = children[0]
             token = str(children[1])
             quantum_cls = self.token_2_class.get(token)
             if quantum_cls:
                 ast=quantum_cls(expr=expr, parse_tree=node)
-                logger.debug(f'visit_single_expr==2:: {quantum_cls} {expr}')
+                logger.debug(f'visit_single_expr==2::Pass: {quantum_cls}(expr={expr})')
                 return ast
             else:
                 raise QuantityError(f"token '{token}' not recognised")
@@ -56,6 +56,6 @@
 
 
     def visit_expressions(self, node, children):                        # OneOrMore(single_expr), Optional( '|' , expressions )
-        logger.debug(f'>>{node}<< len={len(children)} children={children}')
+        logger.debug(f'visit_expressions:: >>{node}<< len={len(children)} children={children}:{type(children)}')
         return peg.Sequence(value=children, parse_tree=node)