07 - Complexity Assessment e Cognitive Load Metrics

# Calcolo della cognitive complexity
class CognitiveComplexityCalculator:
    """Calcola la complessità cognitiva secondo il modello SonarSource"""

    def __init__(self):
        self.complexity = 0
        self.nesting_level = 0

    def calculate(self, ast_node):
        """Calcola la complessità cognitiva di una funzione"""
        self.complexity = 0
        self.nesting_level = 0
        self._visit(ast_node)
        return self.complexity

    def _visit(self, node):
        """Visita ricorsiva dell'AST con calcolo incrementale"""
        import ast

        # Incrementi strutturali (B1): +1 per break nel flusso lineare
        if isinstance(node, (ast.If, ast.For, ast.While)):
            self.complexity += 1  # incremento base
            self.complexity += self.nesting_level  # incremento nesting
            self.nesting_level += 1
            for child in ast.iter_child_nodes(node):
                self._visit(child)
            self.nesting_level -= 1
            return

        # Incrementi per operatori logici composti
        if isinstance(node, ast.BoolOp):
            # Sequenze di and/or contano +1 per switch di operatore
            self.complexity += 1

        # Incrementi per break nel flusso: else, elif, except
        if isinstance(node, ast.ExceptHandler):
            self.complexity += 1
            self.complexity += self.nesting_level

        # Ricorsione e goto (in linguaggi che li supportano): +1
        # Lambda annidate: +1 + nesting
        if isinstance(node, ast.Lambda):
            self.complexity += 1 + self.nesting_level

        for child in ast.iter_child_nodes(node):
            self._visit(child)

# Esempio di codice AI con alta cognitive complexity
# vs versione refactored

# ALTO: Cognitive Complexity = 21
def process_order_ai(order):
    if order:                                      # +1
        if order.status == "pending":              # +2 (nesting=1)
            for item in order.items:               # +3 (nesting=2)
                if item.quantity > 0:              # +4 (nesting=3)
                    if item.in_stock:              # +5 (nesting=4)
                        try:                       #
                            charge(item)           #
                        except PaymentError:       # +6 (nesting=4)
                            if item.retry_count < 3:  # +7 (nesting=5)
                                retry(item)
                            else:
                                cancel(item)
    return None

# BASSO: Cognitive Complexity = 7
def process_order_refactored(order):
    if not order or order.status != "pending":     # +1
        return None

    for item in order.items:                       # +1
        process_single_item(item)                  # funzione estratta

def process_single_item(item):
    if item.quantity <= 0 or not item.in_stock:   # +1 (+1 operatore)
        return
    try_charge_item(item)                          # funzione estratta

def try_charge_item(item):
    try:
        charge(item)
    except PaymentError:                           # +1
        if item.retry_count < 3:                   # +2 (nesting=1)
            retry(item)
        else:                                      # +1
            cancel(item)
      

import math

class HalsteadMetrics:
    """Calcola le metriche di Halstead per il codice sorgente"""

    def __init__(self, operators, operands):
        # n1 = numero di operatori distinti
        # n2 = numero di operandi distinti
        # N1 = numero totale di operatori
        # N2 = numero totale di operandi
        self.n1 = len(set(operators))
        self.n2 = len(set(operands))
        self.N1 = len(operators)
        self.N2 = len(operands)

    def vocabulary(self):
        """n = n1 + n2: vocabolario del programma"""
        return self.n1 + self.n2

    def length(self):
        """N = N1 + N2: lunghezza del programma"""
        return self.N1 + self.N2

    def volume(self):
        """V = N * log2(n): volume del programma"""
        n = self.vocabulary()
        N = self.length()
        return N * math.log2(n) if n > 0 else 0

    def difficulty(self):
        """D = (n1/2) * (N2/n2): difficolta del programma"""
        if self.n2 == 0:
            return 0
        return (self.n1 / 2) * (self.N2 / self.n2)

    def effort(self):
        """E = D * V: effort di implementazione"""
        return self.difficulty() * self.volume()

    def time_to_program(self):
        """T = E / 18: tempo stimato in secondi (Stroud number)"""
        return self.effort() / 18

    def bugs_estimate(self):
        """B = V / 3000: stima dei bug (metrica empirica)"""
        return self.volume() / 3000

    def summary(self):
        """Riepilogo completo delle metriche"""
        return {
            "vocabulary": self.vocabulary(),
            "length": self.length(),
            "volume": round(self.volume(), 2),
            "difficulty": round(self.difficulty(), 2),
            "effort": round(self.effort(), 2),
            "time_seconds": round(self.time_to_program(), 2),
            "estimated_bugs": round(self.bugs_estimate(), 3)
        }
      

# Architecture Fitness Functions per codice AI
class ArchitectureFitness:
    """Valuta l'aderenza architetturale del codice AI"""

    def __init__(self, project_structure, architecture_rules):
        self.structure = project_structure
        self.rules = architecture_rules

    def evaluate_all(self):
        """Esegue tutte le fitness functions"""
        return {
            "coupling": self._check_coupling(),
            "cohesion": self._check_cohesion(),
            "layer_violations": self._check_layer_violations(),
            "circular_dependencies": self._check_circular_deps(),
            "component_size": self._check_component_size(),
            "overall_fitness": self._calculate_overall_score()
        }

    def _check_coupling(self):
        """Misura l'accoppiamento tra moduli"""
        # Afferent coupling (Ca): chi dipende da me
        # Efferent coupling (Ce): da chi dipendo
        # Instability = Ce / (Ca + Ce)
        results = []
        for module in self.structure.modules:
            ca = len(module.dependents)
            ce = len(module.dependencies)
            instability = ce / (ca + ce) if (ca + ce) > 0 else 0
            results.append({
                "module": module.name,
                "afferent": ca,
                "efferent": ce,
                "instability": round(instability, 2),
                "status": "OK" if instability < 0.7 else "WARNING"
            })
        return results

    def _check_layer_violations(self):
        """Verifica che i layer architetturali siano rispettati"""
        # Es: presentation non deve importare da data layer
        violations = []
        for rule in self.rules.get("layer_rules", []):
            source = rule["from_layer"]
            forbidden = rule["cannot_import"]
            imports = self.structure.get_imports(source)
            for imp in imports:
                if any(f in imp for f in forbidden):
                    violations.append({
                        "from": source,
                        "imports": imp,
                        "forbidden_layer": forbidden,
                        "severity": "HIGH"
                    })
        return violations