Solidifier\Visitors\DependencyInjection\InterfaceSegregation

Complexity

Total Complexity

10

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	before()	0	4	1
A	enter()	0	13	4
B	checkIfTypeIsAnInterface()	0	28	4

<?php

namespace Solidifier\Visitors\DependencyInjection;

use Solidifier\Parser\Visitors\ContextualVisitor;
use Solidifier\Visitors\PreAnalyze\ObjectTypes;
use PhpParser\Node;
use PhpParser\Node\Param;
use PhpParser\Node\Name;
use Solidifier\Visitors\ObjectType;
use Solidifier\Defects\DependencyUponImplementation;

class InterfaceSegregation extends ContextualVisitor
{
    private
        $objectTypes,

It is generally advisable to only define one property per statement.

The visibility should be declared for property $objectTypes.

        $types;
    
    public function __construct(ObjectTypes $objectTypes)
    {
        parent::__construct();
        
        $this->objectTypes = $objectTypes;
        $this->types = array();

Equals sign not aligned with surrounding assignments; expected 7 spaces but found 1 space

    }    
    
    public function before(array $nodes)
    {
        $this->types = $this->objectTypes->getObjectTypes();
    }
    
    protected function enter(Node $node)
    {
        if($node instanceof Param)
        {
            if($this->currentMethod !== null)
            {
                if($node->type instanceof Name)
                {
                    $this->checkIfTypeIsAnInterface($node, $node->type);
                }
            }
        }
    }
    
    private function checkIfTypeIsAnInterface(Node $node, Name $type)
    {
        $name = (string) $type;
        
        if($type->isFullyQualified() === false)
        {
            $name = $this->currentNamespace . '\\' . $name;
        }
        
        if(isset($this->types[$name]))
        {
            $objectTypeType= $this->types[$name];

Equals sign not aligned correctly; expected 1 space but found 0 spaces

            
            if($objectTypeType !== ObjectType::TYPE_INTERFACE)
            {
                $defect = new DependencyUponImplementation(
                    $node,
                    $name,
                    $objectTypeType,
                    $this->currentMethod->name
                );
                
                $defect->setContext($this->currentMethod);
                
                $this->dispatch($defect);
            }
        }
    }
}