Commit: 30b384e24ddf6da239bc88563416bb1abb73f2ca - CCastle2 (hg)

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

Commit MetaInfo

• Revision: 30b384e24ddf6da239bc88563416bb1abb73f2ca (tree)
• Zeit: 2022-05-31 03:44:08
• Autor: Albert Mietus < albert AT mietus DOT nl >
• Commiter: Albert Mietus < albert AT mietus DOT nl >

Log Message

Added 'make mutmut' Mutation testing -- and fix/whitelisted some trivials

Ändern Zusammenfassung

• modified: Makefile
• modified: castle/ast/_base.py
• modified: castle/ast/grammar.py
• modified: castle/readers/parser/__init__.py
• modified: castle/readers/parser/grammar/visitor.py

Diff

diff -r 6ccd9a748252 -r 30b384e24ddf Makefile
--- a/Makefile	Mon May 30 20:43:09 2022 +0200
+++ b/Makefile	Mon May 30 20:44:08 2022 +0200
@@ -9,10 +9,17 @@
 	coverage run --branch -m pytest ${PYTEST_OPTONS}  pytst/
 	coverage report  --skip-covered
 	coverage html
+pytest-only:
+	pytest ${PYTEST_OPTONS}  pytst
 pytest-s test-s:
 	pytest ${PYTEST_OPTONS} -s pytst
 test-ds test-sd test-d:
 	pytest ${PYTEST_OPTONS} --log-cli-level=DEBUG -s pytst/
+mutmut:
+	-mutmut run  --tests-dir pytst --paths-to-mutate castle
+	mutmut html && mutmut results
+	open html/index.html
+
 
 demo: pytest-demo python-demo
 
@@ -45,7 +52,12 @@
 clean_caches:
 	find . -type d -name __pycache__    -print0 | xargs -0  rm -r
 	find . -type d -name .pytest_cache  -print0 | xargs -0  rm -r
+	rm -f ./.coverage
+	rm -f ./.mutmut-cache
 
+cleaner: clean
+	rm -rd ./htmlcov/ #coverage
+	rm -rf ./html # mutmut
 
 PYREVERSE_DIR=pyreversed
 PYREVERSE_FORMAT=svg

diff -r 6ccd9a748252 -r 30b384e24ddf castle/ast/_base.py
--- a/castle/ast/_base.py	Mon May 30 20:43:09 2022 +0200
+++ b/castle/ast/_base.py	Mon May 30 20:44:08 2022 +0200
@@ -6,12 +6,12 @@
     """Base class for all Castle ATS nodes"""
 
     def __init__(self, *, parse_tree=None, **kwargs):
-        assert len(kwargs)==0, "Do not call 'Object' with kwargs (caller is wrong)"
+        assert len(kwargs)==0, "Do not call 'Object' with kwargs (caller is wrong)"  # pragma: no mutate
         super().__init__(**kwargs)
         self._parse_tree = parse_tree
 
     def __str__(self): # mostly for debugging
-        return '\n__DEBUG__ ' + str(type(self).__name__) + "\n\t" + "\n\t".join(f'{n}\t{str(v)}:{type(v).__name__}' for n,v in self.__dict__.items() if n[0]!='_')
+        return '\n__DEBUG__ ' + str(type(self).__name__) + "\n\t" + "\n\t".join(f'{n}\t{str(v)}:{type(v).__name__}' for n,v in self.__dict__.items() if n[0]!='_')  # pragma: no mutate
 
     def serialize(self, strategy="XML") -> str:
         return Serialize(strategy).serialize(self)
@@ -24,15 +24,15 @@
     ### Mostly for debugging
     @staticmethod
     def _typeName(of):
-        return type(of).__name__
+        return type(of).__name__                                        # pragma: no mutate
 
     def _valType(self, of:None):
-        if not of: of=self
-        return f'{of}:{self._typeName(of)}'
+        if not of: of=self                                              # pragma: no mutate
+        return f'{of}:{self._typeName(of)}'                             # pragma: no mutate
 
 
 class IDError(ValueError):
-    "The given ID is not valid as an ID"
+    "The given ID is not valid as an ID"                                # pragma: no mutate
 
 
 

diff -r 6ccd9a748252 -r 30b384e24ddf castle/ast/grammar.py
--- a/castle/ast/grammar.py	Mon May 30 20:43:09 2022 +0200
+++ b/castle/ast/grammar.py	Mon May 30 20:44:08 2022 +0200
@@ -1,4 +1,4 @@
-import logging; logger = logging.getLogger(__name__)
+import logging; logger = logging.getLogger(__name__)                    # pragma: no mutate
 
 from ._base import AST_BASE, ID, IDError
 
@@ -14,14 +14,14 @@
     """With this MixIn PEG-classes get the ``.value`` property"""
 
     def __init__(self, *, value=None, **kwargs):
-        logger.debug(f'{self._typeName(self)}.MixIn_value_attribute:: value:=' +
-                     ('[[' +', '.join(f'{v}:{type(v).__name__}' for v in value) + ']]') if isinstance(value, list) else f's>>{value}<<')
+        logger.debug(f'{self._typeName(self)}.MixIn_value_attribute:: value:=' +  # pragma: no mutate
+                     ('[[' +', '.join(f'{v}:{type(v).__name__}' for v in value) + ']]') if isinstance(value, list) else f's>>{value}<<')  # pragma: no mutate
         super().__init__(**kwargs)
         self._value=value
 
     @property
     def value(self):
-        logger.debug(f'{self._typeName(self)}:: @value={self._value}')
+        logger.debug(f'{self._typeName(self)}:: @value={self._value}') # pragma: no mutate
         return self._value
 
 
@@ -29,13 +29,13 @@
     """With this MixIn PEG-classes get the ``.expr`` property"""
 
     def __init__(self, *, expr=None, **kwargs):
-        logger.debug(f'{self._typeName(self)}.MixIn_expr_attribute:: expr:={self._valType(expr)}')
+        logger.debug(f'{self._typeName(self)}.MixIn_expr_attribute:: expr:={self._valType(expr)}') # pragma: no mutate
         super().__init__(**kwargs)
         self._expr = expr
 
     @property
     def expr(self):
-        logger.debug(f'{self._typeName(self)}:: @expr={self._expr}')
+        logger.debug(f'{self._typeName(self)}:: @expr={self._expr}') # pragma: no mutate
         return self._expr
 
 
@@ -43,7 +43,7 @@
     """With this MixIn PEG-class get the ``.children`` property; and sequence-alike methods"""
     def __init__(self, *, children, **kwargs):
         logger.debug(f'{self._typeName(self)}.MixIn_children_tuple:: children[{len(children)}]:=' +
-                     ('[[' +', '.join(f'{c}:{type(c).__name__}' for c in children) + ']]') if isinstance(children, list) else f's>>{children}<<')
+                     ('[[' +', '.join(f'{c}:{type(c).__name__}' for c in children) + ']]') if isinstance(children, list) else f's>>{children}<<') # pragma: no mutate
         super().__init__(**kwargs)
         self._children = tuple(children)
 
@@ -53,7 +53,7 @@
         return self._children[key]
     def __iter__(self): return self._children.__iter__()
     def __str__(self):
-        return f"<{type(self).__name__}.MixIn_children_tuple:{len(self)}[" + ",".join(str(c) for c in self) + "]>"
+        return f"<{type(self).__name__}.MixIn_children_tuple:{len(self)}[" + ",".join(str(c) for c in self) + "]>" # pragma: no mutate
 
 ##
 ## Note: When using TypeHints with PEG-classes; the clases
@@ -66,7 +66,7 @@
 class RegExpTerm(Terminal): pass
 class Number(Terminal):                                            # Value is stored as a string
     def __str__(self):                                             # mostly for debugging
-        return f'<"{self.value}">'
+        return f'<"{self.value}">' # pragma: no mutate
 
 class Markers(PEG): pass                                                # abstract
 class EOF(Markers): pass                                                # XXX Todo ## singleton?
@@ -90,9 +90,9 @@
     def __init__(self, *,
                  name: ID, expr:Expression=None,
                  **kwargs):
-        logger.debug(f'{self._typeName(self)}: name={self._valType(name)}, expr={self._valType(expr)}')
+        logger.debug(f'{self._typeName(self)}: name={self._valType(name)}, expr={self._valType(expr)}') # pragma: no mutate
         if expr:
-            logger.debug("\t" + "; ".join(f'{c}:{type(c)}' for c in expr))
+            logger.debug("\t" + "; ".join(f'{c}:{type(c)}' for c in expr)) # pragma: no mutate
         if not isinstance(name, ID): raise TypeError(f'Rule-name {name} is not of type ID')
         super().__init__(**kwargs)
         self.name = name
@@ -132,14 +132,14 @@
     # __init__ (see MixIn) sets self._children; assuming it is a list
 
     def __str__(self): # mostly for debugging
-        return "Seq{{" + " ; ".join(f"{c}" for c in self) + "}}"
+        return "Seq{{" + " ; ".join(f"{c}" for c in self) + "}}" # pragma: no mutate
 
 
 class OrderedChoice(MixIn_children_tuple, Expression):                  # A | B | C | ...  the order is relevant
     """OC: A _tuple_ of alternative expressions"""
 
     def __str__(self): # mostly for debugging
-        return "OC{{" + " | ".join(f"{c}" for c in self._children) + "}}"
+        return "OC{{" + " | ".join(f"{c}" for c in self._children) + "}}" # pragma: no mutate
 
 class Optional(Quantity):pass
 class ZeroOrMore(Quantity):pass

diff -r 6ccd9a748252 -r 30b384e24ddf castle/readers/parser/__init__.py
--- a/castle/readers/parser/__init__.py	Mon May 30 20:43:09 2022 +0200
+++ b/castle/readers/parser/__init__.py	Mon May 30 20:44:08 2022 +0200
@@ -37,7 +37,7 @@
                  **kwargs):
         super().__init__(read_dirs=read_dirs, **kwargs)
         if language_def is None:
-            raise ValueError("The `language_def` is a mandatory parameter")
+            raise ValueError("The `language_def` is a mandatory parameter") # pragma: no mutate
         # comment_def is allowed to be None
         if visitor is None:
             raise ValueError("visitor is a mandatory parameter")

diff -r 6ccd9a748252 -r 30b384e24ddf castle/readers/parser/grammar/visitor.py
--- a/castle/readers/parser/grammar/visitor.py	Mon May 30 20:43:09 2022 +0200
+++ b/castle/readers/parser/grammar/visitor.py	Mon May 30 20:44:08 2022 +0200
@@ -29,7 +29,7 @@
 
 class PegVisitor(arpeggio.PTNodeVisitor):
     def _logstr_node_children(self, node, children):
-        return f'>>{node}<< children[{len(children)}] >>' + ", ".join(f'{c}:{type(c).__name__}' for c in children) + '<<'
+        return f'>>{node}<< children[{len(children)}] >>' + ", ".join(f'{c}:{type(c).__name__}' for c in children) + '<<' # pragma: no mutate
 
     def visit_str_term(self, node, children):
         return grammar.StrTerm(value=node[1], parse_tree=node)
@@ -54,27 +54,27 @@
                          '#': grammar.UnorderedGroup}
 
         if len(children) == 1: #  No Optional part
-            logger.debug(f'visit_single_expr==1:: {getattr(children[0], "name", children[0])}:{type(children[0])}')
+            logger.debug(f'visit_single_expr==1:: {getattr(children[0], "name", children[0])}:{type(children[0])}')  # pragma: no mutate
             return children[0]
 
         elif len(children) == 2: #  Optional part
-            logger.debug(f'visit_single_expr==2::Got: {children[0]}, {children[1]}')
+            logger.debug(f'visit_single_expr==2::Got: {children[0]}, {children[1]}')  # pragma: no mutate
             expr = children[0]
             token = str(children[1])
             quantum_cls = token_2_class.get(token)
             if quantum_cls:
                 ast=quantum_cls(expr=expr, parse_tree=node)
-                logger.debug(f'visit_single_expr==2::Pass: {quantum_cls}(expr={expr})')
+                logger.debug(f'visit_single_expr==2::Pass: {quantum_cls}(expr={expr})')  # pragma: no mutate
                 return ast
             else:
                 raise QuantityError(f"token '{token}' not recognised")
-        else: # #children not in (1,2)
-            raise  NotImplementedError("visit_single_expr, len>2")      # -- Is this possible?
+        else: # #children not in (1,2)  -- Is this possible?
+            raise  NotImplementedError("visit_single_expr, len>2")      # pragma: no mutate
 
 
     # expression <- sequence, op_alternative; op_alternative <- ('|' expression)?
     def visit_expression(self, node, children) -> Union[grammar.Sequence,  grammar.OrderedChoice]:
-        logger.debug('visit_expression::' + self._logstr_node_children(node, children))
+        logger.debug('visit_expression::' + self._logstr_node_children(node, children))  # pragma: no mutate
         if len(children) == 1: #Only sequence
             return children[0]
         elif len(children) == 2: # So, having 1 or more alternatives in children[1]
@@ -90,14 +90,14 @@
 
     # OneOrMore(single_expr)
     def visit_sequence(self, node, children) -> grammar.Sequence:
-        logger.debug(f'visit_sequence::{self._logstr_node_children(node, children)}')
+        logger.debug(f'visit_sequence::{self._logstr_node_children(node, children)}')  # pragma: no mutate
         return grammar.Sequence(children=children, parse_tree=node)
 
 
     def visit_predicate(self, node, children):
         token_2_predicate = {'&': grammar.AndPredicate,
                              '!': grammar.NotPredicate}
-        logger.debug(f'visit_predicate:: >>{node}<< #children={len(children)}')
+        logger.debug(f'visit_predicate:: >>{node}<< #children={len(children)}')  # pragma: no mutate
 
         if len(children) == 2:
             token = children[0]
@@ -107,12 +107,12 @@
                 return ast
             else:
                 raise PredicateError(f"token '{token}' not recognised")
-        else:
-            raise  NotImplementedError("visit_predicate, len!=2")      # -- Is this possible?
+        else: # -- Is this possible?
+            raise  NotImplementedError("visit_predicate, len!=2")       # pragma: no mutate
 
 
     def visit_rules(self, node, children):                              # Mix of `ParseRule`(s)`Setting`(s) ; will be sorted out n `Grammar`
-        logger.debug('visit_rules::' + self._logstr_node_children(node, children))
+        logger.debug('visit_rules::' + self._logstr_node_children(node, children))  # pragma: no mutate
         return grammar.Rules(children=children[:], parse_tree=node)
 
 
@@ -129,5 +129,5 @@
         return grammar.ID(name=str(node), parse_tree=node)
 
     def visit_setting(self, node, children):
-        logger.debug('visit_setting::' + self._logstr_node_children(node, children))
+        logger.debug('visit_setting::' + self._logstr_node_children(node, children))  # pragma: no mutate
         return grammar.Setting(name=children[0], value=children[1] , parse_tree=node)