TypeReflection::isString() - Code Metrics - Inspection of "support callable type" - Raphhh/trex-reflection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — master (7d01f1)

by Raphaël

created 2015-12-28 00:09 UTC

TypeReflection::isString() A

↳ Parent: TypeReflection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	1

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

<?php
namespace TRex\Reflection;


/**
 * TypeReflection reflect the types.
 *
 * @package TRex\Reflection
 * @author Raphaël Lefebvre <[email protected]>
 * @transient
 */
class TypeReflection
{

    const VOID_TYPE = 'void';
    const MIXED_TYPE = 'mixed';
    const NULL_TYPE = 'null';
    const BOOLEAN_TYPE = 'boolean';
    const STRING_TYPE = 'string';
    const INTEGER_TYPE = 'integer';
    const FLOAT_TYPE = 'float';
    const NUMBER_TYPE = 'number';
    const SCALAR_TYPE = 'scalar';
    const ARRAY_TYPE = 'array';
    const OBJECT_TYPE = 'object';
    const RESOURCE_TYPE = 'resource';
    const CALLABLE_TYPE = 'callable';
    const UNKNOWN_TYPE = 'unknown type';

    /**
     * @var array
     */
    private $typeMappingList = array(
        self::VOID_TYPE => array(
            'void',
        ),
        self::MIXED_TYPE => array(
            'mixed',
        ),
        self::NULL_TYPE => array(
            'null',
        ),
        self::BOOLEAN_TYPE => array(
            'bool',
            'boolean',
        ),
        self::STRING_TYPE => array(
            'string',
        ),
        self::INTEGER_TYPE => array(
            'int',
            'integer',
            'long',
        ),
        self::FLOAT_TYPE => array(
            'float',
            'double',
            'real',
        ),
        self::NUMBER_TYPE => array(
            'int',
            'integer',
            'long',
            'float',
            'double',
            'real',
        ),
        self::SCALAR_TYPE => array(
            'bool',
            'boolean',
            'string',
            'int',
            'integer',
            'long',
            'float',
            'double',
            'real',
        ),
        self::ARRAY_TYPE => array(
            'array',
        ),
        self::OBJECT_TYPE => array(
            'object',
        ),
        self::RESOURCE_TYPE => array(
            'resource',
        ),
        self::CALLABLE_TYPE => array(
            'callable',
        ),
    );

    /**
     * Reflected type or class name
     *
     * @var string
     */
    private $type;

    /**
     * @var bool
     */
    private $enableAutoload;

    /**
     * @param mixed $variable
     * @return TypeReflection
     */
    public static function createFromVariable($variable)
    {
        return new self(is_object($variable) ? get_class($variable) : strtolower(gettype($variable)));
    }

    /**
     * Constructor.
     *
     * @param string $type Reflected type or class name
     * @param bool $enableAutoload
     */
    public function __construct($type, $enableAutoload = false)
    {
        $this->setType($type);
        $this->enableAutoload = $enableAutoload;
    }

    /**
     * Getter of $enableAutoload
     *
     * @return boolean
     */
    public function isAutoloadEnabled()
    {
        return $this->enableAutoload;
    }

    /**
     * Setter of $enableAutoload
     *
     * @param boolean $enableAutoload
     */
    public function setEnableAutoload($enableAutoload)
    {
        $this->enableAutoload = (boolean)$enableAutoload;
    }

    /**
     * Gets the reflected type.
     *
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * Depending on the type, returns a standardized type, a constant value of XXX_TYPE.
     * Note that if the type is a class name, object type is returned.
     *
     *
     * @return string

     */
    public function getStandardizedType()
    {
        foreach ($this->getStandardizedTypes() as $standardizedType) {
            if ($this->is($standardizedType)) {
                return $standardizedType;
            }
        }
        return self::UNKNOWN_TYPE;
    }

    /**
     * Indicates if the type is recognized.
     *
     * @return bool
     */
    public function isValid()
    {
        return !$this->is(self::UNKNOWN_TYPE);
    }

    /**
     * Indicates whether the reflected type is void.
     * Valid values are:
     *  - void
     *
     * @return bool
     */
    public function isVoid()
    {
        return $this->is(self::VOID_TYPE);
    }

    /**
     * Indicates whether the reflected type is mixed.
     * Valid values are:
     *  - mixed
     *
     * @return bool
     */
    public function isMixed()
    {
        return $this->is(self::MIXED_TYPE);
    }

    /**
     * Indicates whether the reflected type is null.
     * Valid values are:
     *  - null
     *
     * @return bool
     */
    public function isNull()
    {
        return $this->is(self::NULL_TYPE);
    }

    /**
     * Indicates whether the reflected type is boolean.
     * Valid values are:
     *  - bool
     *  - boolean
     *
     * @return bool
     */
    public function isBoolean()
    {
        return $this->is(self::BOOLEAN_TYPE);
    }

    /**
     * Indicates whether the reflected type is string.
     * Valid values are:
     *  - string
     *
     * @return bool
     */
    public function isString()
    {
        return $this->is(self::STRING_TYPE);
    }

    /**
     * Indicates whether the reflected type is integer.
     * Valid values are
     *  - int
     *  - integer
     *  - long
     *
     * @return bool
     */
    public function isInteger()
    {
        return $this->is(self::INTEGER_TYPE);
    }

    /**
     * Indicates whether the reflected type is float.
     * Valid values are
     *  - float
     *  - double
     *  - real
     *
     * @return bool
     */
    public function isFloat()
    {
        return $this->is(self::FLOAT_TYPE);
    }

    /**
     * Indicates whether the reflected type is number.
     * Valid values are:
     *  - every value valid for int
     *  - every value valid for float
     *
     * @return bool
     */
    public function isNumber()
    {
        return $this->is(self::NUMBER_TYPE);
    }

    /**
     * Indicates whether the reflected type is scalar.
     * Valid values are:
     *  - every value valid for boolean
     *  - every value valid for string
     *  - every value valid for int
     *  - every value valid for float
     *
     * @return bool
     */
    public function isScalar()
    {
        return $this->is(self::SCALAR_TYPE);
    }

    /**
     * Indicates whether the reflected type is array.
     * Valid values are:
     *  - array
     *  - xxx[]
     *
     * @return bool
     */
    public function isArray()
    {
        return $this->is(self::ARRAY_TYPE);
    }

    /**
     * Indicates whether the reflected type is object.
     * Valid values are:
     *  - object
     *  - valid class name
     *
     * @return bool
     */
    public function isObject()
    {
        return $this->is(self::OBJECT_TYPE);
    }

    /**
     * Indicates whether the reflected type is resource.
     * Valid values are:
     *  - resource
     *
     * @return bool
     */
    public function isResource()
    {
        return $this->is(self::RESOURCE_TYPE);
    }

    /**
     * Indicates whether the reflected type is callable.
     * Valid values are:
     *  - callable
     *
     * @return bool
     */
    public function isCallable()
    {
        return $this->is(self::CALLABLE_TYPE);
    }

    /**
     * Indicates whether the reflected type is $standardizedType.
     *
     * @param string $standardizedType see specific const.
     * @return bool
     */
    public function is($standardizedType)
    {
        if ($standardizedType === self::OBJECT_TYPE && class_exists($this->getType(), $this->isAutoloadEnabled())) {
            return true;
        }
        if ($standardizedType === self::ARRAY_TYPE && stripos($this->getType(), '[]') !== false) {
            return true;
        }
        return $this->isInTypeMapping($standardizedType);
    }

    /**
     * Setter of $type.
     *
     * @param string $type
     */
    private function setType($type)
    {
        $this->type = (string)$type;
    }

    /**
     * Getter of $typeMappingList.
     *
     * @return array
     */
    private function getTypeMappingList()
    {
        return $this->typeMappingList;
    }

    /**
     * Returns a type mapping.
     *
     * @param string $standardizeType
     * @return array
     */
    private function getTypeMapping($standardizeType = '')
    {
        return $this->getTypeMappingList()[$standardizeType];
    }

    /**
     * Indicates whether self::$type is a possible type of $standardizedType.
     *
     * @param string $standardizedType
     * @return bool
     */
    private function isInTypeMapping($standardizedType)
    {
        return in_array(strtolower($this->getType()), $this->getTypeMapping($standardizedType), true);
    }

    /**
     * get the possible types.
     *
     * @return array

     */
    private function getStandardizedTypes()
    {
        return array_keys($this->getTypeMappingList());
    }
}


1		<?php
2		namespace TRex\Reflection;
3
4
5		/**
6		* TypeReflection reflect the types.
7		*
8		* @package TRex\Reflection
9		* @author Raphaël Lefebvre <[email protected]>
10		* @transient
11		*/
12		class TypeReflection
13		{
14
15		const VOID_TYPE = 'void';
16		const MIXED_TYPE = 'mixed';
17		const NULL_TYPE = 'null';
18		const BOOLEAN_TYPE = 'boolean';
19		const STRING_TYPE = 'string';
20		const INTEGER_TYPE = 'integer';
21		const FLOAT_TYPE = 'float';
22		const NUMBER_TYPE = 'number';
23		const SCALAR_TYPE = 'scalar';
24		const ARRAY_TYPE = 'array';
25		const OBJECT_TYPE = 'object';
26		const RESOURCE_TYPE = 'resource';
27		const CALLABLE_TYPE = 'callable';
28		const UNKNOWN_TYPE = 'unknown type';
29
30		/**
31		* @var array
32		*/
33		private $typeMappingList = array(
34		self::VOID_TYPE => array(
35		'void',
36		),
37		self::MIXED_TYPE => array(
38		'mixed',
39		),
40		self::NULL_TYPE => array(
41		'null',
42		),
43		self::BOOLEAN_TYPE => array(
44		'bool',
45		'boolean',
46		),
47		self::STRING_TYPE => array(
48		'string',
49		),
50		self::INTEGER_TYPE => array(
51		'int',
52		'integer',
53		'long',
54		),
55		self::FLOAT_TYPE => array(
56		'float',
57		'double',
58		'real',
59		),
60		self::NUMBER_TYPE => array(
61		'int',
62		'integer',
63		'long',
64		'float',
65		'double',
66		'real',
67		),
68		self::SCALAR_TYPE => array(
69		'bool',
70		'boolean',
71		'string',
72		'int',
73		'integer',
74		'long',
75		'float',
76		'double',
77		'real',
78		),
79		self::ARRAY_TYPE => array(
80		'array',
81		),
82		self::OBJECT_TYPE => array(
83		'object',
84		),
85		self::RESOURCE_TYPE => array(
86		'resource',
87		),
88		self::CALLABLE_TYPE => array(
89		'callable',
90		),
91		);
92
93		/**
94		* Reflected type or class name
95		*
96		* @var string
97		*/
98		private $type;
99
100		/**
101		* @var bool
102		*/
103		private $enableAutoload;
104
105		/**
106		* @param mixed $variable
107	5	* @return TypeReflection
108		*/
109	5	public static function createFromVariable($variable)
110	5	{
111	5	return new self(is_object($variable) ? get_class($variable) : strtolower(gettype($variable)));
112		}
113
114		/**
115		* Constructor.
116		*
117		* @param string $type Reflected type or class name
118	1	* @param bool $enableAutoload
119		*/
120	1	public function __construct($type, $enableAutoload = false)
121		{
122		$this->setType($type);
123		$this->enableAutoload = $enableAutoload;
124		}
125
126		/**
127		* Getter of $enableAutoload
128		*
129		* @return boolean
130		*/
131		public function isAutoloadEnabled()
132		{
133		return $this->enableAutoload;
134		}
135
136		/**
137		* Setter of $enableAutoload
138	5	*
139		* @param boolean $enableAutoload
140	5	*/
141		public function setEnableAutoload($enableAutoload)
142		{
143		$this->enableAutoload = (boolean)$enableAutoload;
144		}
145
146		/**
147		* Gets the reflected type.
148		*
149		* @return string
150	1	*/
151		public function getType()
152	1	{
153	1	return $this->type;
154	1	}
155
156	1	/**
157	1	* Depending on the type, returns a standardized type, a constant value of XXX_TYPE.
158		* Note that if the type is a class name, object type is returned.
159		*
160		*
161		* @return string
		0 ignored issues – show Documentation introduced 2015-12-27 22:46 UTC by Report Bug Copy Issue Report Should the return type not be `integer\|string`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
162		*/
163		public function getStandardizedType()
164		{
165		foreach ($this->getStandardizedTypes() as $standardizedType) {
166		if ($this->is($standardizedType)) {
167		return $standardizedType;
168		}
169		}
170		return self::UNKNOWN_TYPE;
171		}
172
173		/**
174		* Indicates if the type is recognized.
175		*
176		* @return bool
177		*/
178		public function isValid()
179		{
180		return !$this->is(self::UNKNOWN_TYPE);
181		}
182
183		/**
184		* Indicates whether the reflected type is void.
185		* Valid values are:
186		* - void
187		*
188		* @return bool
189		*/
190		public function isVoid()
191		{
192		return $this->is(self::VOID_TYPE);
193		}
194
195		/**
196		* Indicates whether the reflected type is mixed.
197		* Valid values are:
198		* - mixed
199		*
200		* @return bool
201		*/
202		public function isMixed()
203		{
204		return $this->is(self::MIXED_TYPE);
205		}
206
207		/**
208		* Indicates whether the reflected type is null.
209		* Valid values are:
210		* - null
211		*
212		* @return bool
213		*/
214		public function isNull()
215		{
216		return $this->is(self::NULL_TYPE);
217		}
218
219		/**
220		* Indicates whether the reflected type is boolean.
221		* Valid values are:
222		* - bool
223		* - boolean
224		*
225		* @return bool
226		*/
227		public function isBoolean()
228		{
229		return $this->is(self::BOOLEAN_TYPE);
230		}
231
232		/**
233		* Indicates whether the reflected type is string.
234		* Valid values are:
235		* - string
236		*
237		* @return bool
238		*/
239		public function isString()
240	1	{
241		return $this->is(self::STRING_TYPE);
242	1	}
243
244		/**
245		* Indicates whether the reflected type is integer.
246		* Valid values are
247		* - int
248		* - integer
249		* - long
250		*
251		* @return bool
252		*/
253		public function isInteger()
254	1	{
255		return $this->is(self::INTEGER_TYPE);
256	1	}
257
258		/**
259		* Indicates whether the reflected type is float.
260		* Valid values are
261		* - float
262		* - double
263		* - real
264		*
265		* @return bool
266		*/
267	1	public function isFloat()
268		{
269	1	return $this->is(self::FLOAT_TYPE);
270		}
271
272		/**
273		* Indicates whether the reflected type is number.
274		* Valid values are:
275		* - every value valid for int
276		* - every value valid for float
277		*
278		* @return bool
279		*/
280		public function isNumber()
281		{
282	1	return $this->is(self::NUMBER_TYPE);
283		}
284	1
285		/**
286		* Indicates whether the reflected type is scalar.
287		* Valid values are:
288		* - every value valid for boolean
289		* - every value valid for string
290		* - every value valid for int
291		* - every value valid for float
292		*
293		* @return bool
294		*/
295		public function isScalar()
296		{
297		return $this->is(self::SCALAR_TYPE);
298		}
299
300		/**
301		* Indicates whether the reflected type is array.
302		* Valid values are:
303		* - array
304		* - xxx[]
305		*
306		* @return bool
307		*/
308		public function isArray()
309		{
310		return $this->is(self::ARRAY_TYPE);
311		}
312
313		/**
314		* Indicates whether the reflected type is object.
315		* Valid values are:
316		* - object
317		* - valid class name
318		*
319		* @return bool
320		*/
321		public function isObject()
322		{
323		return $this->is(self::OBJECT_TYPE);
324		}
325
326		/**
327		* Indicates whether the reflected type is resource.
328		* Valid values are:
329		* - resource
330		*
331	5	* @return bool
332		*/
333	5	public function isResource()
334	1	{
335		return $this->is(self::RESOURCE_TYPE);
336	5	}
337	1
338		/**
339	5	* Indicates whether the reflected type is callable.
340		* Valid values are:
341		* - callable
342		*
343		* @return bool
344		*/
345		public function isCallable()
346		{
347	5	return $this->is(self::CALLABLE_TYPE);
348		}
349	5
350	5	/**
351		* Indicates whether the reflected type is $standardizedType.
352		*
353		* @param string $standardizedType see specific const.
354		* @return bool
355		*/
356		public function is($standardizedType)
357	5	{
358		if ($standardizedType === self::OBJECT_TYPE && class_exists($this->getType(), $this->isAutoloadEnabled())) {
359	5	return true;
360		}
361		if ($standardizedType === self::ARRAY_TYPE && stripos($this->getType(), '[]') !== false) {
362		return true;
363		}
364		return $this->isInTypeMapping($standardizedType);
365		}
366
367		/**
368	5	* Setter of $type.
369		*
370	5	* @param string $type
371		*/
372		private function setType($type)
373		{
374		$this->type = (string)$type;
375		}
376
377		/**
378		* Getter of $typeMappingList.
379	5	*
380		* @return array
381	5	*/
382		private function getTypeMappingList()
383		{
384		return $this->typeMappingList;
385		}
386
387		/**
388		* Returns a type mapping.
389	1	*
390		* @param string $standardizeType
391	1	* @return array
392		*/
393		private function getTypeMapping($standardizeType = '')
394		{
395		return $this->getTypeMappingList()[$standardizeType];
396		}
397
398		/**
399		* Indicates whether self::$type is a possible type of $standardizedType.
400		*
401		* @param string $standardizedType
402		* @return bool
403		*/
404		private function isInTypeMapping($standardizedType)
405		{
406		return in_array(strtolower($this->getType()), $this->getTypeMapping($standardizedType), true);
407		}
408
409		/**
410		* get the possible types.
411		*
412		* @return array
		0 ignored issues – show Documentation introduced 2015-12-27 22:46 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `array<integer\|string>`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
413		*/
414		private function getStandardizedTypes()
415		{
416		return array_keys($this->getTypeMappingList());
417		}
418		}
419

Raphhh / trex-reflection

GitHub Access Token became invalid

Branch — master (7d01f1)

TypeReflection::isString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like