diff-code-change-range 0.0.1__py3-none-any.whl

diff_code_change_range/reference/extractor.py

@@ -0,0 +1,130 @@
+"""Main reference extractor orchestrating the analysis pipeline."""
+
+import sys
+from typing import Dict, List, Optional
+
+from .models import (
+    Reference,
+    ReferenceResult,
+    AffectedScope,
+    AffectedNode,
+    QualifiedNode,
+    NodeType,
+)
+from .scope_parser import ScopeParser
+from .analyzer import ReferenceAnalyzer
+from .differ import ReferenceDiffer
+
+
+def extract_references(
+    before_code: Dict[str, str],
+    after_code: Dict[str, str],
+    affected_scope: AffectedScope
+) -> ReferenceResult:
+    """
+    Extract references between affected nodes in before and after code versions.
+    
+    Args:
+        before_code: Map of file path -> source code for before version
+        after_code: Map of file path -> source code for after version
+        affected_scope: Affected scope trees for before and after
+        
+    Returns:
+        ReferenceResult containing before/after references and their differences
+    """
+    # Parse scope to get qualified nodes
+    parser = ScopeParser(affected_scope)
+    before_nodes, after_nodes = parser.get_all_qualified_nodes()
+    
+    # Filter to only leaf nodes (methods, functions, members) that can contain references
+    before_leaf_nodes = _filter_leaf_nodes(before_nodes)
+    after_leaf_nodes = _filter_leaf_nodes(after_nodes)
+    
+    # Analyze before version
+    before_refs = _analyze_version(
+        before_code,
+        before_leaf_nodes,
+        before_nodes,  # All nodes as potential targets
+        "before"
+    )
+    
+    # Analyze after version
+    after_refs = _analyze_version(
+        after_code,
+        after_leaf_nodes,
+        after_nodes,  # All nodes as potential targets
+        "after"
+    )
+    
+    # Compute differences
+    result = ReferenceDiffer.compute_diff(before_refs, after_refs)
+    
+    return result
+
+
+def _filter_leaf_nodes(nodes: List[QualifiedNode]) -> List[QualifiedNode]:
+    """Filter to only leaf nodes that can contain references (methods, functions, members)."""
+    leaf_types = {
+        NodeType.METHOD,
+        NodeType.FUNCTION,
+        NodeType.MEMBER,
+        NodeType.VARIABLE,
+    }
+    return [n for n in nodes if n.node_type in leaf_types]
+
+
+def _analyze_version(
+    code_map: Dict[str, str],
+    source_nodes: List[QualifiedNode],
+    all_nodes: List[QualifiedNode],
+    version: str
+) -> List[Reference]:
+    """
+    Analyze one version (before or after) and extract references.
+    
+    Args:
+        code_map: Map of file path -> source code
+        source_nodes: List of nodes to analyze as sources (leaf nodes)
+        all_nodes: List of all nodes as potential targets
+        version: "before" or "after" (for logging)
+        
+    Returns:
+        List of references found
+    """
+    all_references = []
+    
+    # Group nodes by file
+    nodes_by_file: Dict[str, List[QualifiedNode]] = {}
+    for node in source_nodes:
+        if node.file_path not in nodes_by_file:
+            nodes_by_file[node.file_path] = []
+        nodes_by_file[node.file_path].append(node)
+    
+    # Analyze each file
+    for file_path, nodes in nodes_by_file.items():
+        if file_path not in code_map:
+            continue
+        
+        source_code = code_map[file_path]
+        if not source_code:
+            continue
+        
+        # Create analyzer with all nodes as potential targets
+        # (within the same version)
+        analyzer = ReferenceAnalyzer(all_nodes, file_path)
+        
+        # Analyze each node in the file
+        for node in nodes:
+            try:
+                refs = analyzer.analyze(source_code, node)
+                # Filter out self-references (source == target)
+                refs = [r for r in refs if r.source != r.target]
+                all_references.extend(refs)
+            except Exception as e:
+                print(
+                    f"Warning: Failed to analyze {node.qualified_path} in {version}: {e}",
+                    file=sys.stderr
+                )
+                continue
+    
+    return all_references

diff_code_change_range/reference/models.py

@@ -0,0 +1,85 @@
+"""Data models for reference extraction."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Optional, Tuple
+
+
+class ReferenceType(Enum):
+    """Types of references between code nodes."""
+    METHOD_CALL = "method_call"
+    FIELD_ACCESS = "field_access"
+    TYPE_REFERENCE = "type_reference"
+    INSTANTIATION = "instantiation"
+    ANNOTATION = "annotation"
+    INHERITANCE = "inheritance"
+    IMPLEMENTATION = "implementation"
+
+
+class NodeType(Enum):
+    """Types of code nodes."""
+    FILE = "file"
+    CLASS = "class"
+    INTERFACE = "interface"
+    OBJECT = "object"
+    ENUM = "enum"
+    FUNCTION = "function"
+    METHOD = "method"
+    MEMBER = "member"
+    VARIABLE = "variable"
+
+
+@dataclass
+class Reference:
+    """Represents a reference from one code node to another."""
+    source: str  # Fully qualified path of source node
+    target: str  # Fully qualified path of target node
+    type: ReferenceType
+    line: Optional[int] = None  # Line number where reference occurs
+
+    def __hash__(self):
+        # For diffing purposes, ignore line number
+        return hash((self.source, self.target, self.type))
+
+    def __eq__(self, other):
+        if not isinstance(other, Reference):
+            return False
+        return (self.source == other.source and 
+                self.target == other.target and 
+                self.type == other.type)
+
+
+@dataclass
+class ReferenceResult:
+    """Result of reference extraction containing before/after references."""
+    before_references: List[Reference] = field(default_factory=list)
+    after_references: List[Reference] = field(default_factory=list)
+    added_references: List[Reference] = field(default_factory=list)
+    removed_references: List[Reference] = field(default_factory=list)
+
+
+@dataclass
+class AffectedNode:
+    """Represents a node in the affected scope tree."""
+    name: str
+    type: NodeType
+    line_range: Optional[Tuple[int, int]] = None
+    children: Optional[List['AffectedNode']] = None
+
+
+@dataclass
+class AffectedScope:
+    """Container for before and after affected scope trees."""
+    before: List[AffectedNode]
+    after: List[AffectedNode]
+
+
+@dataclass
+class QualifiedNode:
+    """Flattened representation of an affected node with its qualified path."""
+    qualified_path: str
+    name: str
+    node_type: NodeType
+    line_range: Tuple[int, int]
+    file_path: str
+    container_path: Optional[str] = None  # Path of parent class/object

diff_code_change_range/reference/scope_parser.py

@@ -0,0 +1,79 @@
+"""Parser for flattening affected scope tree into qualified node list."""
+
+from typing import List, Optional, Tuple
+from .models import AffectedNode, AffectedScope, NodeType, QualifiedNode
+
+
+class ScopeParser:
+    """Parses affected scope and generates qualified paths for nodes."""
+
+    def __init__(self, scope: AffectedScope):
+        self.scope = scope
+
+    def get_all_qualified_nodes(self) -> Tuple[List[QualifiedNode], List[QualifiedNode]]:
+        """Get all qualified nodes for before and after scopes."""
+        before_nodes = self._flatten_nodes(self.scope.before)
+        after_nodes = self._flatten_nodes(self.scope.after)
+        return before_nodes, after_nodes
+
+    def _flatten_nodes(
+        self,
+        nodes: List[AffectedNode],
+        parent_path: str = "",
+        file_path: str = ""
+    ) -> List[QualifiedNode]:
+        """Recursively flatten node tree into qualified nodes."""
+        result = []
+        
+        for node in nodes:
+            current_path, current_file = self._build_path(node, parent_path, file_path)
+            
+            # Create qualified node if it has a line range
+            if node.line_range:
+                qualified = QualifiedNode(
+                    qualified_path=current_path,
+                    name=node.name,
+                    node_type=node.type,
+                    line_range=node.line_range,
+                    file_path=current_file,
+                    container_path=parent_path if parent_path else None
+                )
+                result.append(qualified)
+            
+            # Process children
+            if node.children:
+                result.extend(self._flatten_nodes(node.children, current_path, current_file))
+        
+        return result
+
+    def _build_path(
+        self,
+        node: AffectedNode,
+        parent_path: str,
+        file_path: str
+    ) -> Tuple[str, str]:
+        """Build qualified path for a node."""
+        if node.type == NodeType.FILE:
+            # File node: path is just the file path
+            return node.name, node.name
+        
+        if not parent_path:
+            # Top-level node (function, class, etc.)
+            return f"{file_path}#{node.name}", file_path
+        
+        # Check if parent_path already contains # or $
+        if '#' in parent_path:
+            # Nested node: append to parent path with $ separator
+            return f"{parent_path}${node.name}", file_path
+        else:
+            # parent_path is just a file path
+            return f"{parent_path}#{node.name}", file_path
+
+    def get_nodes_by_file(self, nodes: List[QualifiedNode]) -> dict:
+        """Group qualified nodes by file path."""
+        result = {}
+        for node in nodes:
+            if node.file_path not in result:
+                result[node.file_path] = []
+            result[node.file_path].append(node)
+        return result