AccessorGuesser::getMethodAccessor() - Code Metrics - Inspection of "feat: Adding support of vitual property" - b2pweb/bdf-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 161f33...20f2fb )

by Sébastien

created 2021-05-18 11:58 UTC

AccessorGuesser::getMethodAccessor() B

↳ Parent: AccessorGuesser

Complexity

Conditions	8
Paths	13

Size

Total Lines	34
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	8
eloc	19
c	0
b	0
f	0
nc	13
nop	5
dl	0
loc	34
rs	8.4444

<?php

namespace Bdf\Serializer\Util;

use Bdf\Serializer\PropertyAccessor\ClosureAccessor;
use Bdf\Serializer\PropertyAccessor\PropertyAccessorInterface;
use Bdf\Serializer\PropertyAccessor\DelegateAccessor;
use Bdf\Serializer\PropertyAccessor\PublicAccessor;
use Bdf\Serializer\PropertyAccessor\MethodAccessor;
use Bdf\Serializer\PropertyAccessor\ReflectionAccessor;
use ReflectionClass;

/**
 * AccessorGuesser
 */
class AccessorGuesser
{
    /**
     * Allows closure accessor
     *
     * @var bool
     */
    private static $useClosure = false;

    /**
     * Guess which property accessor suit the property
     *
     * @param ReflectionClass $reflection
     * @param string $property
     * @param array $options
     *
     * @return PropertyAccessorInterface
     *
     * @deprecated Use getMethodAccessor or getPropertyAccessor instead of
     */
    public static function guessAccessor(ReflectionClass $reflection, string $property, array $options = null): PropertyAccessorInterface
    {
        // use reflection accessor if not set. Guess if property is public to use tue public accessor
        if ($options === null) {
            return self::getPropertyAccessor($reflection, $property);
        }

        return self::getMethodAccessor($reflection, $property, $options['reader'] ?? null, $options['writer'] ?? null, $options['readOnly'] ?? false);
    }

    /**
     * Guess which method accessor suit the property
     *
     * @param ReflectionClass $reflection
     * @param string $property
     * @param PropertyAccessorInterface|string|null $getter
     * @param PropertyAccessorInterface|string|null $setter
     *
     * @return PropertyAccessorInterface
     */
    public static function getMethodAccessor(ReflectionClass $reflection, $property, $getter, $setter, bool $readOnly = false): PropertyAccessorInterface
    {
        // If accessor is an array, it should have reader and writer keys.
        // The reader and the writer are methods, the method accessor will be used
        // Otherwise, the delegate accessor will be built with defined accessors.
        if (is_string($getter) && is_string($setter)) {
            return new MethodAccessor($reflection->name, $property, $getter, $setter);
        }

        if ($getter !== null) {
            if ($getter instanceof PropertyAccessorInterface) {
                $reader = $getter;
            } else {
                $reader = new MethodAccessor($reflection->name, $property, $getter);
            }
        } else {
            $reader = static::getPropertyAccessor($reflection, $property);
        }

        if ($readOnly) {
            return $reader;
        }

        if ($setter !== null) {
            if ($setter instanceof PropertyAccessorInterface) {
                $writter = $setter;
            } else {
                $writter = new MethodAccessor($reflection->name, $property, null, $setter);
            }
        } else {
            $writter = static::getPropertyAccessor($reflection, $property);
        }

        return new DelegateAccessor($reader, $writter);
    }

    /**
     * Guess which property accessor suit the property
     *
     * @param ReflectionClass $reflection
     * @param string $property
     *
     * @return PropertyAccessorInterface
     *
     * @throws \ReflectionException
     */
    public static function getPropertyAccessor(ReflectionClass $reflection, string $property): PropertyAccessorInterface
    {
        $reflection = self::getPropertyOwner($reflection, $property);

        // use reflection accessor if not set. Guess if property is public to use tue public accessor
        if ($reflection->getProperty($property)->isPublic()) {
            return new PublicAccessor($reflection->name, $property);
        }

        if (self::$useClosure) {
            return new ClosureAccessor($reflection->name, $property);
        }

        return new ReflectionAccessor($reflection->name, $property);
    }

    /**
     * Try to guess the setter method
     *
     * @param string $class
     * @param string $property
     *
     * @return null|string
     *
     * @todo Manage magic method __set
     */
    public static function guessSetter(string $class, string $property): ?string
    {
        $method = 'set'.ucfirst($property);

        if (method_exists($class, $method)) {
            return $method;
        }

        return null;
    }

    /**
     * Try to guess the getter method
     *
     * @param string $class
     * @param string $property
     *
     * @return null|string
     *
     * @todo Manage magic method __get
     */
    public static function guessGetter(string $class, string $property): ?string
    {
        if (method_exists($class, $property)) {
            return $property;
        }

        $method = 'get'.ucfirst($property);

        if (method_exists($class, $method)) {
            return $method;
        }

        return null;
    }

    /**
     * Enable/disable the closure accessor
     *
     * @param bool $flag
     */
    public static function useClosureAccessor($flag): void
    {
        self::$useClosure = (bool)$flag;
    }

    /**
     * Get the reflection that ownes the property
     *
     * @param ReflectionClass $reflection
     * @param string $property
     *
     * @return ReflectionClass
     *
     * @throws \LogicException if property does not belongs to this hierarchy
     */
    private static function getPropertyOwner($reflection, $property): ReflectionClass
    {
        do {
            if ($reflection->hasProperty($property)) {
                return $reflection;
            }
        } while ($reflection = $reflection->getParentClass());

        throw new \LogicException('No reflection found for property "'.$property.'"');
    }
}

1			<?php
2
3			namespace Bdf\Serializer\Util;
4
5			use Bdf\Serializer\PropertyAccessor\ClosureAccessor;
6			use Bdf\Serializer\PropertyAccessor\PropertyAccessorInterface;
7			use Bdf\Serializer\PropertyAccessor\DelegateAccessor;
8			use Bdf\Serializer\PropertyAccessor\PublicAccessor;
9			use Bdf\Serializer\PropertyAccessor\MethodAccessor;
10			use Bdf\Serializer\PropertyAccessor\ReflectionAccessor;
11			use ReflectionClass;
12
13			/**
14			* AccessorGuesser
15			*/
16			class AccessorGuesser
17			{
18			/**
19			* Allows closure accessor
20			*
21			* @var bool
22			*/
23			private static $useClosure = false;
24
25			/**
26			* Guess which property accessor suit the property
27			*
28			* @param ReflectionClass $reflection
29			* @param string $property
30			* @param array $options
31			*
32			* @return PropertyAccessorInterface
33			*
34			* @deprecated Use getMethodAccessor or getPropertyAccessor instead of
35			*/
36			public static function guessAccessor(ReflectionClass $reflection, string $property, array $options = null): PropertyAccessorInterface
37			{
38			// use reflection accessor if not set. Guess if property is public to use tue public accessor
39			if ($options === null) {
40			return self::getPropertyAccessor($reflection, $property);
41			}
42
43			return self::getMethodAccessor($reflection, $property, $options['reader'] ?? null, $options['writer'] ?? null, $options['readOnly'] ?? false);
44			}
45
46			/**
47			* Guess which method accessor suit the property
48			*
49			* @param ReflectionClass $reflection
50			* @param string $property
51			* @param PropertyAccessorInterface\|string\|null $getter
52			* @param PropertyAccessorInterface\|string\|null $setter
53			*
54			* @return PropertyAccessorInterface
55			*/
56			public static function getMethodAccessor(ReflectionClass $reflection, $property, $getter, $setter, bool $readOnly = false): PropertyAccessorInterface
57			{
58			// If accessor is an array, it should have reader and writer keys.
59			// The reader and the writer are methods, the method accessor will be used
60			// Otherwise, the delegate accessor will be built with defined accessors.
61			if (is_string($getter) && is_string($setter)) {
62			return new MethodAccessor($reflection->name, $property, $getter, $setter);
63			}
64
65			if ($getter !== null) {
66			if ($getter instanceof PropertyAccessorInterface) {
67			$reader = $getter;
68			} else {
69			$reader = new MethodAccessor($reflection->name, $property, $getter);
70			}
71			} else {
72			$reader = static::getPropertyAccessor($reflection, $property);
73			}
74
75			if ($readOnly) {
76			return $reader;
77			}
78
79			if ($setter !== null) {
80			if ($setter instanceof PropertyAccessorInterface) {
81			$writter = $setter;
82			} else {
83			$writter = new MethodAccessor($reflection->name, $property, null, $setter);
84			}
85			} else {
86			$writter = static::getPropertyAccessor($reflection, $property);
87			}
88
89			return new DelegateAccessor($reader, $writter);
90			}
91
92			/**
93			* Guess which property accessor suit the property
94			*
95			* @param ReflectionClass $reflection
96			* @param string $property
97			*
98			* @return PropertyAccessorInterface
99			*
100			* @throws \ReflectionException
101			*/
102			public static function getPropertyAccessor(ReflectionClass $reflection, string $property): PropertyAccessorInterface
103			{
104			$reflection = self::getPropertyOwner($reflection, $property);
105
106			// use reflection accessor if not set. Guess if property is public to use tue public accessor
107			if ($reflection->getProperty($property)->isPublic()) {
108			return new PublicAccessor($reflection->name, $property);
109			}
110
111			if (self::$useClosure) {
112			return new ClosureAccessor($reflection->name, $property);
113			}
114
115			return new ReflectionAccessor($reflection->name, $property);
116			}
117
118			/**
119			* Try to guess the setter method
120			*
121			* @param string $class
122			* @param string $property
123			*
124			* @return null\|string
125			*
126			* @todo Manage magic method __set
127			*/
128			public static function guessSetter(string $class, string $property): ?string
129			{
130			$method = 'set'.ucfirst($property);
131
132			if (method_exists($class, $method)) {
133			return $method;
134			}
135
136			return null;
137			}
138
139			/**
140			* Try to guess the getter method
141			*
142			* @param string $class
143			* @param string $property
144			*
145			* @return null\|string
146			*
147			* @todo Manage magic method __get
148			*/
149			public static function guessGetter(string $class, string $property): ?string
150			{
151			if (method_exists($class, $property)) {
152			return $property;
153			}
154
155			$method = 'get'.ucfirst($property);
156
157			if (method_exists($class, $method)) {
158			return $method;
159			}
160
161			return null;
162			}
163
164			/**
165			* Enable/disable the closure accessor
166			*
167			* @param bool $flag
168			*/
169			public static function useClosureAccessor($flag): void
170			{
171			self::$useClosure = (bool)$flag;
172			}
173
174			/**
175			* Get the reflection that ownes the property
176			*
177			* @param ReflectionClass $reflection
178			* @param string $property
179			*
180			* @return ReflectionClass
181			*
182			* @throws \LogicException if property does not belongs to this hierarchy
183			*/
184			private static function getPropertyOwner($reflection, $property): ReflectionClass
185			{
186			do {
187			if ($reflection->hasProperty($property)) {
188			return $reflection;
189			}
190			} while ($reflection = $reflection->getParentClass());
191
192			throw new \LogicException('No reflection found for property "'.$property.'"');
193			}
194			}

b2pweb / bdf-serializer

Push — master ( 161f33...20f2fb )

AccessorGuesser::getMethodAccessor() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like