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

src/infrastructure/parsing/config_file_parser.py

@@ -0,0 +1,347 @@
+"""Configuration file parser for extracting APIs, databases, and services.
+
+This module provides parsing capabilities for application.properties,
+application.yml, and .env files to extract external dependencies.
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+import yaml
+from src.domain.value_objects.dependency_type import DependencyType
+
+
+@dataclass
+class ParsedConfig:
+    """Result of parsing configuration files.
+
+    Attributes:
+        databases: List of database connections (JDBC URLs)
+        apis: List of API endpoints (HTTP/HTTPS URLs)
+        services: List of microservice names
+        feature_flags: List of feature flag definitions (Task 11.3)
+    """
+
+    databases: list[dict[str, Any]] = field(default_factory=list)
+    apis: list[dict[str, Any]] = field(default_factory=list)
+    services: list[dict[str, Any]] = field(default_factory=list)
+    feature_flags: list[dict[str, Any]] = field(default_factory=list)  # Task 11.3
+
+
+class ConfigFileParser:
+    """Parser for application configuration files.
+
+    Parses:
+    - application.properties (Java properties format)
+    - application.yml (YAML format)
+    - .env files (KEY=VALUE format, including frontend env vars)
+    - TypeScript/JavaScript config files (config.ts, environment.ts) - Task 11.2
+
+    Extracts:
+    - API URLs (http://, https://, wss://)
+    - Database connections (jdbc:)
+    - Microservice names (service identifiers)
+    - Feature flags (Task 11.3)
+    - Environment-specific configurations (Task 11.1)
+    """
+
+    # Regex patterns
+    JDBC_PATTERN = re.compile(r'jdbc:[^:]+://[^\s]+')
+    HTTP_URL_PATTERN = re.compile(r'https?://[^\s\'"]+')
+    WS_URL_PATTERN = re.compile(r'wss?://[^\s\'"]+')  # WebSocket URLs
+
+    # Keys that typically contain API URLs
+    API_KEYS = {
+        "url", "endpoint", "host", "api", "gateway", "service.url",
+        "external", "client", "rest", "graphql"
+    }
+
+    # Keys that typically contain service names
+    SERVICE_KEYS = {"service", "name", "microservice", "app"}
+
+    # Frontend environment variable prefixes (Task 11.1)
+    FRONTEND_ENV_PREFIXES = {
+        "REACT_APP_", "VITE_", "NEXT_PUBLIC_", "NG_APP_",
+        "VUE_APP_", "NUXT_PUBLIC_"
+    }
+
+    # Feature flag patterns (Task 11.3)
+    FEATURE_FLAG_PATTERNS = {
+        "FEATURE_", "FEAT_", "FLAG_", "ENABLE_", "DISABLE_"
+    }
+
+    def parse_properties(self, content: str) -> ParsedConfig:
+        """Parse Java properties file (application.properties).
+
+        Args:
+            content: String content of properties file
+
+        Returns:
+            ParsedConfig with extracted dependencies
+        """
+        result = ParsedConfig()
+
+        # Remove comments
+        lines = [line for line in content.split('\n') if line.strip() and not line.strip().startswith('#')]
+
+        for line in lines:
+            if '=' not in line:
+                continue
+
+            key, value = line.split('=', 1)
+            key = key.strip()
+            value = value.strip()
+
+            # Extract databases (JDBC)
+            if value.startswith('jdbc:'):
+                result.databases.append({
+                    "url": value,
+                    "type": DependencyType.DATABASE,
+                    "source": key,
+                })
+
+            # Extract APIs (HTTP/HTTPS)
+            elif value.startswith(('http://', 'https://')):
+                result.apis.append({
+                    "url": value,
+                    "type": DependencyType.API,
+                    "source": key,
+                })
+
+            # Extract service names
+            elif any(svc_key in key.lower() for svc_key in self.SERVICE_KEYS):
+                if not value.startswith(('http://', 'https://', 'jdbc:')):
+                    result.services.append({
+                        "name": value,
+                        "type": DependencyType.MICROSERVICE,
+                        "source": key,
+                    })
+
+        return result
+
+    def parse_yaml(self, content: str) -> ParsedConfig:
+        """Parse YAML configuration file (application.yml).
+
+        Args:
+            content: String content of YAML file
+
+        Returns:
+            ParsedConfig with extracted dependencies
+        """
+        result = ParsedConfig()
+
+        try:
+            data = yaml.safe_load(content)
+            if data:
+                self._extract_from_dict(data, result)
+        except yaml.YAMLError:
+            # If YAML parsing fails, return empty result
+            pass
+
+        return result
+
+    def parse_env(self, content: str, environment: str | None = None, detect_feature_flags: bool = False) -> ParsedConfig:
+        """Parse .env file (KEY=VALUE format).
+
+        Args:
+            content: String content of .env file
+            environment: Environment tag (e.g., "development", "production", "staging") - Task 11.1
+            detect_feature_flags: Whether to detect and extract feature flags - Task 11.3
+
+        Returns:
+            ParsedConfig with extracted dependencies
+        """
+        result = ParsedConfig()
+
+        # Remove comments
+        lines = [line for line in content.split('\n') if line.strip() and not line.strip().startswith('#')]
+
+        for line in lines:
+            if '=' not in line:
+                continue
+
+            key, value = line.split('=', 1)
+            key = key.strip()
+            value = value.strip()
+
+            # Task 11.3: Detect feature flags
+            if detect_feature_flags and self._is_feature_flag(key):
+                result.feature_flags.append({
+                    "name": key,
+                    "enabled": self._parse_boolean(value),
+                    "source": "env",
+                    "environment": environment
+                })
+
+            # Extract databases (JDBC)
+            if value.startswith('jdbc:'):
+                result.databases.append({
+                    "url": value,
+                    "type": DependencyType.DATABASE,
+                    "source": key,
+                    "environment": environment  # Task 11.1
+                })
+
+            # Extract WebSocket URLs (Task 11.1)
+            elif value.startswith(('ws://', 'wss://')):
+                result.apis.append({
+                    "url": value,
+                    "type": DependencyType.API,
+                    "source": key,
+                    "environment": environment  # Task 11.1
+                })
+
+            # Extract APIs (HTTP/HTTPS)
+            elif value.startswith(('http://', 'https://')):
+                result.apis.append({
+                    "url": value,
+                    "type": DependencyType.API,
+                    "source": key,
+                    "environment": environment  # Task 11.1
+                })
+
+            # Extract service names
+            elif any(svc_key in key.lower() for svc_key in self.SERVICE_KEYS):
+                if not value.startswith(('http://', 'https://', 'jdbc:', 'ws://', 'wss://')):
+                    result.services.append({
+                        "name": value,
+                        "type": DependencyType.MICROSERVICE,
+                        "source": key,
+                        "environment": environment  # Task 11.1
+                    })
+
+        return result
+
+    def _is_feature_flag(self, key: str) -> bool:
+        """Check if key matches feature flag pattern (Task 11.3)."""
+        key_upper = key.upper()
+        return any(pattern in key_upper for pattern in self.FEATURE_FLAG_PATTERNS)
+
+    def _parse_boolean(self, value: str) -> bool:
+        """Parse boolean value from string (Task 11.3)."""
+        value_lower = value.lower()
+        return value_lower in ("true", "1", "yes", "enabled", "on")
+
+    def parse_typescript_config(
+        self,
+        content: str,
+        typescript_parser=None,
+        environment: str | None = None,
+        detect_feature_flags: bool = False
+    ) -> ParsedConfig:
+        """Parse TypeScript/JavaScript config files (Task 11.2).
+
+        Args:
+            content: String content of config.ts or environment.ts file
+            typescript_parser: TreeSitterTypeScriptParser instance for AST parsing
+            environment: Environment tag (e.g., "development", "production")
+            detect_feature_flags: Whether to detect and extract feature flags
+
+        Returns:
+            ParsedConfig with extracted dependencies
+        """
+        result = ParsedConfig()
+
+        if not typescript_parser:
+            return result
+
+        # Parse with TypeScript parser to extract string literals
+        try:
+            # For testing, typescript_parser might be a mock
+            if hasattr(typescript_parser, 'parse_file'):
+                # Mock or real parser
+                parse_result = typescript_parser.parse_file(content)
+            else:
+                return result
+
+            # Extract URLs from string literals
+            if hasattr(parse_result, 'string_literals'):
+                for literal in parse_result.string_literals:
+                    if isinstance(literal, str):
+                        # Check for URLs
+                        if literal.startswith(('http://', 'https://', 'ws://', 'wss://')):
+                            result.apis.append({
+                                "url": literal,
+                                "type": DependencyType.API,
+                                "source": "typescript_config",
+                                "environment": environment
+                            })
+
+            # Detect environment variable references (Task 11.2)
+            if hasattr(parse_result, 'method_calls'):
+                for call in parse_result.method_calls:
+                    call_name = call.get("name", "")
+                    if "process.env" in call_name:
+                        # Extract full env variable name (keep REACT_APP_, VITE_, etc.)
+                        if "." in call_name:
+                            env_var = call_name.split(".")[-1]  # Get last part after final dot
+                        else:
+                            env_var = call_name
+                        result.apis.append({
+                            "url": None,
+                            "type": DependencyType.API,
+                            "source": "typescript_config",
+                            "environment": environment,
+                            "environment_dependent": True,
+                            "env_variable": env_var
+                        })
+
+            # Task 11.3: Detect feature flags in TypeScript config
+            if detect_feature_flags:
+                # Look for featureFlags, features, flags patterns in content
+                if any(pattern in content for pattern in ["featureFlags", "feature_flags", "FEATURE_FLAGS"]):
+                    # Simple detection: if we find feature flag patterns in content
+                    # Add a generic feature flag entry
+                    result.feature_flags.append({
+                        "name": "detected_in_typescript_config",
+                        "enabled": True,
+                        "source": "typescript_config",
+                        "environment": environment
+                    })
+
+        except Exception:
+            # Graceful degradation - return partial results
+            pass
+
+        return result
+
+    def _extract_from_dict(self, data: dict[str, Any], result: ParsedConfig, parent_key: str = "") -> None:
+        """Recursively extract dependencies from nested dictionary.
+
+        Args:
+            data: Dictionary to extract from
+            result: ParsedConfig to populate
+            parent_key: Parent key path for context
+        """
+        for key, value in data.items():
+            full_key = f"{parent_key}.{key}" if parent_key else key
+
+            if isinstance(value, dict):
+                # Recurse into nested dictionaries
+                self._extract_from_dict(value, result, full_key)
+
+            elif isinstance(value, str):
+                # Extract JDBC URLs
+                if value.startswith('jdbc:'):
+                    result.databases.append({
+                        "url": value,
+                        "type": DependencyType.DATABASE,
+                        "source": full_key,
+                    })
+
+                # Extract HTTP/HTTPS URLs
+                elif value.startswith(('http://', 'https://')):
+                    result.apis.append({
+                        "url": value,
+                        "type": DependencyType.API,
+                        "source": full_key,
+                    })
+
+                # Extract service names
+                elif any(svc_key in full_key.lower() for svc_key in self.SERVICE_KEYS):
+                    if not value.startswith(('http://', 'https://', 'jdbc:')):
+                        result.services.append({
+                            "name": value,
+                            "type": DependencyType.MICROSERVICE,
+                            "source": full_key,
+                        })

src/infrastructure/parsing/gradle_dependency_parser.py

@@ -0,0 +1,159 @@
+"""Gradle build.gradle and build.gradle.kts dependency parser.
+
+This module provides parsing capabilities for Gradle build files to extract
+dependency information for the dependency analysis system.
+"""
+
+import re
+from typing import TypedDict
+from src.domain.value_objects.dependency_type import DependencyType
+
+
+class GradleDependency(TypedDict):
+    """Type definition for Gradle dependency dictionary."""
+
+    group_id: str
+    artifact_id: str
+    version: str
+    scope: str
+    type: DependencyType
+
+
+class GradleDependencyParser:
+    """Parser for Gradle build.gradle and build.gradle.kts files.
+
+    Parses both Groovy (build.gradle) and Kotlin (build.gradle.kts) syntax.
+    Extracts dependency information: group:artifact:version format.
+    Filters out test-scoped dependencies by default.
+
+    Attributes:
+        SCOPE_PATTERNS: Regex patterns for different dependency scopes
+        DEPENDENCY_PATTERN: Regex pattern to extract dependency coordinates
+    """
+
+    # Gradle dependency scopes to include (exclude test scopes)
+    INCLUDE_SCOPES = {"implementation", "api", "compileOnly", "runtimeOnly"}
+    TEST_SCOPES = {"testImplementation", "testCompileOnly", "testRuntimeOnly"}
+
+    # Regex patterns for dependency extraction
+    # Matches: implementation 'group:artifact:version'
+    # Matches: implementation("group:artifact:version")
+    # Matches multiline: implementation(\n    "group:artifact:version"\n)
+    DEPENDENCY_PATTERN = re.compile(
+        r'''
+        (?P<scope>implementation|api|compileOnly|runtimeOnly|testImplementation|testCompileOnly|testRuntimeOnly)
+        \s*
+        \(?\s*                           # Optional opening parenthesis
+        ["']                             # Opening quote (single or double)
+        \s*
+        (?P<coords>[^"']+)               # Dependency coordinates
+        \s*
+        ["']                             # Closing quote (single or double)
+        \s*\)?                           # Optional closing parenthesis
+        ''',
+        re.VERBOSE | re.MULTILINE | re.DOTALL,
+    )
+
+    # Pattern to extract group:artifact:version
+    COORDS_PATTERN = re.compile(r'^([^:]+):([^:]+)(?::([^:]+))?$')
+
+    MANAGED_VERSION = "managed"
+
+    def parse(self, gradle_content: str) -> list[GradleDependency]:
+        """Parse build.gradle or build.gradle.kts content and extract dependencies.
+
+        Args:
+            gradle_content: String content of build.gradle or build.gradle.kts file
+
+        Returns:
+            List of GradleDependency dictionaries with keys:
+            - group_id: Gradle group (e.g., 'org.springframework.boot')
+            - artifact_id: Gradle artifact (e.g., 'spring-boot-starter-web')
+            - version: Version string or 'managed' if not specified
+            - scope: Dependency scope (implementation, api, compileOnly, runtimeOnly)
+            - type: Always DependencyType.LIBRARY
+
+        Note:
+            Test-scoped dependencies (testImplementation, etc) are filtered out.
+            Comments (// and /* */) are removed before parsing.
+        """
+        # Remove comments
+        clean_content = self._remove_comments(gradle_content)
+
+        # Find all dependency declarations
+        matches = self.DEPENDENCY_PATTERN.finditer(clean_content)
+
+        dependencies: list[GradleDependency] = []
+
+        for match in matches:
+            scope = match.group("scope")
+            coords = match.group("coords").strip()
+
+            # Filter out test dependencies
+            if scope in self.TEST_SCOPES:
+                continue
+
+            # Parse coordinates
+            dependency = self._parse_coordinates(coords, scope)
+
+            if dependency:
+                dependencies.append(dependency)
+
+        return dependencies
+
+    def _remove_comments(self, content: str) -> str:
+        """Remove single-line and multi-line comments from Gradle file.
+
+        Args:
+            content: Original Gradle file content
+
+        Returns:
+            Content with comments removed
+        """
+        # Remove single-line comments
+        content = re.sub(r'//.*?$', '', content, flags=re.MULTILINE)
+
+        # Remove multi-line comments
+        content = re.sub(r'/\*.*?\*/', '', content, flags=re.DOTALL)
+
+        return content
+
+    def _parse_coordinates(self, coords: str, scope: str) -> GradleDependency | None:
+        """Parse dependency coordinates in format 'group:artifact:version'.
+
+        Args:
+            coords: Dependency coordinates string
+            scope: Dependency scope (implementation, api, etc)
+
+        Returns:
+            GradleDependency dictionary or None if parsing fails
+        """
+        # Store original coords to check for variables
+        has_variable = "${" in coords
+
+        # Handle variable interpolation (${variable})
+        # For simplicity, treat as managed version
+        if has_variable:
+            coords = re.sub(r'\$\{[^}]+\}', 'managed', coords)
+
+        # Match group:artifact:version pattern
+        match = self.COORDS_PATTERN.match(coords.strip())
+
+        if not match:
+            return None
+
+        group_id = match.group(1).strip()
+        artifact_id = match.group(2).strip()
+        version = match.group(3).strip() if match.group(3) else self.MANAGED_VERSION
+
+        # Skip if essential fields are missing
+        if not group_id or not artifact_id:
+            return None
+
+        return GradleDependency(
+            group_id=group_id,
+            artifact_id=artifact_id,
+            version=version,
+            scope=scope,
+            type=DependencyType.LIBRARY,
+        )