length() - Code Metrics - Inspection of "join, length and match function (#17)" - aerophant/ramda - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 24a9b5...f93101 )

by Siwapun

created 2018-07-01 01:33 UTC

length() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
ccs	3
cts	3
cp	1
crap	1

<?php
namespace Aerophant\Ramda;

/**
 * @param callable $predicateFunction
 * @param array $array
 * @return mixed
 */
function all()
{
  $all = function (callable $predicateFunction, array $array): bool {
    if (empty($array)) {
      return false;
    }
    foreach ($array as $it) {
      if (!$predicateFunction($it)) {
        return false;
      }
    }
    return true;
  };
  $arguments = func_get_args();
  $curried = curryN($all, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $predicateFunction
 * @param array $array
 * @return bool
 */
function any()
{
  $any = function (callable $predicateFunction, array $array) {
    if (empty($array)) {
      return false;
    }
    foreach ($array as $it) {
      if ($predicateFunction($it)) {
        return true;
      }
    }
    return false;
  };
  $arguments = func_get_args();
  $curriedAny = curryN($any, 2);
  return call_user_func_array($curriedAny, $arguments);
}

/**
 * @param callable $fn he function to invoke. Receives one argument
 * @param array $array The list to iterate over.
 * @return null|\Closure
 */
function arrayForEach()
{
  $arrayForEach = function (callable $fn, array $array) {
    foreach ($array as $item) {
      $fn($item);
    }
  };
  $arguments = func_get_args();
  $curriedAny = curryN($arrayForEach, 2);
  return call_user_func_array($curriedAny, $arguments);
}

/**
 * a → [a] → [a]
 * @param mixed $item
 * @param array $array
 * @return array|\Closure
 */
function append()
{
  $append = function ($item, array $array) {
    return array_merge($array, [$item]);
  };
  $arguments = func_get_args();
  $curriedAny = curryN($append, 2);
  return call_user_func_array($curriedAny, $arguments);
}

/**
 * [a] → [a] → [a]
 * @param mixed $item
 * @param array $array
 * @return array|\Closure
 */
function concat()
{
  $concat = function (array $firstArray, array $secondArray) {
    return array_merge($firstArray, $secondArray);
  };
  $arguments = func_get_args();
  $curriedAny = curryN($concat, 2);
  return call_user_func_array($curriedAny, $arguments);
}

/**
 * a → [a] → Boolean
 * @param mixed $item item to compare against
 * @param array $array The array to consider
 * @return boolean|\Closure
 */
function contains()
{
  $contains = partialRight('in_array', [true]);
  $arguments = func_get_args();
  $curriedAny = curryN($contains, 2);
  return call_user_func_array($curriedAny, $arguments);
}

/**
 * @param int $index
 * @param array $array
 * @return mixed
 */
function drop()
{
  $drop = function (int $index, array $array) {
    return array_merge(array_slice($array, 0, $index), array_slice($array, $index + 1));
  };
  $arguments = func_get_args();
  $curried = curryN($drop, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param array $array
 * @return mixed
 */
function dropFirst()
{
  $dropFirst = drop(0);
  $arguments = func_get_args();
  $curried = curryN($dropFirst, 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param array $array
 * @return mixed
 */
function dropLast()
{
  $dropLast = function (array $array) {
    $index = count($array)-1;
    return array_merge(array_slice($array, 0, $index), array_slice($array, $index + 1));
  };

  $arguments = func_get_args();
  $curried = curryN($dropLast, 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param string|array $suffix
 * @param string|array $list
 * @return boolean|\Closure
 */
function endsWith()
{
  $endsWith = function ($suffix, $list) {
    if (is_string($suffix) && is_string($list)) {
      return $suffix === '' || (($temp = strlen($list) - strlen($suffix)) >= 0 && strpos($list, $suffix) !== false);

    }
    if (is_array($suffix) && is_array($list)) {
      $index = count($list) - count($suffix);
      foreach ($suffix as $it) {
        if ($it != $list[$index]) {
          return false;
        }
        $index++;
      }
      return true;
    }
    throw new \InvalidArgumentException(__FUNCTION__ . 'accepts only string or array as it arguments');
  };
  $arguments = func_get_args();
  $curried = curryN($endsWith, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $predicateFunction
 * @param array $array
 * @return mixed
 */
function filter()
{
  $filter = function (callable $predicateFunction, array $array) {
     return array_values(array_filter($array, $predicateFunction));
  };
  $arguments = func_get_args();
  $curried = curryN($filter, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $predicateFunction
 * @param array $array
 * @return mixed
 */
function filterPreserveKey()
{
  $filter = function (callable $predicateFunction, array $array) {
    return array_filter($array, $predicateFunction);
  };
  $arguments = func_get_args();
  $curried = curryN($filter, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $predicateFunction
 * @param array $list
 * @return mixed
 */
function find()
{
  $find = function (callable $predicateFunction, array $list) {
    foreach ($list as $item) {
      if ($predicateFunction($item)) {
        return $item;
      }
    }
    return null;
  };
  $arguments = func_get_args();
  $curried = curryN($find, 2);
  return call_user_func_array($curried, $arguments);
}

function first()
{
  $first = function (array $array) {
    if (empty($array)) {
      return null;
    }
    return $array[0];
  };
  $arguments = func_get_args();
  $curried = curryN($first, 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $keySelector
 * @param array $array
 * @return array
 */
function groupBy()
{
  $groupBy = function (callable $keySelector, array $array) {
    return reduce(
      function ($acc, $item) use ($keySelector) {
        $key = $keySelector($item);
        $acc[$key] = array_key_exists($key, $acc) ? array_merge($acc[$key], [$item]) : [$item];
        return $acc;
      },
      [],
      $array
    );
  };
  $arguments = func_get_args();
  $curried = curryN($groupBy, 2);
  return call_user_func_array($curried, $arguments);
}

function head()
{
  $head = function (array $array) {
    if (empty($array)) {
      return null;
    }
    return $array[0];
  };
  $arguments = func_get_args();
  $curried = curryN($head, 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param int $index
 * @param mixed $element
 * @param array $array
 * @return array|\Closure
 */
function insert()
{
  $insert = function (int $index, $element, array $array) {
    return array_merge(
      array_slice($array, 0, $index),
      [$element],
      array_slice($array, $index)
    );
  };
  $arguments = func_get_args();
  $curried = curryN($insert, 3);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param string $string
 * @param array $array
 * @return string
 */
function join()
{
  $arguments = func_get_args();
  $curried = curryN('implode', 2);
  return call_user_func_array($curried, $arguments);
}

function last()
{
  $last = function (array $array) {
    if (empty($array)) {
      return null;
    }
    return $array[count($array) - 1];
  };
  $arguments = func_get_args();
  $curried = curryN($last, 1);
  return call_user_func_array($curried, $arguments);
}

function length()
{
  $arguments = func_get_args();
  $curried = curryN('count', 1);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $mapper
 * @param array $array
 * @return mixed
 */
function map()
{
  $arguments = func_get_args();
  $curried = curryN('array_map', 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * a → [a] → [a]
 * @param mixed $item
 * @param array $array
 * @return array|\Closure
 */
function prepend()
{
  $prepend = function ($item, array $array) {
    return array_merge([$item], $array);
  };
  $arguments = func_get_args();
  $curriedAny = curryN($prepend, 2);
  return call_user_func_array($curriedAny, $arguments);
}

/**
 * @param callable $accumulator
 * @param mixed $initialValue
 * @param array $array
 * @return mixed
 */
function reduce()
{
  $reduce = function (callable $accumulator, $initialValue, array $array) {
    return array_reduce($array, $accumulator, $initialValue);
  };
  $arguments = func_get_args();
  $curried = curryN($reduce, 3);
  return call_user_func_array($curried, $arguments);
}

function tail()
{
  $tail = function (array $array) {
    if (empty($array)) {
      return null;
    }
    return $array[count($array) - 1];
  };
  $arguments = func_get_args();
  $curried = curryN($tail, 1);
  return call_user_func_array($curried, $arguments);
}


1		<?php
2		namespace Aerophant\Ramda;
3
4		/**
5		* @param callable $predicateFunction
6		* @param array $array
7		* @return mixed
8		*/
9		function all()
10		{
11		$all = function (callable $predicateFunction, array $array): bool {
12	3	if (empty($array)) {
13	1	return false;
14		}
15	2	foreach ($array as $it) {
16	2	if (!$predicateFunction($it)) {
17	2	return false;
18		}
19		}
20	1	return true;
21	3	};
22	3	$arguments = func_get_args();
23	3	$curried = curryN($all, 2);
24	3	return call_user_func_array($curried, $arguments);
25		}
26
27		/**
28		* @param callable $predicateFunction
29		* @param array $array
30		* @return bool
31		*/
32		function any()
33		{
34		$any = function (callable $predicateFunction, array $array) {
35	3	if (empty($array)) {
36	1	return false;
37		}
38	2	foreach ($array as $it) {
39	2	if ($predicateFunction($it)) {
40	2	return true;
41		}
42		}
43	1	return false;
44	3	};
45	3	$arguments = func_get_args();
46	3	$curriedAny = curryN($any, 2);
47	3	return call_user_func_array($curriedAny, $arguments);
48		}
49
50		/**
51		* @param callable $fn he function to invoke. Receives one argument
52		* @param array $array The list to iterate over.
53		* @return null\|\Closure
54		*/
55		function arrayForEach()
56		{
57		$arrayForEach = function (callable $fn, array $array) {
58	1	foreach ($array as $item) {
59	1	$fn($item);
60		}
61	1	};
62	1	$arguments = func_get_args();
63	1	$curriedAny = curryN($arrayForEach, 2);
64	1	return call_user_func_array($curriedAny, $arguments);
65		}
66
67		/**
68		* a → [a] → [a]
69		* @param mixed $item
70		* @param array $array
71		* @return array\|\Closure
72		*/
73		function append()
74		{
75		$append = function ($item, array $array) {
76	2	return array_merge($array, [$item]);
77	2	};
78	2	$arguments = func_get_args();
79	2	$curriedAny = curryN($append, 2);
80	2	return call_user_func_array($curriedAny, $arguments);
81		}
82
83		/**
84		* [a] → [a] → [a]
85		* @param mixed $item
86		* @param array $array
87		* @return array\|\Closure
88		*/
89		function concat()
90		{
91		$concat = function (array $firstArray, array $secondArray) {
92	1	return array_merge($firstArray, $secondArray);
93	1	};
94	1	$arguments = func_get_args();
95	1	$curriedAny = curryN($concat, 2);
96	1	return call_user_func_array($curriedAny, $arguments);
97		}
98
99		/**
100		* a → [a] → Boolean
101		* @param mixed $item item to compare against
102		* @param array $array The array to consider
103		* @return boolean\|\Closure
104		*/
105		function contains()
106		{
107	2	$contains = partialRight('in_array', [true]);
108	2	$arguments = func_get_args();
109	2	$curriedAny = curryN($contains, 2);
110	2	return call_user_func_array($curriedAny, $arguments);
111		}
112
113		/**
114		* @param int $index
115		* @param array $array
116		* @return mixed
117		*/
118		function drop()
119		{
120		$drop = function (int $index, array $array) {
121	9	return array_merge(array_slice($array, 0, $index), array_slice($array, $index + 1));
122	9	};
123	9	$arguments = func_get_args();
124	9	$curried = curryN($drop, 2);
125	9	return call_user_func_array($curried, $arguments);
126		}
127
128		/**
129		* @param array $array
130		* @return mixed
131		*/
132		function dropFirst()
133		{
134	2	$dropFirst = drop(0);
135	2	$arguments = func_get_args();
136	2	$curried = curryN($dropFirst, 1);
137	2	return call_user_func_array($curried, $arguments);
138		}
139
140		/**
141		* @param array $array
142		* @return mixed
143		*/
144		function dropLast()
145		{
146		$dropLast = function (array $array) {
147	1	$index = count($array)-1;
148	1	return array_merge(array_slice($array, 0, $index), array_slice($array, $index + 1));
149	1	};
150
151	1	$arguments = func_get_args();
152	1	$curried = curryN($dropLast, 1);
153	1	return call_user_func_array($curried, $arguments);
154		}
155
156		/**
157		* @param string\|array $suffix
158		* @param string\|array $list
159		* @return boolean\|\Closure
160		*/
161		function endsWith()
162		{
163		$endsWith = function ($suffix, $list) {
164	7	if (is_string($suffix) && is_string($list)) {
165	3	return $suffix === '' \|\| (($temp = strlen($list) - strlen($suffix)) >= 0 && strpos($list, $suffix) !== false);
		0 ignored issues – show Unused Code introduced 2018-06-30 21:43 UTC by Report Bug Copy Issue Report The assignment to `$temp` is dead and can be removed. Loading history...
166		}
167	4	if (is_array($suffix) && is_array($list)) {
168	3	$index = count($list) - count($suffix);
169	3	foreach ($suffix as $it) {
170	2	if ($it != $list[$index]) {
171	1	return false;
172		}
173	1	$index++;
174		}
175	2	return true;
176		}
177	1	throw new \InvalidArgumentException(__FUNCTION__ . 'accepts only string or array as it arguments');
178	7	};
179	7	$arguments = func_get_args();
180	7	$curried = curryN($endsWith, 2);
181	7	return call_user_func_array($curried, $arguments);
182		}
183
184		/**
185		* @param callable $predicateFunction
186		* @param array $array
187		* @return mixed
188		*/
189		function filter()
190		{
191		$filter = function (callable $predicateFunction, array $array) {
192	1	return array_values(array_filter($array, $predicateFunction));
193	1	};
194	1	$arguments = func_get_args();
195	1	$curried = curryN($filter, 2);
196	1	return call_user_func_array($curried, $arguments);
197		}
198
199		/**
200		* @param callable $predicateFunction
201		* @param array $array
202		* @return mixed
203		*/
204		function filterPreserveKey()
205		{
206		$filter = function (callable $predicateFunction, array $array) {
207	1	return array_filter($array, $predicateFunction);
208	1	};
209	1	$arguments = func_get_args();
210	1	$curried = curryN($filter, 2);
211	1	return call_user_func_array($curried, $arguments);
212		}
213
214		/**
215		* @param callable $predicateFunction
216		* @param array $list
217		* @return mixed
218		*/
219		function find()
220		{
221		$find = function (callable $predicateFunction, array $list) {
222	2	foreach ($list as $item) {
223	2	if ($predicateFunction($item)) {
224	2	return $item;
225		}
226		}
227	1	return null;
228	2	};
229	2	$arguments = func_get_args();
230	2	$curried = curryN($find, 2);
231	2	return call_user_func_array($curried, $arguments);
232		}
233
234		function first()
235		{
236		$first = function (array $array) {
237	2	if (empty($array)) {
238	1	return null;
239		}
240	1	return $array[0];
241	2	};
242	2	$arguments = func_get_args();
243	2	$curried = curryN($first, 1);
244	2	return call_user_func_array($curried, $arguments);
245		}
246
247		/**
248		* @param callable $keySelector
249		* @param array $array
250		* @return array
251		*/
252		function groupBy()
253		{
254		$groupBy = function (callable $keySelector, array $array) {
255	1	return reduce(
256		function ($acc, $item) use ($keySelector) {
257	1	$key = $keySelector($item);
258	1	$acc[$key] = array_key_exists($key, $acc) ? array_merge($acc[$key], [$item]) : [$item];
259	1	return $acc;
260	1	},
261	1	[],
262	1	$array
263		);
264	1	};
265	1	$arguments = func_get_args();
266	1	$curried = curryN($groupBy, 2);
267	1	return call_user_func_array($curried, $arguments);
268		}
269
270		function head()
271		{
272		$head = function (array $array) {
273	2	if (empty($array)) {
274	1	return null;
275		}
276	1	return $array[0];
277	2	};
278	2	$arguments = func_get_args();
279	2	$curried = curryN($head, 1);
280	2	return call_user_func_array($curried, $arguments);
281		}
282
283		/**
284		* @param int $index
285		* @param mixed $element
286		* @param array $array
287		* @return array\|\Closure
288		*/
289		function insert()
290		{
291		$insert = function (int $index, $element, array $array) {
292	3	return array_merge(
293	3	array_slice($array, 0, $index),
294	3	[$element],
295	3	array_slice($array, $index)
296		);
297	3	};
298	3	$arguments = func_get_args();
299	3	$curried = curryN($insert, 3);
300	3	return call_user_func_array($curried, $arguments);
301		}
302
303		/**
304		* @param string $string
305		* @param array $array
306		* @return string
307		*/
308		function join()
309		{
310	1	$arguments = func_get_args();
311	1	$curried = curryN('implode', 2);
312	1	return call_user_func_array($curried, $arguments);
313		}
314
315		function last()
316		{
317		$last = function (array $array) {
318	2	if (empty($array)) {
319	1	return null;
320		}
321	1	return $array[count($array) - 1];
322	2	};
323	2	$arguments = func_get_args();
324	2	$curried = curryN($last, 1);
325	2	return call_user_func_array($curried, $arguments);
326		}
327
328		function length()
329		{
330	1	$arguments = func_get_args();
331	1	$curried = curryN('count', 1);
332	1	return call_user_func_array($curried, $arguments);
333		}
334
335		/**
336		* @param callable $mapper
337		* @param array $array
338		* @return mixed
339		*/
340		function map()
341		{
342	1	$arguments = func_get_args();
343	1	$curried = curryN('array_map', 2);
344	1	return call_user_func_array($curried, $arguments);
345		}
346
347		/**
348		* a → [a] → [a]
349		* @param mixed $item
350		* @param array $array
351		* @return array\|\Closure
352		*/
353		function prepend()
354		{
355		$prepend = function ($item, array $array) {
356	2	return array_merge([$item], $array);
357	2	};
358	2	$arguments = func_get_args();
359	2	$curriedAny = curryN($prepend, 2);
360	2	return call_user_func_array($curriedAny, $arguments);
361		}
362
363		/**
364		* @param callable $accumulator
365		* @param mixed $initialValue
366		* @param array $array
367		* @return mixed
368		*/
369		function reduce()
370		{
371		$reduce = function (callable $accumulator, $initialValue, array $array) {
372	2	return array_reduce($array, $accumulator, $initialValue);
373	2	};
374	2	$arguments = func_get_args();
375	2	$curried = curryN($reduce, 3);
376	2	return call_user_func_array($curried, $arguments);
377		}
378
379		function tail()
380		{
381		$tail = function (array $array) {
382	2	if (empty($array)) {
383	1	return null;
384		}
385	1	return $array[count($array) - 1];
386	2	};
387	2	$arguments = func_get_args();
388	2	$curried = curryN($tail, 1);
389	2	return call_user_func_array($curried, $arguments);
390		}
391

aerophant / ramda

Push — master ( 24a9b5...f93101 )

length() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like