reflectsonar 1.0.0__py3-none-any.whl

reflectsonar/__init__.py

@@ -0,0 +1,19 @@
+"""
+ReflectSonar - PDF Report Generator for SonarQube Analysis
+
+ReflectSonar is a Python tool for generating PDF reports from SonarQube analysis data.
+It reads data via the SonarQube API and generates comprehensive PDF reports for 
+general metrics, issues, and security hotspots.
+
+Author: Ata Seren
+License: MIT
+"""
+
+__version__ = "1.0.0"
+__author__ = "Ata Seren"
+__email__ = "ata.seren@hotmail.com"
+__license__ = "GPL-3.0"
+
+from .main import main
+
+__all__ = ["main"]

reflectsonar/__main__.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python3
+"""
+Console script entry point for ReflectSonar
+"""
+import sys
+from reflectsonar.main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

reflectsonar/api/__init__.py

@@ -0,0 +1 @@
+"""API module for ReflectSonar - handles SonarQube API interactions"""

reflectsonar/api/get_data.py

@@ -0,0 +1,256 @@
+"""
+This module is used to fetch data from SonarQube API
+"""
+import traceback
+from typing import Dict, List
+import requests
+
+from ..data.models import (SonarQubeProject, SonarQubeIssue, SonarQubeMeasure, # pylint: disable=import-error
+                         SonarQubeHotspot, ReportData, SonarQubeRule)  # pylint: disable=import-error
+
+from ..report.utils import log
+
+# Helpers
+def get_json(url: str, token: str) -> Dict:
+    """Helper function to perform GET request and return JSON response"""
+    response = requests.get(url, auth=(token, ""), timeout=30)
+    response.raise_for_status()
+    return response.json()
+
+def fetch(name: str, url: str, token: str, verbose: bool) -> Dict:
+    """Fetches data from SonarQube API by using get_json and utils.log"""
+    log(verbose, f"Fetching {name}...")
+    return get_json(url, token)
+
+# Getters
+def get_rules(base_url: str, token: str, rule_keys: List[str],
+              verbose: bool = False) -> Dict[str, 'SonarQubeRule']:
+    """Fetches rule descriptions from SonarQube API for given rule keys"""
+    if not rule_keys:
+        return {}
+
+    try:
+        # SonarQube API: /api/rules/show?key=rule_key
+        rules = {}
+
+        for rule_key in rule_keys:
+
+            log(verbose, f"   📋 Fetching rule description: {rule_key}")
+
+            rule_url = f"{base_url}/api/rules/show?key={rule_key}"
+            response = fetch("rule description...", rule_url, token, verbose)
+
+            if 'rule' in response:
+                rules[rule_key] = SonarQubeRule.from_dict(response['rule'])
+
+        log(verbose, f"   ✅ Fetched {len(rules)} rule descriptions")
+        return rules
+
+    except requests.RequestException as e:
+        print(f"ERROR: Error fetching rules: {e}")
+        return {}
+
+# Function to fetch code snippet for a specific issue or hotspot
+def get_code_snippet(base_url: str, token: str, component: str, line: int) -> str:
+    """Fetches code snippet for a specific issue or hotspotfrom SonarQube API"""
+    try:
+        # Calculate line range (line ± context_lines)
+        from_line = max(1, line - 3)
+        to_line = line + 3
+
+        sources_url = f"{base_url}/api/sources/show?key={component}&from={from_line}&to={to_line}"
+
+        try:
+            response = fetch("code snippets...", sources_url, token, False)
+        except requests.RequestException as api_error:
+            print(f"ERROR: API call failed: {api_error}")
+            return ""
+
+        sources = response.get("sources", [])
+
+        if not sources:
+            print(f"ERROR: No sources found for {component}:{line}")
+            print(f"ERROR: Full API response: {response}")
+            return ""
+
+        # Format the code snippet with line numbers
+        snippet_lines = []
+        for source in sources:
+            line_num = source[0]
+            code = source[1]
+            # Mark the problematic line with >>>
+            marker = ">>> " if line_num == line else "    "
+            snippet_lines.append(f"{marker}{line_num:3d}: {code}")
+
+        result = "\n".join(snippet_lines)
+        return result
+    except requests.RequestException as e:
+        print(f"ERROR: Error fetching code snippet for {component}:{line}: {e}")  # Debug log
+        traceback.print_exc()
+        return ""
+
+def fetch_all_hotspots(base_url: str, token: str, project_key: str) -> Dict:
+    """Fetches all security hotspots from a project"""
+    all_hotspots = []
+    page = 1
+    page_size = 500  # Maximum page size
+
+    while True:
+        hotspots_url = f"{base_url}/api/hotspots/search?projectKey={project_key}&ps={page_size}&p={page}" # pylint: disable=line-too-long
+
+        try:
+            page_data = fetch("hotspots...", hotspots_url, token, False)
+            page_hotspots = page_data.get("hotspots", [])
+
+            all_hotspots.extend(page_hotspots)
+
+            # Check if we have more pages
+            paging = page_data.get("paging", {})
+            total = paging.get("total", 0)
+            current_total = len(all_hotspots)
+
+            if current_total >= total:
+                break
+
+            page += 1
+
+        except requests.RequestException as e:
+            print(f"ERROR: Failed to fetch hotspots page {page}: {e}")
+            break
+
+    # Return in the same format as the original API response
+    return {
+        "hotspots": all_hotspots,
+        "paging": {
+            "pageIndex": 1,
+            "pageSize": len(all_hotspots),
+            "total": len(all_hotspots)
+        }
+    }
+
+# Main function to get all report data
+def get_report_data(base_url: str, token: str,
+                    project_key: str, verbose: bool = False) -> ReportData:
+    """Main function that fetches all necessary data from SonarQube API"""
+    metric_keys = [
+    "software_quality_security_rating",
+    "software_quality_reliability_rating",
+    "software_quality_maintainability_rating",
+    "lines_to_cover",
+    "software_quality_maintainability_issues",
+    "software_quality_security_issues",
+    "software_quality_reliability_issues",
+    "accepted_issues",
+    "coverage",
+    "duplicated_lines_density",
+    "lines",
+    "security_hotspots",
+    ]
+    metrics_param = ",".join(metric_keys)
+
+    component_url = f"{base_url}/api/components/show?component={project_key}"
+    issues_url = f"{base_url}/api/issues/search?componentKeys={project_key}&ps=500"
+    measures_url = f"{base_url}/api/measures/component?component={project_key}&metricKeys={metrics_param}" # pylint: disable=line-too-long
+    settings_url = f"{base_url}/api/settings/values?keys=sonar.multi-quality-mode.enabled"
+
+    component_data = fetch("project component data...", component_url, token, verbose)
+    issues_data = fetch("issues data...", issues_url, token, verbose)
+    measures_data = fetch("measures data...", measures_url, token, verbose)
+    settings_data = fetch("SonarQube settings...", settings_url, token, verbose)
+    hotspots_data = fetch_all_hotspots(base_url, token, project_key)
+
+    project = SonarQubeProject.from_dict(component_data)
+
+    # Process issues and fetch code snippets
+    issues: List[SonarQubeIssue] = []
+    total_issues = len(issues_data.get("issues", []))
+
+    log(verbose, f"Processing {total_issues} issues and fetching code snippets...")
+
+    for i, issue_data in enumerate(issues_data.get("issues", [])):
+        issue = SonarQubeIssue.from_dict(issue_data)
+
+        if (i + 1) % 10 == 0:  # Progress every 10 issues
+            log(verbose, f"   Processed {i + 1}/{total_issues} issues...")
+
+        # Fetch code snippet if the issue has a line number
+        if issue.line:
+
+            code_snippet = get_code_snippet(base_url, token, issue.component, issue.line)
+
+            if not code_snippet.strip():
+                code_snippet = "No code snippet available for this issue."
+
+            issue.code_snippet = code_snippet
+        else:
+            print(f"ERROR: Issue {issue.key} has no line number, skipping code snippet")
+
+        issues.append(issue)
+
+    measures: Dict[str, SonarQubeMeasure] = {
+        m["metric"]: SonarQubeMeasure.from_dict(m)
+        for m in measures_data.get("component", {}).get("measures", [])
+    }
+
+    # Process hotspots and fetch code snippets
+    hotspots: List[SonarQubeHotspot] = []
+    total_hotspots = len(hotspots_data.get("hotspots", []))
+
+    log(verbose, f"Processing {total_hotspots} security hotspots and fetching code snippets...")
+
+    for i, hotspot_data in enumerate(hotspots_data.get("hotspots", [])):
+        hotspot = SonarQubeHotspot.from_dict(hotspot_data)
+
+        if (i + 1) % 10 == 0:  # Progress every 10 hotspots
+            log(verbose, f"   Processed {i + 1}/{total_hotspots} hotspots...")
+
+        # Fetch code snippet if the hotspot has a line number
+        if hotspot.line:
+            code_snippet = get_code_snippet(base_url, token, hotspot.component, hotspot.line)
+
+            if not code_snippet.strip():
+                code_snippet = "No code snippet available for this hotspot."
+
+            hotspot.code_snippet = code_snippet
+        else:
+            log(verbose, f"Hotspot {hotspot.key} has no line number, skipping code snippet")
+
+        hotspots.append(hotspot)
+
+    # Collect unique rule keys from issues and hotspots
+    rule_keys = set()
+    for issue in issues:
+        if issue.rule:
+            rule_keys.add(issue.rule)
+    for hotspot in hotspots:
+        if hotspot.rule_key:
+            rule_keys.add(hotspot.rule_key)
+
+    log(verbose, f"📋 Fetching descriptions for {len(rule_keys)} unique rules...")
+
+    # Fetch rule descriptions
+    rules = get_rules(base_url, token, list(rule_keys), verbose)
+
+    settings: bool = settings_data.get("sonar.multi-quality-mode.enabled",
+                                       {}).get("value", "true").lower() == "true"
+
+    log(verbose, "Data collection summary:")
+    log(verbose, f"   • Project: {project.name}")
+    log(verbose, f"   • Issues collected: {len(issues)}")
+    log(verbose, f"   • Hotspots collected: {len(hotspots)}")
+    log(verbose, f"   • Measures collected: {len(measures)}")
+    log(verbose, f"   • MQR mode enabled: {settings}")
+    log(verbose, f"   • Issues with code snippets: {sum(1 for i in issues if i.code_snippet and i.code_snippet.strip())}") # pylint: disable=line-too-long
+    log(verbose, f"   • Hotspots with code snippets: {sum(1 for h in hotspots if h.code_snippet and h.code_snippet.strip())}") # pylint: disable=line-too-long
+    log(verbose, f"   • Rules descriptions fetched: {len(rules)}")
+
+    return ReportData(
+        project=project,
+        issues=issues,
+        measures=measures,
+        hotspots=hotspots,
+        quality_gate={},
+        quality_profiles=[],
+        mode_setting=settings,
+        rules=rules
+    )

reflectsonar/data/__init__.py

@@ -0,0 +1 @@
+"""Data models for ReflectSonar - SonarQube entity definitions"""

reflectsonar/data/models.py

@@ -0,0 +1,154 @@
+""" 
+Defines data models for SonarQube entities such as issues, rules, hotspots, etc.
+"""
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+@dataclass
+class SonarQubeIssue:
+    """Data model for a SonarQube issue"""
+    key: str
+    component: str
+    project: str
+    rule: str
+    severity: str
+    status: str
+    message: str
+    type: str
+    line: Optional[int] = None
+    effort: Optional[str] = None
+    author: Optional[str] = None
+    tags: List[str] = field(default_factory=list)
+    creation_date: Optional[datetime] = None
+    update_date: Optional[datetime] = None
+    impacts: List[Dict[str, Any]] = field(default_factory=list)
+    code_snippet: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SonarQubeIssue':
+        """Creates a SonarQubeIssue instance from a dictionary"""
+        return cls(
+            key=data.get('key', ''),
+            component=data.get('component', ''),
+            project=data.get('project', ''),
+            rule=data.get('rule', ''),
+            severity=data.get('severity', ''),
+            status=data.get('status', ''),
+            message=data.get('message', ''),
+            type=data.get('type', ''),
+            line=data.get('line'),
+            effort=data.get('effort'),
+            author=data.get('author'),
+            tags=data.get('tags', []),
+            creation_date=data.get('creationDate')
+                if data.get('creationDate') else None,
+            update_date=data.get('updateDate')
+                if data.get('updateDate') else None,
+            impacts=data.get('impacts', [])
+        )
+
+@dataclass
+class SonarQubeRule:
+    """Data model for a SonarQube rule"""
+    key: str
+    name: str
+    description_sections: List[Dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SonarQubeRule':
+        """Creates a SonarQubeRule instance from a dictionary"""
+        return cls(
+            key=data.get('key', ''),
+            name=data.get('name', ''),
+            description_sections=data.get('descriptionSections', [])
+        )
+
+@dataclass
+class SonarQubeMeasure:
+    """Data model for a SonarQube measure"""
+    metric: str
+    value: Any
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SonarQubeMeasure':
+        """Creates a SonarQubeMeasure instance from a dictionary"""
+        return cls(
+            metric=data.get('metric', ''),
+            value=data.get('value') or data.get('period', {}).get('value')
+        )
+
+@dataclass
+class SonarQubeProject:
+    """Data model for a SonarQube project"""
+    key: str
+    name: str
+    qualifier: str
+    visibility: str
+    last_analysis_date: Optional[datetime] = None
+    revision: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SonarQubeProject':
+        """Creates a SonarQubeProject instance from a dictionary"""
+        component = data.get('component', {})
+        return cls(
+            key=component.get('key', ''),
+            name=component.get('name', ''),
+            qualifier=component.get('qualifier', ''),
+            visibility=component.get('visibility', ''),
+            last_analysis_date=component.get('analysisDate')
+                if component.get('analysisDate') else None,
+            revision=component.get('revision')
+        )
+
+@dataclass
+class SonarQubeHotspot:
+    """Data model for a SonarQube security hotspot"""
+    key: str
+    component: str
+    project: str
+    rule: str
+    status: str
+    message: str
+    line: Optional[int] = None
+    author: Optional[str] = None
+    creation_date: Optional[datetime] = None
+    update_date: Optional[datetime] = None
+    vulnerability_probability: str = "MEDIUM"
+    code_snippet: Optional[str] = None
+    security_category: Optional[str] = None
+    rule_key: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SonarQubeHotspot':
+        """Creates a SonarQubeHotspot instance from a dictionary"""
+        return cls(
+            key=data.get('key', ''),
+            component=data.get('component', ''),
+            project=data.get('project', ''),
+            rule=data.get('rule', ''),
+            status=data.get('status', ''),
+            message=data.get('message', ''),
+            line=data.get('line'),
+            author=data.get('author'),
+            creation_date=data.get('creationDate')
+                if data.get('creationDate') else None,
+            update_date=data.get('updateDate')
+                if data.get('updateDate') else None,
+            vulnerability_probability=data.get('vulnerabilityProbability', 'MEDIUM'),
+            security_category=data.get('securityCategory'),
+            rule_key=data.get('ruleKey')
+        )
+
+@dataclass
+class ReportData:
+    """Data model for report data"""
+    project: SonarQubeProject
+    issues: List[SonarQubeIssue]
+    measures: Dict[str, SonarQubeMeasure]
+    hotspots: List[SonarQubeHotspot]
+    quality_gate: Dict[str, Any]
+    quality_profiles: List[Dict[str, Any]]
+    mode_setting: bool
+    rules: Dict[str, SonarQubeRule] = field(default_factory=dict)

reflectsonar/main.py

@@ -0,0 +1,101 @@
+"""
+Main entry point for the ReflectSonar PDF report generator.
+Handles command-line arguments, configuration loading, 
+and orchestrates the report generation process.
+"""
+import argparse
+import sys
+import signal
+import yaml
+
+from .report.pdfgen import generate_pdf
+from .report.utils import log, handle_exception
+from .api.get_data import get_report_data
+
+def load_config(config_path):
+    """Loads configuration from a YAML file"""
+    if not config_path:
+        return {}
+    try:
+        with open(config_path, 'r',  encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e: # pylint: disable=broad-exception-caught
+        print(f"Warning: Could not load config file {config_path}: {e}")
+        return {}
+
+def parse_arguments():
+    """Parses command-line arguments and loads configuration from a YAML file if provided"""
+    parser = argparse.ArgumentParser(description='Generate PDF reports from SonarQube data')
+    parser.add_argument('-c', '--config', default=None,
+            help='Path to YAML configuration file, overrides arguments if provided in the file')
+    parser.add_argument('-o', '--output', help='Output PDF file path')
+    parser.add_argument('-p', '--project', help='SonarQube project key')
+    parser.add_argument('-u', '--url', help='SonarQube server URL', default="http://localhost:9000")
+    parser.add_argument('-t', '--token', help='SonarQube authentication token')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Enable verbose logging')
+
+    args = parser.parse_args()
+
+    # Load config file and override args if config values exist
+    if args.config:
+        config = load_config(args.config)
+        if 'project' in config:
+            args.project = config['project']
+        if 'token' in config:
+            args.token = config['token']
+        if 'url' in config:
+            args.url = config['url']
+        if 'output' in config:
+            args.output = config['output']
+        if 'verbose' in config:
+            args.verbose = config['verbose']
+
+    # Validate required fields
+    if not args.project:
+        parser.error('Project key is required (use -p or set in config file)')
+    if not args.token:
+        parser.error('SonarQube token is required (use -t or set in config file)')
+
+    return args
+
+def handle_interrupt(signum, frame): # pylint: disable=unused-argument
+    """Handles keyboard interrupt (Ctrl+C)"""
+    print("\n")
+    print("🛑 Report generation interrupted by user")
+    print("✨ Thanks for using ReflectSonar!")
+    sys.exit(0)
+
+# Main function to generate the PDF report
+def main():
+    """Main function to generate the PDF report"""
+    signal.signal(signal.SIGINT, handle_interrupt)
+
+    try:
+        args = parse_arguments()
+
+        log(args.verbose, "🚀 Starting ReflectSonar PDF Report Generation")
+        log(args.verbose, f"📊 Project: {args.project}")
+        log(args.verbose, f"🌐 SonarQube URL: {args.url}")
+        log(args.verbose, f"📄 Output: {args.output or f'reflect_sonar_report_{args.project}_[timestamp].pdf'}") # pylint: disable=line-too-long
+
+        # Fetch data from SonarQube
+        log(args.verbose, "📡 Connecting to SonarQube and fetching data...")
+        print("📡 Fetching data from SonarQube... (Press Ctrl+C to cancel)")
+
+        report_data = get_report_data(args.url, args.token, args.project, verbose=args.verbose)
+
+        print("📄 Generating PDF report... (Press Ctrl+C to cancel)")
+
+        output_file = generate_pdf(report_data, args.output, args.project, verbose=args.verbose)
+
+        # Success message
+        print("✅ PDF report generated successfully!")
+        print(f"📁 Saved to: {output_file}")
+
+        return 0
+
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        return handle_exception(e, args.verbose)
+
+if __name__ == "__main__":
+    sys.exit(main())

reflectsonar/report/__init__.py

@@ -0,0 +1 @@
+"""Report generation module for ReflectSonar - PDF creation and formatting"""