AbstractDaftObject::CachePublicGettersAndSetters() - Code Metrics - Inspection of "removing redundant condition" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 6fdc8a...937611 )

by SignpostMarv

created 2017-10-08 14:43 UTC

AbstractDaftObject::CachePublicGettersAndSetters() B

↳ Parent: AbstractDaftObject

Complexity

Conditions	6
Paths	11

Size

Total Lines	38
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	21
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	38
ccs	21
cts	21
cp	1
rs	8.439
c	0
b	0
f	0
cc	6
eloc	23
nc	11
nop	0
crap	6

<?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
    {
        if (false === isset(self::$publicGetters[static::class])) {
            self::$publicGetters[static::class] = [];
            self::$publicSetters[static::class] = [];

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

            $classReflection = new ReflectionClass(static::class);

            foreach (static::DaftObjectProperties() as $property) {
                if (
                    static::HasPublicMethod(
                        $classReflection,
                        static::DaftObjectMethodNameFromProperty($property)
                    )
                ) {
                    self::$publicGetters[static::class][] = $property;
                }

                if (
                    static::HasPublicMethod(
                        $classReflection,
                        static::DaftObjectMethodNameFromProperty(
                            $property,
                            true
                        )
                    )
                ) {
                    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'
                );
            }
        }
    }

    protected static function DaftObjectMethodNameFromProperty(
        string $property,
        bool $SetNotGet = false
    ) : string {
        return ($SetNotGet ? 'Set' : 'Get') . ucfirst($property);
    }

    /**
    * @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 = static::DaftObjectMethodNameFromProperty(
            $property,
            $SetNotGet
        );
        $thingers = static::DaftObjectPublicGetters();

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

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 6fdc8a...937611 )

AbstractDaftObject::CachePublicGettersAndSetters() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like