Solidifier\Visitors\DependencyInjection\StrongCoupling

Complexity

Total Complexity

16

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	addAllowedClass()	0	6	1
A	addExcludePattern()	0	6	1
A	enter()	0	13	4
A	enterNewName()	0	12	3
A	isCurrentClassAllowedToInstanciateObjects()	0	4	1
A	isAnAllowedObjectType()	0	17	3
A	extractClassNameFromFullName()	0	12	2

<?php

namespace Solidifier\Visitors\DependencyInjection;

use Solidifier\Parser\Visitors\ContextualVisitor;
use PhpParser\Node;
use PhpParser\Node\Name;
use PhpParser\Node\Expr\New_;
use Solidifier\Visitors\ObjectType;

class StrongCoupling extends ContextualVisitor
{
    private
        $allowedClass,

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

The visibility should be declared for property $allowedClass.

        $excludePattern;
    
    public function __construct()
    {
        parent::__construct();
        
        $this->allowedClass = array();

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

        $this->excludePattern = array();
    }
    
    public function addAllowedClass($fullyQualifiedClassName)
    {
        $this->allowedClass[] = $fullyQualifiedClassName;
        
        return $this;
    }
    
    public function addExcludePattern($regex)
    {
        $this->excludePattern[] = $regex;
        
        return $this;
    }
    
    protected function enter(Node $node)
    {
        if($this->currentObjectType instanceof ObjectType)
        {
            if($node instanceof New_)
            {
                if($node->class instanceof Name)
                {
                    return $this->enterNewName($node);
                }
            }
        }
    }
    
    private function enterNewName(New_ $node)
    {
        if($this->isCurrentClassAllowedToInstanciateObjects() === false)
        {
            if($this->isAnAllowedObjectType($node->class) === false)
            {
                $defect = new \Solidifier\Defects\StrongCoupling($this->currentObjectType, $node);

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

                $defect->setContext($this->nodeStack->top());
                $this->dispatch($defect);
            }
        }
    }
    
    private function isCurrentClassAllowedToInstanciateObjects()
    {
        return in_array($this->currentObjectType->fullname, $this->allowedClass);
    }
    
    private function isAnAllowedObjectType($objectType)
    {
        $allowed = false;

        $objectType = $this->extractClassNameFromFullName($objectType);

        foreach($this->excludePattern as $pattern)
        {
            if(preg_match($pattern, $objectType))
            {
                $allowed = true;
                break;
            }
        }

        return $allowed;
    }
    
    private function extractClassNameFromFullName($classFullname)
    {
        $classname = $classFullname;
        
        $lastNamespaceDelimiterPosition = strrpos($classFullname, '\\');
        if($lastNamespaceDelimiterPosition !== false)
        {
            $classname = substr($classFullname, $lastNamespaceDelimiterPosition + 1);
        }

        return $classname;
    }
}