PropertyReflectionExtension::getType() - Code Metrics - Inspection of "tweaking test configs" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2fb392...923b97 )

by SignpostMarv

created 2019-01-08 00:58 UTC

PropertyReflectionExtension::getType() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

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

namespace SignpostMarv\DaftObject\PHPStan;

use BadMethodCallException;
use InvalidArgumentException;
use PHPStan\Broker\Broker;
use PHPStan\Reflection\ClassReflection;
use PHPStan\Reflection\PropertyReflection;
use PHPStan\Type\MixedType;
use PHPStan\Type\Type;
use PHPStan\Type\TypehintHelper;
use ReflectionMethod;
use SignpostMarv\DaftObject\DaftObject;
use SignpostMarv\DaftObject\DefinesOwnIdPropertiesInterface;
use SignpostMarv\DaftObject\TypeParanoia;
use SignpostMarv\DaftObject\TypeUtilities;

class PropertyReflectionExtension implements PropertyReflection
{
    const REF_PARAM_INDEX = 0;

    const BOOL_IS_WRITEABLE = true;

    const BOOL_IS_READABLE = true;

    const BOOL_SETNOTGET_SETTER = true;

    const BOOL_SETNOTGET_GETTER = false;

    const BOOL_CLASS_NOT_DAFTOBJECT = false;

    const BOOL_REFLECTION_NO_FILE = false;

    const BOOL_NOT_VARIADIC = false;

    const BOOL_IS_STATIC = false;

    /**
    * @var Type
    */
    protected $type;

    /**
    * @var Broker
    */
    protected $broker;

    /**
    * @var bool
    */
    protected $readable = false;

    /**
    * @var bool
    */
    protected $writeable = false;

    /**
    * @var bool
    */
    protected $public;

    /**
    * @var ClassReflection|null
    */
    protected $readableReflection;

    /**
    * @var ClassReflection|null
    */
    protected $writeableReflection;

    public function __construct(ClassReflection $classReflection, Broker $broker, string $property)
    {
        if ( ! TypeParanoia::IsThingStrings($classReflection->getName(), DaftObject::class)) {
            throw new InvalidArgumentException(sprintf('%s is not an implementation of %s',
                $classReflection->getName(),
                DaftObject::class
            ));
        }

        $this->broker = $broker;

        $this->public = static::PropertyIsPublic($classReflection->getName(), $property);

        $this->type = new MixedType();

        $this->SetupReflections($classReflection, $property);
    }

    public function getType() : Type
    {
        return $this->type;
    }

    public function isReadable() : bool
    {
        return $this->readable;
    }

    public function isWritable() : bool
    {
        return $this->writeable;
    }

    public function isPublic() : bool
    {
        return $this->public;
    }

    public function isPrivate() : bool
    {
        return ! $this->isPublic();
    }

    public function isStatic() : bool
    {
        return self::BOOL_IS_STATIC;
    }

    public function getDeclaringClass() : ClassReflection
    {
        $reflection = $this->readable ? $this->readableReflection : $this->writeableReflection;

        if ( ! ($reflection instanceof ClassReflection)) {
            throw new BadMethodCallException(
                static::class .
                '::SetupReflections() was not called before ' .
                __METHOD__ .
                ' was called!'
            );
        }

        return $reflection;
    }

    protected static function DetermineDeclaringClass(
        Broker $broker,
        ReflectionMethod $refMethod
    ) : ClassReflection {
        $reflectionClass = $refMethod->getDeclaringClass();

        $filename = null;
        if (self::BOOL_REFLECTION_NO_FILE !== $reflectionClass->getFileName()) {
            $filename = $reflectionClass->getFileName();
        }

        return $broker->getClassFromReflection(
            $reflectionClass,
            $reflectionClass->getName(),
            $reflectionClass->isAnonymous() ? $filename : null
        );
    }

    /**
    * @psalm-suppress InvalidStringClass
    * @psalm-suppress MixedMethodCall
    */
    protected static function PropertyIsPublic(string $className, string $property) : bool
    {
        if ( ! TypeParanoia::IsSubThingStrings($className, DaftObject::class)) {
            return self::BOOL_CLASS_NOT_DAFTOBJECT;
        }

        return
            (
                TypeParanoia::IsThingStrings(
                    $className,
                    DefinesOwnIdPropertiesInterface::class
                ) &&
                'id' === $property
            ) ||
            TypeParanoia::MaybeInMaybeArray($property, $className::DaftObjectPublicGetters()) ||
            TypeParanoia::MaybeInMaybeArray($property, $className::DaftObjectPublicSetters());
    }

    private function SetupReflections(ClassReflection $classReflection, string $property) : void
    {
        $class = $classReflection->getName();
        $get = TypeUtilities::MethodNameFromProperty($property, self::BOOL_SETNOTGET_GETTER);
        $set = TypeUtilities::MethodNameFromProperty($property, self::BOOL_SETNOTGET_SETTER);

        $this->writeableReflection = $this->readableReflection = $classReflection;

        if ($classReflection->getNativeReflection()->hasMethod($get)) {
            $this->readableReflection = $this->SetGetterProps(new ReflectionMethod($class, $get));
        }

        if ($classReflection->getNativeReflection()->hasMethod($set)) {
            $this->writeableReflection = $this->SetSetterProps($class, $set);
        }
    }

    private function SetGetterProps(ReflectionMethod $refMethod) : ClassReflection
    {
        $this->readable = self::BOOL_IS_READABLE;

        if ($refMethod->isStatic()) {
            throw new InvalidArgumentException(
                'Implementations of ' .
                DaftObject::class .
                ' must not contain static getters.'
            );
        }

        if ($refMethod->hasReturnType()) {
            $this->type = TypehintHelper::decideTypeFromReflection($refMethod->getReturnType());
        }

        return static::DetermineDeclaringClass($this->broker, $refMethod);
    }

    private function SetSetterProps(string $class, string $set) : ClassReflection
    {
        $refMethod = new ReflectionMethod($class, $set);
        $this->writeable = self::BOOL_IS_WRITEABLE;

        $refParam = $refMethod->getParameters()[self::REF_PARAM_INDEX];

        if ($refParam->hasType()) {
            $this->type = TypehintHelper::decideTypeFromReflection(
                $refParam->getType(),
                null,
                $class,
                self::BOOL_NOT_VARIADIC
            );
        }

        return static::DetermineDeclaringClass($this->broker, $refMethod);
    }
}


1			<?php
2			/**
3			* Base daft objects.
4			*
5			* @author SignpostMarv
6			*/
7			declare(strict_types=1);
8
9			namespace SignpostMarv\DaftObject\PHPStan;
10
11			use BadMethodCallException;
12			use InvalidArgumentException;
13			use PHPStan\Broker\Broker;
14			use PHPStan\Reflection\ClassReflection;
15			use PHPStan\Reflection\PropertyReflection;
16			use PHPStan\Type\MixedType;
17			use PHPStan\Type\Type;
18			use PHPStan\Type\TypehintHelper;
19			use ReflectionMethod;
20			use SignpostMarv\DaftObject\DaftObject;
21			use SignpostMarv\DaftObject\DefinesOwnIdPropertiesInterface;
22			use SignpostMarv\DaftObject\TypeParanoia;
23			use SignpostMarv\DaftObject\TypeUtilities;
24
25			class PropertyReflectionExtension implements PropertyReflection
26			{
27			const REF_PARAM_INDEX = 0;
28
29			const BOOL_IS_WRITEABLE = true;
30
31			const BOOL_IS_READABLE = true;
32
33			const BOOL_SETNOTGET_SETTER = true;
34
35			const BOOL_SETNOTGET_GETTER = false;
36
37			const BOOL_CLASS_NOT_DAFTOBJECT = false;
38
39			const BOOL_REFLECTION_NO_FILE = false;
40
41			const BOOL_NOT_VARIADIC = false;
42
43			const BOOL_IS_STATIC = false;
44
45			/**
46			* @var Type
47			*/
48			protected $type;
49
50			/**
51			* @var Broker
52			*/
53			protected $broker;
54
55			/**
56			* @var bool
57			*/
58			protected $readable = false;
59
60			/**
61			* @var bool
62			*/
63			protected $writeable = false;
64
65			/**
66			* @var bool
67			*/
68			protected $public;
69
70			/**
71			* @var ClassReflection\|null
72			*/
73			protected $readableReflection;
74
75			/**
76			* @var ClassReflection\|null
77			*/
78			protected $writeableReflection;
79
80			public function __construct(ClassReflection $classReflection, Broker $broker, string $property)
81			{
82			if ( ! TypeParanoia::IsThingStrings($classReflection->getName(), DaftObject::class)) {
83			throw new InvalidArgumentException(sprintf('%s is not an implementation of %s',
84			$classReflection->getName(),
85			DaftObject::class
86			));
87			}
88
89			$this->broker = $broker;
90
91			$this->public = static::PropertyIsPublic($classReflection->getName(), $property);
92
93			$this->type = new MixedType();
94
95			$this->SetupReflections($classReflection, $property);
96			}
97
98			public function getType() : Type
99			{
100			return $this->type;
101			}
102
103			public function isReadable() : bool
104			{
105			return $this->readable;
106			}
107
108			public function isWritable() : bool
109			{
110			return $this->writeable;
111			}
112
113			public function isPublic() : bool
114			{
115			return $this->public;
116			}
117
118			public function isPrivate() : bool
119			{
120			return ! $this->isPublic();
121			}
122
123			public function isStatic() : bool
124			{
125			return self::BOOL_IS_STATIC;
126			}
127
128			public function getDeclaringClass() : ClassReflection
129			{
130			$reflection = $this->readable ? $this->readableReflection : $this->writeableReflection;
131
132			if ( ! ($reflection instanceof ClassReflection)) {
133			throw new BadMethodCallException(
134			static::class .
135			'::SetupReflections() was not called before ' .
136			__METHOD__ .
137			' was called!'
138			);
139			}
140
141			return $reflection;
142			}
143
144			protected static function DetermineDeclaringClass(
145			Broker $broker,
146			ReflectionMethod $refMethod
147			) : ClassReflection {
148			$reflectionClass = $refMethod->getDeclaringClass();
149
150			$filename = null;
151			if (self::BOOL_REFLECTION_NO_FILE !== $reflectionClass->getFileName()) {
152			$filename = $reflectionClass->getFileName();
153			}
154
155			return $broker->getClassFromReflection(
156			$reflectionClass,
157			$reflectionClass->getName(),
158			$reflectionClass->isAnonymous() ? $filename : null
159			);
160			}
161
162			/**
163			* @psalm-suppress InvalidStringClass
164			* @psalm-suppress MixedMethodCall
165			*/
166			protected static function PropertyIsPublic(string $className, string $property) : bool
167			{
168			if ( ! TypeParanoia::IsSubThingStrings($className, DaftObject::class)) {
169			return self::BOOL_CLASS_NOT_DAFTOBJECT;
170			}
171
172			return
173			(
174			TypeParanoia::IsThingStrings(
175			$className,
176			DefinesOwnIdPropertiesInterface::class
177			) &&
178			'id' === $property
179			) \|\|
180			TypeParanoia::MaybeInMaybeArray($property, $className::DaftObjectPublicGetters()) \|\|
181			TypeParanoia::MaybeInMaybeArray($property, $className::DaftObjectPublicSetters());
182			}
183
184			private function SetupReflections(ClassReflection $classReflection, string $property) : void
185			{
186			$class = $classReflection->getName();
187			$get = TypeUtilities::MethodNameFromProperty($property, self::BOOL_SETNOTGET_GETTER);
188			$set = TypeUtilities::MethodNameFromProperty($property, self::BOOL_SETNOTGET_SETTER);
189
190			$this->writeableReflection = $this->readableReflection = $classReflection;
191
192			if ($classReflection->getNativeReflection()->hasMethod($get)) {
193			$this->readableReflection = $this->SetGetterProps(new ReflectionMethod($class, $get));
194			}
195
196			if ($classReflection->getNativeReflection()->hasMethod($set)) {
197			$this->writeableReflection = $this->SetSetterProps($class, $set);
198			}
199			}
200
201			private function SetGetterProps(ReflectionMethod $refMethod) : ClassReflection
202			{
203			$this->readable = self::BOOL_IS_READABLE;
204
205			if ($refMethod->isStatic()) {
206			throw new InvalidArgumentException(
207			'Implementations of ' .
208			DaftObject::class .
209			' must not contain static getters.'
210			);
211			}
212
213			if ($refMethod->hasReturnType()) {
214			$this->type = TypehintHelper::decideTypeFromReflection($refMethod->getReturnType());
215			}
216
217			return static::DetermineDeclaringClass($this->broker, $refMethod);
218			}
219
220			private function SetSetterProps(string $class, string $set) : ClassReflection
221			{
222			$refMethod = new ReflectionMethod($class, $set);
223			$this->writeable = self::BOOL_IS_WRITEABLE;
224
225			$refParam = $refMethod->getParameters()[self::REF_PARAM_INDEX];
226
227			if ($refParam->hasType()) {
228			$this->type = TypehintHelper::decideTypeFromReflection(
229			$refParam->getType(),
230			null,
231			$class,
232			self::BOOL_NOT_VARIADIC
233			);
234			}
235
236			return static::DetermineDeclaringClass($this->broker, $refMethod);
237			}
238			}
239

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 2fb392...923b97 )

PropertyReflectionExtension::getType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like