DefinitionBuilder::defineImplementors() - Code Metrics - Inspection of "Working version" - samsonframework/container - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d3edd8...61bf89 )

unknown

created 2016-10-03 09:36 UTC

DefinitionBuilder::defineImplementors() A

↳ Parent: DefinitionBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	6
ccs	0
cts	0
cp	0
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	3
nc	1
nop	2
crap	2

<?php declare(strict_types = 1);
/**
 * Created by PhpStorm.
 * User: root
 * Date: 02.08.16
 * Time: 0:46.
 */
namespace samsonframework\container\definition\builder;

use samsonframework\container\definition\AbstractDefinition;
use samsonframework\container\definition\ClassBuilderInterface;
use samsonframework\container\definition\ClassDefinition;
use samsonframework\container\definition\exception\ClassDefinitionAlreadyExistsException;
use samsonframework\container\definition\parameter\exception\ParameterAlreadyExistsException;
use samsonframework\container\definition\parameter\ParameterBuilder;
use samsonframework\container\definition\parameter\ParameterBuilderInterface;
use samsonframework\container\definition\reference\ClassReference;
use samsonframework\container\definition\reference\ReferenceDependencyInterface;
use samsonframework\container\definition\reference\ReferenceInterface;

/**
 * Class DefinitionBuilder
 *
 * @author Ruslan Molodyko <[email protected]>
 */
class DefinitionBuilder extends AbstractDefinition
{
    /** @var  ClassDefinition[] Definition collection */
    protected $definitionCollection = [];
    /** @var  ParameterBuilder */
    protected $parameterBuilder;
    /** @var array Collection of interface => [classes]*/
    protected $implementors = [];

    /**
     * DefinitionBuilder constructor.
     *
     * @param ParameterBuilder $parameterBuilder
     * @param AbstractDefinition|null $parentDefinition
     */
    public function __construct(ParameterBuilder $parameterBuilder, AbstractDefinition $parentDefinition = null)
    {
        parent::__construct($parentDefinition);

        $this->parameterBuilder = $parameterBuilder;
        $this->parameterBuilder->setParentDefinition($this);
    }

    /**
     * Define parameters
     *
     * @param string $name
     * @param ReferenceInterface $reference
     * @return ParameterBuilderInterface
     * @throws ParameterAlreadyExistsException
     */
    public function defineParameter(string $name, ReferenceInterface $reference): ParameterBuilderInterface
    {
        return $this->parameterBuilder->defineParameter($name, $reference);
    }

    /**
     * Define interface implementors
     *
     * @param string $interfaceName
     * @param ReferenceInterface $class
     * @return DefinitionBuilder
     */
    public function defineImplementors(string $interfaceName, ReferenceInterface $class): DefinitionBuilder
    {
        $this->implementors[$interfaceName] = $class;

        return $this;
    }

    /**
     * Add new class definition
     *
     * @param $className
     * @param string $serviceName
     * @return ClassBuilderInterface
     * @throws \InvalidArgumentException
     * @throws ClassDefinitionAlreadyExistsException
     */
    public function addDefinition($className, string $serviceName = null): ClassBuilderInterface
    {
        // Check if class already exists
        if ($this->hasDefinition($className)) {
            throw new ClassDefinitionAlreadyExistsException();
        }

        // Create new definition
        $classDefinition = new ClassDefinition($this);
        $classDefinition->setClassName(new ClassReference($className));
        if ($serviceName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $classDefinition->setServiceName($serviceName);
        }

        // Register definition
        $this->definitionCollection[$className] = $classDefinition;

        return $classDefinition;
    }

    /**
     * When definition for class name is exists in collection
     *
     * @param $className
     * @return bool
     */
    public function hasDefinition($className): bool
    {
        return array_key_exists($className, $this->definitionCollection);
    }

    /**
     * @return ClassDefinition[]
     */
    public function getDefinitionCollection(): array
    {
        return $this->definitionCollection;
    }

    /**
     * @return ReferenceInterface[]
     */
    public function getParameterCollection(): array
    {
        return $this->parameterBuilder->getParameterCollection();
    }

    /**
     * @return array
     */
    public function getImplementors(): array
    {
        return $this->implementors;
    }
}


1		<?php declare(strict_types = 1);
2		/**
3		* Created by PhpStorm.
4		* User: root
5		* Date: 02.08.16
6		* Time: 0:46.
7		*/
8		namespace samsonframework\container\definition\builder;
9
10		use samsonframework\container\definition\AbstractDefinition;
11		use samsonframework\container\definition\ClassBuilderInterface;
12		use samsonframework\container\definition\ClassDefinition;
13		use samsonframework\container\definition\exception\ClassDefinitionAlreadyExistsException;
14		use samsonframework\container\definition\parameter\exception\ParameterAlreadyExistsException;
15		use samsonframework\container\definition\parameter\ParameterBuilder;
16		use samsonframework\container\definition\parameter\ParameterBuilderInterface;
17		use samsonframework\container\definition\reference\ClassReference;
18		use samsonframework\container\definition\reference\ReferenceDependencyInterface;
19		use samsonframework\container\definition\reference\ReferenceInterface;
20
21		/**
22		* Class DefinitionBuilder
23		*
24		* @author Ruslan Molodyko <[email protected]>
25		*/
26		class DefinitionBuilder extends AbstractDefinition
27		{
28		/** @var ClassDefinition[] Definition collection */
29		protected $definitionCollection = [];
30		/** @var ParameterBuilder */
31		protected $parameterBuilder;
32		/** @var array Collection of interface => [classes]*/
33		protected $implementors = [];
34
35		/**
36		* DefinitionBuilder constructor.
37		*
38		* @param ParameterBuilder $parameterBuilder
39		* @param AbstractDefinition\|null $parentDefinition
40		*/
41	18	public function __construct(ParameterBuilder $parameterBuilder, AbstractDefinition $parentDefinition = null)
42		{
43	18	parent::__construct($parentDefinition);
44
45	18	$this->parameterBuilder = $parameterBuilder;
46	18	$this->parameterBuilder->setParentDefinition($this);
47	18	}
48
49		/**
50		* Define parameters
51		*
52		* @param string $name
53		* @param ReferenceInterface $reference
54		* @return ParameterBuilderInterface
55		* @throws ParameterAlreadyExistsException
56		*/
57	3	public function defineParameter(string $name, ReferenceInterface $reference): ParameterBuilderInterface
58		{
59	3	return $this->parameterBuilder->defineParameter($name, $reference);
60		}
61
62		/**
63		* Define interface implementors
64		*
65		* @param string $interfaceName
66		* @param ReferenceInterface $class
67		* @return DefinitionBuilder
68		*/
69		public function defineImplementors(string $interfaceName, ReferenceInterface $class): DefinitionBuilder
70		{
71		$this->implementors[$interfaceName] = $class;
72
73		return $this;
74		}
75
76		/**
77		* Add new class definition
78		*
79		* @param $className
80		* @param string $serviceName
81		* @return ClassBuilderInterface
82		* @throws \InvalidArgumentException
83		* @throws ClassDefinitionAlreadyExistsException
84		*/
85	16	public function addDefinition($className, string $serviceName = null): ClassBuilderInterface
86		{
87		// Check if class already exists
88	16	if ($this->hasDefinition($className)) {
89	1	throw new ClassDefinitionAlreadyExistsException();
90		}
91
92		// Create new definition
93	16	$classDefinition = new ClassDefinition($this);
94	16	$classDefinition->setClassName(new ClassReference($className));
95	16	if ($serviceName) {
		0 ignored issues – show Bug Best Practice introduced 2016-09-07 12:05 UTC by Report Bug Copy Issue Report The expression `$serviceName` of type `null\|string` is loosely compared to `true`; this is ambiguous if the string can be empty. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
96	2	$classDefinition->setServiceName($serviceName);
97		}
98
99		// Register definition
100	16	$this->definitionCollection[$className] = $classDefinition;
101
102	16	return $classDefinition;
103		}
104
105		/**
106		* When definition for class name is exists in collection
107		*
108		* @param $className
109		* @return bool
110		*/
111	16	public function hasDefinition($className): bool
112		{
113	16	return array_key_exists($className, $this->definitionCollection);
114		}
115
116		/**
117		* @return ClassDefinition[]
118		*/
119	10	public function getDefinitionCollection(): array
120		{
121	10	return $this->definitionCollection;
122		}
123
124		/**
125		* @return ReferenceInterface[]
126		*/
127	4	public function getParameterCollection(): array
128		{
129	4	return $this->parameterBuilder->getParameterCollection();
130		}
131
132		/**
133		* @return array
134		*/
135		public function getImplementors(): array
136		{
137		return $this->implementors;
138		}
139		}
140

samsonframework / container

Push — master ( d3edd8...61bf89 )

DefinitionBuilder::defineImplementors() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like