SavinMikhail\CommentsDensity\CommentDensity

Complexity

Total Complexity

22

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	21
Bugs	6	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	isInWhitelist()	0	8	3
A	createOutputDTO()	0	19	2
A	prepareComments()	0	28	4
B	analyze()	0	44	6
B	prepareCommentStatistics()	0	32	6

<?php

declare(strict_types=1);

namespace SavinMikhail\CommentsDensity;

use Generator;
use SavinMikhail\CommentsDensity\Comments\CommentFactory;
use SavinMikhail\CommentsDensity\Comments\CommentTypeInterface;
use SavinMikhail\CommentsDensity\DTO\Input\ConfigDTO;

The type SavinMikhail\CommentsDensity\DTO\Input\ConfigDTO was not found. Maybe you did not declare it correctly or list all dependencies?

use SavinMikhail\CommentsDensity\DTO\Output\CommentDTO;

The type SavinMikhail\CommentsDensity\DTO\Output\CommentDTO was not found. Maybe you did not declare it correctly or list all dependencies?

use SavinMikhail\CommentsDensity\DTO\Output\CommentStatisticsDTO;

The type SavinMikhail\CommentsDensity\DTO\Output\CommentStatisticsDTO was not found. Maybe you did not declare it correctly or list all dependencies?

use SavinMikhail\CommentsDensity\DTO\Output\OutputDTO;

The type SavinMikhail\CommentsDensity\DTO\Output\OutputDTO was not found. Maybe you did not declare it correctly or list all dependencies?

use SavinMikhail\CommentsDensity\Metrics\Metrics;

The type SavinMikhail\CommentsDensity\Metrics\Metrics was not found. Maybe you did not declare it correctly or list all dependencies?

use SavinMikhail\CommentsDensity\Reporters\ReporterInterface;
use SplFileInfo;

use function str_contains;

final class CommentDensity
{
    private bool $exceedThreshold = false;

    public function __construct(
        private readonly ConfigDTO $configDTO,
        private readonly CommentFactory $commentFactory,
        private readonly FileAnalyzer $fileAnalyzer,

The type SavinMikhail\CommentsDensity\FileAnalyzer was not found. Maybe you did not declare it correctly or list all dependencies?

        private readonly ReporterInterface $reporter,
        private readonly MissingDocBlockAnalyzer $missingDocBlock,
        private readonly Metrics $metrics,
    ) {
    }

    public function analyze(Generator $files): bool
    {
        $this->metrics->startPerformanceMonitoring();
        $comments = [];
        $commentStatistics = [];
        $totalLinesOfCode = 0;
        $cdsSum = 0;
        $filesAnalyzed = 0;

        foreach ($files as $file) {
            if (! ($file instanceof SplFileInfo)) {
                continue;
            }
            if ($this->isInWhitelist($file->getRealPath())) {
                continue;
            }
            if ($file->getSize() === 0) {
                continue;
            }

            $this->fileAnalyzer->analyzeFile(
                $file,
                $commentStatistics,
                $comments,
                $totalLinesOfCode,
                $cdsSum
            );
            $filesAnalyzed++;
        }

        $this->metrics->stopPerformanceMonitoring();

        $averageCds = $totalLinesOfCode === 0 ? 0 : $cdsSum / $totalLinesOfCode;

The condition $totalLinesOfCode === 0 is always true.

        $outputDTO = $this->createOutputDTO(
            $comments,
            $commentStatistics,
            $totalLinesOfCode,
            $averageCds,
            $filesAnalyzed,
        );

        $this->reporter->report($outputDTO);

        return $this->exceedThreshold;
    }

    private function createOutputDTO(
        array $comments,
        array $commentStatistics,
        int $linesOfCode,
        float $cds,
        int $filesAnalyzed,
    ): OutputDTO {
        $outputDTO = new OutputDTO(
            $filesAnalyzed,
            $this->prepareCommentStatistics($commentStatistics),
            $this->prepareComments($comments),
            $this->metrics->getPerformanceMetrics(),
            $this->metrics->prepareComToLoc($commentStatistics, $linesOfCode),
            $this->metrics->prepareCDS($cds)
        );
        if ($this->metrics->hasExceededThreshold()) {
            $this->exceedThreshold = true;
        }
        return $outputDTO;
    }

    private function prepareCommentStatistics(array $commentStatistics): array
    {
        $preparedStatistics = [];
        foreach ($commentStatistics as $type => $stat) {
            if ($type === 'missingDocblock') {
                $preparedStatistics[] = new CommentStatisticsDTO(
                    $this->missingDocBlock->getColor(),
                    $this->missingDocBlock->getName(),
                    $stat['lines'],
                    $this->missingDocBlock->getStatColor($stat['count'], $this->configDTO->thresholds),
                    $stat['count']
                );
                if ($this->missingDocBlock->hasExceededThreshold()) {
                    $this->exceedThreshold = true;
                }
                continue;
            }
            $commentType = $this->commentFactory->getCommentType($type);
            if ($commentType) {
                $preparedStatistics[] = new CommentStatisticsDTO(
                    $commentType->getColor(),
                    $commentType->getName(),
                    $stat['lines'],
                    $commentType->getStatColor($stat['count'], $this->configDTO->thresholds),
                    $stat['count']
                );
                if ($commentType->hasExceededThreshold()) {
                    $this->exceedThreshold = true;
                }
            }
        }
        return $preparedStatistics;
    }

    private function prepareComments(array $comments): array
    {
        $preparedComments = [];
        foreach ($comments as $comment) {
            /** @var CommentTypeInterface|string $commentType */
            $commentType = $comment['type'];
            if ($commentType === 'missingDocblock') {
                $preparedComments[] = new CommentDTO(
                    'missingDocblock',
                    'red',
                    $comment['file'],
                    $comment['line'],
                    $comment['content']
                );
                continue;
            }
            if ($commentType->getAttitude() === 'good') {
                continue;
            }
            $preparedComments[] = new CommentDTO(
                $commentType->getName(),
                $commentType->getColor(),
                $comment['file'],
                $comment['line'],
                $comment['content']
            );
        }
        return $preparedComments;
    }

    private function isInWhitelist(string $filePath): bool
    {
        foreach ($this->configDTO->exclude as $whitelistedDir) {
            if (str_contains($filePath, $whitelistedDir)) {
                return true;
            }
        }
        return false;
    }
}