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

Passed

Push — master ( 604fdd...dcd7bc )

by SignpostMarv

created 2017-10-08 14:28 UTC

AbstractDaftObject::DaftObjectJsonProperties() A

↳ Parent: AbstractDaftObject

Complexity

Conditions	2
Paths	1

Size

Total Lines	9
Code Lines	4

Duplication

Lines	9
Ratio	100 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

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

<?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;
    }

    final protected static function HasPublicMethod(
        ReflectionClass $classReflection,
        string $method
    ) : bool {
        if (
            $classReflection->hasMethod($method)
        ) {
            $methodReflection = new ReflectionMethod(
                static::class,
                $method
            );

            return
                $methodReflection->isPublic() &&
                false === $methodReflection->isStatic();
        }

        return false;
    }

    final protected static function CachePublicGettersAndSetters() : void
    {
        $refresh = false === isset(self::$publicGetters[static::class]);

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

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

        if ($refresh) {
            $classReflection = new ReflectionClass(static::class);

            foreach (static::DaftObjectProperties() as $property) {
                if (

                    static::HasPublicMethod(
                        $classReflection,
                        'Get' . ucfirst($property)
                    )
                ) {
                    self::$publicGetters[static::class][] = $property;
                }

                if (

                    static::HasPublicMethod(
                        $classReflection,
                        'Set' . ucfirst($property)
                    )
                ) {
                    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);
        }

        $expectedMethod = 'Get' . ucfirst($property);
        $thingers = static::DaftObjectPublicGetters();

        if ($SetNotGet) {
            $expectedMethod = 'Set' . ucfirst($property);
            $thingers = static::DaftObjectPublicSetters();
        }

        if (
            false === (
                in_array(
                    $property,
                    $thingers,
                    true
                )
            )
        ) {
            throw new $notPublic(
                static::class,
                $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	104		final public static function DaftObjectPublicGetters() : array
155			{
156	104		static::CachePublicGettersAndSetters();
157
158	104		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	12		final protected static function HasPublicMethod(
186			ReflectionClass $classReflection,
187			string $method
188			) : bool {
189			if (
190	12		$classReflection->hasMethod($method)
191			) {
192	12		$methodReflection = new ReflectionMethod(
193	12		static::class,
194	12		$method
195			);
196
197			return
198	12		$methodReflection->isPublic() &&
199	12		false === $methodReflection->isStatic();
200			}
201
202	4		return false;
203			}
204
205	104		final protected static function CachePublicGettersAndSetters() : void
206			{
207	104		$refresh = false === isset(self::$publicGetters[static::class]);
208
209	104		if ($refresh) {
210	12		self::$publicGetters[static::class] = [];
211	12		self::$publicSetters[static::class] = [];
212
213			if (
214	12		is_a(
215	12		static::class,
216	12		DefinesOwnIdPropertiesInterface::class,
217	12		true
218			)
219			) {
220	7		self::$publicGetters[static::class][] = 'id';
221			}
222			}
223
224	104		if ($refresh) {
225	12		$classReflection = new ReflectionClass(static::class);
226
227	12		foreach (static::DaftObjectProperties() as $property) {
228		View Code Duplication	if (
			0 ignored issues – show Duplication introduced 2017-10-08 14:30 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...
229	12		static::HasPublicMethod(
230	12		$classReflection,
231	12		'Get' . ucfirst($property)
232			)
233			) {
234	10		self::$publicGetters[static::class][] = $property;
235			}
236
237		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...
238	12		static::HasPublicMethod(
239	12		$classReflection,
240	12		'Set' . ucfirst($property)
241			)
242			) {
243	10		self::$publicSetters[static::class][] = $property;
244			}
245			}
246			}
247	104		}
248
249			/**
250			* Nudge the state of a given property, marking it as dirty.
251			*
252			* @param string $property property being nudged
253			* @param mixed $value value to nudge property with
254			*
255			* @throws UndefinedPropertyException if $property is not in static::DaftObjectProperties()
256			* @throws PropertyNotNullableException if $property is not in static::DaftObjectNullableProperties()
257			* @throws PropertyNotRewriteableException if class is write-once read-many and $property was already changed
258			*/
259			abstract protected function NudgePropertyValue(
260			string $property,
261			$value
262			) : void;
263
264			/**
265			* Checks if a type correctly defines it's own id.
266			*
267			* @param DaftObject $object
268			*
269			* @throws ClassDoesNotImplementClassException if $object is not an implementation of DefinesOwnIdPropertiesInterface
270			* @throws ClassMethodReturnHasZeroArrayCountException if $object::DaftObjectIdProperties() does not contain at least one property
271			* @throws ClassMethodReturnIsNotArrayOfStringsException if $object::DaftObjectIdProperties() is not string[]
272			* @throws UndefinedPropertyException if an id property is not in $object::DaftObjectIdProperties()
273			*/
274	117		final protected static function CheckTypeDefinesOwnIdProperties(
275			DaftObject $object
276			) : void {
277	117		$class = get_class($object);
278	117		if (false === ($object instanceof DefinesOwnIdPropertiesInterface)) {
279	1		throw new ClassDoesNotImplementClassException(
280	1		$class,
281	1		DefinesOwnIdPropertiesInterface::class
282			);
283			}
284
285			/**
286			* @var DefinesOwnIdPropertiesInterface $object
287			*/
288	116		$object = $object;
289
290	116		$properties = $object::DaftObjectIdProperties();
291
292	116		if (count($properties) < 1) {
293	1		throw new ClassMethodReturnHasZeroArrayCountException(
294	1		$class,
295	1		'DaftObjectIdProperties'
296			);
297			}
298
299	115		foreach ($properties as $property) {
300	115		if (false === is_string($property)) {
301	1		throw new ClassMethodReturnIsNotArrayOfStringsException(
302	1		$class,
303	1		'DaftObjectIdProperties'
304			);
305			}
306			}
307	114		}
308
309			/**
310			* @param mixed $v
311			*
312			* @return mixed
313			*/
314	107		protected function DoGetSet(
315			string $property,
316			bool $SetNotGet,
317			string $notPublic,
318			$v = null
319			) {
320			if (
321			(
322	107		'id' !== $property \|\|
323	9		false === ($this instanceof DefinesOwnIdPropertiesInterface)
324			) &&
325	107		false === in_array($property, static::DaftObjectProperties(), true)
326			) {
327	3		throw new UndefinedPropertyException(static::class, $property);
328			}
329
330	104		$expectedMethod = 'Get' . ucfirst($property);
331	104		$thingers = static::DaftObjectPublicGetters();
332
333	104		if ($SetNotGet) {
334	77		$expectedMethod = 'Set' . ucfirst($property);
335	77		$thingers = static::DaftObjectPublicSetters();
336			}
337
338			if (
339			false === (
340	104		in_array(
341	104		$property,
342	104		$thingers,
343	104		true
344			)
345			)
346			) {
347	2		throw new $notPublic(
348	2		static::class,
349	2		$property
350			);
351			}
352
353	102		return $this->$expectedMethod($v);
354			}
355			}
356

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 604fdd...dcd7bc )

AbstractDaftObject::DaftObjectJsonProperties() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like