MS\PHPMD\Rule\CleanCode\PrivateFieldDeclaration

Complexity

Total Complexity

15

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	apply()	0	24	6
A	getPublicMethods()	0	13	3
A	calculateVariablePercentOfMethods()	0	12	2
A	getMethodsContainsVariable()	0	21	4

<?php

namespace MS\PHPMD\Rule\CleanCode;

use MS\PHPMD\Guesser\DataStructureGuesser;
use PHPMD\AbstractNode;
use PHPMD\Node\ClassNode;

/**
 * To have a high cohesion the private variables of a class should be used in many methods. Otherwise the class probably does more than one thing.
 */
class PrivateFieldDeclaration extends AbstractDataStructure
{
    use DataStructureGuesser;

    /**
     * @param AbstractNode|ClassNode $node
     */
    public function apply(AbstractNode $node)
    {
        if (true === $this->isDataStructure($node)) {

$node of type object<PHPMD\AbstractNode> is not a sub-type of object<PHPMD\Node\ClassNode>. It seems like you assume a child class of the class PHPMD\AbstractNode to be always present.

            return;
        }

        $minPercent = $this->getIntProperty('percent');
        $publicMethods = $this->getPublicMethods($node);

$node of type object<PHPMD\AbstractNode> is not a sub-type of object<PHPMD\Node\ClassNode>. It seems like you assume a child class of the class PHPMD\AbstractNode to be always present.

        foreach ($node->findChildrenOfType('FieldDeclaration') as $fieldDeclaration) {
            if (false === $fieldDeclaration->isPrivate() || true === $fieldDeclaration->isStatic()) {
                continue;
            }

            $variableDeclarator = $fieldDeclaration->getFirstChildOfType('VariableDeclarator');

            $variableName = substr($variableDeclarator->getName(), 1);
            $methodPercent = $this->calculateVariablePercentOfMethods($publicMethods, $variableName);

            if ($minPercent >= $methodPercent) {
                $this->addViolation($fieldDeclaration, [$methodPercent, $minPercent]);
            }
        }
    }

    /**
     * @param ClassNode $node
     *
     * @return array
     */
    private function getPublicMethods(ClassNode $node)
    {
        $methods = $node->getMethods();
        $publicMethods = [];

        foreach ($methods as $method) {
            if (true === $method->isPublic()) {
                $publicMethods[] = $method;
            }
        }

        return $publicMethods;
    }

    /**
     * @param array  $methods
     * @param string $variableName
     *
     * @return float
     */
    private function calculateVariablePercentOfMethods(array $methods, $variableName)
    {
        $methodCount = count($methods);

        if (0 === $methodCount) {
            return 0;
        }

        $methodsWithVariable = $this->getMethodsContainsVariable($methods, $variableName);

        return round(count($methodsWithVariable) / $methodCount * 100);
    }

    /**
     * @param AbstractNode[] $methods
     * @param string         $variableName
     *
     * @return AbstractNode[]
     */
    private function getMethodsContainsVariable(array $methods, $variableName)
    {
        $methodsWithVariable = [];

        foreach ($methods as $method) {
            $propertyPostfixes = $method->findChildrenOfType('PropertyPostfix');

            /** @var AbstractNode $propertyPostfix */
            foreach ($propertyPostfixes as $propertyPostfix) {
                $identifier = $propertyPostfix->getFirstChildOfType('Identifier');

                if ($variableName === $identifier->getName()) {
                    $methodsWithVariable[] = $method;

                    break;
                }
            }
        }

        return $methodsWithVariable;
    }
}