remove() - Code Metrics - Inspection of "range, reject, remove function (#21)" - aerophant/ramda - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 74f423...06a480 )

by Siwapun

created 2018-07-01 10:34 UTC

remove() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
ccs	5
cts	5
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);
}

/**
 * @param mixed $firstValue
 * @param mixed $secondValue
 * @return array|\Closure
 */
function pair()
{
  $pair = function ($firstValue, $secondValue) {
    return [$firstValue, $secondValue];
  };
  $arguments = func_get_args();
  $curried = curryN($pair, 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);
}

/**
 * Returns a list of numbers from from (inclusive) to to (inclusive).
 * @param int|float|double $from
 * @param int|float|double $to
 * @return array|\Closure
 */
function range()
{
  $arguments = func_get_args();
  $curriedAny = curryN('range', 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);
}

/**
 * @param callable $predicate
 * @param array $array
 * @return array|\Closure
 */
function reject()
{
  $reject = function ($predicate, array $array) {
    return array_values(array_filter($array, compose(not(), $predicate)));
  };
  $arguments = func_get_args();
  $curried = curryN($reject, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * @param callable $predicate
 * @param array $array
 * @return array|\Closure
 */
function rejectPreserveKey()
{
  $reject = function ($predicate, array $array) {
    return array_filter($array, compose(not(), $predicate));
  };
  $arguments = func_get_args();
  $curried = curryN($reject, 2);
  return call_user_func_array($curried, $arguments);
}

/**
 * Number → Number → [a] → [a]
 * @param int $start
 * @param int $count
 * @param array $array
 * @return mixed
 */
function remove()
{
  $remove = function (int $start, int $count, array $array) {
    return array_merge(array_slice($array, 0, $start), array_slice($array, $start + $count));
  };
  $arguments = func_get_args();
  $curried = curryN($remove, 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	11	return array_merge(array_slice($array, 0, $index), array_slice($array, $index + 1));
122	11	};
123	11	$arguments = func_get_args();
124	11	$curried = curryN($drop, 2);
125	11	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		* @param mixed $firstValue
349		* @param mixed $secondValue
350		* @return array\|\Closure
351		*/
352		function pair()
353		{
354		$pair = function ($firstValue, $secondValue) {
355	1	return [$firstValue, $secondValue];
356	1	};
357	1	$arguments = func_get_args();
358	1	$curried = curryN($pair, 2);
359	1	return call_user_func_array($curried, $arguments);
360		}
361
362		/**
363		* a → [a] → [a]
364		* @param mixed $item
365		* @param array $array
366		* @return array\|\Closure
367		*/
368		function prepend()
369		{
370		$prepend = function ($item, array $array) {
371	2	return array_merge([$item], $array);
372	2	};
373	2	$arguments = func_get_args();
374	2	$curriedAny = curryN($prepend, 2);
375	2	return call_user_func_array($curriedAny, $arguments);
376		}
377
378		/**
379		* Returns a list of numbers from from (inclusive) to to (inclusive).
380		* @param int\|float\|double $from
381		* @param int\|float\|double $to
382		* @return array\|\Closure
383		*/
384		function range()
385		{
386	2	$arguments = func_get_args();
387	2	$curriedAny = curryN('range', 2);
388	2	return call_user_func_array($curriedAny, $arguments);
389		}
390
391		/**
392		* @param callable $accumulator
393		* @param mixed $initialValue
394		* @param array $array
395		* @return mixed
396		*/
397		function reduce()
398		{
399		$reduce = function (callable $accumulator, $initialValue, array $array) {
400	12	return array_reduce($array, $accumulator, $initialValue);
401	12	};
402	12	$arguments = func_get_args();
403	12	$curried = curryN($reduce, 3);
404	12	return call_user_func_array($curried, $arguments);
405		}
406
407		/**
408		* @param callable $predicate
409		* @param array $array
410		* @return array\|\Closure
411		*/
412		function reject()
413		{
414		$reject = function ($predicate, array $array) {
415	1	return array_values(array_filter($array, compose(not(), $predicate)));
416	1	};
417	1	$arguments = func_get_args();
418	1	$curried = curryN($reject, 2);
419	1	return call_user_func_array($curried, $arguments);
420		}
421
422		/**
423		* @param callable $predicate
424		* @param array $array
425		* @return array\|\Closure
426		*/
427		function rejectPreserveKey()
428		{
429		$reject = function ($predicate, array $array) {
430	1	return array_filter($array, compose(not(), $predicate));
431	1	};
432	1	$arguments = func_get_args();
433	1	$curried = curryN($reject, 2);
434	1	return call_user_func_array($curried, $arguments);
435		}
436
437		/**
438		* Number → Number → [a] → [a]
439		* @param int $start
440		* @param int $count
441		* @param array $array
442		* @return mixed
443		*/
444		function remove()
445		{
446		$remove = function (int $start, int $count, array $array) {
447	1	return array_merge(array_slice($array, 0, $start), array_slice($array, $start + $count));
448	1	};
449	1	$arguments = func_get_args();
450	1	$curried = curryN($remove, 3);
451	1	return call_user_func_array($curried, $arguments);
452		}
453
454		function tail()
455		{
456		$tail = function (array $array) {
457	2	if (empty($array)) {
458	1	return null;
459		}
460	1	return $array[count($array) - 1];
461	2	};
462	2	$arguments = func_get_args();
463	2	$curried = curryN($tail, 1);
464	2	return call_user_func_array($curried, $arguments);
465		}
466

aerophant / ramda

Push — master ( 74f423...06a480 )

remove() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like