SavinMikhail\CommentsDensity\MissingDocblock\MissingDocBlockAnalyzer

Complexity

Total Complexity

24

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Test Coverage

Coverage

79.69%

Importance

Changes	3
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getStatColor()	0	10	3
A	shouldAnalyzeToken()	0	11	1
A	getColor()	0	3	1
A	__construct()	0	4	1
A	createMissingDocBlockStat()	0	7	1
A	hasExceededThreshold()	0	3	1
A	getMissingDocblocks()	0	3	1
A	analyzeTokens()	0	24	6
A	getName()	0	3	1
B	isDocBlockRequired()	0	25	8

<?php

declare(strict_types=1);

namespace SavinMikhail\CommentsDensity\MissingDocblock;

use SavinMikhail\CommentsDensity\DTO\Input\MissingDocblockConfigDTO;

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

use function is_array;

use const T_CLASS;
use const T_CONST;
use const T_DOC_COMMENT;
use const T_ENUM;
use const T_FUNCTION;
use const T_INTERFACE;
use const T_TRAIT;
use const T_VARIABLE;

final class MissingDocBlockAnalyzer
{
    private bool $exceedThreshold = false;

    public function __construct(
        private readonly Tokenizer $tokenizer,

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

        private readonly MissingDocblockConfigDTO $docblockConfigDTO,
    ) {
    }

    /**
     * Analyzes the tokens of a file for docblocks.
     *
     * @param array $tokens The tokens to analyze.
     * @return array The analysis results.
     */
    private function analyzeTokens(array $tokens, string $filename): array
    {
        $lastDocBlock = null;
        $missingDocBlocks = [];
        $tokenCount = count($tokens);

        for ($i = 0; $i < $tokenCount; $i++) {
            $token = $tokens[$i];

            if (! is_array($token)) {
                continue;
            }

            if ($token[0] === T_DOC_COMMENT) {
                $lastDocBlock = $token[1];
            } elseif ($this->isDocBlockRequired($token, $tokens, $i)) {
                if (empty($lastDocBlock)) {
                    $missingDocBlocks[] = $this->createMissingDocBlockStat($token, $filename);
                }
                $lastDocBlock = null;
            }
        }

        return $missingDocBlocks;
    }

    private function shouldAnalyzeToken(array $token): bool
    {
        return match ($token[0]) {
            T_CLASS => $this->docblockConfigDTO->class,
            T_TRAIT => $this->docblockConfigDTO->trait,
            T_INTERFACE => $this->docblockConfigDTO->interface,
            T_ENUM => $this->docblockConfigDTO->enum,
            T_FUNCTION => $this->docblockConfigDTO->function,
            T_CONST => $this->docblockConfigDTO->constant,
            T_VARIABLE => $this->docblockConfigDTO->property,
            default => false,
        };
    }

    private function isDocBlockRequired(array $token, array $tokens, int $index): bool
    {
        if (!$this->shouldAnalyzeToken($token)) {
            return false;
        }

        if ($this->tokenizer->isClass($token)) {
               return ! $this->tokenizer->isAnonymousClass($tokens, $index)
                && !$this->tokenizer->isClassNameResolution($tokens, $index);
        }

        if ($this->tokenizer->isFunction($token)) {
             return  ! $this->tokenizer->isAnonymousFunction($tokens, $index)
                && ! $this->tokenizer->isFunctionImport($tokens, $index);
        }

        if ($this->tokenizer->isVariable($token)) {
            return $this->tokenizer->isPropertyOrConstant($tokens, $index);
        }

        if ($this->tokenizer->isConst($token)) {
            return $this->tokenizer->isPropertyOrConstant($tokens, $index);
        }

        return true;
    }

    private function createMissingDocBlockStat(array $token, string $filename): array
    {
        return [
            'type' => 'missingDocblock',
            'content' => '',
            'file' => $filename,
            'line' => $token[2]
        ];
    }

    public function getMissingDocblocks(array $tokens, string $filename): array
    {
        return $this->analyzeTokens($tokens, $filename);
    }

    public function getColor(): string
    {
        return 'red';
    }

    public function getStatColor(float $count, array $thresholds): string
    {
        if (! isset($thresholds['missingDocBlock'])) {
            return 'white';
        }
        if ($count <= $thresholds['missingDocBlock']) {
            return 'green';
        }
        $this->exceedThreshold = true;
        return 'red';
    }

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

    public function getName(): string
    {
        return 'missingDocblock';
    }
}