@@ -100,12 +100,12 @@ discard block  | 
                                                    ||
| 100 | 100 | public static function invalidPathChars(): array  | 
                                                        
| 101 | 101 |      { | 
                                                        
| 102 | 102 | return Collection::from(self::INVALID_PATH_ASCII)  | 
                                                        
| 103 | - ->map(  | 
                                                        |
| 104 | -                             function (string $ascii) { | 
                                                        |
| 105 | - return chr($ascii);  | 
                                                        |
| 106 | - }  | 
                                                        |
| 107 | - )  | 
                                                        |
| 108 | - ->toArray();  | 
                                                        |
| 103 | + ->map(  | 
                                                        |
| 104 | +                                function (string $ascii) { | 
                                                        |
| 105 | + return chr($ascii);  | 
                                                        |
| 106 | + }  | 
                                                        |
| 107 | + )  | 
                                                        |
| 108 | + ->toArray();  | 
                                                        |
| 109 | 109 | }  | 
                                                        
| 110 | 110 | |
| 111 | 111 | /**  | 
                                                        
@@ -158,10 +158,10 @@ discard block  | 
                                                    ||
| 158 | 158 | private static function hasIllegalCharacter(string $path): bool  | 
                                                        
| 159 | 159 |      { | 
                                                        
| 160 | 160 | return Collection::from(self::INVALID_PATH_ASCII)  | 
                                                        
| 161 | - ->some(  | 
                                                        |
| 162 | -                             function (string $ascii) use ($path): bool { | 
                                                        |
| 163 | - return strpos($path, chr($ascii));  | 
                                                        |
| 164 | - }  | 
                                                        |
| 165 | - );  | 
                                                        |
| 161 | + ->some(  | 
                                                        |
| 162 | +                                function (string $ascii) use ($path): bool { | 
                                                        |
| 163 | + return strpos($path, chr($ascii));  | 
                                                        |
| 164 | + }  | 
                                                        |
| 165 | + );  | 
                                                        |
| 166 | 166 | }  | 
                                                        
| 167 | 167 | }  | 
                                                        
@@ -101,7 +101,7 @@ discard block  | 
                                                    ||
| 101 | 101 |      { | 
                                                        
| 102 | 102 | return Collection::from(self::INVALID_PATH_ASCII)  | 
                                                        
| 103 | 103 | ->map(  | 
                                                        
| 104 | -                             function (string $ascii) { | 
                                                        |
| 104 | +                             function(string $ascii) { | 
                                                        |
| 105 | 105 | return chr($ascii);  | 
                                                        
| 106 | 106 | }  | 
                                                        
| 107 | 107 | )  | 
                                                        
@@ -177,10 +177,10 @@ discard block  | 
                                                    ||
| 177 | 177 | ]  | 
                                                        
| 178 | 178 | )  | 
                                                        
| 179 | 179 |          ) { | 
                                                        
| 180 | - return "$path1" . self::DIRECTORY_SEPARATOR_CHAR . "$path2";  | 
                                                        |
| 180 | + return "$path1".self::DIRECTORY_SEPARATOR_CHAR."$path2";  | 
                                                        |
| 181 | 181 | }  | 
                                                        
| 182 | 182 | |
| 183 | - return $path1 . $path2;  | 
                                                        |
| 183 | + return $path1.$path2;  | 
                                                        |
| 184 | 184 | }  | 
                                                        
| 185 | 185 | |
| 186 | 186 | /**  | 
                                                        
@@ -203,7 +203,7 @@ discard block  | 
                                                    ||
| 203 | 203 |      { | 
                                                        
| 204 | 204 | return Collection::from(self::INVALID_PATH_ASCII)  | 
                                                        
| 205 | 205 | ->some(  | 
                                                        
| 206 | -                             function (string $ascii) use ($path): bool { | 
                                                        |
| 206 | +                             function(string $ascii) use ($path): bool { | 
                                                        |
| 207 | 207 | return strpos($path, chr($ascii));  | 
                                                        
| 208 | 208 | }  | 
                                                        
| 209 | 209 | );  | 
                                                        
@@ -5,13 +5,13 @@  | 
                                                    ||
| 5 | 5 | $badFileName = "C:\\mydir\\";  | 
                                                        
| 6 | 6 | |
| 7 | 7 | $result = Path::changeExtension($goodFileName, ".old");  | 
                                                        
| 8 | -echo $result . PHP_EOL;  | 
                                                        |
| 8 | +echo $result.PHP_EOL;  | 
                                                        |
| 9 | 9 | |
| 10 | 10 | $result = Path::changeExtension($goodFileName, "");  | 
                                                        
| 11 | -echo $result . PHP_EOL;  | 
                                                        |
| 11 | +echo $result.PHP_EOL;  | 
                                                        |
| 12 | 12 | |
| 13 | 13 | $result = Path::changeExtension($badFileName, ".old");  | 
                                                        
| 14 | -echo $result . PHP_EOL;  | 
                                                        |
| 14 | +echo $result.PHP_EOL;  | 
                                                        |
| 15 | 15 | |
| 16 | 16 | // This code produces output similar to the following:  | 
                                                        
| 17 | 17 | //  |