AbstractDaftObject::DaftObjectExportableProperties() - Code Metrics - Inspection of "attempting deduplication" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dcd7bc...6fdc8a )

by SignpostMarv

created 2017-10-08 14:39 UTC

DaftObjectExportableProperties() A

↳ Parent: AbstractDaftObject

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

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

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( dcd7bc...6fdc8a )

DaftObjectExportableProperties() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like