statable 3.1.0__py3-none-any.whl

codegen/validate/items/queue_validator.py

@@ -0,0 +1,73 @@
+# codegen/validate/items/queue_validator.py
+"""\nQueue validation\n"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class QueueValidator(BaseValidator):
+    """Queue validation class"""
+    
+    category = "queue"
+    
+    def __init__(self):
+        logger.debug("QueueValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'QUEUE_INVALID_SIZE': self._check_invalid_size,
+            'QUEUE_UNDEFINED_EVENT': self._check_undefined_event,
+        }
+        logger.debug(f"QueueValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"QueueValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_invalid_size(self, context):
+        issues = []
+        for queue in context.event_queues:
+            size = getattr(queue, 'size', 0)
+            name = getattr(queue, 'name', '')
+            if size <= 0:
+                issues.append(self._create_issue('QUEUE_INVALID_SIZE', name=name))
+        return issues
+    
+    def _check_undefined_event(self, context):
+        issues = []
+        event_names = set(context.events.keys())
+        for queue in context.event_queues:
+            event_ids = getattr(queue, 'event_ids', [])
+            name = getattr(queue, 'name', '')
+            for event_id in event_ids:
+                if event_id not in event_names:
+                    issues.append(self._create_issue('QUEUE_UNDEFINED_EVENT', name=name))
+        return issues

codegen/validate/items/role_function_validator.py

@@ -0,0 +1,175 @@
+# codegen/validate/items/role_function_validator.py
+"""
+Role function validation
+"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class RoleFunctionValidator(BaseValidator):
+    """Role function validator class"""
+    
+    category = "role_function"
+    
+    def __init__(self):
+        logger.debug("RoleFunctionValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'ROLE_FUNC_NO_RETURN_TYPE': self._check_no_return_type,
+            'ROLE_FUNC_ARG_MISMATCH': self._check_arg_mismatch,
+            'ROLE_FUNC_UNUSED': self._check_unused_functions,
+        }
+        logger.debug(f"RoleFunctionValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"RoleFunctionValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_no_return_type(self, context):
+        issues = []
+        for name, func in context.role_functions.items():
+            return_type = getattr(func, 'return_type', '')
+            if not return_type:
+                issues.append(self._create_issue('ROLE_FUNC_NO_RETURN_TYPE', name=name))
+        return issues
+    
+    def _check_arg_mismatch(self, context):
+        issues = []
+        for name, func in context.role_functions.items():
+            arg1_type = getattr(func, 'arg1_type', '')
+            arg1_name = getattr(func, 'arg1_name', '')
+            arg2_type = getattr(func, 'arg2_type', '')
+            arg2_name = getattr(func, 'arg2_name', '')
+            if (arg1_type and not arg1_name) or (arg1_name and not arg1_type):
+                issues.append(self._create_issue('ROLE_FUNC_ARG_MISMATCH', name=name))
+            if (arg2_type and not arg2_name) or (arg2_name and not arg2_type):
+                issues.append(self._create_issue('ROLE_FUNC_ARG_MISMATCH', name=name))
+        return issues
+    
+    def _collect_referenced_names(self, context):
+        """[v2.7.2 fix] Collect every name that references a role function.
+
+        Sources:
+          - Transition.action / .pre_actions / .else_actions
+          - Transition.condition (parsed for RoleFunc_X / NS.Name)
+          - State.entry / exit / do_actions
+          - Cell actions (via state_machine.get_actions_for_cell)
+          - Event.trigger_detail.caller
+        """
+        import re
+        used = set()
+
+        def add(ref):
+            if not ref:
+                return
+            ref = str(ref).strip()
+            if not ref:
+                return
+            used.add(ref)
+            if '.' in ref:
+                used.add(ref.split('.', 1)[1])
+
+        def add_text(text):
+            if not text:
+                return
+            text = str(text)
+            # RoleFunc_<NS>_<Name> pattern
+            for m in re.finditer(r'RoleFunc_(\w+)', text):
+                used.add(m.group(0))
+                used.add(m.group(1))
+            # NS.Name pattern
+            for m in re.finditer(r'([A-Z]\w*)\.([A-Za-z_]\w*)', text):
+                used.add(f"{m.group(1)}.{m.group(2)}")
+                used.add(m.group(2))
+
+        # 1. Transitions
+        for t in getattr(context, 'transitions', []) or []:
+            add(getattr(t, 'action', ''))
+            add_text(getattr(t, 'condition', ''))
+            for a in (getattr(t, 'pre_actions', []) or []):
+                add(a)
+            for a in (getattr(t, 'else_actions', []) or []):
+                add(a)
+
+        # 2. Via state_machine (defensive)
+        sm = (getattr(context, 'state_machine', None)
+              or getattr(context, 'sm', None))
+        if sm is not None:
+            for state in (getattr(sm, 'states', {}) or {}).values():
+                for attr in ('entry', 'exit', 'do_actions'):
+                    for a in (getattr(state, attr, []) or []):
+                        rf = getattr(a, 'role_function', None)
+                        if rf:
+                            add(rf)
+                        elif isinstance(a, str):
+                            add(a)
+            for ev in (getattr(sm, 'events', {}) or {}).values():
+                td = getattr(ev, 'trigger_detail', None)
+                if td is not None:
+                    add(getattr(td, 'caller', ''))
+            try:
+                for key in sm.get_cell_keys():
+                    for a in sm.get_actions_for_cell(*key):
+                        rf = getattr(a, 'role_function', None)
+                        if rf:
+                            add(rf)
+            except Exception:
+                pass
+
+        # 3. Fallback: context.states
+        for state in (getattr(context, 'states', {}) or {}).values():
+            for attr in ('entry', 'exit', 'do_actions'):
+                for a in (getattr(state, attr, []) or []):
+                    rf = getattr(a, 'role_function', None)
+                    if rf:
+                        add(rf)
+                    elif isinstance(a, str):
+                        add(a)
+
+        return used
+
+    def _check_unused_functions(self, context):
+        """[v2.7.2 fix] Match refs via bare / qualified / RoleFunc_ aliases."""
+        issues = []
+        used = self._collect_referenced_names(context)
+        for name, func in context.role_functions.items():
+            aliases = {name}
+            ns = getattr(func, 'namespace', '') or ''
+            if ns:
+                aliases.add(f"{ns}.{name}")
+                aliases.add(f"RoleFunc_{ns}_{name}")
+            aliases.add(f"RoleFunc_{name}")
+            if aliases & used:
+                continue
+            issues.append(self._create_issue('ROLE_FUNC_UNUSED', name=name))
+        return issues

codegen/validate/items/state_validator.py

@@ -0,0 +1,88 @@
+# codegen/validate/items/state_validator.py
+"""\nState validation\n"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class StateValidator(BaseValidator):
+    """State validation class"""
+    
+    category = "state"
+    
+    def __init__(self):
+        logger.debug("StateValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'STATE_NO_INITIAL': self._check_initial_state,
+            'STATE_UNREACHABLE': self._check_unreachable_states,
+            'STATE_NO_TRANSITION': self._check_no_transition_states,
+            'STATE_DUPLICATE': self._check_duplicate_states,
+        }
+        logger.debug(f"StateValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"StateValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _check_initial_state(self, context):
+        if context.initial_state is None:
+            return [self._create_issue('STATE_NO_INITIAL')]
+        return []
+    
+    def _check_unreachable_states(self, context):
+        issues = []
+        reachable = set(t.target for t in context.transitions if t.target)
+        for name in context.states.keys():
+            if name not in reachable and name != context.initial_state:
+                issues.append(self._create_issue('STATE_UNREACHABLE', name=name))
+        return issues
+    
+    def _check_no_transition_states(self, context):
+        issues = []
+        sources = set(t.source for t in context.transitions)
+        for name in context.states.keys():
+            if name not in sources:
+                issues.append(self._create_issue('STATE_NO_TRANSITION', name=name))
+        return issues
+    
+    def _check_duplicate_states(self, context):
+        issues = []
+        lower_names = {}
+        for name in context.states.keys():
+            lower = name.lower()
+            if lower in lower_names:
+                issues.append(self._create_issue('STATE_DUPLICATE', name=name, other=lower_names[lower]))
+            else:
+                lower_names[lower] = name
+        return issues

codegen/validate/items/timer_validator.py

@@ -0,0 +1,120 @@
+# codegen/validate/items/timer_validator.py
+"""
+Timer validation
+"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class TimerValidator(BaseValidator):
+    """Timer validator class"""
+    
+    category = "timer"
+    
+    def __init__(self):
+        logger.debug("TimerValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'TIMER_DUPLICATE_VARIABLE': self._check_duplicate_variables,
+            'TIMER_INVALID_MULTIPLIER': self._check_invalid_multiplier,
+        }
+        logger.debug(f"TimerValidator.__init__ completed: {len(self.rules)} rules")
+    
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug(f"TimerValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        return issues
+    
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=kwargs.get('name', ''),
+        )
+    
+    def _get_all_timer_variables(self, context):
+        timer_vars = []
+        timer_base = context.timer_base
+        if timer_base:
+            timer_vars.append(getattr(timer_base, 'variable_name', ''))
+            for derived in getattr(timer_base, 'derived', []):
+                timer_vars.append(getattr(derived, 'variable_name', ''))
+        for timer in context.extra_timers:
+            timer_vars.append(getattr(timer, 'variable_name', ''))
+            for derived in getattr(timer, 'derived', []):
+                timer_vars.append(getattr(derived, 'variable_name', ''))
+        return timer_vars
+    
+    def _check_duplicate_variables(self, context):
+        """[v2.7.2 fix] Skip when the conflicting SystemVariable is group='Timer'.
+
+        The TUTORIAL declares 'g_system_tick' in both:
+          - <SystemVariables> with group="Timer"
+          - <TimerBase variable_name="g_system_tick">
+        This is the intended pattern (timer base names its counter
+        variable, which is also a shared SystemVariable). Only flag:
+          - two timer bases using the same variable_name
+          - timer name conflicting with a non-Timer SystemVariable
+        """
+        issues = []
+        var_groups = {}
+        for v in context.variables:
+            name = getattr(v, 'name', '')
+            group = getattr(v, 'group', '')
+            var_groups[name] = group
+        timer_vars = self._get_all_timer_variables(context)
+        seen = set()
+        for var_name in timer_vars:
+            if not var_name:
+                continue
+            if var_name in seen:
+                issues.append(self._create_issue(
+                    'TIMER_DUPLICATE_VARIABLE', name=var_name))
+                continue
+            if var_name in var_groups:
+                if var_groups[var_name] == 'Timer':
+                    pass  # expected: shared SystemVariable + TimerBase
+                else:
+                    issues.append(self._create_issue(
+                        'TIMER_DUPLICATE_VARIABLE', name=var_name))
+            seen.add(var_name)
+        return issues
+    
+    def _check_invalid_multiplier(self, context):
+        issues = []
+        timer_base = context.timer_base
+        if timer_base:
+            for derived in getattr(timer_base, 'derived', []):
+                multiplier = getattr(derived, 'multiplier', 0)
+                name = getattr(derived, 'variable_name', '')
+                if multiplier <= 0:
+                    issues.append(self._create_issue('TIMER_INVALID_MULTIPLIER', name=name))
+        for timer in context.extra_timers:
+            for derived in getattr(timer, 'derived', []):
+                multiplier = getattr(derived, 'multiplier', 0)
+                name = getattr(derived, 'variable_name', '')
+                if multiplier <= 0:
+                    issues.append(self._create_issue('TIMER_INVALID_MULTIPLIER', name=name))
+        return issues

codegen/validate/items/transition_validator.py

@@ -0,0 +1,113 @@
+# codegen/validate/items/transition_validator.py
+"""
+Transition validation
+
+[v1.8 section 11.2 #6]
+  - Unified logger output with StateValidator
+  - Added start / completion logs to __init__ / validate
+  - Wrapped rule execution in try/except; on failure, log via logger.error
+"""
+
+import sys
+import os
+from typing import List
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from ..logger import logger
+from ..models import ValidationIssue, ValidationSeverity, ValidationContext
+from ..data.validation_rules import VALIDATION_RULES
+from .base_validator import BaseValidator
+
+
+class TransitionValidator(BaseValidator):
+    """Transition validation class"""
+
+    category = "transition"
+
+    def __init__(self):
+        logger.debug("TransitionValidator.__init__ started")
+        self.rules_data = VALIDATION_RULES.get(self.category, {})
+        self.rules = {
+            'TRANSITION_TARGET_UNDEFINED': self._check_target_undefined,
+            'TRANSITION_EVENT_UNDEFINED': self._check_event_undefined,
+            'TRANSITION_SOURCE_UNDEFINED': self._check_source_undefined,
+            'TRANSITION_DUPLICATE': self._check_duplicate_transitions,
+            'TRANSITION_SELF_LOOP': self._check_self_loops,
+        }
+        logger.debug(f"TransitionValidator.__init__ completed: {len(self.rules)} rules")
+
+    def validate(self, context: ValidationContext) -> List[ValidationIssue]:
+        logger.debug("TransitionValidator.validate started")
+        issues = []
+        for code, rule_func in self.rules.items():
+            try:
+                result = rule_func(context)
+                if result:
+                    issues.extend(result)
+            except Exception as e:
+                logger.error(f"Rule '{code}' failed: {e}", exc_info=True)
+        logger.debug(f"TransitionValidator.validate completed: {len(issues)} issues")
+        return issues
+
+    def _create_issue(self, code: str, **kwargs) -> ValidationIssue:
+        rule = self.rules_data.get(code, {})
+        message = rule.get('message', '').format(**kwargs)
+        severity = ValidationSeverity.from_string(rule.get('severity', 'info'))
+
+        target = kwargs.get('target', '') or kwargs.get('source', '') or kwargs.get('event', '')
+
+        return ValidationIssue(
+            category=self.category,
+            code=code,
+            message=message,
+            severity=severity,
+            suggestion=rule.get('suggestion', ''),
+            target=target,
+        )
+
+    def _check_target_undefined(self, context):
+        issues = []
+        state_names = set(context.states.keys())
+        for t in context.transitions:
+            if t.target and t.target not in state_names:
+                issues.append(self._create_issue('TRANSITION_TARGET_UNDEFINED', target=t.target))
+        return issues
+
+    def _check_event_undefined(self, context):
+        issues = []
+        event_names = set(context.events.keys())
+        for t in context.transitions:
+            if t.event and t.event not in event_names:
+                issues.append(self._create_issue('TRANSITION_EVENT_UNDEFINED', event=t.event))
+        return issues
+
+    def _check_source_undefined(self, context):
+        issues = []
+        state_names = set(context.states.keys())
+        for t in context.transitions:
+            if t.source not in state_names:
+                issues.append(self._create_issue('TRANSITION_SOURCE_UNDEFINED', source=t.source))
+        return issues
+
+    def _check_duplicate_transitions(self, context):
+        issues = []
+        seen = set()
+        for t in context.transitions:
+            key = (t.source, t.event, t.target)
+            if key in seen:
+                issues.append(self._create_issue(
+                    'TRANSITION_DUPLICATE', source=t.source, event=t.event, target=t.target
+                ))
+            else:
+                seen.add(key)
+        return issues
+
+    def _check_self_loops(self, context):
+        issues = []
+        for t in context.transitions:
+            if t.source == t.target:
+                issues.append(self._create_issue(
+                    'TRANSITION_SELF_LOOP', source=t.source, event=t.event
+                ))
+        return issues