graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/infrastructure/parsing/groovy_parser.py

@@ -0,0 +1,198 @@
+"""
+Groovy / Jenkinsfile parser — extracts pipeline definitions, shared library
+functions, stage names, and library references.
+
+Handles:
+  - Jenkins Shared Library vars/*.groovy  (def call(...) functions)
+  - Jenkinsfile / pipeline_config.groovy  (pipeline{}, libraries{}, stages)
+  - JTE (Jenkins Templating Engine) configs
+
+Extracts:
+  - Function definitions (def call, def myFunc)
+  - Library references (libraries { helm_deploy() }, @Library('name'))
+  - Stage names (stage('Build') { ... })
+  - Shell commands with service/image names
+  - Environment variables and credentials references
+  - evaluate(new File("other.groovy")) — local lib imports
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from src.domain.repositories.i_code_parser import ParseResult
+
+
+# ---------------------------------------------------------------------------
+# Patterns
+# ---------------------------------------------------------------------------
+
+# def call(Map config) / def call() / async def myFunc(x)
+_RE_DEF = re.compile(r'\bdef\s+(\w+)\s*\(', re.M)
+
+# @Library('jenkins-shared-library') / @Library(['lib1','lib2'])
+_RE_AT_LIBRARY = re.compile(r"@Library\s*\(\s*['\"]([^'\"]+)['\"]", re.I)
+
+# libraries { helm_deploy() }  — JTE style
+_RE_LIBRARIES_BLOCK = re.compile(r'libraries\s*\{([^}]{0,2000})\}', re.S)
+_RE_LIBRARY_ENTRY   = re.compile(r'(\w[\w-]*)\s*\{', re.M)  # name { ... }
+
+# stage('Build') { ... }
+_RE_STAGE = re.compile(r"stage\s*\(\s*['\"]([^'\"]+)['\"]", re.I)
+
+# evaluate(new File("other.groovy"))
+_RE_EVALUATE = re.compile(r'evaluate\s*\(\s*new\s+File\s*\(\s*["\']([^"\']+)["\']', re.I)
+
+# pipeline_template = "Jenkinsfile_services_ci"
+_RE_TEMPLATE = re.compile(r'pipeline_template\s*=\s*["\']([^"\']+)["\']', re.I)
+
+# sh "docker build ... service-name ..."  — extract image/service hints
+_RE_SH_IMAGE = re.compile(r'\bsh\s+["\'].*?([\w-]+-service[\w-]*|[\w-]+-app[\w-]*)["\']', re.I)
+
+# credentialsId: "${config.xxx}" or 'my-credential-id'
+_RE_CRED = re.compile(r'credentialsId\s*[=:]\s*["\']([^"\'$]{3,60})["\']', re.I)
+
+# withCredentials, withAWS, azureKeyVault — external service hints
+_RE_EXT_SERVICE = re.compile(
+    r'\b(withCredentials|azureKeyVault|withAWS|dockerRegistry|artifactory|helm|kubectl|az\s+\w+)\s*[\(\{]',
+    re.I,
+)
+
+
+def _line_of(content: str, pos: int) -> int:
+    return content[:pos].count('\n') + 1
+
+
+class GroovyParser:
+    """Parser for Groovy/Jenkinsfile source files."""
+
+    GROOVY_EXTENSIONS = {'.groovy', '.Jenkinsfile', ''}  # empty for bare 'Jenkinsfile'
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        suffix = file_path.suffix.lower()
+        name   = file_path.name
+
+        # Accept .groovy files and bare Jenkinsfile / pipeline_config
+        is_groovy = (
+            suffix == '.groovy'
+            or name in ('Jenkinsfile', 'Jenkinsfile_ci', 'Jenkinsfile_cd',
+                        'pipeline_config', 'pipeline_properties')
+            or name.startswith('Jenkinsfile')
+        )
+        if not is_groovy:
+            return ParseResult(file_path=file_path)
+
+        if not file_path.exists():
+            return ParseResult(file_path=file_path)
+
+        try:
+            content = file_path.read_text(encoding='utf-8', errors='replace')
+        except Exception:
+            return ParseResult(file_path=file_path)
+
+        # ── Module name ────────────────────────────────────────────────────
+        stem = file_path.stem
+        module_name = stem
+
+        # ── Classes = pipeline definitions / shared-lib files ─────────────
+        classes = []
+
+        # One class per file representing the pipeline/lib file itself
+        classes.append({
+            'name': stem,
+            'qualified_name': module_name,
+            'node_type': 'CLASS',
+            'line': 1,
+            'metadata': {
+                'language': 'groovy',
+                'file_type': 'jenkinsfile' if 'Jenkinsfile' in name else 'shared_lib',
+                'file_path': str(file_path),
+            }
+        })
+
+        # ── Methods = def call / def xxx ───────────────────────────────────
+        methods = []
+        for m in _RE_DEF.finditer(content):
+            fn = m.group(1)
+            methods.append({
+                'name': fn,
+                'qualified_name': f"{module_name}.{fn}",
+                'node_type': 'METHOD',
+                'line': _line_of(content, m.start()),
+                'metadata': {
+                    'language': 'groovy',
+                    'file_path': str(file_path),
+                }
+            })
+
+        # ── Imports = @Library + evaluate() + libraries{} block ───────────
+        imports = []
+        seen: set[str] = set()
+
+        def add_import(lib: str, line: int, source: str):
+            lib = lib.strip()
+            if lib and lib not in seen:
+                seen.add(lib)
+                imports.append({
+                    'import_path': lib,
+                    'line': line,
+                    'metadata': {'source': source},
+                })
+
+        # @Library('jenkins-shared-library')
+        for m in _RE_AT_LIBRARY.finditer(content):
+            add_import(m.group(1), _line_of(content, m.start()), '@Library')
+
+        # evaluate(new File("serviceUtil.groovy"))
+        for m in _RE_EVALUATE.finditer(content):
+            lib = m.group(1).replace('.groovy', '')
+            add_import(lib, _line_of(content, m.start()), 'evaluate')
+
+        # libraries { helm_deploy { } docker_build { } }
+        for block in _RE_LIBRARIES_BLOCK.finditer(content):
+            block_text = block.group(1)
+            for entry in _RE_LIBRARY_ENTRY.finditer(block_text):
+                name_candidate = entry.group(1)
+                if name_candidate not in ('jte', 'pipeline', 'stage', 'steps', 'post', 'environment'):
+                    add_import(name_candidate, _line_of(content, block.start()), 'libraries{}')
+
+        # ── Method calls = stages + external services ─────────────────────
+        method_calls = []
+
+        # Stage names → useful for understanding pipeline structure
+        for m in _RE_STAGE.finditer(content):
+            method_calls.append({
+                'callee': f"stage.{m.group(1).replace(' ','_')}",
+                'line': _line_of(content, m.start()),
+                'metadata': {'stage_name': m.group(1)},
+            })
+
+        # pipeline_template reference
+        for m in _RE_TEMPLATE.finditer(content):
+            method_calls.append({
+                'callee': f"pipeline_template.{m.group(1)}",
+                'is_api_call': False,
+                'line': _line_of(content, m.start()),
+            })
+
+        # External service hints (Azure, Helm, kubectl, Artifactory)
+        for m in _RE_EXT_SERVICE.finditer(content):
+            method_calls.append({
+                'callee': m.group(1).strip(),
+                'line': _line_of(content, m.start()),
+                'metadata': {'ext_service': True},
+            })
+
+        # ── String literals (credentials, images) ─────────────────────────
+        string_literals: list[str] = []
+        for m in _RE_CRED.finditer(content):
+            string_literals.append(f"credential:{m.group(1)}")
+
+        return ParseResult(
+            file_path=file_path,
+            classes=classes,
+            methods=methods,
+            imports=imports,
+            method_calls=method_calls,
+            string_literals=string_literals,
+        )

src/infrastructure/parsing/maven_dependency_parser.py

@@ -0,0 +1,147 @@
+"""Maven pom.xml dependency parser using lxml.
+
+This module provides parsing capabilities for Maven POM files to extract
+dependency information for the dependency analysis system.
+"""
+
+from typing import Any, TypedDict
+from lxml import etree
+from src.domain.value_objects.dependency_type import DependencyType
+
+
+class MavenDependency(TypedDict):
+    """Type definition for Maven dependency dictionary."""
+
+    group_id: str
+    artifact_id: str
+    version: str
+    scope: str
+    type: DependencyType
+
+
+class MavenDependencyParser:
+    """Parser for Maven pom.xml files to extract dependencies.
+
+    Parses Maven POM files using lxml with proper namespace handling.
+    Extracts dependency information: groupId, artifactId, version, scope.
+    Filters out test-scoped dependencies by default.
+
+    Attributes:
+        MAVEN_NS: Maven POM namespace URI
+        NAMESPACES: Namespace mapping for XPath queries
+    """
+
+    # Maven POM namespace
+    MAVEN_NS = "http://maven.apache.org/POM/4.0.0"
+    NAMESPACES = {"mvn": MAVEN_NS}
+    DEFAULT_SCOPE = "compile"
+    MANAGED_VERSION = "managed"
+
+    def parse(self, pom_content: str) -> list[MavenDependency]:
+        """Parse pom.xml content and extract dependencies.
+
+        Args:
+            pom_content: String content of pom.xml file
+
+        Returns:
+            List of MavenDependency dictionaries with keys:
+            - group_id: Maven groupId (e.g., 'org.springframework.boot')
+            - artifact_id: Maven artifactId (e.g., 'spring-boot-starter-web')
+            - version: Version string or 'managed' if not specified
+            - scope: Dependency scope (compile, runtime, provided, test)
+            - type: Always DependencyType.LIBRARY
+
+        Raises:
+            etree.XMLSyntaxError: If XML is malformed
+
+        Note:
+            Test-scoped dependencies (scope='test') are filtered out.
+        """
+        root = self._parse_xml(pom_content)
+        dependency_elements = self._find_dependency_elements(root)
+
+        dependencies: list[MavenDependency] = []
+
+        for dep_elem in dependency_elements:
+            dependency = self._extract_dependency(dep_elem)
+
+            # Skip if essential fields are missing or test-scoped
+            if dependency is None:
+                continue
+
+            dependencies.append(dependency)
+
+        return dependencies
+
+    def _parse_xml(self, pom_content: str) -> etree._Element:
+        """Parse XML content into element tree.
+
+        Args:
+            pom_content: String content of pom.xml file
+
+        Returns:
+            Root element of parsed XML tree
+
+        Raises:
+            etree.XMLSyntaxError: If XML is malformed
+        """
+        try:
+            return etree.fromstring(pom_content.encode("utf-8"))
+        except etree.XMLSyntaxError as e:
+            raise etree.XMLSyntaxError(f"Failed to parse pom.xml: {e}") from e
+
+    def _find_dependency_elements(self, root: etree._Element) -> list[etree._Element]:
+        """Find all dependency elements using XPath.
+
+        Args:
+            root: Root element of parsed XML
+
+        Returns:
+            List of dependency elements
+        """
+        return root.xpath("//mvn:dependency", namespaces=self.NAMESPACES)
+
+    def _extract_dependency(self, dep_elem: etree._Element) -> MavenDependency | None:
+        """Extract dependency information from XML element.
+
+        Args:
+            dep_elem: Dependency XML element
+
+        Returns:
+            MavenDependency dictionary or None if essential fields missing or test-scoped
+        """
+        # Extract fields using XPath with namespace
+        group_id = self._extract_text(dep_elem, "mvn:groupId")
+        artifact_id = self._extract_text(dep_elem, "mvn:artifactId")
+        version = self._extract_text(dep_elem, "mvn:version") or self.MANAGED_VERSION
+        scope = self._extract_text(dep_elem, "mvn:scope") or self.DEFAULT_SCOPE
+
+        # Skip if essential fields are missing
+        if not group_id or not artifact_id:
+            return None
+
+        # Filter out test-scoped dependencies
+        if scope == "test":
+            return None
+
+        # Build dependency dictionary
+        return MavenDependency(
+            group_id=group_id,
+            artifact_id=artifact_id,
+            version=version,
+            scope=scope,
+            type=DependencyType.LIBRARY,
+        )
+
+    def _extract_text(self, elem: etree._Element, xpath: str) -> str | None:
+        """Extract text from XML element using XPath.
+
+        Args:
+            elem: Parent XML element
+            xpath: XPath query string
+
+        Returns:
+            Text content or None if element not found
+        """
+        result = elem.xpath(xpath, namespaces=self.NAMESPACES)
+        return result[0].text if result and result[0].text else None

src/infrastructure/parsing/microfrontend_config_parser.py

@@ -0,0 +1,242 @@
+"""MicrofrontendConfigParser - Parse microfrontend configurations.
+
+Detects and extracts webpack module federation and single-spa configurations.
+Creates dependency nodes and edges for graph storage.
+"""
+import re
+from pathlib import Path
+from typing import Any
+
+
+class MicrofrontendConfigParser:
+    """
+    Microfrontend configuration parser.
+
+    Extracts module federation and single-spa configurations from config files.
+    """
+
+    def __init__(self, typescript_parser=None):
+        """
+        Initialize with optional TypeScript parser (Task 12.3).
+
+        Args:
+            typescript_parser: TreeSitterTypeScriptParser instance for parsing config files
+        """
+        self.typescript_parser = typescript_parser
+
+    def detect_module_federation(self, file_path: Path) -> dict | None:
+        """
+        Detect webpack module federation configuration.
+
+        Args:
+            file_path: Path to webpack config file
+
+        Returns:
+            Dict with exposed modules and remotes, or None if not found
+        """
+        if not file_path.exists():
+            return None
+
+        content = file_path.read_text(encoding="utf-8")
+
+        # Simple regex-based detection for ModuleFederationPlugin
+        if "ModuleFederationPlugin" not in content:
+            return None
+
+        config = {
+            "type": "module_federation",
+            "name": self._extract_name(content),
+            "exposes": self._extract_exposes(content),
+            "remotes": self._extract_remotes(content),
+            "shared": self._extract_shared(content),
+        }
+
+        return config
+
+    def detect_single_spa(self, file_path: Path) -> dict | None:
+        """
+        Detect single-spa configuration.
+
+        Args:
+            file_path: Path to single-spa config file
+
+        Returns:
+            Dict with registered applications, or None if not found
+        """
+        if not file_path.exists():
+            return None
+
+        content = file_path.read_text(encoding="utf-8")
+
+        # Simple detection for registerApplication
+        if "registerApplication" not in content:
+            return None
+
+        config = {
+            "type": "single_spa",
+            "applications": self._extract_applications(content),
+        }
+
+        return config
+
+    def _extract_name(self, content: str) -> str | None:
+        """Extract module federation name."""
+        # name: "app_name"
+        match = re.search(r'name:\s*["\']([^"\']+)["\']', content)
+        if match:
+            return match.group(1)
+        return None
+
+    def _extract_exposes(self, content: str) -> dict:
+        """Extract exposed modules from module federation config."""
+        exposes = {}
+
+        # exposes: { "./Component": "./src/Component" }
+        exposes_match = re.search(
+            r"exposes:\s*\{([^}]+)\}", content, re.DOTALL
+        )
+        if exposes_match:
+            exposes_block = exposes_match.group(1)
+            # Extract key-value pairs
+            for match in re.finditer(
+                r'["\']([^"\']+)["\']\s*:\s*["\']([^"\']+)["\']', exposes_block
+            ):
+                key = match.group(1)
+                value = match.group(2)
+                exposes[key] = value
+
+        return exposes
+
+    def _extract_remotes(self, content: str) -> dict:
+        """Extract remote entries from module federation config."""
+        remotes = {}
+
+        # remotes: { app1: "app1@http://localhost:3001/remoteEntry.js" }
+        remotes_match = re.search(
+            r"remotes:\s*\{([^}]+)\}", content, re.DOTALL
+        )
+        if remotes_match:
+            remotes_block = remotes_match.group(1)
+            for match in re.finditer(
+                r'["\']?(\w+)["\']?\s*:\s*["\']([^"\']+)["\']', remotes_block
+            ):
+                key = match.group(1)
+                value = match.group(2)
+                remotes[key] = value
+
+        return remotes
+
+    def _extract_shared(self, content: str) -> list[str]:
+        """Extract shared dependencies."""
+        shared = []
+
+        # shared: ["react", "react-dom"]
+        shared_match = re.search(
+            r"shared:\s*\[([^\]]+)\]", content, re.DOTALL
+        )
+        if shared_match:
+            shared_block = shared_match.group(1)
+            for match in re.finditer(r'["\']([^"\']+)["\']', shared_block):
+                shared.append(match.group(1))
+
+        return shared
+
+    def _extract_applications(self, content: str) -> list[dict]:
+        """Extract registered applications from single-spa config."""
+        applications = []
+
+        # registerApplication({ name: "app1", app: () => import("app1"), activeWhen: "/" })
+        for match in re.finditer(
+            r'registerApplication\s*\(\s*\{([^}]+)\}\s*\)', content, re.DOTALL
+        ):
+            app_block = match.group(1)
+
+            name_match = re.search(r'name:\s*["\']([^"\']+)["\']', app_block)
+            url_match = re.search(r'app:\s*["\']([^"\']+)["\']', app_block)
+
+            if name_match:
+                app = {"name": name_match.group(1)}
+                if url_match:
+                    app["url"] = url_match.group(1)
+                applications.append(app)
+
+        return applications
+
+    def create_dependency_nodes_and_edges(
+        self, config: dict, repository_name: str
+    ) -> tuple[list[dict], list[dict]]:
+        """
+        Create dependency nodes and edges from microfrontend config (Task 3.3).
+
+        Args:
+            config: Parsed microfrontend configuration
+            repository_name: Name of the repository
+
+        Returns:
+            Tuple of (nodes, edges) lists
+        """
+        nodes = []
+        edges = []
+
+        if config["type"] == "module_federation":
+            # Create nodes for exposed modules
+            for expose_key, expose_path in config.get("exposes", {}).items():
+                node = {
+                    "node_type": "MICROFRONTEND",
+                    "name": f"{config.get('name', repository_name)}:{expose_key}",
+                    "module_name": config.get("name"),
+                    "expose_key": expose_key,
+                    "path": expose_path,
+                    "repository": repository_name,
+                }
+                nodes.append(node)
+
+                # Create EXPOSES_MODULE edge from repository to exposed module
+                edge = {
+                    "edge_type": "EXPOSES_MODULE",
+                    "source": repository_name,
+                    "target": node["name"],
+                    "metadata": {
+                        "expose_key": expose_key,
+                        "path": expose_path,
+                    },
+                }
+                edges.append(edge)
+
+            # Create edges for consumed remotes
+            for remote_name, remote_url in config.get("remotes", {}).items():
+                edge = {
+                    "edge_type": "CONSUMES_MODULE",
+                    "source": repository_name,
+                    "target": remote_name,
+                    "metadata": {
+                        "remote_url": remote_url,
+                        "shared": config.get("shared", []),
+                    },
+                }
+                edges.append(edge)
+
+        elif config["type"] == "single_spa":
+            # Create nodes for single-spa applications
+            for app in config.get("applications", []):
+                node = {
+                    "node_type": "MICROFRONTEND",
+                    "name": app["name"],
+                    "application_type": "single_spa",
+                    "url": app.get("url"),
+                    "repository": repository_name,
+                }
+                nodes.append(node)
+
+                # Create edge from repository to application
+                edge = {
+                    "edge_type": "REGISTERS_APPLICATION",
+                    "source": repository_name,
+                    "target": app["name"],
+                    "metadata": {
+                        "url": app.get("url"),
+                    },
+                }
+                edges.append(edge)
+
+        return nodes, edges