PHP Quality Analyzer for SciTools Understand

Front Matter

Title: PHP Quality Analyzer User Guide
Version: 1.0
Date: December 2025
Author: Development Team
Audience: PHP Developers, Software Architects, Quality Assurance Engineers
Purpose: User guide for PHP Quality Analyzer plugin in SciTools Understand

Table of Contents

1. Introduction
2. Concept of Operations
3. Installation
4. User Procedures
5. Information for Uninstallation
6. Troubleshooting
7. Appendices

List of Figures and Tables

• Figure 1: IReport Interface
• Table 1: Configuration Options
• Table 2: Analysis Results Interpretation
• Table 3: Severity Levels

1. Introduction

1.1 Purpose

The PHP Quality Analyzer plugin for SciTools Understand provides comprehensive static code analysis for PHP projects. This user guide explains how to install, configure, and use the plugin to analyze PHP code quality, identify architectural smells, design issues, and implementation problems.

1.2 Scope

This document covers:

• Installation and setup procedures
• Configuration of analysis parameters
• Interpretation of analysis results
• Troubleshooting common issues

1.3 Audience

This guide is intended for:

• PHP developers
• Software architects
• Quality assurance engineers
• Project managers

1.4 Conventions

• Bold text: UI elements, menu items, buttons
• Monospace: Code examples, file paths, commands
• ⚠️ Warning: Important notes about potential issues
• 💡 Tip: Helpful suggestions for better usage
• 🔧 Note: Technical details or additional information

1.5 System Requirements

• SciTools Understand (with PHP language support)
• Windows/Linux/macOS operating system
• Minimum 4GB RAM recommended for large projects

2. Concept of Operations

2.1 Overview

The PHP Quality Analyzer operates as an IReport plugin within SciTools Understand, providing automated static analysis of PHP source code. The plugin analyzes the entire PHP project database to identify code quality issues across multiple dimensions.

2.2 Analysis Capabilities

2.2.1 Architecture Smells Detection

The plugin identifies architectural issues that affect system maintainability and scalability:

• Unstable Dependency: Components depending on less stable components
• God Component: Excessively large components (high LOC or method count)
• Feature Concentration: Components implementing multiple architectural concerns
• Dense Structure: Components with excessive dependency density

2.2.2 Design Smells Detection

Design-level issues violating object-oriented principles:

• Multifaceted Abstraction: Classes with multiple responsibilities
• Feature Envy: Methods accessing external class members excessively
• Insufficient Encapsulation: Members with overly permissive access
• Broken Modularization: Members scattered across abstractions
• Hub-like Modularization: Classes with excessive dependencies (>20)
• Wide/Deep Hierarchy: Inheritance hierarchies that are too wide or deep

2.2.3 Implementation Smells Detection

Code-level issues affecting readability and maintainability:

• Complex Conditional: Conditions with high cyclomatic complexity
• Complex Method: Methods with high cyclomatic complexity
• Empty Catch Clause: Empty or comment-only catch blocks
• Long Identifiers: Identifiers exceeding 50 characters
• Long Methods: Methods exceeding 50 lines of code
• Long Parameter Lists: Methods with more than 7 parameters

2.2.4 Code Quality Metrics

Quantitative measures of code quality:

• LOC: Lines of Code
• CC: Cyclomatic Complexity
• PC: Parameter Count
• NOM/NOPM: Number of Methods/Public Methods
• LCOM: Lack of Cohesion in Methods
• FANIN/FANOUT: Dependency metrics

2.3 Algorithmic Approach

The plugin uses algorithmic analysis rather than keyword-based detection:

1. Complexity Analysis: Methods are evaluated using the formula complexity = LOC × CC + parameters
2. Cluster Analysis: Methods are grouped by complexity levels (high/medium/low)
3. Pattern Recognition: Automated identification of problematic patterns
4. Metric Calculation: Direct computation using Understand's built-in metrics

2.4 Output Format

Results are presented in a structured HTML report with:

• Executive summary of findings
• Detailed issue descriptions with file locations
• Severity classifications (HIGH/MEDIUM/LOW)
• Refactoring recommendations
• Code quality statistics

3. Installation

3.1 Prerequisites

• SciTools Understand installed with PHP language support
• Administrative privileges for plugin installation
• Valid Understand license

3.2 Installation Procedure

1. Locate the SciTools Understand plugins directory:

   • Windows: C:\Program Files\SciTools\plugins\
   • Linux: /opt/scitools/plugins/
   • macOS: /Applications/SciTools/plugins/

2. Copy the plugin files to the IReport subdirectory:

   plugins/IReport/PHP_Quality_Analyzer/
   ├── check.upy
   ├── README.md
   └── test files/
   

3. Verify the installation:

   • Restart SciTools Understand
   • Open Tools → Reports → IReport
   • Confirm "PHP Quality Analyzer Report" appears in the list

3.3 Post-Installation Verification

• Launch SciTools Understand
• Create or open a PHP project
• Access IReport and select the PHP Quality Analyzer
• Run a test analysis on sample PHP files

4. User Procedures

4.1 Starting the Analysis

4.1.1 Open PHP Project

1. Launch SciTools Understand
2. Select File → New Project or File → Open Project
3. Add PHP source files to the project
4. Ensure files are recognized as PHP language
5. Build the project database (Project → Analyze)

4.1.2 Access the Plugin

1. Select Tools → Reports → IReport from the main menu
2. In the IReport dialog, select "PHP Quality Analyzer Report"
3. Click Run Report

4.2 Configuration

4.2.1 Analysis Options

Configure which types of analysis to perform:

• ☑️ Analyze Architecture Smells: Detect architectural issues
• ☑️ Analyze Design Smells: Identify design problems
• ☑️ Analyze Implementation Smells: Find code-level issues
• ☑️ Calculate Code Metrics: Compute quality metrics

4.2.2 Threshold Settings

Architecture Smells:

• God Component LOC Threshold: Maximum lines of code (default: 2000)
• God Component Classes Threshold: Maximum class count (default: 50)
• Hub Dependencies Threshold: Maximum dependencies (default: 20)
• Feature Concentration Threshold: Minimum complexity clusters (default: 3)

Design Smells:

• Feature Envy Threshold: External access percentage (default: 70%)
• LCOM Threshold: Cohesion threshold (default: 80%)

Implementation Smells:

• Complex Method CC Threshold: Cyclomatic complexity (default: 15)
• Long Method LOC Threshold: Lines of code (default: 50)
• Long Identifier Threshold: Character length (default: 50)
• Long Parameter List Threshold: Parameter count (default: 7)

4.2.3 Display Limits

Configure result display limits:

• Max God Components to Show: Default 10
• Max Feature Concentration Issues to Show: Default 3
• Max Classes/Functions in Summary: Default 10

4.3 Generating Reports

1. Click Generate to start analysis
2. Monitor progress in the status bar
3. Review results in the report window

4.4 Interpreting Results

4.4.1 Report Structure

PHP Quality Analyzer Report
==================================================

🏗️ ARCHITECTURE SMELLS ANALYSIS
----------------------------------------
⚠️ God Components Found: 1
  • ClassName in file.php:line (LOC: 1500, Methods: 45)

⚠️ Feature Concentration: 2
  • ClassName in file.php:line
    MEDIUM: 3 weakly cohesive method groups
    • Cluster 1: 3 methods - high complexity methods
      • method1 (complexity: 150)
      • method2 (complexity: 120)
    • Cluster 2: 4 methods - medium complexity methods
      • method3 (complexity: 45)
      • method4 (complexity: 38)

📊 CODE QUALITY METRICS
----------------------------------------
📈 Project Statistics:
  • Classes: 25
  • Methods/Functions: 180
  • Total Lines of Code: 3500

4.4.2 Severity Levels

• 🔴 HIGH: Critical architectural issues
• 🟡 MEDIUM: Design and implementation problems
• 🟢 LOW: Minor code quality issues

5. Information for Uninstallation

5.1 Standard Uninstallation Procedure

To remove the PHP Quality Analyzer plugin from SciTools Understand:

1. Close SciTools Understand completely
2. Navigate to the plugins directory:
   • Windows: C:\Program Files\SciTools\plugins\IReport\
   • Linux: /opt/scitools/plugins/IReport/
   • macOS: /Applications/SciTools/plugins/IReport/
3. Delete the entire PHP_Quality_Analyzer folder
4. Restart SciTools Understand

5.2 Data Cleanup

The plugin does not create:

• Registry entries
• Configuration files outside the plugin directory
• Persistent user data
• Database modifications

No additional cleanup is required.

5.3 System Impact

After uninstallation:

• "PHP Quality Analyzer Report" will no longer appear in IReport menu
• Existing project databases remain unaffected
• Other plugins continue to function normally
• No system performance impact

6. Troubleshooting

6.1 Plugin Not Appearing in IReport

Symptoms:

• "PHP Quality Analyzer Report" not visible in IReport menu

Possible Causes and Solutions:

1. Incorrect Installation Path

   • Solution: Verify plugin files are in plugins/IReport/PHP_Quality_Analyzer/
   • Action: Recopy files to correct location

2. Missing check.upy File

   • Solution: Ensure check.upy exists in plugin directory
   • Action: Verify file integrity

3. Understand Not Restarted

   • Solution: Restart SciTools Understand after installation
   • Action: Complete application restart required

6.2 Empty or Incomplete Reports

Symptoms:

• Report shows "No PHP files found"
• Missing analysis results

Possible Causes and Solutions:

1. No PHP Files in Project

   • Solution: Add PHP source files to project
   • Action: Use Project → Add Files

2. Files Not Recognized as PHP

   • Solution: Check file language settings
   • Action: Right-click files → Properties → Language

3. Database Not Analyzed

   • Solution: Build project database
   • Action: Project → Analyze

6.3 Performance Issues

Symptoms:

• Analysis takes too long
• High memory usage

Possible Causes and Solutions:

1. Large Project Size

   • Solution: Disable unnecessary analysis types
   • Action: Uncheck analysis options in configuration

2. Low System Resources

   • Solution: Increase memory allocation
   • Action: Close other applications during analysis

6.4 Analysis Errors

Symptoms:

• Error messages during analysis
• Incomplete results

Possible Causes and Solutions:

1. Corrupted Project Database

   • Solution: Rebuild project database
   • Action: Project → Analyze (force rebuild)

2. Plugin Version Incompatibility

   • Solution: Check Understand version compatibility
   • Action: Verify minimum version requirements

6.5 Getting Help

If problems persist:

1. Check SciTools Understand documentation
2. Review plugin README for updates
3. Contact technical support with:
   • Understand version
   • Operating system
   • Error messages
   • Project size information

Налаштування опцій

Архітектурні запахи

• God Component LOC Threshold: Максимальна кількість рядків коду (за замовчуванням: 2000)
• God Component Classes Threshold: Максимальна кількість класів (за замовчуванням: 50)
• Hub Dependencies Threshold: Максимальна кількість залежностей (за замовчуванням: 20)
• Feature Concentration Threshold: Мінімальна кількість груп методів різної складності (за замовчуванням: 3)
• Dense Structure Density Threshold: Максимальна щільність залежностей (%) (за замовчуванням: 70)
• Wide Hierarchy Threshold: Максимальна кількість прямих підкласів (за замовчуванням: 10)
• Deep Hierarchy Threshold: Максимальна глибина наслідування (за замовчуванням: 6)

Алгоритмічний підхід до аналізу

Feature Concentration - Алгоритмічний аналіз

Плагін використовує алгоритмічний підхід замість жорстко заданих категорій:

Методика аналізу:

1. Метричний аналіз складності: Кожен метод оцінюється за формулою: складність = LOC × CC + кількість_параметрів
2. Кластеризація: Методи групуються за рівнями складності:
   • Висока складність: > 50 (складні алгоритми, обробка даних)
   • Середня складність: 20-50 (бізнес-логіка, валідація)
   • Низька складність: < 20 (гетери, сетери, утиліти)
3. Виявлення: Якщо клас має методи з 3+ різних груп складності - це Feature Concentration

Переваги:

• ✅ Алгоритмічний: Не залежить від жорстко заданих ключових слів
• ✅ Вимірюваний: Заснований на об'єктивних метриках коду
• ✅ Адаптивний: Працює з різними стилями програмування
• ✅ Точний: Використовує кількісні виміри складності

4.2.3 Display Limits

Configure result display limits:

• Max God Components to Show: Default 10
• Max Hub Classes to Show: Default 5
• Max Feature Concentration Issues to Show: Default 3
• Max Dense Structure Issues to Show: Default 5
• Max Multifaceted Abstractions to Show: Default 5
• Max Insufficient Modularization Issues to Show: Default 5
• Max Classes in Summary: Default 10
• Max Functions in Summary: Default 10

Design Smells:

• Feature Envy Threshold: External access percentage (default: 70%)
• LCOM Threshold: Cohesion threshold (default: 80%)

Implementation Smells:

• Complex Method CC Threshold: Cyclomatic complexity (default: 15)
• Long Method LOC Threshold: Lines of code (default: 50)
• Long Identifier Threshold: Character length (default: 50)
• Long Parameter List Threshold: Parameter count (default: 7)
• Long Statement Threshold: Expression length (default: 120)
• Complex Conditional CC: Condition complexity (default: 10)

Report Format

The report includes the following sections:

🏗️ Architecture Smells Analysis

• Statistics of detected "God Components"
• Hub-like modularization analysis
• Refactoring recommendations

🎨 Design Smells Analysis

• Multifaceted abstractions
• Insufficient modularization
• Inheritance hierarchy problems

⚙️ Implementation Smells Analysis

• Complex methods and conditions
• Long identifiers and methods
• Parameter-related problems

📊 Code Quality Metrics

• Overall project statistics
• Class metrics (LOC, NOM, NOF, DIT, LCOM)
• Method metrics (LOC, CC, PC)
• Average, minimum, and maximum values

Test Files

The plugin includes comprehensive test files that demonstrate various code quality issues:

• test_god_component.php: Demonstrates "God Component" smell
• test_design_smells.php: Shows various design smells
• test_implementation_smells.php: Contains implementation smell examples
• test_metrics.php: Provides metric calculation examples

Implementation Details

Framework Integration

The plugin integrates with the IReport framework of SciTools Understand:

• Uses name(), description(), tags() for report metadata
• Provides test_*() functions for filtering
• Uses init() for option settings
• Implements generate() for report creation

Analysis Approach

• Static Analysis: Uses AST and Understand's symbol table
• Metric Calculation: Uses Understand's built-in metrics
• Pattern Recognition: Implements custom heuristics for smell detection
• Configurable Thresholds: Allows sensitivity adjustment

Dependencies

• SciTools Understand (for PHP support)
• Python 3.x (for UPY plugin execution)
• No external Python libraries required

Limitations

• Some complex smells require deeper semantic analysis
• Machine learning smells not fully implemented (PHP context limitations)
• Cross-file/project architectural analysis is simplified
• Some metrics may slightly differ from academic definitions

Future Improvements

• Enhanced semantic analysis for more accurate smell detection
• Cross-project architecture analysis
• Integration with additional PHP quality tools
• Performance optimization for large codebases
• Additional configuration options

References

• DPy (Design Pattern detector) framework
• Refactoring for Software Design Smells (Mäntylä et al.)
• Object-Oriented Metrics in Practice (Lorenz and Kidd)
• Various scientific papers on code smells and metrics

---

🐛 Bug Fixes:

The plugin has been fully updated for IReport API compatibility:

1. API Options: report.option() → report.options() (parentheses added)
2. API Database: report.db → report.db() (parentheses added)
3. Full functionality tested

📊 Detailed Usage Guide:

Step 1: Launch SciTools Understand

# Launch Understand
"C:\Program Files\SciTools\bin\pc-win64\ud.exe"

Step 2: Open or Create PHP Project

• File → New Project (create new PHP project)
• File → Open Project (open existing .udb file)
• Add PHP files to project for analysis

Step 3: Launch Report Generator

1. Tools → Reports → IReport (or Ctrl+Shift+R)
2. In IReport window find "PHP Quality Analyzer Report"
3. Click Run Report

Step 4: Configure Analysis Parameters

In the settings dialog select:

Core Analysis Parameters:

• ☑️ Analyze Architecture Smells - Analyze architectural issues
• ☑️ Analyze Design Smells - Analyze design problems
• ☑️ Analyze Implementation Smells - Analyze implementation issues
• ☑️ Calculate Code Metrics - Calculate quality metrics

Architecture Smells Thresholds:

• God Component LOC Threshold: 2000 (maximum lines of code)
• God Component Classes Threshold: 50 (maximum classes)
• Hub Dependencies Threshold: 20 (maximum dependencies)
• Wide Hierarchy Threshold: 10 (maximum subclasses)
• Deep Hierarchy Threshold: 6 (maximum inheritance depth)

Design Smells Thresholds:

• Feature Envy Threshold: 70% (external access percentage)
• LCOM Threshold: 80% (cohesion threshold)

Implementation Smells Thresholds:

• Complex Method CC Threshold: 15 (cyclomatic complexity)
• Long Method LOC Threshold: 50 (lines of code)
• Long Identifier Length: 50 (identifier length)
• Long Parameter Count: 7 (parameter count)
• Long Statement Length: 120 (statement length)
• Complex Conditional CC: 10 (condition complexity)

Step 5: Generate Report

1. Click Generate to create report
2. Wait for analysis completion (progress bar shown)
3. IMPORTANT: Report analyzes ALL PHP files in project, not just selected file
4. Review results in report window with file and line references for each issue

Шаг 6: Интерпретация результатов

PHP Quality Analyzer Report
==================================================

🏗️ ARCHITECTURE SMELLS ANALYSIS
⚠️  God Components Found: 1
  • GodComponent in test_god_component.php:8 (LOC: 2397, Methods: 2015, Fields: 21)

✅ No Hub-like modularization detected

⚠️  Feature Concentration: 1
  • hKit in hkit.class.php:60
    MEDIUM: 3 weakly cohesive method groups
    Methods: 15 | Weak clusters: 3
    • Cluster 1: 3 methods - very low cohesion, high complexity methods
      • processnodes (complexity: 255)
      • resolvepath (complexity: 93)
      • parse (complexity: 85)
    • Cluster 2: 5 methods - low cohesion, medium complexity methods
      • find (complexity: 45)
      • extract (complexity: 38)
      • validate (complexity: 32)
      • format (complexity: 28)
      • convert (complexity: 25)
    • Cluster 3: 7 methods - low cohesion, low complexity methods
      • getName (complexity: 3)
      • setValue (complexity: 4)
      • isValid (complexity: 5)
      • ... and 4 more methods
    💡 Improve cohesion within clusters before splitting | Apply Single Responsibility Principle
  ... and X more (configure "Max Feature Concentration Issues to Show")

⚠️  Dense Structure: 1
  • CentralManager in architecture_test.php:15 (85% density, 12 dependencies)

🎨 DESIGN SMELLS ANALYSIS
⚠️  Multifaceted Abstractions: 3
  • GodComponent in test_god_component.php:8 (4 concerns)
  • ReportGenerator in test_implementation_smells.php:8 (5 concerns)
  • UtilityClass in test_design_smells.php:155 (4 concerns)

⚠️  Insufficient Modularization: 18
  • GodComponent in test_god_component.php:8 (LCOM: 0.93)
  • UserManager in test_design_smells.php:8 (LCOM: 1.00)
  • ReportGenerator in test_implementation_smells.php:8 (LCOM: 1.00)

⚙️ IMPLEMENTATION SMELLS ANALYSIS
⚠️  Long Methods: 1
  • DataProcessor::processdatawithcomplexlogic in test_implementation_smells.php:101 (68 lines)

⚠️  Long Identifiers: 5
  • UserAuthenticationAndAuthorizationManagementService in test_implementation_smells.php:228 (51 chars)
  • performuserauthenticationandauthorizationcheckingprocess in test_implementation_smells.php:260 (56 chars)

📊 CODE QUALITY METRICS
Project Statistics:
  • Classes: 63
  • Methods/Functions: 341
  • Total Lines of Code: 958

Class Metrics:
  • LOC: Avg=15.2, Min=0, Max=138
  • NOM: Avg=2.7, Min=0, Max=27
  • NOF: Avg=1.5, Min=0, Max=21
  • DIT: Avg=0.0, Min=0, Max=0
  • LCOM: Avg=0.4, Min=0.0, Max=1.0

Method Metrics:
  • LOC: Avg=2.2, Min=0, Max=68
  • CC: Avg=0.5, Min=0, Max=6
  • PC: Avg=0.0, Min=0, Max=0

📋 Top 10 Classes by LOC (showing top 10):
• GodComponent - 2397 LOC, 2244 methods
• LargeClass - 850 LOC, 45 methods
• ComplexClass - 320 LOC, 28 methods
... and 7 more classes (configure "Max Classes in Summary")

📋 Top 10 Functions by LOC (showing top 10):
• processLargeData - 68 LOC, CC: 12
• complexCalculation - 45 LOC, CC: 8
• handleMultipleTasks - 38 LOC, CC: 6
... and 11 more functions (configure "Max Functions in Summary")

🎯 Results Interpretation

Complete Project Analysis:

Plugin analyzes ALL PHP files in the project, regardless of the file selected in IReport. This provides a complete picture of the entire project's code quality.

Severity Levels:

• 🔴 HIGH: Architectural smells, complex methods
• 🟡 MEDIUM: Design smells, long methods
• 🟢 LOW: Implementation smells, metric warnings

Problem Location:

Each issue now shows:

IssueName in file.php:line (details)

This allows quick navigation to problematic code in IDE.

Refactoring Recommendations:

🐘 God Component:

// BAD: One huge class
class UserManager {
    // 2000+ lines of code, multiple responsibilities
}

// GOOD: Split into specialized classes
class UserRepository { /* data only */ }
class UserService { /* business logic only */ }
class UserValidator { /* validation only */ }

🎭 Multifaceted Abstraction:

// BAD: Class with multiple responsibilities
class OrderProcessor {
    public function validate() { /* validation */ }
    public function save() { /* persistence */ }
    public function sendEmail() { /* notifications */ }
    public function calculateTax() { /* calculations */ }
}

// GOOD: Single Responsibility Principle
class OrderValidator { /* validation only */ }
class OrderRepository { /* persistence only */ }
class OrderNotifier { /* notifications only */ }
class TaxCalculator { /* calculations only */ }

🌀 Complex Method:

// BAD: Complex method with high cyclomatic complexity
public function processOrder($orderData) {
    if ($orderData['type'] == 'new') {
        if ($orderData['payment'] == 'card') {
            if ($orderData['amount'] > 100) {
                // ... many nested conditions
            }
        }
    }
}

// GOOD: Break into simple methods
public function processOrder($orderData) {
    if (!$this->isValidOrder($orderData)) return false;
    $this->processPayment($orderData);
    $this->updateInventory($orderData);
    $this->sendConfirmation($orderData);
}

Quality Metrics Guidelines:

• LOC < 50: Excellent method
• CC < 10: Good complexity
• LCOM < 0.5: High cohesion
• DIT < 4: Acceptable inheritance depth

📈 CI/CD Integration

For automated analysis, use:

# In build script
ud -db project.udb -report "PHP Quality Analyzer Report" -output quality_report.html

🔧 Расширение плагина

Чтобы добавить новые проверки:

# Добавить в check.upy
def analyze_custom_smell(entities):
    """Пользовательская проверка"""
    custom_smells = []
    for cls in entities['classes']:
        # Ваша логика анализа
        if some_condition(cls):
            custom_smells.append({'name': cls.name(), 'issue': 'Custom Issue'})
    return custom_smells

# Добавить вызов в generate()
def generate_custom_report(report, entities):
    custom_issues = analyze_custom_smell(entities)
    if custom_issues:
        report.print(f"⚠️  Custom Issues: {len(custom_issues)}\n")
        for issue in custom_issues:
            report.print(f"  • {issue['name']}: {issue['issue']}\n")

📚 Источники и стандарты

• DPy Framework - Основа для анализа качества кода
• SOLID принципы - Основы объектно-ориентированного дизайна
• Clean Code (Robert Martin) - Стандарты чистого кода
• Refactoring (Martin Fowler) - Техники рефакторинга

🆘 Troubleshooting

Plugin Not Appearing in IReport:

• Check path: IReport/PHP_Quality_Analyzer/check.upy
• Restart Understand
• Verify check.upy file exists

Empty Reports:

• Ensure PHP files exist in project
• Check file language settings (should be PHP)
• Try analyzing individual files

Performance Issues:

• For large projects, disable some analysis types
• Increase thresholds to reduce detections
• Analyze individual packages/directories

🎉 Conclusion

PHP Quality Analyzer is a powerful tool for maintaining high PHP code quality. It combines proven analysis methodologies (DPy framework) with the convenient SciTools Understand interface.

Key Advantages:

• ✅ Comprehensive analysis of all code quality aspects
• ✅ Configurable thresholds to match your team's standards
• ✅ Detailed reports with refactoring recommendations
• ✅ IDE integration for ease of use
• ✅ Open source for extensions and modifications

Happy coding and quality analysis! 🎯

7. Appendices

Appendix A: Configuration Options Reference

Table 1: Configuration Options

Option	Default	Description
Analyze Architecture Smells	True	Enable architectural issue detection
Analyze Design Smells	True	Enable design problem detection
Analyze Implementation Smells	True	Enable code-level issue detection
Calculate Code Metrics	True	Enable quality metrics calculation
God Component LOC Threshold	2000	Maximum lines of code for God Component
God Component Classes Threshold	50	Maximum classes for God Component
Hub Dependencies Threshold	20	Maximum dependencies for hub detection
Feature Concentration Threshold	3	Minimum complexity clusters
Feature Envy Threshold	70%	External access percentage threshold
LCOM Threshold	80%	Lack of cohesion threshold
Complex Method CC Threshold	15	Cyclomatic complexity threshold
Long Method LOC Threshold	50	Lines of code threshold
Long Identifier Threshold	50	Character length threshold
Long Parameter List Threshold	7	Parameter count threshold

Appendix B: Analysis Results Interpretation

Table 2: Severity Level Guidelines

Severity	Description	Action Required
?? HIGH	Critical architectural issues	Immediate refactoring required
?? MEDIUM	Design and implementation problems	Plan refactoring in next sprint
?? LOW	Minor code quality issues	Address during code review

Table 3: Common Refactoring Recommendations

Issue Type	Common Solution
God Component	Split into smaller, focused classes
Feature Concentration	Extract methods into separate classes
Multifaceted Abstraction	Apply Single Responsibility Principle
Long Method	Extract method or decompose functionality
High Complexity	Simplify logic, reduce nesting

Appendix C: Glossary

• Cyclomatic Complexity (CC): Measure of code complexity based on control flow
• Lack of Cohesion in Methods (LCOM): Measure of how closely related methods are within a class
• Feature Concentration: Architectural smell where a component handles multiple concerns
• God Component: Anti-pattern of a class that knows too much or does too much
• Refactoring: Improving code structure without changing its external behavior

Appendix D: References

1. ISO/IEC/IEEE 26514:2018 - Systems and software engineering - User documentation standards
2. DPy Framework - Design Pattern Detection Framework
3. Martin, R. C. (2008). Clean Code: A Handbook of Agile Software Craftsmanship
4. Fowler, M. (1999). Refactoring: Improving the Design of Existing Code
5. Lorenz, M., & Kidd, J. (1994). Object-Oriented Software Metrics

Appendix E: Version History

• Version 1.0 (December 2025): Initial release with comprehensive PHP analysis
  • Architecture, design, and implementation smell detection
  • Code quality metrics calculation
  • Algorithmic Feature Concentration analysis
  • IReport integration