AbstractDaftObject::__debugInfo() - Code Metrics - Inspection of "php-cs-fixer" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ec2097...604fdd )

by SignpostMarv

created 2017-10-08 14:10 UTC

AbstractDaftObject::__debugInfo() A

↳ Parent: AbstractDaftObject

Complexity

Conditions	4
Paths	3

Size

Total Lines	15
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	15
ccs	9
cts	9
cp	1
rs	9.2
c	0
b	0
f	0
cc	4
eloc	9
nc	3
nop	0
crap	4

<?php
/**
* Base daft objects.
*
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject;

use ReflectionClass;
use ReflectionMethod;

/**
* Base daft object.
*/
abstract class AbstractDaftObject implements DaftObject
{
    /**
    * List of properties that can be defined on an implementation.
    *
    * @var string[]
    */
    const PROPERTIES = [];

    /**
    * List of nullable properties that can be defined on an implementation.
    *
    * @var string[]
    */
    const NULLABLE_PROPERTIES = [];

    /**
    * List of exportable properties that can be defined on an implementation.
    *
    * @var string[]
    */
    const EXPORTABLE_PROPERTIES = [];

    /**
    * import/export definition for DaftJson.
    */
    const JSON_PROPERTIES = [];

    /**
    * @var string[][]
    */
    private static $publicGetters = [];

    /**
    * @var string[][]
    */
    private static $publicSetters = [];

    /**
    * Does some sanity checking.
    *
    * @see DefinesOwnIdPropertiesInterface
    * @see self::CheckTypeDefinesOwnIdProperties()
    */
    public function __construct()
    {
        if (
            ($this instanceof DefinesOwnIdPropertiesInterface)
        ) {
            self::CheckTypeDefinesOwnIdProperties($this);
        }
    }

    /**
    * {@inheritdoc}
    */
    public function __get(string $property)
    {
        return $this->DoGetSet(
            $property,
            false,
            NotPublicGetterPropertyException::class
        );
    }

    /**
    * {@inheritdoc}
    */
    public function __set(string $property, $v)
    {
        return $this->DoGetSet(
            $property,
            true,
            NotPublicSetterPropertyException::class,
            $v
        );
    }

    /**
    * {@inheritdoc}
    *
    * @see static::NudgePropertyValue()
    */
    public function __unset(string $property) : void
    {
        $this->NudgePropertyValue($property, null);
    }

    /**
    * {@inheritdoc}
    */
    public function __debugInfo() : array
    {
        $out = [];
        $publicGetters = static::DaftObjectPublicGetters();
        foreach (static::DaftObjectExportableProperties() as $prop) {
            $expectedMethod = 'Get' . ucfirst($prop);
            if (
                $this->__isset($prop) &&
                in_array($prop, $publicGetters, true)
            ) {
                $out[$prop] = $this->$expectedMethod();
            }
        }

        return $out;
    }

    /**
    * List of properties that can be defined on an implementation.
    *
    * @return string[]
    */
    final public static function DaftObjectProperties() : array
    {
        return static::PROPERTIES;
    }

    /**
    * {@inheritdoc}
    */
    final public static function DaftObjectNullableProperties() : array
    {
        return static::NULLABLE_PROPERTIES;
    }

    /**
    * {@inheritdoc}
    */
    final public static function DaftObjectExportableProperties() : array
    {
        return static::EXPORTABLE_PROPERTIES;
    }

    /**
    * {@inheritdoc}
    */
    final public static function DaftObjectPublicGetters() : array
    {
        static::CachePublicGettersAndSetters();

        return self::$publicGetters[static::class];
    }

    /**
    * {@inheritdoc}
    */
    final public static function DaftObjectPublicSetters() : array
    {
        static::CachePublicGettersAndSetters();

        return self::$publicSetters[static::class];
    }

    /**
    * {@inheritdoc}
    */
    final public static function DaftObjectJsonProperties() : array

    {
        if (false === is_a(static::class, DaftJson::class, true)) {
            throw new DaftObjectNotDaftJsonBadMethodCallException(
                static::class
            );
        }

        return static::JSON_PROPERTIES;
    }

    protected static function CachePublicGettersAndSetters() : void
    {
        $refreshGetters = false === isset(self::$publicGetters[static::class]);
        $refreshSetters = false === isset(self::$publicSetters[static::class]);

        if ($refreshGetters) {
            self::$publicGetters[static::class] = [];

            if (
                is_a(
                    static::class,
                    DefinesOwnIdPropertiesInterface::class,
                    true
                )
            ) {
                self::$publicGetters[static::class][] = 'id';
            }
        }

        if ($refreshSetters) {
            self::$publicSetters[static::class] = [];
        }

        if ($refreshGetters || $refreshSetters) {
            $classReflection = new ReflectionClass(static::class);

            foreach (static::DaftObjectProperties() as $property) {
                $getter = 'Get' . ucfirst($property);

                $setter = 'Set' . ucfirst($property);

                if (

                    $refreshGetters &&
                    $classReflection->hasMethod($getter) &&
                    (
                        $methodReflection = new ReflectionMethod(
                            static::class,
                            $getter
                        )
                    )->isPublic() &&
                    false === $methodReflection->isStatic()
                ) {
                    self::$publicGetters[static::class][] = $property;
                }

                if (

                    $refreshSetters &&
                    $classReflection->hasMethod($setter) &&
                    (
                        $methodReflection = new ReflectionMethod(
                            static::class,
                            $setter
                        )
                    )->isPublic() &&
                    false === $methodReflection->isStatic()
                ) {
                    self::$publicSetters[static::class][] = $property;
                }
            }
        }
    }

    /**
    * Nudge the state of a given property, marking it as dirty.
    *
    * @param string $property property being nudged
    * @param mixed $value value to nudge property with
    *
    * @throws UndefinedPropertyException if $property is not in static::DaftObjectProperties()
    * @throws PropertyNotNullableException if $property is not in static::DaftObjectNullableProperties()
    * @throws PropertyNotRewriteableException if class is write-once read-many and $property was already changed
    */
    abstract protected function NudgePropertyValue(
        string $property,
        $value
    ) : void;

    /**
    * Checks if a type correctly defines it's own id.
    *
    * @param DaftObject $object
    *
    * @throws ClassDoesNotImplementClassException if $object is not an implementation of DefinesOwnIdPropertiesInterface
    * @throws ClassMethodReturnHasZeroArrayCountException if $object::DaftObjectIdProperties() does not contain at least one property
    * @throws ClassMethodReturnIsNotArrayOfStringsException if $object::DaftObjectIdProperties() is not string[]
    * @throws UndefinedPropertyException if an id property is not in $object::DaftObjectIdProperties()
    */
    final protected static function CheckTypeDefinesOwnIdProperties(
        DaftObject $object
    ) : void {
        $class = get_class($object);
        if (false === ($object instanceof DefinesOwnIdPropertiesInterface)) {
            throw new ClassDoesNotImplementClassException(
                $class,
                DefinesOwnIdPropertiesInterface::class
            );
        }

        /**
        * @var DefinesOwnIdPropertiesInterface $object
        */
        $object = $object;

        $properties = $object::DaftObjectIdProperties();

        if (count($properties) < 1) {
            throw new ClassMethodReturnHasZeroArrayCountException(
                $class,
                'DaftObjectIdProperties'
            );
        }

        foreach ($properties as $property) {
            if (false === is_string($property)) {
                throw new ClassMethodReturnIsNotArrayOfStringsException(
                    $class,
                    'DaftObjectIdProperties'
                );
            }
        }
    }

    /**
    * @param mixed $v
    *
    * @return mixed
    */
    protected function DoGetSet(
        string $property,
        bool $SetNotGet,
        string $notPublic,
        $v = null
    ) {
        if (
            (
                'id' !== $property ||
                false === ($this instanceof DefinesOwnIdPropertiesInterface)
            ) &&
            false === in_array($property, static::DaftObjectProperties(), true)
        ) {
            throw new UndefinedPropertyException(static::class, $property);
        } elseif (
            false === (
                in_array(
                    $property,
                    (
                        $SetNotGet
                            ? static::DaftObjectPublicSetters()
                            : static::DaftObjectPublicGetters()
                    ),
                    true
                )
            )
        ) {
            throw new $notPublic(
                static::class,
                $property
            );
        }

        $expectedMethod = ($SetNotGet ? 'Set' : 'Get') . ucfirst($property);

        return $this->$expectedMethod($v);
    }
}


1			<?php
2			/**
3			* Base daft objects.
4			*
5			* @author SignpostMarv
6			*/
7			declare(strict_types=1);
8
9			namespace SignpostMarv\DaftObject;
10
11			use ReflectionClass;
12			use ReflectionMethod;
13
14			/**
15			* Base daft object.
16			*/
17			abstract class AbstractDaftObject implements DaftObject
18			{
19			/**
20			* List of properties that can be defined on an implementation.
21			*
22			* @var string[]
23			*/
24			const PROPERTIES = [];
25
26			/**
27			* List of nullable properties that can be defined on an implementation.
28			*
29			* @var string[]
30			*/
31			const NULLABLE_PROPERTIES = [];
32
33			/**
34			* List of exportable properties that can be defined on an implementation.
35			*
36			* @var string[]
37			*/
38			const EXPORTABLE_PROPERTIES = [];
39
40			/**
41			* import/export definition for DaftJson.
42			*/
43			const JSON_PROPERTIES = [];
44
45			/**
46			* @var string[][]
47			*/
48			private static $publicGetters = [];
49
50			/**
51			* @var string[][]
52			*/
53			private static $publicSetters = [];
54
55			/**
56			* Does some sanity checking.
57			*
58			* @see DefinesOwnIdPropertiesInterface
59			* @see self::CheckTypeDefinesOwnIdProperties()
60			*/
61	187		public function __construct()
62			{
63			if (
64	187		($this instanceof DefinesOwnIdPropertiesInterface)
65			) {
66	116		self::CheckTypeDefinesOwnIdProperties($this);
67			}
68	185		}
69
70			/**
71			* {@inheritdoc}
72			*/
73	40		public function __get(string $property)
74			{
75	40		return $this->DoGetSet(
76	40		$property,
77	40		false,
78	40		NotPublicGetterPropertyException::class
79			);
80			}
81
82			/**
83			* {@inheritdoc}
84			*/
85	79		public function __set(string $property, $v)
86			{
87	79		return $this->DoGetSet(
88	79		$property,
89	79		true,
90	79		NotPublicSetterPropertyException::class,
91	79		$v
92			);
93			}
94
95			/**
96			* {@inheritdoc}
97			*
98			* @see static::NudgePropertyValue()
99			*/
100	20		public function __unset(string $property) : void
101			{
102	20		$this->NudgePropertyValue($property, null);
103	18		}
104
105			/**
106			* {@inheritdoc}
107			*/
108	31		public function __debugInfo() : array
109			{
110	31		$out = [];
111	31		$publicGetters = static::DaftObjectPublicGetters();
112	31		foreach (static::DaftObjectExportableProperties() as $prop) {
113	30		$expectedMethod = 'Get' . ucfirst($prop);
114			if (
115	30		$this->__isset($prop) &&
116	30		in_array($prop, $publicGetters, true)
117			) {
118	24		$out[$prop] = $this->$expectedMethod();
119			}
120			}
121
122	31		return $out;
123			}
124
125			/**
126			* List of properties that can be defined on an implementation.
127			*
128			* @return string[]
129			*/
130	221		final public static function DaftObjectProperties() : array
131			{
132	221		return static::PROPERTIES;
133			}
134
135			/**
136			* {@inheritdoc}
137			*/
138	65		final public static function DaftObjectNullableProperties() : array
139			{
140	65		return static::NULLABLE_PROPERTIES;
141			}
142
143			/**
144			* {@inheritdoc}
145			*/
146	65		final public static function DaftObjectExportableProperties() : array
147			{
148	65		return static::EXPORTABLE_PROPERTIES;
149			}
150
151			/**
152			* {@inheritdoc}
153			*/
154	52		final public static function DaftObjectPublicGetters() : array
155			{
156	52		static::CachePublicGettersAndSetters();
157
158	52		return self::$publicGetters[static::class];
159			}
160
161			/**
162			* {@inheritdoc}
163			*/
164	77		final public static function DaftObjectPublicSetters() : array
165			{
166	77		static::CachePublicGettersAndSetters();
167
168	77		return self::$publicSetters[static::class];
169			}
170
171			/**
172			* {@inheritdoc}
173			*/
174	34	View Code Duplication	final public static function DaftObjectJsonProperties() : array
			0 ignored issues – show Duplication introduced 2017-10-04 21:37 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
175			{
176	34		if (false === is_a(static::class, DaftJson::class, true)) {
177	16		throw new DaftObjectNotDaftJsonBadMethodCallException(
178	16		static::class
179			);
180			}
181
182	18		return static::JSON_PROPERTIES;
183			}
184
185	104		protected static function CachePublicGettersAndSetters() : void
186			{
187	104		$refreshGetters = false === isset(self::$publicGetters[static::class]);
188	104		$refreshSetters = false === isset(self::$publicSetters[static::class]);
189
190	104		if ($refreshGetters) {
191	12		self::$publicGetters[static::class] = [];
192
193			if (
194	12		is_a(
195	12		static::class,
196	12		DefinesOwnIdPropertiesInterface::class,
197	12		true
198			)
199			) {
200	7		self::$publicGetters[static::class][] = 'id';
201			}
202			}
203
204	104		if ($refreshSetters) {
205	12		self::$publicSetters[static::class] = [];
206			}
207
208	104		if ($refreshGetters \|\| $refreshSetters) {
209	12		$classReflection = new ReflectionClass(static::class);
210
211	12		foreach (static::DaftObjectProperties() as $property) {
212	12		$getter = 'Get' . ucfirst($property);
213
214	12		$setter = 'Set' . ucfirst($property);
215
216		View Code Duplication	if (
			0 ignored issues – show Duplication introduced 2017-10-08 14:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
217	12		$refreshGetters &&
218	12		$classReflection->hasMethod($getter) &&
219			(
220	10		$methodReflection = new ReflectionMethod(
221	10		static::class,
222	10		$getter
223			)
224	10		)->isPublic() &&
225	10		false === $methodReflection->isStatic()
226			) {
227	10		self::$publicGetters[static::class][] = $property;
228			}
229
230		View Code Duplication	if (
			0 ignored issues – show Duplication introduced 2017-10-08 14:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
231	12		$refreshSetters &&
232	12		$classReflection->hasMethod($setter) &&
233			(
234	10		$methodReflection = new ReflectionMethod(
235	10		static::class,
236	10		$setter
237			)
238	10		)->isPublic() &&
239	10		false === $methodReflection->isStatic()
240			) {
241	10		self::$publicSetters[static::class][] = $property;
242			}
243			}
244			}
245	104		}
246
247			/**
248			* Nudge the state of a given property, marking it as dirty.
249			*
250			* @param string $property property being nudged
251			* @param mixed $value value to nudge property with
252			*
253			* @throws UndefinedPropertyException if $property is not in static::DaftObjectProperties()
254			* @throws PropertyNotNullableException if $property is not in static::DaftObjectNullableProperties()
255			* @throws PropertyNotRewriteableException if class is write-once read-many and $property was already changed
256			*/
257			abstract protected function NudgePropertyValue(
258			string $property,
259			$value
260			) : void;
261
262			/**
263			* Checks if a type correctly defines it's own id.
264			*
265			* @param DaftObject $object
266			*
267			* @throws ClassDoesNotImplementClassException if $object is not an implementation of DefinesOwnIdPropertiesInterface
268			* @throws ClassMethodReturnHasZeroArrayCountException if $object::DaftObjectIdProperties() does not contain at least one property
269			* @throws ClassMethodReturnIsNotArrayOfStringsException if $object::DaftObjectIdProperties() is not string[]
270			* @throws UndefinedPropertyException if an id property is not in $object::DaftObjectIdProperties()
271			*/
272	117		final protected static function CheckTypeDefinesOwnIdProperties(
273			DaftObject $object
274			) : void {
275	117		$class = get_class($object);
276	117		if (false === ($object instanceof DefinesOwnIdPropertiesInterface)) {
277	1		throw new ClassDoesNotImplementClassException(
278	1		$class,
279	1		DefinesOwnIdPropertiesInterface::class
280			);
281			}
282
283			/**
284			* @var DefinesOwnIdPropertiesInterface $object
285			*/
286	116		$object = $object;
287
288	116		$properties = $object::DaftObjectIdProperties();
289
290	116		if (count($properties) < 1) {
291	1		throw new ClassMethodReturnHasZeroArrayCountException(
292	1		$class,
293	1		'DaftObjectIdProperties'
294			);
295			}
296
297	115		foreach ($properties as $property) {
298	115		if (false === is_string($property)) {
299	1		throw new ClassMethodReturnIsNotArrayOfStringsException(
300	1		$class,
301	1		'DaftObjectIdProperties'
302			);
303			}
304			}
305	114		}
306
307			/**
308			* @param mixed $v
309			*
310			* @return mixed
311			*/
312	107		protected function DoGetSet(
313			string $property,
314			bool $SetNotGet,
315			string $notPublic,
316			$v = null
317			) {
318			if (
319			(
320	107		'id' !== $property \|\|
321	9		false === ($this instanceof DefinesOwnIdPropertiesInterface)
322			) &&
323	107		false === in_array($property, static::DaftObjectProperties(), true)
324			) {
325	3		throw new UndefinedPropertyException(static::class, $property);
326			} elseif (
327			false === (
328	104		in_array(
329	104		$property,
330			(
331	104		$SetNotGet
332	77		? static::DaftObjectPublicSetters()
333	104		: static::DaftObjectPublicGetters()
334			),
335	104		true
336			)
337			)
338			) {
339	2		throw new $notPublic(
340	2		static::class,
341	2		$property
342			);
343			}
344
345	102		$expectedMethod = ($SetNotGet ? 'Set' : 'Get') . ucfirst($property);
346
347	102		return $this->$expectedMethod($v);
348			}
349			}
350

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( ec2097...604fdd )

AbstractDaftObject::__debugInfo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like