SavinMikhail\CommentsDensity\Metrics\CDS

Complexity

Total Complexity

16

Size/Duplication

Total Lines	93
Duplicated Lines	0 %

Test Coverage

Coverage

96.15%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareCDS()	0	6	1
A	__construct()	0	4	1
A	calculateRawScore()	0	14	3
A	getMaxPossibleScore()	0	7	1
A	getMinPossibleScore()	0	16	4
A	calculateCDS()	0	11	2
A	getColorForCDS()	0	10	3
A	hasExceededThreshold()	0	3	1

<?php

declare(strict_types=1);

namespace SavinMikhail\CommentsDensity\Metrics;

use InvalidArgumentException;
use Mikhail\PrimitiveWrappers\Int\Integer;
use SavinMikhail\CommentsDensity\Comments\CommentFactory;
use SavinMikhail\CommentsDensity\Comments\DocBlockComment;
use SavinMikhail\CommentsDensity\DTO\Output\CdsDTO;

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

use function in_array;
use function round;

final class CDS
{
    private const MISSING_DOCBLOCK_WEIGHT = -1;

    private bool $exceedThreshold = false;

    public function __construct(
        private readonly array $thresholds,
        private readonly CommentFactory $commentFactory,
    ) {
    }

    public function calculateCDS(array $commentStatistics): float
    {
        $rawScore = $this->calculateRawScore($commentStatistics);
        $minPossibleScore = $this->getMinPossibleScore($commentStatistics);
        $maxPossibleScore = $this->getMaxPossibleScore($commentStatistics);

        try {
            return (new Integer(0))
                ->scaleToRange($rawScore, $minPossibleScore, $maxPossibleScore);
        } catch (InvalidArgumentException) {
            return 0;
        }
    }

    private function calculateRawScore(array $commentStatistics): float
    {
        $rawScore = 0;

        foreach ($commentStatistics as $type => $stat) {
            $comment = $this->commentFactory->getCommentType($type);
            if ($comment) {
                $rawScore += $stat['count'] * $comment->getWeight();
                continue;
            }
            $rawScore += $stat['count'] * self::MISSING_DOCBLOCK_WEIGHT;
        }

        return $rawScore;
    }

    private function getMinPossibleScore(array $commentStatistics): float
    {
        $minScore = 0;
        foreach ($commentStatistics as $type => $stat) {
            $comment = $this->commentFactory->getCommentType($type);
            if (!$comment) {
                $minScore += self::MISSING_DOCBLOCK_WEIGHT * $stat['count'];
                continue;
            }
            if ($comment->getWeight() < 0) {
                $minScore += $comment->getWeight() * $stat['count'];
                continue;
            }
            $minScore -= $comment->getWeight() * $stat['count'];
        }
        return $minScore;
    }

    private function getMaxPossibleScore(array $commentStatistics): float
    {
        return (
                ($commentStatistics['missingDocblock']['count'] ?? 0)
                + ($commentStatistics['docblock']['count'] ?? 0)
            )
            * ((new DocBlockComment())->getWeight());
    }

    public function prepareCDS(float $cds): CdsDTO
    {
        $cds = round($cds, 2);
        return new CdsDTO(
            $cds,
            $this->getColorForCDS($cds),
        );
    }

    private function getColorForCDS(float $cds): string
    {
        if (! isset($this->thresholds['CDS'])) {
            return 'white';
        }
        if ($cds >= $this->thresholds['CDS']) {
            return 'green';
        }
        $this->exceedThreshold = true;
        return 'red';
    }

    public function hasExceededThreshold(): bool
    {
        return $this->exceedThreshold;
    }
}