TypeParanoia::IsThingStrings() - Code Metrics - Inspection of "Merge branch 'master' into php7.3" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — php7.3 ( a4fbeb...9ddd99 )

by SignpostMarv

created 2019-01-10 09:15 UTC

TypeParanoia::IsThingStrings() A

↳ Parent: TypeParanoia

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject;

use InvalidArgumentException;

class TypeParanoia
{
    const INDEX_FIRST_ARG = 1;

    const INDEX_SECOND_ARG = 2;

    const BOOL_VAR_EXPORT_RETURN = true;

    /**
    * @param mixed $needle
    * @param mixed $haystack
    */
    public static function MaybeInMaybeArray($needle, $haystack) : bool
    {
        $haystack = self::EnsureArgumentIsArray($haystack, self::INDEX_SECOND_ARG, __METHOD__);

        return static::MaybeInArray($needle, $haystack);
    }

    /**
    * @param mixed $needle
    */
    public static function MaybeInArray($needle, array $haystack) : bool
    {
        return in_array($needle, $haystack, true);
    }

    /**
    * @param mixed $maybe
    */
    public static function EnsureArgumentIsArray($maybe, int $argument = null, string $method = __METHOD__) : array
    {
        if ( ! is_array($maybe)) {
            throw new InvalidArgumentException(
                'Argument ' .
                (is_int($argument) ? $argument : self::INDEX_FIRST_ARG) .
                ' passed to ' .
                $method .
                ' must be an array, ' .
                (is_object($maybe) ? get_class($maybe) : gettype($maybe)) .
                ' given!'
            );
        }

        return $maybe;
    }

    /**
    * @param mixed $maybe
    */
    public static function ForceArgumentAsArray($maybe) : array
    {
        return is_array($maybe) ? $maybe : [$maybe];
    }

    /**
    * @param mixed $maybe
    */
    public static function VarExportNonScalars($maybe) : string
    {
        if (is_string($maybe)) {
            return $maybe;
        }

        return
            is_scalar($maybe)
                ? (string) $maybe
                : var_export($maybe, self::BOOL_VAR_EXPORT_RETURN);
    }

    /**
    * @param mixed $maybe
    */
    public static function EnsureArgumentIsString($maybe) : string
    {
        if ( ! is_string($maybe)) {
            throw new InvalidArgumentException(
                'Argument 1 passed to ' .
                __METHOD__ .
                ' must be a string, ' .
                (is_object($maybe) ? get_class($maybe) : gettype($maybe)) .
                ' given!'
            );
        }

        return $maybe;
    }

    public static function IsThingStrings(string $maybe, string $thing) : bool
    {
        return is_a($maybe, $thing, true);
    }

    public static function IsSubThingStrings(string $maybe, string $thing) : bool
    {
        return is_subclass_of($maybe, $thing, true);
    }

    /**
    * @param mixed $value
    *
    * @return array<int, mixed> filtered $value
    */
    public static function MaybeThrowIfValueDoesNotMatchMultiTypedArray(
        bool $autoTrimStrings,
        bool $throwIfNotUnique,
        $value,
        string ...$types
    ) : array {
        if ( ! is_array($value)) {
            throw new InvalidArgumentException(
                'Argument 3 passed to ' .
                __METHOD__ .
                ' must be an array, ' .
                (is_object($value) ? get_class($value) : gettype($value)) .
                ' given!'
            );
        }

        return static::MaybeThrowIfValueDoesNotMatchMultiTypedArrayValueArray(
            $autoTrimStrings,
            $throwIfNotUnique,
            $value,
            ...$types
        );
    }

    /**
    * @return array<int, mixed> filtered $value
    */
    private static function MaybeThrowIfValueDoesNotMatchMultiTypedArrayValueArray(
        bool $autoTrimStrings,
        bool $throwIfNotUnique,
        array $value,
        string ...$types
    ) : array {
        $value = static::MaybeThrowIfNotArrayIntKeys($value);
        $value = static::MaybeThrowIfValueArrayDoesNotMatchTypes($value, ...$types);
        $value = static::MaybeRemapStringsToTrimmedStrings($value, $autoTrimStrings, ...$types);

        $initialCount = count($value);

        $value = array_unique($value, SORT_REGULAR);

        if ($throwIfNotUnique && count($value) !== $initialCount) {
            throw new InvalidArgumentException(
                'Argument 3 passed to ' .
                __METHOD__ .
                ' contained non-unique values!'
            );
        }

        return array_values($value);
    }

    /**
    * @return array<int, mixed> filtered $value
    */
    private static function MaybeThrowIfNotArrayIntKeys(array $value) : array
    {
        $initialCount = count($value);

        /**
        * @var array<int, mixed>
        */
        $value = array_filter($value, 'is_int', ARRAY_FILTER_USE_KEY);

        if (count($value) !== $initialCount) {
            throw new InvalidArgumentException(
                'Argument 3 passed to ' .
                __METHOD__ .
                ' must be array<int, mixed>'
            );
        }

        return $value;
    }

    /**
    * @param array<int, mixed> $value
    *
    * @return array<int, mixed> filtered $value
    */
    private static function MaybeThrowIfValueArrayDoesNotMatchTypes(
        array $value,
        string ...$types
    ) : array {
        $initialCount = count($value);

        $value = array_filter(
            $value,
            /**
            * @param mixed $maybe
            */
            function ($maybe) use ($types) : bool {
                if (is_object($maybe)) {
                    foreach ($types as $maybeType) {
                        if (is_a($maybe, $maybeType)) {
                            return true;
                        }
                    }

                    return false;
                }

                return TypeParanoia::MaybeInArray(gettype($maybe), $types);
            }
        );

        if (count($value) !== $initialCount) {
            throw new InvalidArgumentException(
                'Argument 3 passed to ' .
                __METHOD__ .
                ' contained values that did not match the provided types!'
            );
        }

        return $value;
    }

    /**
    * @param array<int, mixed> $value
    *
    * @return array<int, mixed>
    */
    private static function MaybeRemapStringsToTrimmedStrings(
        array $value,
        bool $autoTrimStrings,
        string ...$types
    ) : array {
        if (TypeParanoia::MaybeInArray('string', $types) && $autoTrimStrings) {
            $value = array_map(
                /**
                * @param mixed $maybe
                *
                * @return mixed
                */
                function ($maybe) {
                    return is_string($maybe) ? trim($maybe) : $maybe;
                },
                $value
            );
        }

        return $value;
    }
}


1			<?php
2			/**
3			* @author SignpostMarv
4			*/
5			declare(strict_types=1);
6
7			namespace SignpostMarv\DaftObject;
8
9			use InvalidArgumentException;
10
11			class TypeParanoia
12			{
13			const INDEX_FIRST_ARG = 1;
14
15			const INDEX_SECOND_ARG = 2;
16
17			const BOOL_VAR_EXPORT_RETURN = true;
18
19			/**
20			* @param mixed $needle
21			* @param mixed $haystack
22			*/
23			public static function MaybeInMaybeArray($needle, $haystack) : bool
24			{
25			$haystack = self::EnsureArgumentIsArray($haystack, self::INDEX_SECOND_ARG, __METHOD__);
26
27			return static::MaybeInArray($needle, $haystack);
28			}
29
30			/**
31			* @param mixed $needle
32			*/
33			public static function MaybeInArray($needle, array $haystack) : bool
34			{
35			return in_array($needle, $haystack, true);
36			}
37
38			/**
39			* @param mixed $maybe
40			*/
41			public static function EnsureArgumentIsArray($maybe, int $argument = null, string $method = __METHOD__) : array
42			{
43			if ( ! is_array($maybe)) {
44			throw new InvalidArgumentException(
45			'Argument ' .
46			(is_int($argument) ? $argument : self::INDEX_FIRST_ARG) .
47			' passed to ' .
48			$method .
49			' must be an array, ' .
50			(is_object($maybe) ? get_class($maybe) : gettype($maybe)) .
51			' given!'
52			);
53			}
54
55			return $maybe;
56			}
57
58			/**
59			* @param mixed $maybe
60			*/
61			public static function ForceArgumentAsArray($maybe) : array
62			{
63			return is_array($maybe) ? $maybe : [$maybe];
64			}
65
66			/**
67			* @param mixed $maybe
68			*/
69			public static function VarExportNonScalars($maybe) : string
70			{
71			if (is_string($maybe)) {
72			return $maybe;
73			}
74
75			return
76			is_scalar($maybe)
77			? (string) $maybe
78			: var_export($maybe, self::BOOL_VAR_EXPORT_RETURN);
79			}
80
81			/**
82			* @param mixed $maybe
83			*/
84			public static function EnsureArgumentIsString($maybe) : string
85			{
86			if ( ! is_string($maybe)) {
87			throw new InvalidArgumentException(
88			'Argument 1 passed to ' .
89			__METHOD__ .
90			' must be a string, ' .
91			(is_object($maybe) ? get_class($maybe) : gettype($maybe)) .
92			' given!'
93			);
94			}
95
96			return $maybe;
97			}
98
99			public static function IsThingStrings(string $maybe, string $thing) : bool
100			{
101			return is_a($maybe, $thing, true);
102			}
103
104			public static function IsSubThingStrings(string $maybe, string $thing) : bool
105			{
106			return is_subclass_of($maybe, $thing, true);
107			}
108
109			/**
110			* @param mixed $value
111			*
112			* @return array<int, mixed> filtered $value
113			*/
114			public static function MaybeThrowIfValueDoesNotMatchMultiTypedArray(
115			bool $autoTrimStrings,
116			bool $throwIfNotUnique,
117			$value,
118			string ...$types
119			) : array {
120			if ( ! is_array($value)) {
121			throw new InvalidArgumentException(
122			'Argument 3 passed to ' .
123			__METHOD__ .
124			' must be an array, ' .
125			(is_object($value) ? get_class($value) : gettype($value)) .
126			' given!'
127			);
128			}
129
130			return static::MaybeThrowIfValueDoesNotMatchMultiTypedArrayValueArray(
131			$autoTrimStrings,
132			$throwIfNotUnique,
133			$value,
134			...$types
135			);
136			}
137
138			/**
139			* @return array<int, mixed> filtered $value
140			*/
141			private static function MaybeThrowIfValueDoesNotMatchMultiTypedArrayValueArray(
142			bool $autoTrimStrings,
143			bool $throwIfNotUnique,
144			array $value,
145			string ...$types
146			) : array {
147			$value = static::MaybeThrowIfNotArrayIntKeys($value);
148			$value = static::MaybeThrowIfValueArrayDoesNotMatchTypes($value, ...$types);
149			$value = static::MaybeRemapStringsToTrimmedStrings($value, $autoTrimStrings, ...$types);
150
151			$initialCount = count($value);
152
153			$value = array_unique($value, SORT_REGULAR);
154
155			if ($throwIfNotUnique && count($value) !== $initialCount) {
156			throw new InvalidArgumentException(
157			'Argument 3 passed to ' .
158			__METHOD__ .
159			' contained non-unique values!'
160			);
161			}
162
163			return array_values($value);
164			}
165
166			/**
167			* @return array<int, mixed> filtered $value
168			*/
169			private static function MaybeThrowIfNotArrayIntKeys(array $value) : array
170			{
171			$initialCount = count($value);
172
173			/**
174			* @var array<int, mixed>
175			*/
176			$value = array_filter($value, 'is_int', ARRAY_FILTER_USE_KEY);
177
178			if (count($value) !== $initialCount) {
179			throw new InvalidArgumentException(
180			'Argument 3 passed to ' .
181			__METHOD__ .
182			' must be array<int, mixed>'
183			);
184			}
185
186			return $value;
187			}
188
189			/**
190			* @param array<int, mixed> $value
191			*
192			* @return array<int, mixed> filtered $value
193			*/
194			private static function MaybeThrowIfValueArrayDoesNotMatchTypes(
195			array $value,
196			string ...$types
197			) : array {
198			$initialCount = count($value);
199
200			$value = array_filter(
201			$value,
202			/**
203			* @param mixed $maybe
204			*/
205			function ($maybe) use ($types) : bool {
206			if (is_object($maybe)) {
207			foreach ($types as $maybeType) {
208			if (is_a($maybe, $maybeType)) {
209			return true;
210			}
211			}
212
213			return false;
214			}
215
216			return TypeParanoia::MaybeInArray(gettype($maybe), $types);
217			}
218			);
219
220			if (count($value) !== $initialCount) {
221			throw new InvalidArgumentException(
222			'Argument 3 passed to ' .
223			__METHOD__ .
224			' contained values that did not match the provided types!'
225			);
226			}
227
228			return $value;
229			}
230
231			/**
232			* @param array<int, mixed> $value
233			*
234			* @return array<int, mixed>
235			*/
236			private static function MaybeRemapStringsToTrimmedStrings(
237			array $value,
238			bool $autoTrimStrings,
239			string ...$types
240			) : array {
241			if (TypeParanoia::MaybeInArray('string', $types) && $autoTrimStrings) {
242			$value = array_map(
243			/**
244			* @param mixed $maybe
245			*
246			* @return mixed
247			*/
248			function ($maybe) {
249			return is_string($maybe) ? trim($maybe) : $maybe;
250			},
251			$value
252			);
253			}
254
255			return $value;
256			}
257			}
258

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — php7.3 ( a4fbeb...9ddd99 )

TypeParanoia::IsThingStrings() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like