Helper::convertStringToArray() - Code Metrics - Inspection of "finish up for release" - pryley/site-reviews - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6375bf...7ef419 )

by Paul

created 2018-09-12 15:07 UTC

Helper::convertStringToArray() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2.032

Importance

Changes

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

<?php

namespace GeminiLabs\SiteReviews;

use GeminiLabs\SiteReviews\Database\Cache;
use Vectorface\Whip\Whip;

class Helper
{
	/**
	 * @param string $name
	 * @param string $path
	 * @return string
	 */
	public function buildClassName( $name, $path = '' )
	{
		$className = $this->camelCase( $name );
		$path = ltrim( str_replace( __NAMESPACE__, '', $path ), '\\' );
		return !empty( $path )
			? __NAMESPACE__.'\\'.$path.'\\'.$className
			: $className;
	}

	/**
	 * @param string $name
	 * @param string $prefix
	 * @return string
	 */
	public function buildMethodName( $name, $prefix = '' )
	{
		return lcfirst( $prefix.$this->buildClassName( $name ));
	}

	/**
	 * @param string $name
	 * @return string
	 */
	public function buildPropertyName( $name )
	{
		return lcfirst( $this->buildClassName( $name ));
	}

	/**
	 * @param string $string
	 * @return string
	 */
	public function camelCase( $string )
	{
		$string = ucwords( str_replace( ['-', '_'], ' ', trim( $string )));
		return str_replace( ' ', '', $string );
	}

	/**
	 * @return bool
	 */
	public function compareArrays( array $arr1, array $arr2 )
	{
		sort( $arr1 );
		sort( $arr2 );
		return $arr1 == $arr2;
	}

	/**
	 * @return array
	 */
	public function convertDotNotationArray( array $array )
	{
		$results = [];
		foreach( $array as $path => $value ) {
			$results = $this->setPathValue( $path, $value, $results );
		}
		return $results;
	}

	/**
	 * @param string $name
	 * @return string
	 */
	public function convertPathToId( $path, $prefix = '' )
	{
		return str_replace( ['[', ']'], ['-', ''], $this->convertPathToName( $path, $prefix ));
	}

	/**
	 * @param string $path
	 * @return string
	 */
	public function convertPathToName( $path, $prefix = '' )
	{
		$levels = explode( '.', $path );
		return array_reduce( $levels, function( $result, $value ) {
			return $result.= '['.$value.']';
		}, $prefix );
	}

	/**
	 * @param string $string
	 * @param mixed $callback
	 * @return array
	 */
	public function convertStringToArray( $string, $callback = null )
	{
		$array = array_map( 'trim', explode( ',', $string ));
		return $callback
			? array_filter( $array, $callback )
			: array_filter( $array );
	}

	/**
	 * @param string $string
	 * @return string
	 */
	public function dashCase( $string )
	{
		return str_replace( '_', '-', $this->snakeCase( $string ));
	}

	/**
	 * @param string $needle
	 * @param string $haystack
	 * @return bool
	 */
	public function endsWith( $needle, $haystack )
	{
		$length = strlen( $needle );
		return $length != 0
			? substr( $haystack, -$length ) === $needle
			: true;
	}

	/**
	 * @param string $key
	 * @return mixed
	 */
	public function filterInput( $key, array $request = [] )
	{
		if( isset( $request[$key] )) {
			return $request[$key];
		}
		$variable = filter_input( INPUT_POST, $key );
		if( is_null( $variable ) && isset( $_POST[$key] )) {
			$variable = $_POST[$key];
		}
		return $variable;
	}

	/**
	 * @param string $key
	 * @return array
	 */
	public function filterInputArray( $key )
	{
		$variable = filter_input( INPUT_POST, $key, FILTER_DEFAULT, FILTER_REQUIRE_ARRAY );
		if( empty( $variable ) && !empty( $_POST[$key] ) && is_array( $_POST[$key] )) {
			$variable = $_POST[$key];
		}
		return (array)$variable;
	}

	/**
	 * @param bool $flattenValue
	 * @param string $prefix
	 * @return array
	 */
	public function flattenArray( array $array, $flattenValue = false, $prefix = '' )
	{
		$result = [];
		foreach( $array as $key => $value ) {
			$newKey = ltrim( $prefix.'.'.$key, '.' );
			if( $this->isIndexedFlatArray( $value )) {
				if( $flattenValue ) {
					$value = '['.implode( ', ', $value ).']';
				}
			}
			else if( is_array( $value )) {
				$result = array_merge( $result, $this->flattenArray( $value, $flattenValue, $newKey ));
				continue;
			}
			$result[$newKey] = $value;
		}
		return $result;
	}

	/**
	 * @return string
	 */
	public function getIpAddress()
	{
		$cloudflareIps = glsr( Cache::class )->getCloudflareIps();
		return (string)(new Whip( Whip::CLOUDFLARE_HEADERS | Whip::REMOTE_ADDR, [
			Whip::CLOUDFLARE_HEADERS => [
				Whip::IPV4 => $cloudflareIps['v4'],
				Whip::IPV6 => $cloudflareIps['v6'],
			],
		]))->getValidIpAddress();
	}

	/**
	 * Get a value from an array of values using a dot-notation path as reference
	 * @param string $path
	 * @param mixed $fallback
	 * @return void|mixed
	 */
	public function getPathValue( $path = '', array $values, $fallback = '' )
	{
		$keys = explode( '.', $path );
		foreach( $keys as $key ) {
			if( !isset( $values[$key] )) {
				return $fallback;
			}
			$values = $values[$key];
		}
		return $values;
	}

	/**
	 * @param mixed $array
	 * @return bool
	 */
	public function isIndexedArray( $array )
	{
		if( !is_array( $array )) {
			return false;
		}
		$current = 0;
		foreach( array_keys( $array ) as $key ) {
			if( $key !== $current ) {
				return false;
			}
			$current++;
		}
		return true;
	}

	/**
	 * @param mixed $array
	 * @return bool
	 */
	public function isIndexedFlatArray( $array )
	{
		if( !is_array( $array ) || array_filter( $array, 'is_array' )) {
			return false;
		}
		return $this->isIndexedArray( $array );
	}

	/**
	 * @param string $string
	 * @param string $prefix
	 * @return string
	 */
	public function prefixString( $string, $prefix = '' )
	{
		return $prefix.str_replace( $prefix, '', trim( $string ));
	}

	/**
	 * @return array
	 */
	public function removeEmptyArrayValues( array $array )
	{
		$result = [];
		foreach( $array as $key => $value ) {
			if( !$value )continue;
			$result[$key] = is_array( $value )
				? $this->removeEmptyArrayValues( $value )
				: $value;
		}
		return $result;
	}

	/**
	 * Set a value to an array of values using a dot-notation path as reference
	 * @param string $path
	 * @param mixed $value
	 * @return array
	 */
	public function setPathValue( $path, $value, array $values )
	{
		$token = strtok( $path, '.' );
		$ref = &$values;
		while( $token !== false ) {
			$ref = is_array( $ref )
				? $ref
				: [];
			$ref = &$ref[$token];
			$token = strtok( '.' );
		}
		$ref = $value;
		return $values;
	}

	/**
	 * @param string $string
	 * @return string
	 */
	public function snakeCase( $string )
	{
		if( !ctype_lower( $string )) {
			$string = preg_replace( '/\s+/u', '', $string );
			$string = preg_replace( '/(.)(?=[A-Z])/u', '$1_', $string );
			$string = mb_strtolower( $string, 'UTF-8' );
		}
		return str_replace( '-', '_', $string );
	}

	/**
	 * @param string $needle
	 * @param string $haystack
	 * @return bool
	 */
	public function startsWith( $needle, $haystack )
	{
		return substr( $haystack, 0, strlen( $needle )) === $needle;
	}
}


1		<?php
2
3		namespace GeminiLabs\SiteReviews;
4
5		use GeminiLabs\SiteReviews\Database\Cache;
6		use Vectorface\Whip\Whip;
7
8		class Helper
9		{
10		/**
11		* @param string $name
12		* @param string $path
13		* @return string
14		*/
15	4	public function buildClassName( $name, $path = '' )
16		{
17	4	$className = $this->camelCase( $name );
18	4	$path = ltrim( str_replace( __NAMESPACE__, '', $path ), '\\' );
19	4	return !empty( $path )
20	2	? __NAMESPACE__.'\\'.$path.'\\'.$className
21	4	: $className;
22		}
23
24		/**
25		* @param string $name
26		* @param string $prefix
27		* @return string
28		*/
29	2	public function buildMethodName( $name, $prefix = '' )
30		{
31	2	return lcfirst( $prefix.$this->buildClassName( $name ));
32		}
33
34		/**
35		* @param string $name
36		* @return string
37		*/
38	1	public function buildPropertyName( $name )
39		{
40	1	return lcfirst( $this->buildClassName( $name ));
41		}
42
43		/**
44		* @param string $string
45		* @return string
46		*/
47	4	public function camelCase( $string )
48		{
49	4	$string = ucwords( str_replace( ['-', '_'], ' ', trim( $string )));
50	4	return str_replace( ' ', '', $string );
51		}
52
53		/**
54		* @return bool
55		*/
56	1	public function compareArrays( array $arr1, array $arr2 )
57		{
58	1	sort( $arr1 );
59	1	sort( $arr2 );
60	1	return $arr1 == $arr2;
61		}
62
63		/**
64		* @return array
65		*/
66	8	public function convertDotNotationArray( array $array )
67		{
68	8	$results = [];
69	8	foreach( $array as $path => $value ) {
70	8	$results = $this->setPathValue( $path, $value, $results );
71		}
72	8	return $results;
73		}
74
75		/**
76		* @param string $name
77		* @return string
78		*/
79	1	public function convertPathToId( $path, $prefix = '' )
80		{
81	1	return str_replace( ['[', ']'], ['-', ''], $this->convertPathToName( $path, $prefix ));
82		}
83
84		/**
85		* @param string $path
86		* @return string
87		*/
88	2	public function convertPathToName( $path, $prefix = '' )
89		{
90	2	$levels = explode( '.', $path );
91	2	return array_reduce( $levels, function( $result, $value ) {
92	2	return $result.= '['.$value.']';
93	2	}, $prefix );
94		}
95
96		/**
97		* @param string $string
98		* @param mixed $callback
99		* @return array
100		*/
101	1	public function convertStringToArray( $string, $callback = null )
102		{
103	1	$array = array_map( 'trim', explode( ',', $string ));
104	1	return $callback
105		? array_filter( $array, $callback )
106	1	: array_filter( $array );
107		}
108
109		/**
110		* @param string $string
111		* @return string
112		*/
113	8	public function dashCase( $string )
114		{
115	8	return str_replace( '_', '-', $this->snakeCase( $string ));
116		}
117
118		/**
119		* @param string $needle
120		* @param string $haystack
121		* @return bool
122		*/
123	1	public function endsWith( $needle, $haystack )
124		{
125	1	$length = strlen( $needle );
126	1	return $length != 0
127	1	? substr( $haystack, -$length ) === $needle
128	1	: true;
129		}
130
131		/**
132		* @param string $key
133		* @return mixed
134		*/
135	2	public function filterInput( $key, array $request = [] )
136		{
137	2	if( isset( $request[$key] )) {
138	1	return $request[$key];
139		}
140	2	$variable = filter_input( INPUT_POST, $key );
141	2	if( is_null( $variable ) && isset( $_POST[$key] )) {
142	2	$variable = $_POST[$key];
143		}
144	2	return $variable;
145		}
146
147		/**
148		* @param string $key
149		* @return array
150		*/
151	2	public function filterInputArray( $key )
152		{
153	2	$variable = filter_input( INPUT_POST, $key, FILTER_DEFAULT, FILTER_REQUIRE_ARRAY );
154	2	if( empty( $variable ) && !empty( $_POST[$key] ) && is_array( $_POST[$key] )) {
155	2	$variable = $_POST[$key];
156		}
157	2	return (array)$variable;
158		}
159
160		/**
161		* @param bool $flattenValue
162		* @param string $prefix
163		* @return array
164		*/
165	1	public function flattenArray( array $array, $flattenValue = false, $prefix = '' )
166		{
167	1	$result = [];
168	1	foreach( $array as $key => $value ) {
169	1	$newKey = ltrim( $prefix.'.'.$key, '.' );
170	1	if( $this->isIndexedFlatArray( $value )) {
171	1	if( $flattenValue ) {
172	1	$value = '['.implode( ', ', $value ).']';
173		}
174		}
175	1	else if( is_array( $value )) {
176	1	$result = array_merge( $result, $this->flattenArray( $value, $flattenValue, $newKey ));
177	1	continue;
178		}
179	1	$result[$newKey] = $value;
180		}
181	1	return $result;
182		}
183
184		/**
185		* @return string
186		*/
187	1	public function getIpAddress()
188		{
189	1	$cloudflareIps = glsr( Cache::class )->getCloudflareIps();
190	1	return (string)(new Whip( Whip::CLOUDFLARE_HEADERS \| Whip::REMOTE_ADDR, [
191	1	Whip::CLOUDFLARE_HEADERS => [
192	1	Whip::IPV4 => $cloudflareIps['v4'],
193	1	Whip::IPV6 => $cloudflareIps['v6'],
194		],
195	1	]))->getValidIpAddress();
196		}
197
198		/**
199		* Get a value from an array of values using a dot-notation path as reference
200		* @param string $path
201		* @param mixed $fallback
202		* @return void\|mixed
203		*/
204	8	public function getPathValue( $path = '', array $values, $fallback = '' )
205		{
206	8	$keys = explode( '.', $path );
207	8	foreach( $keys as $key ) {
208	8	if( !isset( $values[$key] )) {
209	3	return $fallback;
210		}
211	8	$values = $values[$key];
212		}
213	8	return $values;
214		}
215
216		/**
217		* @param mixed $array
218		* @return bool
219		*/
220	3	public function isIndexedArray( $array )
221		{
222	3	if( !is_array( $array )) {
223	1	return false;
224		}
225	3	$current = 0;
226	3	foreach( array_keys( $array ) as $key ) {
227	3	if( $key !== $current ) {
228	1	return false;
229		}
230	3	$current++;
231		}
232	3	return true;
233		}
234
235		/**
236		* @param mixed $array
237		* @return bool
238		*/
239	2	public function isIndexedFlatArray( $array )
240		{
241	2	if( !is_array( $array ) \|\| array_filter( $array, 'is_array' )) {
242	2	return false;
243		}
244	2	return $this->isIndexedArray( $array );
245		}
246
247		/**
248		* @param string $string
249		* @param string $prefix
250		* @return string
251		*/
252	1	public function prefixString( $string, $prefix = '' )
253		{
254	1	return $prefix.str_replace( $prefix, '', trim( $string ));
255		}
256
257		/**
258		* @return array
259		*/
260	8	public function removeEmptyArrayValues( array $array )
261		{
262	8	$result = [];
263	8	foreach( $array as $key => $value ) {
264	8	if( !$value )continue;
265	8	$result[$key] = is_array( $value )
266	7	? $this->removeEmptyArrayValues( $value )
267	8	: $value;
268		}
269	8	return $result;
270		}
271
272		/**
273		* Set a value to an array of values using a dot-notation path as reference
274		* @param string $path
275		* @param mixed $value
276		* @return array
277		*/
278	9	public function setPathValue( $path, $value, array $values )
279		{
280	9	$token = strtok( $path, '.' );
281	9	$ref = &$values;
282	9	while( $token !== false ) {
283	9	$ref = is_array( $ref )
284	9	? $ref
285	9	: [];
286	9	$ref = &$ref[$token];
287	9	$token = strtok( '.' );
288		}
289	9	$ref = $value;
290	9	return $values;
291		}
292
293		/**
294		* @param string $string
295		* @return string
296		*/
297	9	public function snakeCase( $string )
298		{
299	9	if( !ctype_lower( $string )) {
300	9	$string = preg_replace( '/\s+/u', '', $string );
301	9	$string = preg_replace( '/(.)(?=[A-Z])/u', '$1_', $string );
302	9	$string = mb_strtolower( $string, 'UTF-8' );
303		}
304	9	return str_replace( '-', '_', $string );
305		}
306
307		/**
308		* @param string $needle
309		* @param string $haystack
310		* @return bool
311		*/
312	8	public function startsWith( $needle, $haystack )
313		{
314	8	return substr( $haystack, 0, strlen( $needle )) === $needle;
315		}
316		}
317

pryley / site-reviews

Push — master ( 6375bf...7ef419 )

Helper::convertStringToArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like