ClassDefinition::getClassName() - Code Metrics - Inspection of "removed useless docs" - fwk/Di - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0 ( e401e5...72b328 )

by Julien

created 2016-05-31 21:03 UTC

ClassDefinition::getClassName() A

↳ Parent: ClassDefinition

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
nc	1
cc	1
eloc	2
nop	0
crap	1

<?php
/**
 * Fwk
 *
 * Copyright (c) 2011-2012, Julien Ballestracci <[email protected]>.
 * All rights reserved.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * PHP Version 5.3
 *
 * @category  DependencyInjection
 * @package   Fwk\Di
 * @author    Julien Ballestracci <[email protected]>
 * @copyright 2011-2014 Julien Ballestracci <[email protected]>
 * @license   http://www.opensource.org/licenses/bsd-license.php  BSD License
 * @link      http://www.nitronet.org/fwk
 */
namespace Fwk\Di;

use Fwk\Di\Exceptions\InvalidClassDefinition;

/**
 * ClassDefinition
 * 
 * Represents a Definition returning an instance of some class.
 *
 * @category Definition
 * @package  Fwk\Di
 * @author   Julien Ballestracci <[email protected]>
 * @license  http://www.opensource.org/licenses/bsd-license.php  BSD License
 * @link     http://www.nitronet.org/fwk
 */
class ClassDefinition extends AbstractDefinition implements Invokable
{
    /**
     * Name of the class to be instanciated
     * @var string
     */
    protected $className;
    
    /**
     * List of class' methods to be called after instanciation
     * @var array<string>
     */
    protected $methodCalls  = array();
    
    /**
     * Constructor
     * 
     * @param string       $className Name of the class to be instanciated
     * @param array<mixed> $arguments List of (constructor) arguments
     * 
     * @return void

     */
    public function __construct($className, array $arguments = array())
    {
        $this->className    = $className;
        $this->arguments    = $arguments;
    }
    
    /**
     * Instanciates $this->className and return the instance.
     * 
     * @param Container   $container The Di Container
     * @param null|string $name      Name of the current definition (if any)
     * 
     * @return object
     * @throws Exceptions\InvalidClassDefinition
     */
    public function invoke(Container $container, $name = null)
    {
        if ($this->className instanceof Invokable) {
            try {
                $this->className = $this->className->invoke($container, $name);
            } catch(Exception $exp) {
                throw new InvalidClassDefinition($this->className, $name, $exp);
            }
        } 
        
        if (!is_string($this->className)) {
            throw new InvalidClassDefinition(
                '???', 
                new \InvalidArgumentException(
                    sprintf(
                        'Classname must be a string or a Fwk\Di\Reference ' .
                        'instance (' . (is_object($this->className) 
                            ? get_class($this->className) 
                            : get_type($this->className)
                        ) . ' given)'
                    )
                )
            );
        }
        
        $instance = $this->newInstance($container, $name);
        $this->executeMethodCalls($instance, $container, $name);
        
        return $instance;
    }
    
    /**
     * Executes registered methods (in the order they were added)
     * 
     * @param object      $instance   The class instance
     * @param Container   $container  The Di Container
     * @param null|string $definition Name of the current definition
     * 
     * @return void
     * @throws Exceptions\InvalidClassDefinition
     */
    protected function executeMethodCalls($instance, Container $container, 
        $definition = null
    ) {
        foreach ($this->methodCalls as $methodCall) {
            $callable = $methodCall->getCallable();
            if (is_string($callable)) {
                $callable = $container->propertizeString($callable);
            }
            
            if (!is_callable($callable)) {
                $callable = array($instance, $callable);
            }
            $methodCall->setCallable($callable);
            $methodCall->invoke($container, $definition);
            $methodCall->setCallable($callable);
        }
    }
    
    /**
     * Instanciates the class ($this->className) 
     * 
     * @param Container   $container  The Di Container
     * @param null|string $definition Name of the current definition (if any)
     * 
     * @return object
     * @throws Exceptions\ClassNotFound
     * @throws Exceptions\InvalidClassDefinition
     */
    protected function newInstance(Container $container, $definition = null)
    {
        if (is_string($this->className) && strpos($this->className, ':') >= 0) {
            $this->className = $container->propertizeString($this->className);
        }
        
        if (!class_exists($this->className, true)) {
            throw new Exceptions\ClassNotFound($this->className);
        }
        
        $reflect    = new \ReflectionClass($this->className);
        if (null !== $reflect->getConstructor()) {
            $args = array();
            try {
                $args = $this->getConstructorArguments($container, $definition);
            } catch(Exception $exp) {
                throw new InvalidClassDefinition(
                    $this->className, 
                    $definition, 
                    $exp
                );
            }
            
            $return = $reflect->newInstanceArgs($args);
        } else {
            $return = new $this->className();
        }
        
        return $return;
    }
    
    /**
     * Returns the Class name
     * 
     * @return string
     */
    public function getClassName()
    {
        return $this->className;
    }
    
    /**
     * Defines the Class name
     * 
     * @param string $className The class name
     * 
     * @return void
     */
    public function setClassName($className)
    {
        $this->className = $className;
    }

    /**
     * Adds a method to be called right after the class was instanciated
     * 
     * @param string       $methodName The name of the method to be called
     * @param array<mixed> $arguments  List of arguments (optional)
     * 
     * @return ClassDefinition 
     */
    public function addMethodCall($methodName, array $arguments = array())
    {
        $this->methodCalls[] = new CallableDefinition(
            $methodName, 
            $arguments
        );

        return $this;
    }
    
    /**
     * Removes a call to a specified method
     * 
     * @param string $methodName The method name
     * 
     * @return ClassDefinition 
     */
    public function removeMethodClass($methodName)
    {
        $this->methodCalls = array_filter(
            $this->methodCalls, 
            function ($call) use ($methodName) {
                return $methodName !== $call->getCallable();
            }
        );
        
        return $this;
    }
}

1		<?php
2		/**
3		* Fwk
4		*
5		* Copyright (c) 2011-2012, Julien Ballestracci <[email protected]>.
6		* All rights reserved.
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*
11		* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
12		* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
13		* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
14		* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
15		* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
16		* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
17		* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
18		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
19		* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
20		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
21		* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
22		* POSSIBILITY OF SUCH DAMAGE.
23		*
24		* PHP Version 5.3
25		*
26		* @category DependencyInjection
27		* @package Fwk\Di
28		* @author Julien Ballestracci <[email protected]>
29		* @copyright 2011-2014 Julien Ballestracci <[email protected]>
30		* @license http://www.opensource.org/licenses/bsd-license.php BSD License
31		* @link http://www.nitronet.org/fwk
32		*/
33		namespace Fwk\Di;
34
35		use Fwk\Di\Exceptions\InvalidClassDefinition;
36
37		/**
38		* ClassDefinition
39		*
40		* Represents a Definition returning an instance of some class.
41		*
42		* @category Definition
43		* @package Fwk\Di
44		* @author Julien Ballestracci <[email protected]>
45		* @license http://www.opensource.org/licenses/bsd-license.php BSD License
46		* @link http://www.nitronet.org/fwk
47		*/
48		class ClassDefinition extends AbstractDefinition implements Invokable
49		{
50		/**
51		* Name of the class to be instanciated
52		* @var string
53		*/
54		protected $className;
55
56		/**
57		* List of class' methods to be called after instanciation
58		* @var array<string>
59		*/
60		protected $methodCalls = array();
61
62		/**
63		* Constructor
64		*
65		* @param string $className Name of the class to be instanciated
66		* @param array<mixed> $arguments List of (constructor) arguments
67		*
68		* @return void
		0 ignored issues – show Comprehensibility Best Practice introduced 2016-05-31 19:45 UTC by Report Bug Copy Issue Report Adding a `@return` annotation to constructors is generally not recommended as a constructor does not have a meaningful return value. Adding a `@return` annotation to a constructor is not recommended, since a constructor does not have a meaningful return value. Please refer to the PHP core documentation on constructors. Loading history...
69		*/
70	20	public function __construct($className, array $arguments = array())
71		{
72	20	$this->className = $className;
73	20	$this->arguments = $arguments;
74	20	}
75
76		/**
77		* Instanciates $this->className and return the instance.
78		*
79		* @param Container $container The Di Container
80		* @param null\|string $name Name of the current definition (if any)
81		*
82		* @return object
83		* @throws Exceptions\InvalidClassDefinition
84		*/
85	16	public function invoke(Container $container, $name = null)
86		{
87	16	if ($this->className instanceof Invokable) {
88		try {
89	2	$this->className = $this->className->invoke($container, $name);
90	2	} catch(Exception $exp) {
91	1	throw new InvalidClassDefinition($this->className, $name, $exp);
92		}
93	1	}
94
95	15	if (!is_string($this->className)) {
96	1	throw new InvalidClassDefinition(
97	1	'???',
98	1	new \InvalidArgumentException(
99	1	sprintf(
100		'Classname must be a string or a Fwk\Di\Reference ' .
101	1	'instance (' . (is_object($this->className)
102	1	? get_class($this->className)
103	1	: get_type($this->className)
104	1	) . ' given)'
105	1	)
106	1	)
107	1	);
108		}
109
110	14	$instance = $this->newInstance($container, $name);
111	12	$this->executeMethodCalls($instance, $container, $name);
112
113	11	return $instance;
114		}
115
116		/**
117		* Executes registered methods (in the order they were added)
118		*
119		* @param object $instance The class instance
120		* @param Container $container The Di Container
121		* @param null\|string $definition Name of the current definition
122		*
123		* @return void
124		* @throws Exceptions\InvalidClassDefinition
125		*/
126	12	protected function executeMethodCalls($instance, Container $container,
127		$definition = null
128		) {
129	12	foreach ($this->methodCalls as $methodCall) {
130	4	$callable = $methodCall->getCallable();
131	4	if (is_string($callable)) {
132	4	$callable = $container->propertizeString($callable);
133	4	}
134
135	4	if (!is_callable($callable)) {
136	4	$callable = array($instance, $callable);
137	4	}
138	4	$methodCall->setCallable($callable);
139	4	$methodCall->invoke($container, $definition);
140	3	$methodCall->setCallable($callable);
141	11	}
142	11	}
143
144		/**
145		* Instanciates the class ($this->className)
146		*
147		* @param Container $container The Di Container
148		* @param null\|string $definition Name of the current definition (if any)
149		*
150		* @return object
151		* @throws Exceptions\ClassNotFound
152		* @throws Exceptions\InvalidClassDefinition
153		*/
154	14	protected function newInstance(Container $container, $definition = null)
155		{
156	14	if (is_string($this->className) && strpos($this->className, ':') >= 0) {
157	14	$this->className = $container->propertizeString($this->className);
158	14	}
159
160	14	if (!class_exists($this->className, true)) {
161	1	throw new Exceptions\ClassNotFound($this->className);
162		}
163
164	13	$reflect = new \ReflectionClass($this->className);
165	13	if (null !== $reflect->getConstructor()) {
166	8	$args = array();
167		try {
168	8	$args = $this->getConstructorArguments($container, $definition);
169	8	} catch(Exception $exp) {
170	1	throw new InvalidClassDefinition(
171	1	$this->className,
172	1	$definition,
173		$exp
174	1	);
175		}
176
177	7	$return = $reflect->newInstanceArgs($args);
178	7	} else {
179	5	$return = new $this->className();
180		}
181
182	12	return $return;
183		}
184
185		/**
186		* Returns the Class name
187		*
188		* @return string
189		*/
190	2	public function getClassName()
191		{
192	2	return $this->className;
193		}
194
195		/**
196		* Defines the Class name
197		*
198		* @param string $className The class name
199		*
200		* @return void
201		*/
202	2	public function setClassName($className)
203		{
204	2	$this->className = $className;
205	2	}
206
207		/**
208		* Adds a method to be called right after the class was instanciated
209		*
210		* @param string $methodName The name of the method to be called
211		* @param array<mixed> $arguments List of arguments (optional)
212		*
213		* @return ClassDefinition
214		*/
215	7	public function addMethodCall($methodName, array $arguments = array())
216		{
217	7	$this->methodCalls[] = new CallableDefinition(
218	7	$methodName,
219		$arguments
220	7	);
221
222	7	return $this;
223		}
224
225		/**
226		* Removes a call to a specified method
227		*
228		* @param string $methodName The method name
229		*
230		* @return ClassDefinition
231		*/
232	1	public function removeMethodClass($methodName)
233		{
234	1	$this->methodCalls = array_filter(
235	1	$this->methodCalls,
236	1	function ($call) use ($methodName) {
237	1	return $methodName !== $call->getCallable();
238		}
239	1	);
240
241	1	return $this;
242		}
243		}

fwk / Di

Push — 1.0 ( e401e5...72b328 )

ClassDefinition::getClassName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like