Strings::compactNewlines() - Code Metrics - libreworks/caridea-filter - Measure and Improve Code Quality continuously with Scrutinizer

Strings::compactNewlines() A
last analyzed 2018-01-20 20:56 UTC

↳ Parent: Strings

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php
declare(strict_types=1);
/**
 * Caridea
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 *
 * @copyright 2015-2018 LibreWorks contributors
 * @license   Apache-2.0
 */
namespace Caridea\Filter;

/**
 * A loaded six-string on my back.
 */
class Strings
{
    /**
     * Coerces a value into a string or throws an exception.
     *
     * @param mixed $var - The value to coerce
     * @return string The converted string
     * @throws \InvalidArgumentException if the value could not be coerced
     */
    public static function coerce($var): string
    {
        if ($var === null || is_scalar($var) || is_callable([$var, '__toString'])) {
            return (string) $var;
        }
        throw new \InvalidArgumentException("Could not convert to string: " . gettype($var));
    }

    /**
     * Returns a filter that coerces a value to a string.
     *
     * @return callable The created filter
     */
    public static function toString(): callable
    {
        return [__CLASS__, 'coerce'];
    }

    /**
     * Returns a new lowercasing filter.
     *
     * @return \Closure The created filter
     */
    public static function lowerCase(): \Closure
    {
        return function ($value) {
            return mb_convert_case(Strings::coerce($value), MB_CASE_LOWER, 'UTF-8');
        };
    }

    /**
     * Returns a new uppercasing filter.
     *
     * @return \Closure The created filter
     */
    public static function upperCase(): \Closure
    {
        return function ($value) {
            return mb_convert_case(Strings::coerce($value), MB_CASE_UPPER, 'UTF-8');
        };
    }

    /**
     * Returns a new uppercasing filter.
     *
     * @return \Closure The created filter
     */
    public static function titleCase(): \Closure
    {
        return function ($value) {
            return mb_convert_case(Strings::coerce($value), MB_CASE_TITLE, 'UTF-8');
        };
    }

    /**
     * Returns a new whitespace trimming filter.
     *
     * @return \Closure The created filter
     */
    public static function trim(): \Closure
    {
        return function ($value) {
            return trim(Strings::coerce($value));
        };
    }

    /**
     * Returns a new substring filter.
     *
     * @param int $length The maximum string length
     * @return \Closure The created filter
     */
    public static function cut(int $length): \Closure
    {
        return function ($value) use ($length) {
            return substr(Strings::coerce($value), 0, $length);
        };
    }

    /**
     * Creates a new search and replace filter.
     *
     * @param string $search The value to find
     * @param string $replacement The value to use as a replacement
     * @return \Closure The created filter
     */
    public static function replace(string $search, string $replacement): \Closure
    {
        return function ($value) use ($search, $replacement) {
            return str_replace($search, $replacement, Strings::coerce($value));
        };
    }

    /**
     * Creates a new regular expression filter.
     *
     * @param string $pattern The search pattern
     * @param string $replacement The value to use as a replacement
     * @return \Closure The created filter
     */
    public static function regex(string $pattern, string $replacement): \Closure
    {
        return function ($value) use ($pattern, $replacement) {
            return preg_replace($pattern, $replacement, Strings::coerce($value));
        };
    }

    /**
     * Creates a new filter that removes non-alphanumeric characters.
     *
     * @return \Closure The created filter
     */
    public static function alnum(): \Closure
    {
        return self::regex('/[^\p{L}\p{Nd}]/u', '');
    }

    /**
     * Creates a new filter that removes non-alphabetic characters.
     *
     * @return \Closure The created filter
     */
    public static function alpha(): \Closure
    {
        return self::regex('/[^\p{L}]/u', '');
    }

    /**
     * Creates a new filter that removes non-digit characters.
     *
     * @return \Closure The created filter
     */
    public static function numeric(): \Closure
    {
        return self::regex('/[^\p{N}]/u', '');
    }

    /**
     * Creates a new filter that turns any newlines into UNIX-style newlines.
     *
     * @return \Closure The created filter
     */
    public static function unixNewlines(): \Closure
    {
        return self::regex("/\R/", "\n");
    }

    /**
     * Creates a new filter that turns multiple newlines into two.
     *
     * Meant to be run after `unixNewlines`.
     *
     * @return \Closure The created filter
     */
    public static function compactNewlines(): \Closure
    {
        return self::regex("/\n\n+/", "\n\n");
    }
}


1		<?php
2		declare(strict_types=1);
3		/**
4		* Caridea
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License"); you may not
7		* use this file except in compliance with the License. You may obtain a copy of
8		* the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
14		* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
15		* License for the specific language governing permissions and limitations under
16		* the License.
17		*
18		* @copyright 2015-2018 LibreWorks contributors
19		* @license Apache-2.0
20		*/
21		namespace Caridea\Filter;
22
23		/**
24		* A loaded six-string on my back.
25		*/
26		class Strings
27		{
28		/**
29		* Coerces a value into a string or throws an exception.
30		*
31		* @param mixed $var - The value to coerce
32		* @return string The converted string
33		* @throws \InvalidArgumentException if the value could not be coerced
34		*/
35	2	public static function coerce($var): string
36		{
37	2	if ($var === null \|\| is_scalar($var) \|\| is_callable([$var, '__toString'])) {
38	1	return (string) $var;
39		}
40	1	throw new \InvalidArgumentException("Could not convert to string: " . gettype($var));
41		}
42
43		/**
44		* Returns a filter that coerces a value to a string.
45		*
46		* @return callable The created filter
47		*/
48	1	public static function toString(): callable
49		{
50	1	return [__CLASS__, 'coerce'];
51		}
52
53		/**
54		* Returns a new lowercasing filter.
55		*
56		* @return \Closure The created filter
57		*/
58		public static function lowerCase(): \Closure
59		{
60	1	return function ($value) {
61	1	return mb_convert_case(Strings::coerce($value), MB_CASE_LOWER, 'UTF-8');
62	1	};
63		}
64
65		/**
66		* Returns a new uppercasing filter.
67		*
68		* @return \Closure The created filter
69		*/
70		public static function upperCase(): \Closure
71		{
72	1	return function ($value) {
73	1	return mb_convert_case(Strings::coerce($value), MB_CASE_UPPER, 'UTF-8');
74	1	};
75		}
76
77		/**
78		* Returns a new uppercasing filter.
79		*
80		* @return \Closure The created filter
81		*/
82		public static function titleCase(): \Closure
83		{
84	1	return function ($value) {
85	1	return mb_convert_case(Strings::coerce($value), MB_CASE_TITLE, 'UTF-8');
86	1	};
87		}
88
89		/**
90		* Returns a new whitespace trimming filter.
91		*
92		* @return \Closure The created filter
93		*/
94		public static function trim(): \Closure
95		{
96	1	return function ($value) {
97	1	return trim(Strings::coerce($value));
98	1	};
99		}
100
101		/**
102		* Returns a new substring filter.
103		*
104		* @param int $length The maximum string length
105		* @return \Closure The created filter
106		*/
107		public static function cut(int $length): \Closure
108		{
109	1	return function ($value) use ($length) {
110	1	return substr(Strings::coerce($value), 0, $length);
111	1	};
112		}
113
114		/**
115		* Creates a new search and replace filter.
116		*
117		* @param string $search The value to find
118		* @param string $replacement The value to use as a replacement
119		* @return \Closure The created filter
120		*/
121		public static function replace(string $search, string $replacement): \Closure
122		{
123	1	return function ($value) use ($search, $replacement) {
124	1	return str_replace($search, $replacement, Strings::coerce($value));
125	1	};
126		}
127
128		/**
129		* Creates a new regular expression filter.
130		*
131		* @param string $pattern The search pattern
132		* @param string $replacement The value to use as a replacement
133		* @return \Closure The created filter
134		*/
135		public static function regex(string $pattern, string $replacement): \Closure
136		{
137	1	return function ($value) use ($pattern, $replacement) {
138	1	return preg_replace($pattern, $replacement, Strings::coerce($value));
139	1	};
140		}
141
142		/**
143		* Creates a new filter that removes non-alphanumeric characters.
144		*
145		* @return \Closure The created filter
146		*/
147	1	public static function alnum(): \Closure
148		{
149	1	return self::regex('/[^\p{L}\p{Nd}]/u', '');
150		}
151
152		/**
153		* Creates a new filter that removes non-alphabetic characters.
154		*
155		* @return \Closure The created filter
156		*/
157	1	public static function alpha(): \Closure
158		{
159	1	return self::regex('/[^\p{L}]/u', '');
160		}
161
162		/**
163		* Creates a new filter that removes non-digit characters.
164		*
165		* @return \Closure The created filter
166		*/
167	1	public static function numeric(): \Closure
168		{
169	1	return self::regex('/[^\p{N}]/u', '');
170		}
171
172		/**
173		* Creates a new filter that turns any newlines into UNIX-style newlines.
174		*
175		* @return \Closure The created filter
176		*/
177	1	public static function unixNewlines(): \Closure
178		{
179	1	return self::regex("/\R/", "\n");
180		}
181
182		/**
183		* Creates a new filter that turns multiple newlines into two.
184		*
185		* Meant to be run after `unixNewlines`.
186		*
187		* @return \Closure The created filter
188		*/
189	1	public static function compactNewlines(): \Closure
190		{
191	1	return self::regex("/\n\n+/", "\n\n");
192		}
193		}
194

libreworks / caridea-filter

Strings::compactNewlines() A last analyzed 2018-01-20 20:56 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Strings::compactNewlines() A
last analyzed 2018-01-20 20:56 UTC