BestIt\Sniffs\Formatting\UCVFSortingSniff

Complexity

Total Complexity

14

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	loadSubTokenPositions()	0	9	1
A	loadSubTokens()	0	6	1
A	loadTokensForPositions()	0	8	1
A	processToken()	0	7	1
A	removeUnwantedTokens()	0	19	3
A	setUp()	0	6	1
A	sortTokens()	0	19	2
A	validateSorting()	0	23	4

<?php

declare(strict_types=1);

namespace BestIt\Sniffs\Formatting;

use BestIt\CodeSniffer\Helper\PropertyHelper;
use BestIt\Sniffs\AbstractSniff;
use BestIt\Sniffs\ClassRegistrationTrait;
use SlevomatCodingStandard\Helpers\TokenHelper;
use SlevomatCodingStandard\Helpers\UseStatementHelper;
use function array_combine;
use function array_filter;
use function array_keys;
use function array_map;
use function array_search;
use function uasort;
use const T_CONST;
use const T_FUNCTION;
use const T_USE;
use const T_VARIABLE;

/**
 * Checks the sorting of the contents of a class (T_USE > T_CONST > T_VARIABLE > T_FUNCTION).
 *
 * @author blange <bjoern.lange@bestit-online.de>
 * @package BestIt\Sniffs\Formatting
 */
class UCVFSortingSniff extends AbstractSniff
{
    use ClassRegistrationTrait;

    /**
     * Error code for the wrong position of a structure.
     *
     * @var string
     */
    public const CODE_WRONG_POSITION = 'WrongPosition';

    /**
     * The error message of a structure is at the wrong position.
     *
     * @var string
     */
    private const MESSAGE_WRONG_POSITION = 'Your php structure is at a wrong position. ' .
        'The sorting order is: T_USE, T_CONST, T_VARIABLE, T_FUNCTION. We expect a %s (%s).';

    /**
     * The tokens which are checked in the correct sorting order.
     *
     * @var array
     */
    private $sortedTokens = [
        T_USE,
        T_CONST,
        T_VARIABLE,
        T_FUNCTION
    ];

    /**
     * Loads the positons for the tokens of $this->>sortedTokens.
     *
     * @return int[]
     */
    private function loadSubTokenPositions(): array
    {
        return TokenHelper::findNextAll(
            $this->file->getBaseFile(),
            $this->sortedTokens,
            $this->stackPos,
            $this->token['scope_closer']
        );
    }

    /**
     * Loads all sub tokens.
     *
     * @return array
     */
    private function loadSubTokens(): array
    {
        $subTokens = $this->loadTokensForPositions($this->loadSubTokenPositions());

        return $this->removeUnwantedTokens($subTokens);
    }

    /**
     * Loads the tokens for the positions.
     *
     * @param array $subTokenPoss
     *
     * @return array
     */
    private function loadTokensForPositions(array $subTokenPoss): array
    {
        $subTokens = array_map(function (int $position): array {
            return $this->tokens[$position];
        }, $subTokenPoss);

        return array_combine($subTokenPoss, $subTokens);
    }

    /**
     * Processes the token.
     *
     * @return void
     */
    protected function processToken(): void
    {
        $subTokens = $this->loadSubTokens();
        $sortedTokens = $this->sortTokens($subTokens);

        $this->validateSorting($subTokens, $sortedTokens);
    }

    /**
     * Removes inline vars and uses for anon-functions.
     *
     * @param array $subTokens
     *
     * @return array
     */
    private function removeUnwantedTokens(array $subTokens): array
    {
        return array_filter($subTokens, function (array $subToken): bool {
            switch ($subToken['code']) {
                case T_VARIABLE:
                    $return = (new PropertyHelper($this->file))->isProperty($subToken['pointer']);

It seems like $this->file can be null; however, __construct() does not accept null, maybe add an additional type check?

                    break;

                case T_USE:
                    $return = UseStatementHelper::isTraitUse($this->file, $subToken['pointer']);

It seems like $this->file can be null; however, isTraitUse() does not accept null, maybe add an additional type check?

                    break;

                default:
                    $return = true;
            }

            return $return;
        });
    }

    /**
     * This sniff needs the pointer marker so add it to the tokens.
     *
     * @return void
     */
    protected function setUp(): void
    {
        parent::setUp();

        $this->addPointerToTokens();
    }

    /**
     * Sorts the tokens as required by $this->sortingTokens.
     *
     * @param array $subTokens
     *
     * @return array
     */
    private function sortTokens(array $subTokens): array
    {
        uasort($subTokens, function (array $leftToken, array $rightToken): int {
            // Don't change the structure by default.
            $return = $leftToken['line'] <=> $rightToken['line'];

            // Sort by type
            if ($leftToken['code'] != $rightToken['code']) {
                $leftIndex = array_search($leftToken['code'], $this->sortedTokens);
                $rightIndex = array_search($rightToken['code'], $this->sortedTokens);

                $return = $leftIndex <=> $rightIndex;
            }

            return $return;
        });

        return $subTokens;
    }

    /**
     * Validates the sorting of the tokens and registers an error if wrong sorted.
     *
     * @param array $originalTokens
     * @param array $sortedTokens
     *
     * @return void
     */
    private function validateSorting(array $originalTokens, array $sortedTokens): void
    {
        $sortedPositions = array_keys($sortedTokens);
        $sortedIndex = 0;

        foreach ($originalTokens as $originalPosition => $originalToken) {
            $sortedPosition = $sortedPositions[$sortedIndex++];
            $sortedToken = $sortedTokens[$sortedPosition];

            // We don't need an error if the "type block" is the same, so check the code additionally.
            if (($sortedPosition !== $originalPosition) && ($originalToken['code'] !== $sortedToken['code'])) {
                $this->file->addError(
                    self::MESSAGE_WRONG_POSITION,
                    $originalPosition,
                    self::CODE_WRONG_POSITION,
                    [
                        $sortedToken['type'],
                        $sortedToken['content']
                    ]
                );
            }
        }
    }
}