Object::getProperties() - Code Metrics - Inspection of "Merge branch 'release/v1.0.0'" - slickframework/di - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 95a6e8...b8af6d )

by Filipe

created 2016-12-12 01:47 UTC

Object::getProperties() A

↳ Parent: Object

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

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

<?php

/**
 * This file is part of slick/di package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Di\Definition;

use Slick\Common\Inspector;
use Slick\Di\Definition\Resolver\Object as Resolver;
use Slick\Di\Definition\Resolver\ObjectResolver;
use Slick\Di\Exception\InvalidArgumentException;

/**
 * Object definition class
 *
 * @package Slick\Di\Definition
 * @author  Filipe Silva <[email protected]>
 *
 * @property string $name          Definition name or key
 * @property string $className
 * @property object $instance
 * @property array  $constructArgs
 * @property array  $properties
 * @property array  $methods
 */
class Object extends AbstractDefinition implements ObjectDefinitionInterface
{
    /**
     * @readwrite
     * @var string
     */
    protected $className;

    /**
     * @readwrite
     * @var object
     */
    protected $instance;

    /**
     * @readwrite
     * @var array
     */
    protected $constructArgs = [];

    /**
     * @readwrite
     * @var array
     */
    protected $properties = [];

    /**
     * @readwrite
     * @var array
     */
    protected $methods = [];

    /**
     * @var Inspector
     */
    protected $classMetaData;

    /**
     * @readwrite
     * @var ObjectResolver
     */
    protected $resolver;

    /**
     * Gets class meta data (Inspector)
     *
     * @return Inspector
     */
    protected function getClassMetaData()
    {
        if (is_null($this->classMetaData)) {
            $this->classMetaData = Inspector::forClass($this->getClassName());
        }
        return $this->classMetaData;
    }

    /**
     * Gets definition class name
     *
     * If class name is not set and there is an instance set the class name
     * will be retrieved from instance object.
     *
     * @return string
     */
    public function getClassName()
    {
        if (is_null($this->className) && is_object($this->instance)) {
            $this->className = get_class($this->instance);
        }
        return $this->className;
    }

    /**
     * Gets the instance object for current definition
     *
     * If instance is not defined yet and the class name is set and
     * is an existing class, a new instance will be created and the
     * constructor arguments will be used.
     *
     * @return object
     */
    public function getInstance()
    {
        if (is_null($this->instance) && class_exists($this->className)) {
            $reflection = $this->getClassMetaData()->getReflection();
            $this->instance = (!empty($this->constructArgs))
                ? $reflection->newInstanceArgs(
                    $this->getResolver()->checkValues($this->constructArgs)
                )
                : new $this->className();
        }
        return $this->instance;
    }

    /**
     * Sets constructor arguments used on instance instantiation
     *
     * @param array $arguments
     * @return $this|self
     */
    public function setConstructArgs(array $arguments)
    {
        $this->constructArgs = $arguments;
        return $this;
    }

    /**
     * Set a method to be called when resolving this definition
     *
     * @param string $name      Method name
     * @param array  $arguments Method parameters
     *
     * @return $this|self
     */
    public function setMethod($name, array $arguments = [])
    {
        if (!$this->getClassMetaData()->hasMethod($name)) {
            throw new InvalidArgumentException(
                "The method {$name} does not exists in class ".
                "{$this->getClassName()}"
            );
        }

        $this->methods[] = compact('name', 'arguments');
        return $this;
    }

    /**
     * Sets property value when resolving this definition
     *
     * @param string $name  The property name
     * @param mixed  $value The property value
     *
     * @return $this|self
     */
    public function setProperty($name, $value)
    {
        if (!$this->getClassMetaData()->hasProperty($name)) {
            throw new InvalidArgumentException(
                "The property {$name} does not exists in class ".
                "{$this->getClassName()}"
            );
        }

        $this->properties[$name] = $value;
        return $this;
    }

    /**
     * Resolves current definition and returns its value
     *
     * @return mixed
     */
    public function resolve()
    {
        return $this->getResolver()->resolve();
    }

    /**
     * Gets property values
     *
     * @return array
     */
    public function getProperties()
    {
        return $this->properties;
    }

    /**
     * Returns the list of methods to call
     *
     * @return mixed
     */
    public function getMethods()
    {
        return $this->methods;
    }

    /**
     * Returns resolver for this definition
     *
     * @return Resolver|ObjectResolver
     */
    protected function getResolver()
    {
        if (is_null($this->resolver)) {
            $this->resolver = new Resolver(
                [
                    'definition' => $this
                ]
            );
        }
        return $this->resolver;
    }
}

1		<?php
2
3		/**
4		* This file is part of slick/di package
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*/
9
10		namespace Slick\Di\Definition;
11
12		use Slick\Common\Inspector;
13		use Slick\Di\Definition\Resolver\Object as Resolver;
14		use Slick\Di\Definition\Resolver\ObjectResolver;
15		use Slick\Di\Exception\InvalidArgumentException;
16
17		/**
18		* Object definition class
19		*
20		* @package Slick\Di\Definition
21		* @author Filipe Silva <[email protected]>
22		*
23		* @property string $name Definition name or key
24		* @property string $className
25		* @property object $instance
26		* @property array $constructArgs
27		* @property array $properties
28		* @property array $methods
29		*/
30		class Object extends AbstractDefinition implements ObjectDefinitionInterface
31		{
32		/**
33		* @readwrite
34		* @var string
35		*/
36		protected $className;
37
38		/**
39		* @readwrite
40		* @var object
41		*/
42		protected $instance;
43
44		/**
45		* @readwrite
46		* @var array
47		*/
48		protected $constructArgs = [];
49
50		/**
51		* @readwrite
52		* @var array
53		*/
54		protected $properties = [];
55
56		/**
57		* @readwrite
58		* @var array
59		*/
60		protected $methods = [];
61
62		/**
63		* @var Inspector
64		*/
65		protected $classMetaData;
66
67		/**
68		* @readwrite
69		* @var ObjectResolver
70		*/
71		protected $resolver;
72
73		/**
74		* Gets class meta data (Inspector)
75		*
76		* @return Inspector
77		*/
78	56	protected function getClassMetaData()
79		{
80	56	if (is_null($this->classMetaData)) {
81	56	$this->classMetaData = Inspector::forClass($this->getClassName());
82	56	}
83	56	return $this->classMetaData;
84		}
85
86		/**
87		* Gets definition class name
88		*
89		* If class name is not set and there is an instance set the class name
90		* will be retrieved from instance object.
91		*
92		* @return string
93		*/
94	72	public function getClassName()
95		{
96	72	if (is_null($this->className) && is_object($this->instance)) {
97	48	$this->className = get_class($this->instance);
98	48	}
99	72	return $this->className;
100		}
101
102		/**
103		* Gets the instance object for current definition
104		*
105		* If instance is not defined yet and the class name is set and
106		* is an existing class, a new instance will be created and the
107		* constructor arguments will be used.
108		*
109		* @return object
110		*/
111	58	public function getInstance()
112		{
113	58	if (is_null($this->instance) && class_exists($this->className)) {
114	22	$reflection = $this->getClassMetaData()->getReflection();
115	22	$this->instance = (!empty($this->constructArgs))
116	22	? $reflection->newInstanceArgs(
117	10	$this->getResolver()->checkValues($this->constructArgs)
118	10	)
119	22	: new $this->className();
120	22	}
121	58	return $this->instance;
122		}
123
124		/**
125		* Sets constructor arguments used on instance instantiation
126		*
127		* @param array $arguments
128		* @return $this\|self
129		*/
130	26	public function setConstructArgs(array $arguments)
131		{
132	26	$this->constructArgs = $arguments;
133	26	return $this;
134		}
135
136		/**
137		* Set a method to be called when resolving this definition
138		*
139		* @param string $name Method name
140		* @param array $arguments Method parameters
141		*
142		* @return $this\|self
143		*/
144	34	public function setMethod($name, array $arguments = [])
145		{
146	34	if (!$this->getClassMetaData()->hasMethod($name)) {
147	2	throw new InvalidArgumentException(
148	2	"The method {$name} does not exists in class ".
149	2	"{$this->getClassName()}"
150	2	);
151		}
152
153	32	$this->methods[] = compact('name', 'arguments');
154	32	return $this;
155		}
156
157		/**
158		* Sets property value when resolving this definition
159		*
160		* @param string $name The property name
161		* @param mixed $value The property value
162		*
163		* @return $this\|self
164		*/
165	30	public function setProperty($name, $value)
166		{
167	30	if (!$this->getClassMetaData()->hasProperty($name)) {
168	2	throw new InvalidArgumentException(
169	2	"The property {$name} does not exists in class ".
170	2	"{$this->getClassName()}"
171	2	);
172		}
173
174	28	$this->properties[$name] = $value;
175	28	return $this;
176		}
177
178		/**
179		* Resolves current definition and returns its value
180		*
181		* @return mixed
182		*/
183	58	public function resolve()
184		{
185	58	return $this->getResolver()->resolve();
186		}
187
188		/**
189		* Gets property values
190		*
191		* @return array
192		*/
193	58	public function getProperties()
194		{
195	58	return $this->properties;
196		}
197
198		/**
199		* Returns the list of methods to call
200		*
201		* @return mixed
202		*/
203	58	public function getMethods()
204		{
205	58	return $this->methods;
206		}
207
208		/**
209		* Returns resolver for this definition
210		*
211		* @return Resolver\|ObjectResolver
212		*/
213	58	protected function getResolver()
214		{
215	58	if (is_null($this->resolver)) {
216	58	$this->resolver = new Resolver(
217		[
218		'definition' => $this
219	58	]
220	58	);
221	58	}
222	58	return $this->resolver;
223		}
224		}

slickframework / di

Push — master ( 95a6e8...b8af6d )

Object::getProperties() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like