first() - Code Metrics - bpolaszek/violin - Measure and Improve Code Quality continuously with Scrutinizer

first() A
last analyzed 2019-05-07 14:43 UTC

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace BenTools\Violin;

/**
 * @param $str
 * @return Violin
 * @throws \InvalidArgumentException
 */
function string($str): Violin
{
    return Violin::tune($str);
}

/**
 * @param $str
 * @return bool
 */
function is_stringable($str): bool
{
    return Violin::isStringable($str);
}

/**
 * @param $str
 * @return bool
 * @throws \InvalidArgumentException
 */
function is_empty($str): bool
{
    return string($str)->isEmpty();
}

/**
 * @param $str
 * @return bool
 * @throws \InvalidArgumentException
 */
function is_blank($str): bool
{
    return string($str)->isBlank();
}

/**
 * @param $str
 * @return string
 * @throws \InvalidArgumentException
 */
function strtoupper($str): string
{
    return (string) string($str)->toUpperCase();
}

/**
 * @param $str
 * @return string
 * @throws \InvalidArgumentException
 */
function strtolower($str): string
{
    return (string) string($str)->toLowerCase();
}

/**
 * @param          $str
 * @param int      $start
 * @param int|null $length
 * @return string
 * @throws \InvalidArgumentException
 */
function substr($str, int $start, int $length = null): string
{
    return (string) string($str)->substr($start, $length);
}

/**
 * @param      $str
 * @param      $separator
 * @param bool $include
 * @return null|string
 * @throws \InvalidArgumentException
 */
function substring_after_first($str, $separator, bool $include = false): ?string
{
    return (string) string($str)->substringAfterFirst($separator, $include);
}

/**
 * @param      $str
 * @param      $separator
 * @param bool $include
 * @return null|string
 * @throws \InvalidArgumentException
 */
function substring_after_last($str, $separator, bool $include = false): ?string
{
    return (string) string($str)->substringAfterLast($separator, $include);
}

/**
 * @param      $str
 * @param      $separator
 * @param bool $include
 * @return null|string
 * @throws \InvalidArgumentException
 */
function substring_before_first($str, $separator, bool $include = false): ?string
{
    return (string) string($str)->substringBeforeFirst($separator, $include);
}

/**
 * @param      $str
 * @param      $separator
 * @param bool $include
 * @return null|string
 * @throws \InvalidArgumentException
 */
function substring_before_last($str, $separator, bool $include = false): ?string
{
    return (string) string($str)->substringBeforeLast($separator, $include);
}

/**
 * @param     $str
 * @param int $numberOfChars
 * @return string
 * @throws \InvalidArgumentException
 */
function first($str, int $numberOfChars = 1): string
{
    return (string) string($str)->first($numberOfChars);
}

/**
 * @param     $str
 * @param int $numberOfChars
 * @return string
 * @throws \InvalidArgumentException
 */
function last($str, int $numberOfChars = 1): string
{
    return (string) string($str)->last($numberOfChars);
}

/**
 * @param $haystack
 * @param $needle
 * @return bool
 * @throws \InvalidArgumentException
 */
function starts_with($haystack, $needle): bool
{
    return string($haystack)->startsWith($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return bool
 * @throws \InvalidArgumentException
 */
function starts_with_any($haystack, $needle): bool
{
    return string($haystack)->startsWithAny($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return bool
 * @throws \InvalidArgumentException
 */
function ends_with($haystack, $needle): bool
{
    return string($haystack)->endsWith($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return bool
 * @throws \InvalidArgumentException
 */
function ends_with_any($haystack, $needle): bool
{
    return string($haystack)->endsWithAny($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return string
 * @throws \InvalidArgumentException
 */
function ensure_left($haystack, $needle): string
{
    return (string) string($haystack)->ensureLeft($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return string
 * @throws \InvalidArgumentException
 */
function ensure_right($haystack, $needle): string
{
    return (string) string($haystack)->ensureLeft($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return string
 * @throws \InvalidArgumentException
 */
function remove_left($haystack, $needle): string
{
    return (string) string($haystack)->removeLeft($needle);
}

/**
 * @param $haystack
 * @param $needle
 * @return string
 * @throws \InvalidArgumentException
 */
function remove_right($haystack, $needle): string
{
    return (string) string($haystack)->removeRight($needle);
}

/**
 * @param        $str
 * @param string $charlist
 * @return string
 * @throws \InvalidArgumentException
 */
function trim($str, string $charlist = " \t\n\r\0\x0B"): string
{
    return (string) string($str)->trim($charlist);
}

/**
 * @param        $str
 * @param string $charlist
 * @return string
 * @throws \InvalidArgumentException
 */
function ltrim($str, string $charlist = " \t\n\r\0\x0B"): string
{
    return (string) string($str)->trimLeft($charlist);
}

/**
 * @param        $str
 * @param string $charlist
 * @return string
 * @throws \InvalidArgumentException
 */
function rtrim($str, string $charlist = " \t\n\r\0\x0B"): string
{
    return (string) string($str)->trimRight($charlist);
}

/**
 * @param $str
 * @return string
 * @throws \InvalidArgumentException
 */
function strrev($str): string
{
    return (string) string($str)->reverse();
}

/**
 * @param        $haystack
 * @param string $needle
 * @param int    $offset
 * @return bool|false|int
 * @throws \InvalidArgumentException
 */
function strpos($haystack, string $needle, int $offset = 0)
{
    return string($haystack)->indexOf($needle, $offset, true);
}

/**
 * @param        $haystack
 * @param string $needle
 * @param int    $offset
 * @return bool|false|int
 * @throws \InvalidArgumentException
 */
function stripos($haystack, string $needle, int $offset = 0)
{
    return string($haystack)->indexOf($needle, $offset, false);
}

/**
 * @param        $haystack
 * @param string $needle
 * @param int    $offset
 * @return bool|false|int
 * @throws \InvalidArgumentException
 */
function strrpos($haystack, string $needle, int $offset = 0)
{
    return string($haystack)->indexOfLast($needle, $offset, true);
}

/**
 * @param        $haystack
 * @param string $needle
 * @param int    $offset
 * @return bool|false|int
 * @throws \InvalidArgumentException
 */
function strripos($haystack, string $needle, int $offset = 0)
{
    return string($haystack)->indexOfLast($needle, $offset, false);
}

/**
 * @param        $haystack
 * @param string $needle
 * @param bool   $caseSensitive
 * @return bool
 * @throws \InvalidArgumentException
 */
function contains($haystack, string $needle, bool $caseSensitive = false): bool
{
    return string($haystack)->contains($needle, $caseSensitive);
}

/**
 * @param          $haystack
 * @param iterable $needles
 * @param bool     $caseSensitive
 * @return bool
 * @throws \InvalidArgumentException
 */
function contains_any($haystack, iterable $needles, bool $caseSensitive = false): bool
{
    return string($haystack)->containsAny($needles, $caseSensitive);
}

/**
 * @param          $haystack
 * @param iterable $needles
 * @param bool     $caseSensitive
 * @return bool
 * @throws \InvalidArgumentException
 */
function contains_all($haystack, iterable $needles, bool $caseSensitive = false): bool
{
    return string($haystack)->containsAll($needles, $caseSensitive);
}


1			<?php
2
3			namespace BenTools\Violin;
4
5			/**
6			* @param $str
7			* @return Violin
8			* @throws \InvalidArgumentException
9			*/
10			function string($str): Violin
11			{
12			return Violin::tune($str);
13			}
14
15			/**
16			* @param $str
17			* @return bool
18			*/
19			function is_stringable($str): bool
20			{
21			return Violin::isStringable($str);
22			}
23
24			/**
25			* @param $str
26			* @return bool
27			* @throws \InvalidArgumentException
28			*/
29			function is_empty($str): bool
30			{
31			return string($str)->isEmpty();
32			}
33
34			/**
35			* @param $str
36			* @return bool
37			* @throws \InvalidArgumentException
38			*/
39			function is_blank($str): bool
40			{
41			return string($str)->isBlank();
42			}
43
44			/**
45			* @param $str
46			* @return string
47			* @throws \InvalidArgumentException
48			*/
49			function strtoupper($str): string
50			{
51			return (string) string($str)->toUpperCase();
52			}
53
54			/**
55			* @param $str
56			* @return string
57			* @throws \InvalidArgumentException
58			*/
59			function strtolower($str): string
60			{
61			return (string) string($str)->toLowerCase();
62			}
63
64			/**
65			* @param $str
66			* @param int $start
67			* @param int\|null $length
68			* @return string
69			* @throws \InvalidArgumentException
70			*/
71			function substr($str, int $start, int $length = null): string
72			{
73			return (string) string($str)->substr($start, $length);
74			}
75
76			/**
77			* @param $str
78			* @param $separator
79			* @param bool $include
80			* @return null\|string
81			* @throws \InvalidArgumentException
82			*/
83			function substring_after_first($str, $separator, bool $include = false): ?string
84			{
85			return (string) string($str)->substringAfterFirst($separator, $include);
86			}
87
88			/**
89			* @param $str
90			* @param $separator
91			* @param bool $include
92			* @return null\|string
93			* @throws \InvalidArgumentException
94			*/
95			function substring_after_last($str, $separator, bool $include = false): ?string
96			{
97			return (string) string($str)->substringAfterLast($separator, $include);
98			}
99
100			/**
101			* @param $str
102			* @param $separator
103			* @param bool $include
104			* @return null\|string
105			* @throws \InvalidArgumentException
106			*/
107			function substring_before_first($str, $separator, bool $include = false): ?string
108			{
109			return (string) string($str)->substringBeforeFirst($separator, $include);
110			}
111
112			/**
113			* @param $str
114			* @param $separator
115			* @param bool $include
116			* @return null\|string
117			* @throws \InvalidArgumentException
118			*/
119			function substring_before_last($str, $separator, bool $include = false): ?string
120			{
121			return (string) string($str)->substringBeforeLast($separator, $include);
122			}
123
124			/**
125			* @param $str
126			* @param int $numberOfChars
127			* @return string
128			* @throws \InvalidArgumentException
129			*/
130			function first($str, int $numberOfChars = 1): string
131			{
132			return (string) string($str)->first($numberOfChars);
133			}
134
135			/**
136			* @param $str
137			* @param int $numberOfChars
138			* @return string
139			* @throws \InvalidArgumentException
140			*/
141			function last($str, int $numberOfChars = 1): string
142			{
143			return (string) string($str)->last($numberOfChars);
144			}
145
146			/**
147			* @param $haystack
148			* @param $needle
149			* @return bool
150			* @throws \InvalidArgumentException
151			*/
152			function starts_with($haystack, $needle): bool
153			{
154			return string($haystack)->startsWith($needle);
155			}
156
157			/**
158			* @param $haystack
159			* @param $needle
160			* @return bool
161			* @throws \InvalidArgumentException
162			*/
163			function starts_with_any($haystack, $needle): bool
164			{
165			return string($haystack)->startsWithAny($needle);
166			}
167
168			/**
169			* @param $haystack
170			* @param $needle
171			* @return bool
172			* @throws \InvalidArgumentException
173			*/
174			function ends_with($haystack, $needle): bool
175			{
176			return string($haystack)->endsWith($needle);
177			}
178
179			/**
180			* @param $haystack
181			* @param $needle
182			* @return bool
183			* @throws \InvalidArgumentException
184			*/
185			function ends_with_any($haystack, $needle): bool
186			{
187			return string($haystack)->endsWithAny($needle);
188			}
189
190			/**
191			* @param $haystack
192			* @param $needle
193			* @return string
194			* @throws \InvalidArgumentException
195			*/
196			function ensure_left($haystack, $needle): string
197			{
198			return (string) string($haystack)->ensureLeft($needle);
199			}
200
201			/**
202			* @param $haystack
203			* @param $needle
204			* @return string
205			* @throws \InvalidArgumentException
206			*/
207			function ensure_right($haystack, $needle): string
208			{
209			return (string) string($haystack)->ensureLeft($needle);
210			}
211
212			/**
213			* @param $haystack
214			* @param $needle
215			* @return string
216			* @throws \InvalidArgumentException
217			*/
218			function remove_left($haystack, $needle): string
219			{
220			return (string) string($haystack)->removeLeft($needle);
221			}
222
223			/**
224			* @param $haystack
225			* @param $needle
226			* @return string
227			* @throws \InvalidArgumentException
228			*/
229			function remove_right($haystack, $needle): string
230			{
231			return (string) string($haystack)->removeRight($needle);
232			}
233
234			/**
235			* @param $str
236			* @param string $charlist
237			* @return string
238			* @throws \InvalidArgumentException
239			*/
240			function trim($str, string $charlist = " \t\n\r\0\x0B"): string
241			{
242			return (string) string($str)->trim($charlist);
243			}
244
245			/**
246			* @param $str
247			* @param string $charlist
248			* @return string
249			* @throws \InvalidArgumentException
250			*/
251			function ltrim($str, string $charlist = " \t\n\r\0\x0B"): string
252			{
253			return (string) string($str)->trimLeft($charlist);
254			}
255
256			/**
257			* @param $str
258			* @param string $charlist
259			* @return string
260			* @throws \InvalidArgumentException
261			*/
262			function rtrim($str, string $charlist = " \t\n\r\0\x0B"): string
263			{
264			return (string) string($str)->trimRight($charlist);
265			}
266
267			/**
268			* @param $str
269			* @return string
270			* @throws \InvalidArgumentException
271			*/
272			function strrev($str): string
273			{
274			return (string) string($str)->reverse();
275			}
276
277			/**
278			* @param $haystack
279			* @param string $needle
280			* @param int $offset
281			* @return bool\|false\|int
282			* @throws \InvalidArgumentException
283			*/
284			function strpos($haystack, string $needle, int $offset = 0)
285			{
286			return string($haystack)->indexOf($needle, $offset, true);
287			}
288
289			/**
290			* @param $haystack
291			* @param string $needle
292			* @param int $offset
293			* @return bool\|false\|int
294			* @throws \InvalidArgumentException
295			*/
296			function stripos($haystack, string $needle, int $offset = 0)
297			{
298			return string($haystack)->indexOf($needle, $offset, false);
299			}
300
301			/**
302			* @param $haystack
303			* @param string $needle
304			* @param int $offset
305			* @return bool\|false\|int
306			* @throws \InvalidArgumentException
307			*/
308			function strrpos($haystack, string $needle, int $offset = 0)
309			{
310			return string($haystack)->indexOfLast($needle, $offset, true);
311			}
312
313			/**
314			* @param $haystack
315			* @param string $needle
316			* @param int $offset
317			* @return bool\|false\|int
318			* @throws \InvalidArgumentException
319			*/
320			function strripos($haystack, string $needle, int $offset = 0)
321			{
322			return string($haystack)->indexOfLast($needle, $offset, false);
323			}
324
325			/**
326			* @param $haystack
327			* @param string $needle
328			* @param bool $caseSensitive
329			* @return bool
330			* @throws \InvalidArgumentException
331			*/
332			function contains($haystack, string $needle, bool $caseSensitive = false): bool
333			{
334			return string($haystack)->contains($needle, $caseSensitive);
335			}
336
337			/**
338			* @param $haystack
339			* @param iterable $needles
340			* @param bool $caseSensitive
341			* @return bool
342			* @throws \InvalidArgumentException
343			*/
344			function contains_any($haystack, iterable $needles, bool $caseSensitive = false): bool
345			{
346			return string($haystack)->containsAny($needles, $caseSensitive);
347			}
348
349			/**
350			* @param $haystack
351			* @param iterable $needles
352			* @param bool $caseSensitive
353			* @return bool
354			* @throws \InvalidArgumentException
355			*/
356			function contains_all($haystack, iterable $needles, bool $caseSensitive = false): bool
357			{
358			return string($haystack)->containsAll($needles, $caseSensitive);
359			}
360

bpolaszek / violin

first() A last analyzed 2019-05-07 14:43 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

first() A
last analyzed 2019-05-07 14:43 UTC