Passed
Push — master ( 8f4401...eac24c )
by Sebastian
02:56
created
src/Request/URLComparer.php 2 patches
Indentation   +24 added lines, -24 removed lines patch added patch discarded remove patch
@@ -23,44 +23,44 @@
 block discarded – undo
23 23
  */
24 24
 class Request_URLComparer
25 25
 {
26
-   /**
27
-    * @var Request
28
-    */
26
+    /**
27
+     * @var Request
28
+     */
29 29
     protected Request $request;
30 30
     
31
-   /**
32
-    * @var string
33
-    */
31
+    /**
32
+     * @var string
33
+     */
34 34
     protected string $sourceURL;
35 35
     
36
-   /**
37
-    * @var string
38
-    */
36
+    /**
37
+     * @var string
38
+     */
39 39
     protected string $targetURL;
40 40
     
41
-   /**
42
-    * @var string[]
43
-    */
41
+    /**
42
+     * @var string[]
43
+     */
44 44
     protected array $limitParams = array();
45 45
     
46
-   /**
47
-    * @var bool
48
-    */
46
+    /**
47
+     * @var bool
48
+     */
49 49
     protected bool $isMatch = false;
50 50
     
51
-   /**
52
-    * @var bool
53
-    */
51
+    /**
52
+     * @var bool
53
+     */
54 54
     protected bool $ignoreFragment = true;
55 55
 
56
-   /**
57
-    * @var URLInfo
58
-    */
56
+    /**
57
+     * @var URLInfo
58
+     */
59 59
     protected URLInfo $sourceInfo;
60 60
     
61
-   /**
62
-    * @var URLInfo
63
-    */
61
+    /**
62
+     * @var URLInfo
63
+     */
64 64
     protected URLInfo $targetInfo;
65 65
     
66 66
     public function __construct(Request $request, string $sourceURL, string $targetURL)
Please login to merge, or discard this patch.
Spacing   +12 added lines, -12 removed lines patch added patch discarded remove patch
@@ -81,7 +81,7 @@  discard block
 block discarded – undo
81 81
     
82 82
     public function addLimitParam(string $name) : Request_URLComparer
83 83
     {
84
-        if(!in_array($name, $this->limitParams, true))
84
+        if (!in_array($name, $this->limitParams, true))
85 85
         {
86 86
             $this->limitParams[] = $name;
87 87
         }
@@ -95,7 +95,7 @@  discard block
 block discarded – undo
95 95
      */
96 96
     public function addLimitParams(array $names) : Request_URLComparer
97 97
     {
98
-        foreach($names as $name)
98
+        foreach ($names as $name)
99 99
         {
100 100
             $this->addLimitParam($name);
101 101
         }
@@ -103,7 +103,7 @@  discard block
 block discarded – undo
103 103
         return $this;
104 104
     }
105 105
     
106
-    public function setIgnoreFragment(bool $ignore=true) : Request_URLComparer
106
+    public function setIgnoreFragment(bool $ignore = true) : Request_URLComparer
107 107
     {
108 108
         $this->ignoreFragment = $ignore;
109 109
         return $this;
@@ -126,13 +126,13 @@  discard block
 block discarded – undo
126 126
             'query' 
127 127
         );
128 128
         
129
-        if(!$this->ignoreFragment) {
129
+        if (!$this->ignoreFragment) {
130 130
             $keys[] = 'fragment';
131 131
         }
132 132
         
133
-        foreach($keys as $key)
133
+        foreach ($keys as $key)
134 134
         {
135
-            if(!$this->compareKey($key)) {
135
+            if (!$this->compareKey($key)) {
136 136
                 return false;
137 137
             }
138 138
         }
@@ -147,7 +147,7 @@  discard block
 block discarded – undo
147 147
         
148 148
         $filter = 'filter_'.$key;
149 149
         
150
-        if(method_exists($this, $filter)) 
150
+        if (method_exists($this, $filter)) 
151 151
         {
152 152
             $sVal = $this->$filter($sVal);
153 153
             $tVal = $this->$filter($tVal);
@@ -159,7 +159,7 @@  discard block
 block discarded – undo
159 159
     protected function filter_path(string $path) : string
160 160
     {
161 161
         // fix double slashes in URLs
162
-        while(strpos($path, '//') !== false)
162
+        while (strpos($path, '//') !== false)
163 163
         {
164 164
             $path = str_replace('//', '/', $path);
165 165
         }
@@ -169,7 +169,7 @@  discard block
 block discarded – undo
169 169
     
170 170
     protected function filter_query(string $query) : string
171 171
     {
172
-        if(empty($query)) {
172
+        if (empty($query)) {
173 173
             return '';
174 174
         }
175 175
         
@@ -188,15 +188,15 @@  discard block
 block discarded – undo
188 188
      */
189 189
     protected function limitParams(array $params) : array
190 190
     {
191
-        if(empty($this->limitParams)) {
191
+        if (empty($this->limitParams)) {
192 192
             return $params;
193 193
         }
194 194
         
195 195
         $keep = array();
196 196
         
197
-        foreach($this->limitParams as $name)
197
+        foreach ($this->limitParams as $name)
198 198
         {
199
-            if(isset($params[$name])) {
199
+            if (isset($params[$name])) {
200 200
                 $keep[$name] = $params[$name];
201 201
             }
202 202
         }
Please login to merge, or discard this patch.
src/Traits/RenderableTrait.php 1 patch
Braces   +1 added lines, -2 removed lines patch added patch discarded remove patch
@@ -35,8 +35,7 @@
 block discarded – undo
35 35
         try
36 36
         {
37 37
             return $this->render();
38
-        }
39
-        catch (Throwable $e)
38
+        } catch (Throwable $e)
40 39
         {
41 40
             return sprintf(
42 41
                 'Exception while rendering [%s]: %s',
Please login to merge, or discard this patch.
src/Traits/RenderableBufferedTrait.php 1 patch
Braces   +1 added lines, -2 removed lines patch added patch discarded remove patch
@@ -35,8 +35,7 @@
 block discarded – undo
35 35
         try
36 36
         {
37 37
             return $this->render();
38
-        }
39
-        catch (Throwable $e)
38
+        } catch (Throwable $e)
40 39
         {
41 40
             return sprintf(
42 41
                 'Exception while rendering [%s]: %s',
Please login to merge, or discard this patch.
src/functions.php 1 patch
Spacing   +7 added lines, -7 removed lines patch added patch discarded remove patch
@@ -12,9 +12,9 @@  discard block
 block discarded – undo
12 12
  * @param bool $forceNew
13 13
  * @return NumberInfo
14 14
  */
15
-function parseNumber($value, bool $forceNew=false)
15
+function parseNumber($value, bool $forceNew = false)
16 16
 {
17
-    if($value instanceof NumberInfo && $forceNew !== true) {
17
+    if ($value instanceof NumberInfo && $forceNew !== true) {
18 18
         return $value;
19 19
     }
20 20
     
@@ -109,7 +109,7 @@  discard block
 block discarded – undo
109 109
     $args = func_get_args();
110 110
     
111 111
     // is the localization package installed?
112
-    if(function_exists('\AppLocalize\t'))
112
+    if (function_exists('\AppLocalize\t'))
113 113
     {
114 114
         return call_user_func_array('\AppLocalize\t', $args);
115 115
     }
@@ -124,7 +124,7 @@  discard block
 block discarded – undo
124 124
  * @param bool $initial The initial boolean value to use.
125 125
  * @return Value_Bool
126 126
  */
127
-function valBool(bool $initial=false) : Value_Bool
127
+function valBool(bool $initial = false) : Value_Bool
128 128
 {
129 129
     return new Value_Bool($initial);
130 130
 }
@@ -137,7 +137,7 @@  discard block
 block discarded – undo
137 137
  * @param bool $initial
138 138
  * @return Value_Bool_True
139 139
  */
140
-function valBoolTrue(bool $initial=false) : Value_Bool_True
140
+function valBoolTrue(bool $initial = false) : Value_Bool_True
141 141
 {
142 142
     return new Value_Bool_True($initial);
143 143
 }
@@ -150,7 +150,7 @@  discard block
 block discarded – undo
150 150
  * @param bool $initial
151 151
  * @return Value_Bool_False
152 152
  */
153
-function valBoolFalse(bool $initial=true) : Value_Bool_False
153
+function valBoolFalse(bool $initial = true) : Value_Bool_False
154 154
 {
155 155
     return new Value_Bool_False($initial);
156 156
 }
@@ -181,7 +181,7 @@  discard block
 block discarded – undo
181 181
  */
182 182
 function init() : void
183 183
 {
184
-    if(!class_exists('\AppLocalize\Localization')) {
184
+    if (!class_exists('\AppLocalize\Localization')) {
185 185
         return;
186 186
     }
187 187
     
Please login to merge, or discard this patch.
src/ConvertHelper.php 2 patches
Indentation   +469 added lines, -469 removed lines patch added patch discarded remove patch
@@ -60,13 +60,13 @@  discard block
 block discarded – undo
60 60
         return ConvertHelper_String::tabs2spaces($string, $tabSize);
61 61
     }
62 62
     
63
-   /**
64
-    * Converts spaces to tabs in the specified string.
65
-    * 
66
-    * @param string $string
67
-    * @param int $tabSize The amount of spaces per tab in the source string.
68
-    * @return string
69
-    */
63
+    /**
64
+     * Converts spaces to tabs in the specified string.
65
+     * 
66
+     * @param string $string
67
+     * @param int $tabSize The amount of spaces per tab in the source string.
68
+     * @return string
69
+     */
70 70
     public static function spaces2tabs(string $string, int $tabSize=4) : string
71 71
     {
72 72
         return ConvertHelper_String::spaces2tabs($string, $tabSize);
@@ -84,14 +84,14 @@  discard block
 block discarded – undo
84 84
         return ConvertHelper_String::hidden2visible($string);
85 85
     }
86 86
     
87
-   /**
88
-    * Converts the specified amount of seconds into
89
-    * a human-readable string split in months, weeks,
90
-    * days, hours, minutes and seconds.
91
-    *
92
-    * @param float $seconds
93
-    * @return string
94
-    */
87
+    /**
88
+     * Converts the specified amount of seconds into
89
+     * a human-readable string split in months, weeks,
90
+     * days, hours, minutes and seconds.
91
+     *
92
+     * @param float $seconds
93
+     * @return string
94
+     */
95 95
     public static function time2string($seconds) : string
96 96
     {
97 97
         $converter = new ConvertHelper_TimeConverter($seconds);
@@ -115,85 +115,85 @@  discard block
 block discarded – undo
115 115
      */
116 116
     public static function duration2string($datefrom, $dateto = -1) : string
117 117
     {
118
-         return ConvertHelper_DurationConverter::toString($datefrom, $dateto);
118
+            return ConvertHelper_DurationConverter::toString($datefrom, $dateto);
119 119
     }
120 120
 
121
-   /**
122
-    * Adds HTML syntax highlighting to the specified SQL string.
123
-    * 
124
-    * @param string $sql
125
-    * @return string
126
-    * @deprecated Use the Highlighter class directly instead.
127
-    * @see Highlighter::sql()
128
-    */
121
+    /**
122
+     * Adds HTML syntax highlighting to the specified SQL string.
123
+     * 
124
+     * @param string $sql
125
+     * @return string
126
+     * @deprecated Use the Highlighter class directly instead.
127
+     * @see Highlighter::sql()
128
+     */
129 129
     public static function highlight_sql(string $sql) : string
130 130
     {
131 131
         return Highlighter::sql($sql);
132 132
     }
133 133
 
134
-   /**
135
-    * Adds HTML syntax highlighting to the specified XML code.
136
-    * 
137
-    * @param string $xml The XML to highlight.
138
-    * @param bool $formatSource Whether to format the source with indentation to make it readable.
139
-    * @return string
140
-    * @deprecated Use the Highlighter class directly instead.
141
-    * @see Highlighter::xml()
142
-    */
134
+    /**
135
+     * Adds HTML syntax highlighting to the specified XML code.
136
+     * 
137
+     * @param string $xml The XML to highlight.
138
+     * @param bool $formatSource Whether to format the source with indentation to make it readable.
139
+     * @return string
140
+     * @deprecated Use the Highlighter class directly instead.
141
+     * @see Highlighter::xml()
142
+     */
143 143
     public static function highlight_xml(string $xml, bool $formatSource=false) : string
144 144
     {
145 145
         return Highlighter::xml($xml, $formatSource);
146 146
     }
147 147
 
148
-   /**
149
-    * @param string $phpCode
150
-    * @return string
151
-    * @deprecated Use the Highlighter class directly instead.
152
-    * @see Highlighter::php()
153
-    */
148
+    /**
149
+     * @param string $phpCode
150
+     * @return string
151
+     * @deprecated Use the Highlighter class directly instead.
152
+     * @see Highlighter::php()
153
+     */
154 154
     public static function highlight_php(string $phpCode) : string
155 155
     {
156 156
         return Highlighter::php($phpCode);
157 157
     }
158 158
     
159
-   /**
160
-    * Converts a number of bytes to a human-readable form,
161
-    * e.g. xx Kb / xx Mb / xx Gb
162
-    *
163
-    * @param int $bytes The amount of bytes to convert.
164
-    * @param int $precision The amount of decimals
165
-    * @param int $base The base to calculate with: Base 10 is default (=1000 Bytes in a KB), Base 2 is mainly used for Windows memory (=1024 Bytes in a KB).
166
-    * @return string
167
-    * 
168
-    * @see https://en.m.wikipedia.org/wiki/Megabyte#Definitions
169
-    */
159
+    /**
160
+     * Converts a number of bytes to a human-readable form,
161
+     * e.g. xx Kb / xx Mb / xx Gb
162
+     *
163
+     * @param int $bytes The amount of bytes to convert.
164
+     * @param int $precision The amount of decimals
165
+     * @param int $base The base to calculate with: Base 10 is default (=1000 Bytes in a KB), Base 2 is mainly used for Windows memory (=1024 Bytes in a KB).
166
+     * @return string
167
+     * 
168
+     * @see https://en.m.wikipedia.org/wiki/Megabyte#Definitions
169
+     */
170 170
     public static function bytes2readable(int $bytes, int $precision = 1, int $base = ConvertHelper_StorageSizeEnum::BASE_10) : string
171 171
     {
172 172
         return self::parseBytes($bytes)->toString($precision, $base);
173 173
     }
174 174
     
175
-   /**
176
-    * Parses a number of bytes, and creates a converter instance which
177
-    * allows doing common operations with it.
178
-    * 
179
-    * @param int $bytes
180
-    * @return ConvertHelper_ByteConverter
181
-    */
175
+    /**
176
+     * Parses a number of bytes, and creates a converter instance which
177
+     * allows doing common operations with it.
178
+     * 
179
+     * @param int $bytes
180
+     * @return ConvertHelper_ByteConverter
181
+     */
182 182
     public static function parseBytes(int $bytes) : ConvertHelper_ByteConverter
183 183
     {
184 184
         return new ConvertHelper_ByteConverter($bytes);
185 185
     }
186 186
 
187
-   /**
188
-    * Cuts a text to the specified length if it is longer than the
189
-    * target length. Appends a text to signify it has been cut at 
190
-    * the end of the string.
191
-    * 
192
-    * @param string $text
193
-    * @param int $targetLength
194
-    * @param string $append
195
-    * @return string
196
-    */
187
+    /**
188
+     * Cuts a text to the specified length if it is longer than the
189
+     * target length. Appends a text to signify it has been cut at 
190
+     * the end of the string.
191
+     * 
192
+     * @param string $text
193
+     * @param int $targetLength
194
+     * @param string $append
195
+     * @return string
196
+     */
197 197
     public static function text_cut(string $text, int $targetLength, string $append = '...') : string
198 198
     {
199 199
         return ConvertHelper_String::cutText($text, $targetLength, $append);
@@ -217,14 +217,14 @@  discard block
 block discarded – undo
217 217
         return $info->toString();
218 218
     }
219 219
     
220
-   /**
221
-    * Pretty `print_r`.
222
-    * 
223
-    * @param mixed $var The variable to dump.
224
-    * @param bool $return Whether to return the dumped code.
225
-    * @param bool $html Whether to style the dump as HTML.
226
-    * @return string
227
-    */
220
+    /**
221
+     * Pretty `print_r`.
222
+     * 
223
+     * @param mixed $var The variable to dump.
224
+     * @param bool $return Whether to return the dumped code.
225
+     * @param bool $html Whether to style the dump as HTML.
226
+     * @return string
227
+     */
228 228
     public static function print_r($var, bool $return=false, bool $html=true) : string
229 229
     {
230 230
         $result = parseVariable($var)->enableType()->toString();
@@ -245,29 +245,29 @@  discard block
 block discarded – undo
245 245
         return $result;
246 246
     }
247 247
     
248
-   /**
249
-    * Converts a string, number or boolean value to a boolean value.
250
-    *
251
-    * @param mixed $string
252
-    * @throws ConvertHelper_Exception
253
-    * @return bool
254
-    *
255
-    * @see ConvertHelper::ERROR_INVALID_BOOLEAN_STRING
256
-    */
248
+    /**
249
+     * Converts a string, number or boolean value to a boolean value.
250
+     *
251
+     * @param mixed $string
252
+     * @throws ConvertHelper_Exception
253
+     * @return bool
254
+     *
255
+     * @see ConvertHelper::ERROR_INVALID_BOOLEAN_STRING
256
+     */
257 257
     public static function string2bool($string) : bool
258 258
     {
259 259
         return ConvertHelper_Bool::fromString($string);
260 260
     }
261 261
 
262
-   /**
263
-    * Whether the specified string is a boolean string or boolean value.
264
-    * Alias for {@link ConvertHelper::isBoolean()}.
265
-    *
266
-    * @param mixed $string
267
-    * @return bool
268
-    * @deprecated
269
-    * @see ConvertHelper::isBoolean()
270
-    */
262
+    /**
263
+     * Whether the specified string is a boolean string or boolean value.
264
+     * Alias for {@link ConvertHelper::isBoolean()}.
265
+     *
266
+     * @param mixed $string
267
+     * @return bool
268
+     * @deprecated
269
+     * @see ConvertHelper::isBoolean()
270
+     */
271 271
     public static function isBooleanString($string) : bool
272 272
     {
273 273
         return self::isBoolean($string);
@@ -337,36 +337,36 @@  discard block
 block discarded – undo
337 337
         return ConvertHelper_String::transliterate($string, $spaceChar, $lowercase);
338 338
     }
339 339
     
340
-   /**
341
-    * Retrieves the HEX character codes for all control
342
-    * characters that the {@link stripControlCharacters()} 
343
-    * method will remove.
344
-    * 
345
-    * @return string[]
346
-    */
340
+    /**
341
+     * Retrieves the HEX character codes for all control
342
+     * characters that the {@link stripControlCharacters()} 
343
+     * method will remove.
344
+     * 
345
+     * @return string[]
346
+     */
347 347
     public static function getControlCharactersAsHex() : array
348 348
     {
349 349
         return self::createControlCharacters()->getCharsAsHex();
350 350
     }
351 351
     
352
-   /**
353
-    * Retrieves an array of all control characters that
354
-    * the {@link stripControlCharacters()} method will 
355
-    * remove, as the actual UTF-8 characters.
356
-    * 
357
-    * @return string[]
358
-    */
352
+    /**
353
+     * Retrieves an array of all control characters that
354
+     * the {@link stripControlCharacters()} method will 
355
+     * remove, as the actual UTF-8 characters.
356
+     * 
357
+     * @return string[]
358
+     */
359 359
     public static function getControlCharactersAsUTF8() : array
360 360
     {
361 361
         return self::createControlCharacters()->getCharsAsUTF8();
362 362
     }
363 363
     
364
-   /**
365
-    * Retrieves all control characters as JSON encoded
366
-    * characters, e.g. "\u200b".
367
-    * 
368
-    * @return string[]
369
-    */
364
+    /**
365
+     * Retrieves all control characters as JSON encoded
366
+     * characters, e.g. "\u200b".
367
+     * 
368
+     * @return string[]
369
+     */
370 370
     public static function getControlCharactersAsJSON() : array
371 371
     {
372 372
         return self::createControlCharacters()->getCharsAsJSON();
@@ -387,31 +387,31 @@  discard block
 block discarded – undo
387 387
         return self::createControlCharacters()->stripControlCharacters($string);
388 388
     }
389 389
     
390
-   /**
391
-    * Creates the control characters class, used to 
392
-    * work with control characters in strings.
393
-    * 
394
-    * @return ConvertHelper_ControlCharacters
395
-    */
390
+    /**
391
+     * Creates the control characters class, used to 
392
+     * work with control characters in strings.
393
+     * 
394
+     * @return ConvertHelper_ControlCharacters
395
+     */
396 396
     public static function createControlCharacters() : ConvertHelper_ControlCharacters
397 397
     {
398 398
         return new ConvertHelper_ControlCharacters();
399 399
     }
400 400
 
401
-   /**
402
-    * Converts a unicode character to the PHP notation.
403
-    * 
404
-    * Example:
405
-    * 
406
-    * <pre>unicodeChar2php('"\u0000"')</pre>
407
-    * 
408
-    * Returns
409
-    * 
410
-    * <pre>\x0</pre>
411
-    * 
412
-    * @param string $unicodeChar
413
-    * @return string
414
-    */
401
+    /**
402
+     * Converts a unicode character to the PHP notation.
403
+     * 
404
+     * Example:
405
+     * 
406
+     * <pre>unicodeChar2php('"\u0000"')</pre>
407
+     * 
408
+     * Returns
409
+     * 
410
+     * <pre>\x0</pre>
411
+     * 
412
+     * @param string $unicodeChar
413
+     * @return string
414
+     */
415 415
     public static function unicodeChar2php(string $unicodeChar) : string 
416 416
     {
417 417
         $unicodeChar = json_decode($unicodeChar);
@@ -525,138 +525,138 @@  discard block
 block discarded – undo
525 525
         return ConvertHelper_Bool::toStringStrict($boolean, $yesNo);
526 526
     }
527 527
 
528
-   /**
529
-    * Converts an associative array with attribute name > value pairs
530
-    * to an attribute string that can be used in an HTML tag. Empty 
531
-    * attribute values are ignored.
532
-    * 
533
-    * Example:
534
-    * 
535
-    * array2attributeString(array(
536
-    *     'id' => 45,
537
-    *     'href' => 'http://www.mistralys.com'
538
-    * ));
539
-    * 
540
-    * Result:
541
-    * 
542
-    * id="45" href="http://www.mistralys.com"
543
-    * 
544
-    * @param array<string,mixed> $array
545
-    * @return string
546
-    */
528
+    /**
529
+     * Converts an associative array with attribute name > value pairs
530
+     * to an attribute string that can be used in an HTML tag. Empty 
531
+     * attribute values are ignored.
532
+     * 
533
+     * Example:
534
+     * 
535
+     * array2attributeString(array(
536
+     *     'id' => 45,
537
+     *     'href' => 'http://www.mistralys.com'
538
+     * ));
539
+     * 
540
+     * Result:
541
+     * 
542
+     * id="45" href="http://www.mistralys.com"
543
+     * 
544
+     * @param array<string,mixed> $array
545
+     * @return string
546
+     */
547 547
     public static function array2attributeString(array $array) : string
548 548
     {
549 549
         return ConvertHelper_Array::toAttributeString($array);
550 550
     }
551 551
     
552
-   /**
553
-    * Converts a string, so it can safely be used in a javascript
554
-    * statement in an HTML tag: uses single quotes around the string
555
-    * and encodes all special characters as needed.
556
-    * 
557
-    * @param string $string
558
-    * @return string
559
-    * @deprecated Use the JSHelper class instead.
560
-    * @see JSHelper::phpVariable2AttributeJS()
561
-    */
552
+    /**
553
+     * Converts a string, so it can safely be used in a javascript
554
+     * statement in an HTML tag: uses single quotes around the string
555
+     * and encodes all special characters as needed.
556
+     * 
557
+     * @param string $string
558
+     * @return string
559
+     * @deprecated Use the JSHelper class instead.
560
+     * @see JSHelper::phpVariable2AttributeJS()
561
+     */
562 562
     public static function string2attributeJS(string $string) : string
563 563
     {
564 564
         return JSHelper::phpVariable2AttributeJS($string);
565 565
     }
566 566
     
567
-   /**
568
-    * Checks if the specified string is a boolean value, which
569
-    * includes string representations of boolean values, like 
570
-    * <code>yes</code> or <code>no</code>, and <code>true</code>
571
-    * or <code>false</code>.
572
-    * 
573
-    * @param mixed $value
574
-    * @return boolean
575
-    */
567
+    /**
568
+     * Checks if the specified string is a boolean value, which
569
+     * includes string representations of boolean values, like 
570
+     * <code>yes</code> or <code>no</code>, and <code>true</code>
571
+     * or <code>false</code>.
572
+     * 
573
+     * @param mixed $value
574
+     * @return boolean
575
+     */
576 576
     public static function isBoolean($value) : bool
577 577
     {
578 578
         return ConvertHelper_Bool::isBoolean($value);
579 579
     }
580 580
     
581
-   /**
582
-    * Converts an associative array to an HTML style attribute value string.
583
-    * 
584
-    * @param array<string,mixed> $subject
585
-    * @return string
586
-    */
581
+    /**
582
+     * Converts an associative array to an HTML style attribute value string.
583
+     * 
584
+     * @param array<string,mixed> $subject
585
+     * @return string
586
+     */
587 587
     public static function array2styleString(array $subject) : string
588 588
     {
589 589
         return ConvertHelper_Array::toStyleString($subject);
590 590
     }
591 591
     
592
-   /**
593
-    * Converts a DateTime object to a timestamp, which
594
-    * is PHP 5.2 compatible.
595
-    * 
596
-    * @param DateTime $date
597
-    * @return integer
598
-    */
592
+    /**
593
+     * Converts a DateTime object to a timestamp, which
594
+     * is PHP 5.2 compatible.
595
+     * 
596
+     * @param DateTime $date
597
+     * @return integer
598
+     */
599 599
     public static function date2timestamp(DateTime $date) : int
600 600
     {
601 601
         return ConvertHelper_Date::toTimestamp($date);
602 602
     }
603 603
     
604
-   /**
605
-    * Converts a timestamp into a DateTime instance.
606
-    * @param int $timestamp
607
-    * @return DateTime
608
-    */
604
+    /**
605
+     * Converts a timestamp into a DateTime instance.
606
+     * @param int $timestamp
607
+     * @return DateTime
608
+     */
609 609
     public static function timestamp2date(int $timestamp) : DateTime
610 610
     {
611 611
         return ConvertHelper_Date::fromTimestamp($timestamp);
612 612
     }
613 613
     
614
-   /**
615
-    * Strips an absolute path to a file within the application
616
-    * to make the path relative to the application root path.
617
-    * 
618
-    * @param string $path
619
-    * @return string
620
-    * 
621
-    * @see FileHelper::relativizePath()
622
-    * @see FileHelper::relativizePathByDepth()
623
-    */
614
+    /**
615
+     * Strips an absolute path to a file within the application
616
+     * to make the path relative to the application root path.
617
+     * 
618
+     * @param string $path
619
+     * @return string
620
+     * 
621
+     * @see FileHelper::relativizePath()
622
+     * @see FileHelper::relativizePathByDepth()
623
+     */
624 624
     public static function fileRelativize(string $path) : string
625 625
     {
626 626
         return FileHelper::relativizePathByDepth($path);
627 627
     }
628 628
     
629 629
     /**
630
-    * Converts a PHP regex to a javascript RegExp object statement.
631
-    * 
632
-    * NOTE: This is an alias for the JSHelper's `convertRegex` method. 
633
-    * More details are available on its usage there.
634
-    *
635
-    * @param string $regex A PHP preg regex
636
-    * @param string $statementType The type of statement to return: Defaults to a statement to create a RegExp object.
637
-    * @return string Depending on the specified return type.
638
-    * 
639
-    * @see JSHelper::buildRegexStatement()
640
-    */
630
+     * Converts a PHP regex to a javascript RegExp object statement.
631
+     * 
632
+     * NOTE: This is an alias for the JSHelper's `convertRegex` method. 
633
+     * More details are available on its usage there.
634
+     *
635
+     * @param string $regex A PHP preg regex
636
+     * @param string $statementType The type of statement to return: Defaults to a statement to create a RegExp object.
637
+     * @return string Depending on the specified return type.
638
+     * 
639
+     * @see JSHelper::buildRegexStatement()
640
+     */
641 641
     public static function regex2js(string $regex, string $statementType=JSHelper::JS_REGEX_OBJECT) : string
642 642
     {
643 643
         return JSHelper::buildRegexStatement($regex, $statementType);
644 644
     }
645 645
     
646
-   /**
647
-    * Converts the specified variable to JSON. Works just
648
-    * like the native `json_encode` method, except that it
649
-    * will trigger an exception on failure, which has the 
650
-    * json error details included in its developer details.
651
-    * 
652
-    * @param mixed $variable
653
-    * @param int $options JSON encode options.
654
-    * @param int $depth 
655
-    * @return string
656
-    *
657
-    * @throws ConvertHelper_Exception
658
-    * @see ConvertHelper::ERROR_JSON_ENCODE_FAILED
659
-    */
646
+    /**
647
+     * Converts the specified variable to JSON. Works just
648
+     * like the native `json_encode` method, except that it
649
+     * will trigger an exception on failure, which has the 
650
+     * json error details included in its developer details.
651
+     * 
652
+     * @param mixed $variable
653
+     * @param int $options JSON encode options.
654
+     * @param int $depth 
655
+     * @return string
656
+     *
657
+     * @throws ConvertHelper_Exception
658
+     * @see ConvertHelper::ERROR_JSON_ENCODE_FAILED
659
+     */
660 660
     public static function var2json($variable, int $options=0, int $depth=512) : string
661 661
     {
662 662
         $result = json_encode($variable, $options, $depth);
@@ -691,12 +691,12 @@  discard block
 block discarded – undo
691 691
             ->toString();
692 692
     }
693 693
     
694
-   /**
695
-    * Strips all known UTF byte order marks from the specified string.
696
-    * 
697
-    * @param string $string
698
-    * @return string
699
-    */
694
+    /**
695
+     * Strips all known UTF byte order marks from the specified string.
696
+     * 
697
+     * @param string $string
698
+     * @return string
699
+     */
700 700
     public static function stripUTFBom(string $string) : string
701 701
     {
702 702
         $boms = FileHelper::createUnicodeHandling()->getUTFBOMs();
@@ -715,69 +715,69 @@  discard block
 block discarded – undo
715 715
         return $string;
716 716
     }
717 717
 
718
-   /**
719
-    * Converts a string to valid utf8, regardless
720
-    * of the string's encoding(s).
721
-    * 
722
-    * @param string $string
723
-    * @return string
724
-    */
718
+    /**
719
+     * Converts a string to valid utf8, regardless
720
+     * of the string's encoding(s).
721
+     * 
722
+     * @param string $string
723
+     * @return string
724
+     */
725 725
     public static function string2utf8(string $string) : string
726 726
     {
727 727
         return ConvertHelper_String::toUtf8($string);
728 728
     }
729 729
     
730
-   /**
731
-    * Checks whether the specified string is an ASCII
732
-    * string, without any special or UTF8 characters.
733
-    * Note: empty strings and NULL are considered ASCII.
734
-    * Any variable types other than strings are not.
735
-    * 
736
-    * @param string|float|int|NULL $string
737
-    * @return boolean
738
-    */
730
+    /**
731
+     * Checks whether the specified string is an ASCII
732
+     * string, without any special or UTF8 characters.
733
+     * Note: empty strings and NULL are considered ASCII.
734
+     * Any variable types other than strings are not.
735
+     * 
736
+     * @param string|float|int|NULL $string
737
+     * @return boolean
738
+     */
739 739
     public static function isStringASCII($string) : bool
740 740
     {
741 741
         return ConvertHelper_String::isASCII(strval($string));
742 742
     }
743 743
     
744
-   /**
745
-    * Adds HTML syntax highlighting to an URL.
746
-    * 
747
-    * NOTE: Includes the necessary CSS styles. When
748
-    * highlighting several URLs in the same page,
749
-    * prefer using the `parseURL` function instead.
750
-    * 
751
-    * @param string $url
752
-    * @return string
753
-    * @deprecated Use the Highlighter class directly instead.
754
-    * @see Highlighter
755
-    */
744
+    /**
745
+     * Adds HTML syntax highlighting to an URL.
746
+     * 
747
+     * NOTE: Includes the necessary CSS styles. When
748
+     * highlighting several URLs in the same page,
749
+     * prefer using the `parseURL` function instead.
750
+     * 
751
+     * @param string $url
752
+     * @return string
753
+     * @deprecated Use the Highlighter class directly instead.
754
+     * @see Highlighter
755
+     */
756 756
     public static function highlight_url(string $url) : string
757 757
     {
758 758
         return Highlighter::url($url);
759 759
     }
760 760
 
761
-   /**
762
-    * Calculates a percentage match of the source string with the target string.
763
-    * 
764
-    * Options are:
765
-    * 
766
-    * - maxLevenshtein, default: 10
767
-    *   Any levenshtein results above this value are ignored.
768
-    *   
769
-    * - precision, default: 1
770
-    *   The precision of the percentage float value
771
-    * 
772
-    * @param string $source
773
-    * @param string $target
774
-    * @param array<string,mixed> $options
775
-    * @return float
776
-    *
777
-    * @see ConvertHelper_TextComparer
778
-    * @see ConvertHelper_TextComparer::OPTION_MAX_LEVENSHTEIN_DISTANCE
779
-    * @see ConvertHelper_TextComparer::OPTION_PRECISION
780
-    */
761
+    /**
762
+     * Calculates a percentage match of the source string with the target string.
763
+     * 
764
+     * Options are:
765
+     * 
766
+     * - maxLevenshtein, default: 10
767
+     *   Any levenshtein results above this value are ignored.
768
+     *   
769
+     * - precision, default: 1
770
+     *   The precision of the percentage float value
771
+     * 
772
+     * @param string $source
773
+     * @param string $target
774
+     * @param array<string,mixed> $options
775
+     * @return float
776
+     *
777
+     * @see ConvertHelper_TextComparer
778
+     * @see ConvertHelper_TextComparer::OPTION_MAX_LEVENSHTEIN_DISTANCE
779
+     * @see ConvertHelper_TextComparer::OPTION_PRECISION
780
+     */
781 781
     public static function matchString(string $source, string $target, array $options=array()) : float
782 782
     {
783 783
         return (new ConvertHelper_TextComparer())
@@ -785,109 +785,109 @@  discard block
 block discarded – undo
785 785
             ->match($source, $target);
786 786
     }
787 787
     
788
-   /**
789
-    * Converts a date interval to a human-readable string with
790
-    * all necessary time components, e.g. "1 year, 2 months and 4 days".
791
-    * 
792
-    * @param DateInterval $interval
793
-    * @return string
794
-    * @see ConvertHelper_IntervalConverter
795
-    *
796
-    * @throws ConvertHelper_Exception
797
-    * @see ConvertHelper_IntervalConverter::ERROR_MISSING_TRANSLATION
798
-    */
788
+    /**
789
+     * Converts a date interval to a human-readable string with
790
+     * all necessary time components, e.g. "1 year, 2 months and 4 days".
791
+     * 
792
+     * @param DateInterval $interval
793
+     * @return string
794
+     * @see ConvertHelper_IntervalConverter
795
+     *
796
+     * @throws ConvertHelper_Exception
797
+     * @see ConvertHelper_IntervalConverter::ERROR_MISSING_TRANSLATION
798
+     */
799 799
     public static function interval2string(DateInterval $interval) : string
800 800
     {
801 801
         return (new ConvertHelper_IntervalConverter())
802 802
             ->toString($interval);
803 803
     }
804 804
     
805
-   /**
806
-    * Converts an interval to its total amount of days.
807
-    * @param DateInterval $interval
808
-    * @return int
809
-    */
805
+    /**
806
+     * Converts an interval to its total amount of days.
807
+     * @param DateInterval $interval
808
+     * @return int
809
+     */
810 810
     public static function interval2days(DateInterval $interval) : int
811 811
     {
812 812
         return ConvertHelper_DateInterval::toDays($interval);
813 813
     }
814 814
 
815
-   /**
816
-    * Converts an interval to its total amount of hours.
817
-    * @param DateInterval $interval
818
-    * @return int
819
-    */
815
+    /**
816
+     * Converts an interval to its total amount of hours.
817
+     * @param DateInterval $interval
818
+     * @return int
819
+     */
820 820
     public static function interval2hours(DateInterval $interval) : int
821 821
     {
822 822
         return ConvertHelper_DateInterval::toHours($interval);
823 823
     }
824 824
     
825
-   /**
826
-    * Converts an interval to its total amount of minutes. 
827
-    * @param DateInterval $interval
828
-    * @return int
829
-    */
825
+    /**
826
+     * Converts an interval to its total amount of minutes. 
827
+     * @param DateInterval $interval
828
+     * @return int
829
+     */
830 830
     public static function interval2minutes(DateInterval $interval) : int
831 831
     {
832 832
         return ConvertHelper_DateInterval::toMinutes($interval);
833 833
     }
834 834
     
835
-   /**
836
-    * Converts an interval to its total amount of seconds.
837
-    * @param DateInterval $interval
838
-    * @return int
839
-    */    
835
+    /**
836
+     * Converts an interval to its total amount of seconds.
837
+     * @param DateInterval $interval
838
+     * @return int
839
+     */    
840 840
     public static function interval2seconds(DateInterval $interval) : int
841 841
     {
842 842
         return ConvertHelper_DateInterval::toSeconds($interval);
843 843
     }
844 844
     
845
-   /**
846
-    * Calculates the total amount of days / hours / minutes or seconds
847
-    * of a date interval object (depending on the specified units), and
848
-    * returns the total amount.
849
-    * 
850
-    * @param DateInterval $interval
851
-    * @param string $unit What total value to calculate.
852
-    * @return integer
853
-    * 
854
-    * @see ConvertHelper::INTERVAL_SECONDS
855
-    * @see ConvertHelper::INTERVAL_MINUTES
856
-    * @see ConvertHelper::INTERVAL_HOURS
857
-    * @see ConvertHelper::INTERVAL_DAYS
858
-    */
845
+    /**
846
+     * Calculates the total amount of days / hours / minutes or seconds
847
+     * of a date interval object (depending on the specified units), and
848
+     * returns the total amount.
849
+     * 
850
+     * @param DateInterval $interval
851
+     * @param string $unit What total value to calculate.
852
+     * @return integer
853
+     * 
854
+     * @see ConvertHelper::INTERVAL_SECONDS
855
+     * @see ConvertHelper::INTERVAL_MINUTES
856
+     * @see ConvertHelper::INTERVAL_HOURS
857
+     * @see ConvertHelper::INTERVAL_DAYS
858
+     */
859 859
     public static function interval2total(DateInterval $interval, string $unit=self::INTERVAL_SECONDS) : int
860 860
     {
861 861
         return ConvertHelper_DateInterval::toTotal($interval, $unit);
862 862
     }
863 863
 
864
-   /**
865
-    * Converts a date to the corresponding day name.
866
-    * 
867
-    * @param DateTime $date
868
-    * @param bool $short
869
-    * @return string|NULL
870
-    */
864
+    /**
865
+     * Converts a date to the corresponding day name.
866
+     * 
867
+     * @param DateTime $date
868
+     * @param bool $short
869
+     * @return string|NULL
870
+     */
871 871
     public static function date2dayName(DateTime $date, bool $short=false) : ?string
872 872
     {
873 873
         return ConvertHelper_Date::toDayName($date, $short);
874 874
     }
875 875
     
876
-   /**
877
-    * Retrieves a list of english day names.
878
-    * @return string[]
879
-    */
876
+    /**
877
+     * Retrieves a list of english day names.
878
+     * @return string[]
879
+     */
880 880
     public static function getDayNamesInvariant() : array
881 881
     {
882 882
         return ConvertHelper_Date::getDayNamesInvariant();
883 883
     }
884 884
     
885
-   /**
886
-    * Retrieves the day names list for the current locale.
887
-    * 
888
-    * @param bool $short
889
-    * @return string[]
890
-    */
885
+    /**
886
+     * Retrieves the day names list for the current locale.
887
+     * 
888
+     * @param bool $short
889
+     * @return string[]
890
+     */
891 891
     public static function getDayNames(bool $short=false) : array
892 892
     {
893 893
         return ConvertHelper_Date::getDayNames($short);
@@ -906,68 +906,68 @@  discard block
 block discarded – undo
906 906
         return ConvertHelper_Array::implodeWithAnd($list, $sep, $conjunction);
907 907
     }
908 908
     
909
-   /**
910
-    * Splits a string into an array of all characters it is composed of.
911
-    * Unicode character safe.
912
-    * 
913
-    * NOTE: Spaces and newlines (both \r and \n) are also considered single
914
-    * characters.
915
-    * 
916
-    * @param string $string
917
-    * @return string[]
918
-    */
909
+    /**
910
+     * Splits a string into an array of all characters it is composed of.
911
+     * Unicode character safe.
912
+     * 
913
+     * NOTE: Spaces and newlines (both \r and \n) are also considered single
914
+     * characters.
915
+     * 
916
+     * @param string $string
917
+     * @return string[]
918
+     */
919 919
     public static function string2array(string $string) : array
920 920
     {
921 921
         return ConvertHelper_String::toArray($string);
922 922
     }
923 923
     
924
-   /**
925
-    * Checks whether the specified string contains HTML code.
926
-    * 
927
-    * @param string $string
928
-    * @return boolean
929
-    */
924
+    /**
925
+     * Checks whether the specified string contains HTML code.
926
+     * 
927
+     * @param string $string
928
+     * @return boolean
929
+     */
930 930
     public static function isStringHTML(string $string) : bool
931 931
     {
932 932
         return ConvertHelper_String::isHTML($string);
933 933
     }
934 934
     
935
-   /**
936
-    * UTF8-safe wordwrap method: works like the regular wordwrap
937
-    * PHP function but compatible with UTF8. Otherwise the lengths
938
-    * are not calculated correctly.
939
-    * 
940
-    * @param string $str
941
-    * @param int $width
942
-    * @param string $break
943
-    * @param bool $cut
944
-    * @return string
945
-    */
935
+    /**
936
+     * UTF8-safe wordwrap method: works like the regular wordwrap
937
+     * PHP function but compatible with UTF8. Otherwise the lengths
938
+     * are not calculated correctly.
939
+     * 
940
+     * @param string $str
941
+     * @param int $width
942
+     * @param string $break
943
+     * @param bool $cut
944
+     * @return string
945
+     */
946 946
     public static function wordwrap(string $str, int $width = 75, string $break = "\n", bool $cut = false) : string 
947 947
     {
948 948
         return ConvertHelper_String::wordwrap($str, $width, $break, $cut);
949 949
     }
950 950
     
951
-   /**
952
-    * Calculates the byte length of a string, taking into 
953
-    * account any unicode characters.
954
-    * 
955
-    * @param string $string
956
-    * @return int
957
-    */
951
+    /**
952
+     * Calculates the byte length of a string, taking into 
953
+     * account any unicode characters.
954
+     * 
955
+     * @param string $string
956
+     * @return int
957
+     */
958 958
     public static function string2bytes(string $string): int
959 959
     {
960 960
         return ConvertHelper_String::toBytes($string);
961 961
     }
962 962
     
963
-   /**
964
-    * Creates a short, 8-character long hash for the specified string.
965
-    * 
966
-    * WARNING: Not cryptographically safe.
967
-    * 
968
-    * @param string $string
969
-    * @return string
970
-    */
963
+    /**
964
+     * Creates a short, 8-character long hash for the specified string.
965
+     * 
966
+     * WARNING: Not cryptographically safe.
967
+     * 
968
+     * @param string $string
969
+     * @return string
970
+     */
971 971
     public static function string2shortHash(string $string) : string
972 972
     {
973 973
         return ConvertHelper_String::toShortHash($string);
@@ -1013,88 +1013,88 @@  discard block
 block discarded – undo
1013 1013
         return ConvertHelper_ThrowableInfo::fromThrowable($e);
1014 1014
     }
1015 1015
     
1016
-   /**
1017
-    * Parses the specified query string like the native 
1018
-    * function <code>parse_str</code>, without the key
1019
-    * naming limitations.
1020
-    * 
1021
-    * Using parse_str, dots or spaces in key names are 
1022
-    * replaced by underscores. This method keeps all names
1023
-    * intact.
1024
-    * 
1025
-    * It still uses the parse_str implementation as it 
1026
-    * is tested and tried, but fixes the parameter names
1027
-    * after parsing, as needed.
1028
-    * 
1029
-    * @param string $queryString
1030
-    * @return array<string,string>
1031
-    * @see ConvertHelper_QueryParser
1032
-    */
1016
+    /**
1017
+     * Parses the specified query string like the native 
1018
+     * function <code>parse_str</code>, without the key
1019
+     * naming limitations.
1020
+     * 
1021
+     * Using parse_str, dots or spaces in key names are 
1022
+     * replaced by underscores. This method keeps all names
1023
+     * intact.
1024
+     * 
1025
+     * It still uses the parse_str implementation as it 
1026
+     * is tested and tried, but fixes the parameter names
1027
+     * after parsing, as needed.
1028
+     * 
1029
+     * @param string $queryString
1030
+     * @return array<string,string>
1031
+     * @see ConvertHelper_QueryParser
1032
+     */
1033 1033
     public static function parseQueryString(string $queryString) : array
1034 1034
     {
1035 1035
         $parser = new ConvertHelper_QueryParser();
1036 1036
         return $parser->parse($queryString);
1037 1037
     }
1038 1038
 
1039
-   /**
1040
-    * Searches for needle in the specified string, and returns a list
1041
-    * of all occurrences, including the matched string. The matched 
1042
-    * string is useful when doing a case-insensitive search, as it
1043
-    * shows the exact matched case of needle.
1044
-    *   
1045
-    * @param string $needle
1046
-    * @param string $haystack
1047
-    * @param bool $caseInsensitive
1048
-    * @return ConvertHelper_StringMatch[]
1049
-    */
1039
+    /**
1040
+     * Searches for needle in the specified string, and returns a list
1041
+     * of all occurrences, including the matched string. The matched 
1042
+     * string is useful when doing a case-insensitive search, as it
1043
+     * shows the exact matched case of needle.
1044
+     *   
1045
+     * @param string $needle
1046
+     * @param string $haystack
1047
+     * @param bool $caseInsensitive
1048
+     * @return ConvertHelper_StringMatch[]
1049
+     */
1050 1050
     public static function findString(string $needle, string $haystack, bool $caseInsensitive=false): array
1051 1051
     {
1052 1052
         return ConvertHelper_String::findString($needle, $haystack, $caseInsensitive);
1053 1053
     }
1054 1054
     
1055
-   /**
1056
-    * Like explode, but trims all entries, and removes 
1057
-    * empty entries from the resulting array.
1058
-    * 
1059
-    * @param string $delimiter
1060
-    * @param string $string
1061
-    * @return string[]
1062
-    */
1055
+    /**
1056
+     * Like explode, but trims all entries, and removes 
1057
+     * empty entries from the resulting array.
1058
+     * 
1059
+     * @param string $delimiter
1060
+     * @param string $string
1061
+     * @return string[]
1062
+     */
1063 1063
     public static function explodeTrim(string $delimiter, string $string) : array
1064 1064
     {
1065 1065
         return ConvertHelper_String::explodeTrim($delimiter, $string);
1066 1066
     }
1067 1067
     
1068
-   /**
1069
-    * Detects the most used end-of-line character in the subject string.
1070
-    * 
1071
-    * @param string $subjectString The string to check.
1072
-    * @return NULL|ConvertHelper_EOL The detected EOL instance, or NULL if none has been detected.
1073
-    */
1068
+    /**
1069
+     * Detects the most used end-of-line character in the subject string.
1070
+     * 
1071
+     * @param string $subjectString The string to check.
1072
+     * @return NULL|ConvertHelper_EOL The detected EOL instance, or NULL if none has been detected.
1073
+     */
1074 1074
     public static function detectEOLCharacter(string $subjectString) : ?ConvertHelper_EOL
1075 1075
     {
1076 1076
         return ConvertHelper_EOL::detect($subjectString);
1077 1077
     }
1078 1078
 
1079
-   /**
1080
-    * Removes the specified keys from the target array,
1081
-    * if they exist.
1082
-    * 
1083
-    * @param array<string|int,mixed> $array
1084
-    * @param string[] $keys
1085
-    */
1079
+    /**
1080
+     * Removes the specified keys from the target array,
1081
+     * if they exist.
1082
+     * 
1083
+     * @param array<string|int,mixed> $array
1084
+     * @param string[] $keys
1085
+     */
1086 1086
     public static function arrayRemoveKeys(array &$array, array $keys) : void
1087 1087
     {
1088 1088
         ConvertHelper_Array::removeKeys($array, $keys);
1089 1089
     }
1090 1090
     
1091
-   /**
1092
-    * Checks if the specified variable is an integer or a string containing an integer.
1093
-    * Accepts both positive and negative integers.
1094
-    * 
1095
-    * @param mixed $value
1096
-    * @return bool
1097
-    */
1091
+    /**
1092
+     * Checks if the specified variable is an integer or a string containing an integer.
1093
+     * Accepts both positive and negative integers.
1094
+     * 
1095
+     * @param mixed $value
1096
+     * @return bool
1097
+     */
1098 1098
     public static function isInteger($value) : bool
1099 1099
     {
1100 1100
         if(is_int($value)) {
@@ -1114,52 +1114,52 @@  discard block
 block discarded – undo
1114 1114
         return false;    
1115 1115
     }
1116 1116
     
1117
-   /**
1118
-    * Converts an amount of seconds to a DateInterval object.
1119
-    * 
1120
-    * @param int $seconds
1121
-    * @return DateInterval
1122
-    * @throws ConvertHelper_Exception If the date interval cannot be created.
1123
-    * 
1124
-    * @see ConvertHelper::ERROR_CANNOT_GET_DATE_DIFF
1125
-    */
1117
+    /**
1118
+     * Converts an amount of seconds to a DateInterval object.
1119
+     * 
1120
+     * @param int $seconds
1121
+     * @return DateInterval
1122
+     * @throws ConvertHelper_Exception If the date interval cannot be created.
1123
+     * 
1124
+     * @see ConvertHelper::ERROR_CANNOT_GET_DATE_DIFF
1125
+     */
1126 1126
     public static function seconds2interval(int $seconds) : DateInterval
1127 1127
     {
1128 1128
         return ConvertHelper_DateInterval::fromSeconds($seconds)->getInterval();
1129 1129
     }
1130 1130
     
1131
-   /**
1132
-    * Converts a size string like "50 MB" to the corresponding byte size.
1133
-    * It is case-insensitive, ignores spaces, and supports both traditional
1134
-    * "MB" and "MiB" notations.
1135
-    * 
1136
-    * @param string $size
1137
-    * @return int
1138
-    */
1131
+    /**
1132
+     * Converts a size string like "50 MB" to the corresponding byte size.
1133
+     * It is case-insensitive, ignores spaces, and supports both traditional
1134
+     * "MB" and "MiB" notations.
1135
+     * 
1136
+     * @param string $size
1137
+     * @return int
1138
+     */
1139 1139
     public static function size2bytes(string $size) : int
1140 1140
     {
1141 1141
         return self::parseSize($size)->toBytes();
1142 1142
     }
1143 1143
     
1144
-   /**
1145
-    * Parses a size string like "50 MB" and returns a size notation instance
1146
-    * that has utility methods to access information on it, and convert it.
1147
-    * 
1148
-    * @param string $size
1149
-    * @return ConvertHelper_SizeNotation
1150
-    */
1144
+    /**
1145
+     * Parses a size string like "50 MB" and returns a size notation instance
1146
+     * that has utility methods to access information on it, and convert it.
1147
+     * 
1148
+     * @param string $size
1149
+     * @return ConvertHelper_SizeNotation
1150
+     */
1151 1151
     public static function parseSize(string $size) : ConvertHelper_SizeNotation
1152 1152
     {
1153 1153
         return new ConvertHelper_SizeNotation($size);
1154 1154
     }
1155 1155
     
1156
-   /**
1157
-    * Creates a URL finder instance, which can be used to find
1158
-    * URLs in a string - be it plain text, or HTML.
1159
-    * 
1160
-    * @param string $subject
1161
-    * @return ConvertHelper_URLFinder
1162
-    */
1156
+    /**
1157
+     * Creates a URL finder instance, which can be used to find
1158
+     * URLs in a string - be it plain text, or HTML.
1159
+     * 
1160
+     * @param string $subject
1161
+     * @return ConvertHelper_URLFinder
1162
+     */
1163 1163
     public static function createURLFinder(string $subject) : ConvertHelper_URLFinder
1164 1164
     {
1165 1165
         return new ConvertHelper_URLFinder($subject);
Please login to merge, or discard this patch.
Spacing   +24 added lines, -24 removed lines patch added patch discarded remove patch
@@ -55,7 +55,7 @@  discard block
 block discarded – undo
55 55
      * @param int $tabSize The amount of spaces per tab.
56 56
      * @return string
57 57
      */
58
-    public static function tabs2spaces(string $string, int $tabSize=4) : string
58
+    public static function tabs2spaces(string $string, int $tabSize = 4) : string
59 59
     {
60 60
         return ConvertHelper_String::tabs2spaces($string, $tabSize);
61 61
     }
@@ -67,7 +67,7 @@  discard block
 block discarded – undo
67 67
     * @param int $tabSize The amount of spaces per tab in the source string.
68 68
     * @return string
69 69
     */
70
-    public static function spaces2tabs(string $string, int $tabSize=4) : string
70
+    public static function spaces2tabs(string $string, int $tabSize = 4) : string
71 71
     {
72 72
         return ConvertHelper_String::spaces2tabs($string, $tabSize);
73 73
     }
@@ -140,7 +140,7 @@  discard block
 block discarded – undo
140 140
     * @deprecated Use the Highlighter class directly instead.
141 141
     * @see Highlighter::xml()
142 142
     */
143
-    public static function highlight_xml(string $xml, bool $formatSource=false) : string
143
+    public static function highlight_xml(string $xml, bool $formatSource = false) : string
144 144
     {
145 145
         return Highlighter::xml($xml, $formatSource);
146 146
     }
@@ -206,11 +206,11 @@  discard block
 block discarded – undo
206 206
      * @param bool $html
207 207
      * @return string
208 208
      */
209
-    public static function var_dump($var, bool $html=true) : string
209
+    public static function var_dump($var, bool $html = true) : string
210 210
     {
211 211
         $info = parseVariable($var);
212 212
         
213
-        if($html) {
213
+        if ($html) {
214 214
             return $info->toHTML();
215 215
         }
216 216
         
@@ -225,11 +225,11 @@  discard block
 block discarded – undo
225 225
     * @param bool $html Whether to style the dump as HTML.
226 226
     * @return string
227 227
     */
228
-    public static function print_r($var, bool $return=false, bool $html=true) : string
228
+    public static function print_r($var, bool $return = false, bool $html = true) : string
229 229
     {
230 230
         $result = parseVariable($var)->enableType()->toString();
231 231
         
232
-        if($html) 
232
+        if ($html) 
233 233
         {
234 234
             $result = 
235 235
             '<pre style="background:#fff;color:#333;padding:16px;border:solid 1px #bbb;border-radius:4px">'.
@@ -237,7 +237,7 @@  discard block
 block discarded – undo
237 237
             '</pre>';
238 238
         }
239 239
         
240
-        if(!$return) 
240
+        if (!$return) 
241 241
         {
242 242
             echo $result;
243 243
         }
@@ -419,12 +419,12 @@  discard block
 block discarded – undo
419 419
         $output = '';
420 420
         $split = str_split($unicodeChar);
421 421
         
422
-        foreach($split as $octet) 
422
+        foreach ($split as $octet) 
423 423
         {
424 424
             $ordInt = ord($octet);
425 425
             // Convert from int (base 10) to hex (base 16), for PHP \x syntax
426 426
             $ordHex = base_convert((string)$ordInt, 10, 16);
427
-            $output .= '\x' . $ordHex;
427
+            $output .= '\x'.$ordHex;
428 428
         }
429 429
         
430 430
         return $output;
@@ -638,7 +638,7 @@  discard block
 block discarded – undo
638 638
     * 
639 639
     * @see JSHelper::buildRegexStatement()
640 640
     */
641
-    public static function regex2js(string $regex, string $statementType=JSHelper::JS_REGEX_OBJECT) : string
641
+    public static function regex2js(string $regex, string $statementType = JSHelper::JS_REGEX_OBJECT) : string
642 642
     {
643 643
         return JSHelper::buildRegexStatement($regex, $statementType);
644 644
     }
@@ -657,11 +657,11 @@  discard block
 block discarded – undo
657 657
     * @throws ConvertHelper_Exception
658 658
     * @see ConvertHelper::ERROR_JSON_ENCODE_FAILED
659 659
     */
660
-    public static function var2json($variable, int $options=0, int $depth=512) : string
660
+    public static function var2json($variable, int $options = 0, int $depth = 512) : string
661 661
     {
662 662
         $result = json_encode($variable, $options, $depth);
663 663
         
664
-        if($result !== false) {
664
+        if ($result !== false) {
665 665
             return $result;
666 666
         }
667 667
         
@@ -701,12 +701,12 @@  discard block
 block discarded – undo
701 701
     {
702 702
         $boms = FileHelper::createUnicodeHandling()->getUTFBOMs();
703 703
 
704
-        foreach($boms as $bomChars)
704
+        foreach ($boms as $bomChars)
705 705
         {
706 706
             $length = mb_strlen($bomChars);
707 707
             $text = mb_substr($string, 0, $length);
708 708
 
709
-            if($text===$bomChars)
709
+            if ($text === $bomChars)
710 710
             {
711 711
                 return mb_substr($string, $length);
712 712
             }
@@ -778,7 +778,7 @@  discard block
 block discarded – undo
778 778
     * @see ConvertHelper_TextComparer::OPTION_MAX_LEVENSHTEIN_DISTANCE
779 779
     * @see ConvertHelper_TextComparer::OPTION_PRECISION
780 780
     */
781
-    public static function matchString(string $source, string $target, array $options=array()) : float
781
+    public static function matchString(string $source, string $target, array $options = array()) : float
782 782
     {
783 783
         return (new ConvertHelper_TextComparer())
784 784
             ->setOptions($options)
@@ -856,7 +856,7 @@  discard block
 block discarded – undo
856 856
     * @see ConvertHelper::INTERVAL_HOURS
857 857
     * @see ConvertHelper::INTERVAL_DAYS
858 858
     */
859
-    public static function interval2total(DateInterval $interval, string $unit=self::INTERVAL_SECONDS) : int
859
+    public static function interval2total(DateInterval $interval, string $unit = self::INTERVAL_SECONDS) : int
860 860
     {
861 861
         return ConvertHelper_DateInterval::toTotal($interval, $unit);
862 862
     }
@@ -868,7 +868,7 @@  discard block
 block discarded – undo
868 868
     * @param bool $short
869 869
     * @return string|NULL
870 870
     */
871
-    public static function date2dayName(DateTime $date, bool $short=false) : ?string
871
+    public static function date2dayName(DateTime $date, bool $short = false) : ?string
872 872
     {
873 873
         return ConvertHelper_Date::toDayName($date, $short);
874 874
     }
@@ -888,7 +888,7 @@  discard block
 block discarded – undo
888 888
     * @param bool $short
889 889
     * @return string[]
890 890
     */
891
-    public static function getDayNames(bool $short=false) : array
891
+    public static function getDayNames(bool $short = false) : array
892 892
     {
893 893
         return ConvertHelper_Date::getDayNames($short);
894 894
     }
@@ -1047,7 +1047,7 @@  discard block
 block discarded – undo
1047 1047
     * @param bool $caseInsensitive
1048 1048
     * @return ConvertHelper_StringMatch[]
1049 1049
     */
1050
-    public static function findString(string $needle, string $haystack, bool $caseInsensitive=false): array
1050
+    public static function findString(string $needle, string $haystack, bool $caseInsensitive = false): array
1051 1051
     {
1052 1052
         return ConvertHelper_String::findString($needle, $haystack, $caseInsensitive);
1053 1053
     }
@@ -1097,17 +1097,17 @@  discard block
 block discarded – undo
1097 1097
     */
1098 1098
     public static function isInteger($value) : bool
1099 1099
     {
1100
-        if(is_int($value)) {
1100
+        if (is_int($value)) {
1101 1101
             return true;
1102 1102
         }
1103 1103
         
1104 1104
         // booleans get converted to numbers, so they would
1105 1105
         // actually match the regex.
1106
-        if(is_bool($value)) {
1106
+        if (is_bool($value)) {
1107 1107
             return false;
1108 1108
         }
1109 1109
         
1110
-        if(is_string($value) && $value !== '') {
1110
+        if (is_string($value) && $value !== '') {
1111 1111
             return preg_match('/\A-?\d+\z/', $value) === 1;
1112 1112
         }
1113 1113
         
@@ -1173,7 +1173,7 @@  discard block
 block discarded – undo
1173 1173
      * @param bool $keepKeys
1174 1174
      * @return array<number|string,mixed>
1175 1175
      */
1176
-    public static function arrayRemoveValues(array $sourceArray, array $values, bool $keepKeys=false) : array
1176
+    public static function arrayRemoveValues(array $sourceArray, array $values, bool $keepKeys = false) : array
1177 1177
     {
1178 1178
         return ConvertHelper_Array::removeValues($sourceArray, $values, $keepKeys);
1179 1179
     }
Please login to merge, or discard this patch.
src/FileHelper/UploadFileSizeInfo.php 1 patch
Spacing   +1 added lines, -1 removed lines patch added patch discarded remove patch
@@ -51,7 +51,7 @@
 block discarded – undo
51 51
         $unit = preg_replace('/[^bkmgtpezy]/i', '', $size); // Remove the non-unit characters from the size.
52 52
         $result = (float)preg_replace('/[^0-9\.]/', '', $size); // Remove the non-numeric characters from the size.
53 53
 
54
-        if($unit)
54
+        if ($unit)
55 55
         {
56 56
             // Find the position of the unit in the ordered string which is the power of magnitude to multiply a kilobyte by.
57 57
             return (int)round($result * (1024 ** stripos('bkmgtpezy', $unit[0])));
Please login to merge, or discard this patch.
src/FileHelper/PathRelativizer.php 1 patch
Spacing   +6 added lines, -6 removed lines patch added patch discarded remove patch
@@ -18,7 +18,7 @@  discard block
 block discarded – undo
18 18
      * @param int $depth The folder depth to reduce the path to
19 19
      * @return string
20 20
      */
21
-    public static function relativizeByDepth(string $path, int $depth=2) : string
21
+    public static function relativizeByDepth(string $path, int $depth = 2) : string
22 22
     {
23 23
         $path = FileHelper::normalizePath($path);
24 24
 
@@ -26,17 +26,17 @@  discard block
 block discarded – undo
26 26
         $tokens = array_filter($tokens); // remove empty entries (trailing slash for example)
27 27
         $tokens = array_values($tokens); // re-index keys
28 28
 
29
-        if(empty($tokens)) {
29
+        if (empty($tokens)) {
30 30
             return '';
31 31
         }
32 32
 
33 33
         // remove the drive if present
34
-        if(strpos($tokens[0], ':') !== false) {
34
+        if (strpos($tokens[0], ':') !== false) {
35 35
             array_shift($tokens);
36 36
         }
37 37
 
38 38
         // path was only the drive
39
-        if(count($tokens) === 0) {
39
+        if (count($tokens) === 0) {
40 40
             return '';
41 41
         }
42 42
 
@@ -45,8 +45,8 @@  discard block
 block discarded – undo
45 45
 
46 46
         // reduce the path to the specified depth
47 47
         $length = count($tokens);
48
-        if($length > $depth) {
49
-            $tokens = array_slice($tokens, $length-$depth);
48
+        if ($length > $depth) {
49
+            $tokens = array_slice($tokens, $length - $depth);
50 50
         }
51 51
 
52 52
         // append the last element again
Please login to merge, or discard this patch.
src/FileHelper/FileFinder.php 3 patches
Spacing   +16 added lines, -16 removed lines patch added patch discarded remove patch
@@ -7,7 +7,7 @@  discard block
 block discarded – undo
7 7
  * @see \AppUtils\FileHelper\FileFinder
8 8
  */
9 9
 
10
-declare(strict_types = 1);
10
+declare(strict_types=1);
11 11
 
12 12
 namespace AppUtils\FileHelper;
13 13
 
@@ -90,7 +90,7 @@  discard block
 block discarded – undo
90 90
      * @param bool $enabled
91 91
      * @return FileFinder
92 92
      */
93
-    public function makeRecursive(bool $enabled=true) : FileFinder
93
+    public function makeRecursive(bool $enabled = true) : FileFinder
94 94
     {
95 95
         return $this->setOption('recursive', $enabled);
96 96
     }
@@ -295,22 +295,22 @@  discard block
 block discarded – undo
295 295
         return $this->getAll();
296 296
     }
297 297
     
298
-    protected function find(string $path, bool $isRoot=false) : void
298
+    protected function find(string $path, bool $isRoot = false) : void
299 299
     {
300
-        if($isRoot) {
300
+        if ($isRoot) {
301 301
             $this->found = array();
302 302
         }
303 303
         
304 304
         $recursive = $this->getBoolOption('recursive');
305 305
         
306 306
         $d = new DirectoryIterator($path);
307
-        foreach($d as $item)
307
+        foreach ($d as $item)
308 308
         {
309 309
             $pathname = $item->getPathname();
310 310
             
311
-            if($item->isDir())
311
+            if ($item->isDir())
312 312
             {
313
-                if($recursive && !$item->isDot()) {
313
+                if ($recursive && !$item->isDot()) {
314 314
                     $this->find($pathname);
315 315
                 }
316 316
                 
@@ -319,7 +319,7 @@  discard block
 block discarded – undo
319 319
             
320 320
             $file = $this->filterFile($pathname);
321 321
             
322
-            if($file !== null) 
322
+            if ($file !== null) 
323 323
             {
324 324
                 $this->found[] = $file;
325 325
             }
@@ -332,23 +332,23 @@  discard block
 block discarded – undo
332 332
         
333 333
         $extension = FileHelper::getExtension($path);
334 334
         
335
-        if(!$this->filterExclusion($extension)) {
335
+        if (!$this->filterExclusion($extension)) {
336 336
             return null;
337 337
         }
338 338
         
339 339
         $path = $this->filterPath($path);
340 340
         
341
-        if($this->getOption('strip-extensions') === true)
341
+        if ($this->getOption('strip-extensions') === true)
342 342
         {
343 343
             $path = str_replace('.'.$extension, '', $path);
344 344
         }
345 345
         
346
-        if($path === '') {
346
+        if ($path === '') {
347 347
             return null;
348 348
         }
349 349
         
350 350
         $replace = $this->getOption('slash-replacement');
351
-        if(!empty($replace)) {
351
+        if (!empty($replace)) {
352 352
             $path = str_replace('/', $replace, $path);
353 353
         }
354 354
         
@@ -367,13 +367,13 @@  discard block
 block discarded – undo
367 367
         $include = $this->getOption(self::OPTION_INCLUDE_EXTENSIONS);
368 368
         $exclude = $this->getOption(self::OPTION_EXCLUDE_EXTENSIONS);
369 369
         
370
-        if(!empty($include))
370
+        if (!empty($include))
371 371
         {
372
-            if(!in_array($extension, $include, true)) {
372
+            if (!in_array($extension, $include, true)) {
373 373
                 return false;
374 374
             }
375 375
         }
376
-        else if(!empty($exclude) && in_array($extension, $exclude, true))
376
+        else if (!empty($exclude) && in_array($extension, $exclude, true))
377 377
         {
378 378
             return false;
379 379
         }
@@ -389,7 +389,7 @@  discard block
 block discarded – undo
389 389
     */
390 390
     protected function filterPath(string $path) : string
391 391
     {
392
-        switch($this->getStringOption(self::OPTION_PATHMODE))
392
+        switch ($this->getStringOption(self::OPTION_PATHMODE))
393 393
         {
394 394
             case self::PATH_MODE_STRIP:
395 395
                 return basename($path);
Please login to merge, or discard this patch.
Braces   +1 added lines, -2 removed lines patch added patch discarded remove patch
@@ -372,8 +372,7 @@
 block discarded – undo
372 372
             if(!in_array($extension, $include, true)) {
373 373
                 return false;
374 374
             }
375
-        }
376
-        else if(!empty($exclude) && in_array($extension, $exclude, true))
375
+        } else if(!empty($exclude) && in_array($extension, $exclude, true))
377 376
         {
378 377
             return false;
379 378
         }
Please login to merge, or discard this patch.
Indentation   +130 added lines, -130 removed lines patch added patch discarded remove patch
@@ -44,20 +44,20 @@  discard block
 block discarded – undo
44 44
 
45 45
     protected FolderInfo $path;
46 46
     
47
-   /**
48
-    * @var string[]
49
-    */
47
+    /**
48
+     * @var string[]
49
+     */
50 50
     protected array $found = array();
51 51
     
52
-   /**
53
-    * The path must exist when the class is instantiated: its
54
-    * real path will be determined to work with.
55
-    * 
56
-    * @param string|PathInfoInterface|SplFileInfo $path The absolute path to the target folder.
57
-    *
58
-    * @throws FileHelper_Exception
59
-    * @see FileHelper::ERROR_PATH_IS_NOT_A_FOLDER
60
-    */
52
+    /**
53
+     * The path must exist when the class is instantiated: its
54
+     * real path will be determined to work with.
55
+     * 
56
+     * @param string|PathInfoInterface|SplFileInfo $path The absolute path to the target folder.
57
+     *
58
+     * @throws FileHelper_Exception
59
+     * @see FileHelper::ERROR_PATH_IS_NOT_A_FOLDER
60
+     */
61 61
     public function __construct($path)
62 62
     {
63 63
         $this->path = AbstractPathInfo::resolveType($path)->requireExists()->requireIsFolder();
@@ -75,11 +75,11 @@  discard block
 block discarded – undo
75 75
         );
76 76
     }
77 77
     
78
-   /**
79
-    * Enables extension stripping, to return file names without extension.
80
-    * 
81
-    * @return FileFinder
82
-    */
78
+    /**
79
+     * Enables extension stripping, to return file names without extension.
80
+     * 
81
+     * @return FileFinder
82
+     */
83 83
     public function stripExtensions() : FileFinder
84 84
     {
85 85
         return $this->setOption('strip-extensions', true);
@@ -96,46 +96,46 @@  discard block
 block discarded – undo
96 96
         return $this->setOption('recursive', $enabled);
97 97
     }
98 98
     
99
-   /**
100
-    * Retrieves all extensions that were added to
101
-    * the list of included extensions.
102
-    * 
103
-    * @return string[]
104
-    */
99
+    /**
100
+     * Retrieves all extensions that were added to
101
+     * the list of included extensions.
102
+     * 
103
+     * @return string[]
104
+     */
105 105
     public function getIncludeExtensions() : array
106 106
     {
107 107
         return $this->getArrayOption(self::OPTION_INCLUDE_EXTENSIONS);
108 108
     }
109 109
     
110
-   /**
111
-    * Includes a single extension in the file search: only
112
-    * files with this extension will be used in the results.
113
-    * 
114
-    * NOTE: Included extensions take precedence before excluded
115
-    * extensions. If any excluded extensions are specified, they
116
-    * will be ignored.
117
-    * 
118
-    * @param string $extension Extension name, without dot (`php` for example).
119
-    * @return FileFinder
120
-    * @see FileFinder::includeExtensions()
121
-    */
110
+    /**
111
+     * Includes a single extension in the file search: only
112
+     * files with this extension will be used in the results.
113
+     * 
114
+     * NOTE: Included extensions take precedence before excluded
115
+     * extensions. If any excluded extensions are specified, they
116
+     * will be ignored.
117
+     * 
118
+     * @param string $extension Extension name, without dot (`php` for example).
119
+     * @return FileFinder
120
+     * @see FileFinder::includeExtensions()
121
+     */
122 122
     public function includeExtension(string $extension) : FileFinder
123 123
     {
124 124
         return $this->includeExtensions(array($extension));
125 125
     }
126 126
     
127
-   /**
128
-    * Includes several extensions in the file search: only
129
-    * files with these extensions wil be used in the results.
130
-    * 
131
-    * NOTE: Included extensions take precedence before excluded
132
-    * extensions. If any excluded extensions are specified, they
133
-    * will be ignored.
134
-    * 
135
-    * @param string[] $extensions Extension names, without dot (`php` for example).
136
-    * @return FileFinder
137
-    * @see FileFinder::includeExtension()
138
-    */
127
+    /**
128
+     * Includes several extensions in the file search: only
129
+     * files with these extensions wil be used in the results.
130
+     * 
131
+     * NOTE: Included extensions take precedence before excluded
132
+     * extensions. If any excluded extensions are specified, they
133
+     * will be ignored.
134
+     * 
135
+     * @param string[] $extensions Extension names, without dot (`php` for example).
136
+     * @return FileFinder
137
+     * @see FileFinder::includeExtension()
138
+     */
139 139
     public function includeExtensions(array $extensions) : FileFinder
140 140
     {
141 141
         $items = $this->getIncludeExtensions();
@@ -146,37 +146,37 @@  discard block
 block discarded – undo
146 146
         return $this;
147 147
     }
148 148
 
149
-   /**
150
-    * Retrieves a list of all extensions currently set as 
151
-    * excluded from the search.
152
-    * 
153
-    * @return string[]
154
-    */
149
+    /**
150
+     * Retrieves a list of all extensions currently set as 
151
+     * excluded from the search.
152
+     * 
153
+     * @return string[]
154
+     */
155 155
     public function getExcludeExtensions() : array
156 156
     {
157 157
         return $this->getArrayOption(self::OPTION_EXCLUDE_EXTENSIONS);
158 158
     }
159 159
     
160
-   /**
161
-    * Excludes a single extension from the search.
162
-    * 
163
-    * @param string $extension Extension name, without dot (`php` for example).
164
-    * @return FileFinder
165
-    * @see FileFinder::excludeExtensions()
166
-    */
160
+    /**
161
+     * Excludes a single extension from the search.
162
+     * 
163
+     * @param string $extension Extension name, without dot (`php` for example).
164
+     * @return FileFinder
165
+     * @see FileFinder::excludeExtensions()
166
+     */
167 167
     public function excludeExtension(string $extension) : FileFinder
168 168
     {
169 169
         return $this->excludeExtensions(array($extension));
170 170
     }
171 171
 
172
-   /**
173
-    * Add several extensions to the list of extensions to
174
-    * exclude from the file search.
175
-    *  
176
-    * @param string[] $extensions Extension names, without dot (`php` for example).
177
-    * @return FileFinder
178
-    * @see FileFinder::excludeExtension()
179
-    */
172
+    /**
173
+     * Add several extensions to the list of extensions to
174
+     * exclude from the file search.
175
+     *  
176
+     * @param string[] $extensions Extension names, without dot (`php` for example).
177
+     * @return FileFinder
178
+     * @see FileFinder::excludeExtension()
179
+     */
180 180
     public function excludeExtensions(array $extensions) : FileFinder
181 181
     {
182 182
         $items = $this->getExcludeExtensions();
@@ -187,52 +187,52 @@  discard block
 block discarded – undo
187 187
         return $this;
188 188
     }
189 189
     
190
-   /**
191
-    * In this mode, the entire path to the file will be stripped,
192
-    * leaving only the file name in the files list.
193
-    * 
194
-    * @return FileFinder
195
-    */
190
+    /**
191
+     * In this mode, the entire path to the file will be stripped,
192
+     * leaving only the file name in the files list.
193
+     * 
194
+     * @return FileFinder
195
+     */
196 196
     public function setPathmodeStrip() : FileFinder
197 197
     {
198 198
         return $this->setPathmode(self::PATH_MODE_STRIP);
199 199
     }
200 200
     
201
-   /**
202
-    * In this mode, only the path relative to the source folder
203
-    * will be included in the files list.
204
-    * 
205
-    * @return FileFinder
206
-    */
201
+    /**
202
+     * In this mode, only the path relative to the source folder
203
+     * will be included in the files list.
204
+     * 
205
+     * @return FileFinder
206
+     */
207 207
     public function setPathmodeRelative() : FileFinder
208 208
     {
209 209
         return $this->setPathmode(self::PATH_MODE_RELATIVE);
210 210
     }
211 211
     
212
-   /**
213
-    * In this mode, the full, absolute paths to the files will
214
-    * be included in the files list.
215
-    * 
216
-    * @return FileFinder
217
-    */
212
+    /**
213
+     * In this mode, the full, absolute paths to the files will
214
+     * be included in the files list.
215
+     * 
216
+     * @return FileFinder
217
+     */
218 218
     public function setPathmodeAbsolute() : FileFinder
219 219
     {
220 220
         return $this->setPathmode(self::PATH_MODE_ABSOLUTE);
221 221
     }
222 222
     
223
-   /**
224
-    * This sets a character or string to replace the slashes
225
-    * in the paths with. 
226
-    * 
227
-    * This is used for example in the `getPHPClassNames()` 
228
-    * method, to return files from subfolders as class names
229
-    * using the "_" character:
230
-    * 
231
-    * Subfolder/To/File.php => Subfolder_To_File.php
232
-    * 
233
-    * @param string $character
234
-    * @return FileFinder
235
-    */
223
+    /**
224
+     * This sets a character or string to replace the slashes
225
+     * in the paths with. 
226
+     * 
227
+     * This is used for example in the `getPHPClassNames()` 
228
+     * method, to return files from subfolders as class names
229
+     * using the "_" character:
230
+     * 
231
+     * Subfolder/To/File.php => Subfolder_To_File.php
232
+     * 
233
+     * @param string $character
234
+     * @return FileFinder
235
+     */
236 236
     public function setSlashReplacement(string $character) : FileFinder
237 237
     {
238 238
         return $this->setOption('slash-replacement', $character);
@@ -255,12 +255,12 @@  discard block
 block discarded – undo
255 255
         return $this->setOption(self::OPTION_PATHMODE, $mode);
256 256
     }
257 257
     
258
-   /**
259
-    * Retrieves a list of all matching file names/paths,
260
-    * depending on the selected options.
261
-    * 
262
-    * @return string[]
263
-    */
258
+    /**
259
+     * Retrieves a list of all matching file names/paths,
260
+     * depending on the selected options.
261
+     * 
262
+     * @return string[]
263
+     */
264 264
     public function getAll() : array
265 265
     {
266 266
         $this->find((string)$this->path, true);
@@ -268,24 +268,24 @@  discard block
 block discarded – undo
268 268
         return $this->found;
269 269
     }
270 270
     
271
-   /**
272
-    * Retrieves only PHP files. Can be combined with other
273
-    * options like enabling recursion into sub-folders.
274
-    * 
275
-    * @return string[]
276
-    */
271
+    /**
272
+     * Retrieves only PHP files. Can be combined with other
273
+     * options like enabling recursion into sub-folders.
274
+     * 
275
+     * @return string[]
276
+     */
277 277
     public function getPHPFiles() : array
278 278
     {
279 279
         $this->includeExtensions(array('php'));
280 280
         return $this->getAll();
281 281
     }
282 282
     
283
-   /**
284
-    * Generates PHP class names from file paths: it replaces
285
-    * slashes with underscores, and removes file extensions.
286
-    * 
287
-    * @return string[] An array of PHP file names without extension.
288
-    */
283
+    /**
284
+     * Generates PHP class names from file paths: it replaces
285
+     * slashes with underscores, and removes file extensions.
286
+     * 
287
+     * @return string[] An array of PHP file names without extension.
288
+     */
289 289
     public function getPHPClassNames() : array
290 290
     {
291 291
         $this->includeExtensions(array('php'));
@@ -356,13 +356,13 @@  discard block
 block discarded – undo
356 356
         return $path;
357 357
     }
358 358
     
359
-   /**
360
-    * Checks whether the specified extension is allowed 
361
-    * with the current settings.
362
-    * 
363
-    * @param string $extension
364
-    * @return bool
365
-    */
359
+    /**
360
+     * Checks whether the specified extension is allowed 
361
+     * with the current settings.
362
+     * 
363
+     * @param string $extension
364
+     * @return bool
365
+     */
366 366
     protected function filterExclusion(string $extension) : bool
367 367
     {
368 368
         $include = $this->getOption(self::OPTION_INCLUDE_EXTENSIONS);
@@ -382,12 +382,12 @@  discard block
 block discarded – undo
382 382
         return true;
383 383
     }
384 384
     
385
-   /**
386
-    * Adjusts the path according to the selected path mode.
387
-    * 
388
-    * @param string $path
389
-    * @return string
390
-    */
385
+    /**
386
+     * Adjusts the path according to the selected path mode.
387
+     * 
388
+     * @param string $path
389
+     * @return string
390
+     */
391 391
     protected function filterPath(string $path) : string
392 392
     {
393 393
         switch($this->getStringOption(self::OPTION_PATHMODE))
Please login to merge, or discard this patch.
src/Request/RequestParam.php 2 patches
Indentation   +119 added lines, -119 removed lines patch added patch discarded remove patch
@@ -177,12 +177,12 @@  discard block
 block discarded – undo
177 177
         return $this->applyValidations($value);
178 178
     }
179 179
     
180
-   /**
181
-    * Runs the value through all validations that were added.
182
-    * 
183
-    * @param mixed $value
184
-    * @return mixed
185
-    */
180
+    /**
181
+     * Runs the value through all validations that were added.
182
+     * 
183
+     * @param mixed $value
184
+     * @return mixed
185
+     */
186 186
     protected function applyValidations($value, bool $subval=false)
187 187
     {
188 188
         // go through all enqueued validations in turn, each time
@@ -195,17 +195,17 @@  discard block
 block discarded – undo
195 195
         return $value;
196 196
     }
197 197
     
198
-   /**
199
-    * Validates the specified value using the validation type. Returns
200
-    * the validated value. 
201
-    * 
202
-    * @param mixed $value
203
-    * @param string $type
204
-    * @param array<string,mixed> $params
205
-    * @param bool $subval Whether this is a subvalue in a list
206
-    * @throws Request_Exception
207
-    * @return mixed
208
-    */
198
+    /**
199
+     * Validates the specified value using the validation type. Returns
200
+     * the validated value. 
201
+     * 
202
+     * @param mixed $value
203
+     * @param string $type
204
+     * @param array<string,mixed> $params
205
+     * @param bool $subval Whether this is a subvalue in a list
206
+     * @throws Request_Exception
207
+     * @return mixed
208
+     */
209 209
     protected function validateType($value, string $type, array $params, bool $subval)
210 210
     {
211 211
         $class = Request_Param_Validator::class.'_'.ucfirst($type);
@@ -270,13 +270,13 @@  discard block
 block discarded – undo
270 270
         return $this->setValidation(self::VALIDATION_TYPE_URL);
271 271
     }
272 272
     
273
-   /**
274
-    * Sets the variable to contain a comma-separated list of integer IDs.
275
-    * Example: <code>145,248,4556</code>. A single ID is also allowed, e.g.
276
-    * <code>145</code>.
277
-    * 
278
-    * @return $this
279
-    */
273
+    /**
274
+     * Sets the variable to contain a comma-separated list of integer IDs.
275
+     * Example: <code>145,248,4556</code>. A single ID is also allowed, e.g.
276
+     * <code>145</code>.
277
+     * 
278
+     * @return $this
279
+     */
280 280
     public function setIDList() : self
281 281
     {
282 282
         $this->valueType = self::VALUE_TYPE_LIST;
@@ -286,13 +286,13 @@  discard block
 block discarded – undo
286 286
         return $this;
287 287
     }
288 288
     
289
-   /**
290
-    * Sets the variable to be an alias, as defined by the
291
-    * {@link RegexHelper::REGEX_ALIAS} regular expression.
292
-    * 
293
-    * @return $this
294
-    * @see RegexHelper::REGEX_ALIAS
295
-    */
289
+    /**
290
+     * Sets the variable to be an alias, as defined by the
291
+     * {@link RegexHelper::REGEX_ALIAS} regular expression.
292
+     * 
293
+     * @return $this
294
+     * @see RegexHelper::REGEX_ALIAS
295
+     */
296 296
     public function setAlias() : self
297 297
     {
298 298
         return $this->setRegex(RegexHelper::REGEX_ALIAS);
@@ -333,12 +333,12 @@  discard block
 block discarded – undo
333 333
         return $this->setValidation(self::VALIDATION_TYPE_ALPHA);
334 334
     }
335 335
     
336
-   /**
337
-    * Sets the parameter value as a string containing lowercase
338
-    * and/or uppercase letters, as well as numbers.
339
-    * 
340
-    * @return $this
341
-    */
336
+    /**
337
+     * Sets the parameter value as a string containing lowercase
338
+     * and/or uppercase letters, as well as numbers.
339
+     * 
340
+     * @return $this
341
+     */
342 342
     public function setAlnum() : self
343 343
     {
344 344
         return $this->setValidation(self::VALIDATION_TYPE_ALNUM);   
@@ -396,11 +396,11 @@  discard block
 block discarded – undo
396 396
         );
397 397
     }
398 398
     
399
-   /**
400
-    * Whether the parameter is a list of values.
401
-    * 
402
-    * @return bool
403
-    */
399
+    /**
400
+     * Whether the parameter is a list of values.
401
+     * 
402
+     * @return bool
403
+     */
404 404
     public function isList() : bool
405 405
     {
406 406
         return $this->valueType === self::VALUE_TYPE_LIST;
@@ -442,28 +442,28 @@  discard block
 block discarded – undo
442 442
         return $this->setValidation(self::VALIDATION_TYPE_JSON, array('arrays' => false));
443 443
     }
444 444
     
445
-   /**
446
-    * The parameter is a string boolean representation. This means
447
-    * it can be any of the following: "yes", "true", "no", "false".
448
-    * The value is automatically converted to a boolean when retrieving
449
-    * the parameter.
450
-    * 
451
-    * @return $this
452
-    */
445
+    /**
446
+     * The parameter is a string boolean representation. This means
447
+     * it can be any of the following: "yes", "true", "no", "false".
448
+     * The value is automatically converted to a boolean when retrieving
449
+     * the parameter.
450
+     * 
451
+     * @return $this
452
+     */
453 453
     public function setBoolean() : self
454 454
     {
455 455
         return $this->addClassFilter('Boolean');
456 456
     }
457 457
     
458
-   /**
459
-    * Validates the request parameter as an MD5 string,
460
-    * so that only values resembling md5 values are accepted.
461
-    * 
462
-    * NOTE: This can only guarantee the format, not whether
463
-    * it is an actual valid hash of something.
464
-    * 
465
-    * @return $this
466
-    */
458
+    /**
459
+     * Validates the request parameter as an MD5 string,
460
+     * so that only values resembling md5 values are accepted.
461
+     * 
462
+     * NOTE: This can only guarantee the format, not whether
463
+     * it is an actual valid hash of something.
464
+     * 
465
+     * @return $this
466
+     */
467 467
     public function setMD5() : self
468 468
     {
469 469
         return $this->setRegex(RegexHelper::REGEX_MD5);
@@ -503,14 +503,14 @@  discard block
 block discarded – undo
503 503
         return $this;
504 504
     }
505 505
     
506
-   /**
507
-    * Retrieves the value of the request parameter,
508
-    * applying all filters (if any) and validation
509
-    * (if any).
510
-    * 
511
-    * @param mixed $default
512
-    * @return mixed
513
-    */
506
+    /**
507
+     * Retrieves the value of the request parameter,
508
+     * applying all filters (if any) and validation
509
+     * (if any).
510
+     * 
511
+     * @param mixed $default
512
+     * @return mixed
513
+     */
514 514
     public function get($default=null)
515 515
     {
516 516
         $value = $this->request->getParam($this->paramName);
@@ -523,17 +523,17 @@  discard block
 block discarded – undo
523 523
 
524 524
     // region: Filtering
525 525
 
526
-   /**
527
-    * Filters the specified value by going through all available
528
-    * filters, if any. If none have been set, the value is simply
529
-    * passed through.
530
-    *
531
-    * @param mixed $value
532
-    * @return mixed
533
-    *
534
-    * @see RequestParam::applyFilter_callback()
535
-    * @see RequestParam::applyFilter_class()
536
-    */
526
+    /**
527
+     * Filters the specified value by going through all available
528
+     * filters, if any. If none have been set, the value is simply
529
+     * passed through.
530
+     *
531
+     * @param mixed $value
532
+     * @return mixed
533
+     *
534
+     * @see RequestParam::applyFilter_callback()
535
+     * @see RequestParam::applyFilter_class()
536
+     */
537 537
     protected function filter($value)
538 538
     {
539 539
         foreach ($this->filters as $filter)
@@ -622,12 +622,12 @@  discard block
 block discarded – undo
622 622
         return $this;
623 623
     }
624 624
     
625
-   /**
626
-    * Adds a filter that trims whitespace from the request
627
-    * parameter using the PHP <code>trim</code> function.
628
-    * 
629
-    * @return $this
630
-    */
625
+    /**
626
+     * Adds a filter that trims whitespace from the request
627
+     * parameter using the PHP <code>trim</code> function.
628
+     * 
629
+     * @return $this
630
+     */
631 631
     public function addFilterTrim() : self
632 632
     {
633 633
         // to guarantee we only work with strings
@@ -636,13 +636,13 @@  discard block
 block discarded – undo
636 636
         return $this->addCallbackFilter('trim');
637 637
     }
638 638
 
639
-   /**
640
-    * Converts the value to a string, even if it is not
641
-    * a string value. Complex types like arrays and objects
642
-    * are converted to an empty string.
643
-    * 
644
-    * @return $this
645
-    */
639
+    /**
640
+     * Converts the value to a string, even if it is not
641
+     * a string value. Complex types like arrays and objects
642
+     * are converted to an empty string.
643
+     * 
644
+     * @return $this
645
+     */
646 646
     public function addStringFilter() : self
647 647
     {
648 648
         return $this->addClassFilter('String');
@@ -694,12 +694,12 @@  discard block
 block discarded – undo
694 694
         return $this->addCallbackFilter('strip_tags', array($allowedTags));
695 695
     }
696 696
     
697
-   /**
698
-    * Adds a filter that strips all whitespace from the
699
-    * request parameter, from spaces to tabs and newlines.
700
-    * 
701
-    * @return $this
702
-    */
697
+    /**
698
+     * Adds a filter that strips all whitespace from the
699
+     * request parameter, from spaces to tabs and newlines.
700
+     * 
701
+     * @return $this
702
+     */
703 703
     public function addStripWhitespaceFilter() : self
704 704
     {
705 705
         // to ensure we only work with strings.
@@ -708,14 +708,14 @@  discard block
 block discarded – undo
708 708
         return $this->addClassFilter('StripWhitespace');
709 709
     }   
710 710
     
711
-   /**
712
-    * Adds a filter that transforms comma separated values
713
-    * into an array of values.
714
-    * 
715
-    * @param bool $trimEntries Trim whitespace from each entry?
716
-    * @param bool $stripEmptyEntries Remove empty entries from the array?
717
-    * @return $this
718
-    */
711
+    /**
712
+     * Adds a filter that transforms comma separated values
713
+     * into an array of values.
714
+     * 
715
+     * @param bool $trimEntries Trim whitespace from each entry?
716
+     * @param bool $stripEmptyEntries Remove empty entries from the array?
717
+     * @return $this
718
+     */
719 719
     public function addCommaSeparatedFilter(bool $trimEntries=true, bool $stripEmptyEntries=true) : self
720 720
     {
721 721
         $this->setArray();
@@ -746,12 +746,12 @@  discard block
 block discarded – undo
746 746
         );
747 747
     }
748 748
     
749
-   /**
750
-    * Adds a filter that encodes all HTML special characters
751
-    * using the PHP <code>htmlspecialchars</code> function.
752
-    * 
753
-    * @return $this
754
-    */
749
+    /**
750
+     * Adds a filter that encodes all HTML special characters
751
+     * using the PHP <code>htmlspecialchars</code> function.
752
+     * 
753
+     * @return $this
754
+     */
755 755
     public function addHTMLSpecialcharsFilter() : self
756 756
     {
757 757
         return $this->addCallbackFilter('htmlspecialchars', array(ENT_QUOTES, 'UTF-8'));
@@ -764,14 +764,14 @@  discard block
 block discarded – undo
764 764
         return $this->paramName;
765 765
     }
766 766
     
767
-   /**
768
-    * Marks this request parameter as required. To use this feature,
769
-    * you have to call the request's {@link Request::validate()}
770
-    * method.
771
-    * 
772
-    * @return RequestParam
773
-    * @see Request::validate()
774
-    */
767
+    /**
768
+     * Marks this request parameter as required. To use this feature,
769
+     * you have to call the request's {@link Request::validate()}
770
+     * method.
771
+     * 
772
+     * @return RequestParam
773
+     * @see Request::validate()
774
+     */
775 775
     public function makeRequired() : RequestParam
776 776
     {
777 777
         $this->required = true;
Please login to merge, or discard this patch.
Spacing   +15 added lines, -15 removed lines patch added patch discarded remove patch
@@ -124,7 +124,7 @@  discard block
 block discarded – undo
124 124
      * @return $this
125 125
      * @throws Request_Exception
126 126
      */
127
-    public function setCallback(callable $callback, array $args=array()) : self
127
+    public function setCallback(callable $callback, array $args = array()) : self
128 128
     {
129 129
         return $this->setValidation(
130 130
             self::VALIDATION_TYPE_CALLBACK, 
@@ -149,22 +149,22 @@  discard block
 block discarded – undo
149 149
         // first off, apply filtering
150 150
         $value = $this->filter($value);
151 151
         
152
-        if($this->valueType === self::VALUE_TYPE_LIST)
152
+        if ($this->valueType === self::VALUE_TYPE_LIST)
153 153
         {
154
-            if(!is_array($value))
154
+            if (!is_array($value))
155 155
             {
156 156
                 $value = explode(',', $value);
157 157
             }
158 158
             
159 159
             $keep = array();
160 160
             
161
-            foreach($value as $subval)
161
+            foreach ($value as $subval)
162 162
             {
163 163
                 $subval = $this->filter($subval);
164 164
                 
165 165
                 $subval = $this->applyValidations($subval, true);
166 166
 
167
-                if($subval !== null) {
167
+                if ($subval !== null) {
168 168
                     $keep[] = $subval;
169 169
                 }
170 170
             }
@@ -183,11 +183,11 @@  discard block
 block discarded – undo
183 183
     * @param mixed $value
184 184
     * @return mixed
185 185
     */
186
-    protected function applyValidations($value, bool $subval=false)
186
+    protected function applyValidations($value, bool $subval = false)
187 187
     {
188 188
         // go through all enqueued validations in turn, each time
189 189
         // replacing the value with the adjusted, validated value.
190
-        foreach($this->validations as $validateDef)
190
+        foreach ($this->validations as $validateDef)
191 191
         {
192 192
             $value = $this->validateType($value, $validateDef['type'], $validateDef['params'], $subval);
193 193
         }
@@ -210,7 +210,7 @@  discard block
 block discarded – undo
210 210
     {
211 211
         $class = Request_Param_Validator::class.'_'.ucfirst($type);
212 212
         
213
-        if(!class_exists($class))
213
+        if (!class_exists($class))
214 214
         {
215 215
             throw new Request_Exception(
216 216
                 'Unknown validation type.',
@@ -361,7 +361,7 @@  discard block
 block discarded – undo
361 361
     {
362 362
         $args = func_get_args(); // cannot be used as function parameter in some PHP versions
363 363
         
364
-        if(is_array($args[0])) 
364
+        if (is_array($args[0])) 
365 365
         {
366 366
             $args = $args[0];
367 367
         }
@@ -511,10 +511,10 @@  discard block
 block discarded – undo
511 511
     * @param mixed $default
512 512
     * @return mixed
513 513
     */
514
-    public function get($default=null)
514
+    public function get($default = null)
515 515
     {
516 516
         $value = $this->request->getParam($this->paramName);
517
-        if($value !== null && $value !== '') {
517
+        if ($value !== null && $value !== '') {
518 518
             return $value;
519 519
         }
520 520
 
@@ -538,7 +538,7 @@  discard block
 block discarded – undo
538 538
     {
539 539
         foreach ($this->filters as $filter)
540 540
         {
541
-            $method = 'applyFilter_' . $filter['type'];
541
+            $method = 'applyFilter_'.$filter['type'];
542 542
             $value = $this->$method($value, $filter['params']);
543 543
         }
544 544
 
@@ -557,7 +557,7 @@  discard block
 block discarded – undo
557 557
         
558 558
         $filter = new $class($this);
559 559
 
560
-        if($filter instanceof Request_Param_Filter)
560
+        if ($filter instanceof Request_Param_Filter)
561 561
         {
562 562
             $filter->setOptions($config['params']);
563 563
             return $filter->filter($value);
@@ -716,7 +716,7 @@  discard block
 block discarded – undo
716 716
     * @param bool $stripEmptyEntries Remove empty entries from the array?
717 717
     * @return $this
718 718
     */
719
-    public function addCommaSeparatedFilter(bool $trimEntries=true, bool $stripEmptyEntries=true) : self
719
+    public function addCommaSeparatedFilter(bool $trimEntries = true, bool $stripEmptyEntries = true) : self
720 720
     {
721 721
         $this->setArray();
722 722
         
@@ -735,7 +735,7 @@  discard block
 block discarded – undo
735 735
      * @return $this
736 736
      * @throws Request_Exception
737 737
      */
738
-    protected function addClassFilter(string $name, array $params=array()) : self
738
+    protected function addClassFilter(string $name, array $params = array()) : self
739 739
     {
740 740
         return $this->addFilter(
741 741
             self::FILTER_TYPE_CLASS,
Please login to merge, or discard this patch.