Path::checkInvalidPathChars() - Code Metrics - roukmoute/io - Measure and Improve Code Quality continuously with Scrutinizer

Path::checkInvalidPathChars() A
last analyzed 2017-04-24 12:37 UTC

↳ Parent: Path

Complexity

Conditions	2
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Roukmoute\IO;

use DusanKasan\Knapsack\Collection;

/**
 * Provides methods for processing directory strings.
 * The methods will handle most string operations.
 */
class Path
{
    /**
     * Platform specific directory separator character.
     * This is backslash ('\') on Windows, slash ('/') on Unix, and colon (':') on Mac.
     */
    const DIRECTORY_SEPARATOR_CHAR = '\\';

    /**
     * Platform specific alternate directory separator character.
     * This is backslash ('\') on Unix, and slash ('/') on Windows and MacOS.
     */
    const ALTDIRECTORY_SEPARATOR_CHAR = '/';

    /**
     * Platform specific volume separator character.
     * This is colon (':') on Windows and MacOS, and slash ('/') on Unix.
     *
     * This is mostly useful for parsing paths like
     * "c:\windows" or "MacVolume:System Folder".
     */
    const VOLUME_SEPARATOR_CHAR = ':';

    const INVALID_PATH_ASCII = [
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
        21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
        31, 34, 60, 62, 124
    ];

    /**
     * Changes the extension of a path string.
     *
     * If path is null, the function returns null.
     *
     * @param string $path      The path information to modify.
     *                          The path cannot contain any of the characters
     *                          defined in invalidPathChars.
     *                          If it does not contain a file extension,
     *                          the new file extension is appended to the path.
     * @param string $extension The new extension (with or without a leading period).
     *                          Specify null to remove an existing extension from path.
     *                          If it is null, any existing extension is removed from path.
     *
     * @return string           A file path with the same root, directory,
     *                          and base name parts as path,
     *                          but with the file extension changed
     *                          to the specified extension.
     */
    public static function changeExtension(string $path, string $extension = null): string
    {
        self::checkInvalidPathChars($path);

        $newPath = $path;
        $pathLength = mb_strlen($path);

        for ($i = $pathLength; --$i >= 0;) {
            $character = $path[$i];

            if ($character == '.') {
                $newPath = mb_substr($newPath, 0, $i);
                break;
            }

            if (in_array(
                $character,
                [
                    self::DIRECTORY_SEPARATOR_CHAR,
                    self::ALTDIRECTORY_SEPARATOR_CHAR,
                    self::VOLUME_SEPARATOR_CHAR,
                ]
            )) {
                break;
            }
        }

        if ($extension !== null && $pathLength !== 0) {
            if (mb_strlen($extension) === 0 || $extension[0] !== '.') {
                $newPath .= ".";
            }
            $newPath .= $extension;
        }

        return $newPath;
    }

    /**
     * Gets an array containing the characters that are not allowed in path names.
     */
    public static function invalidPathChars(): array
    {
        return Collection::from(self::INVALID_PATH_ASCII)
                         ->map(
                             function (string $ascii) {
                                 return chr($ascii);
                             }
                         )
                         ->toArray();
    }

    /**
     * Gets a value indicating whether the specified path string contains a root.
     *
     * A path is considered rooted if it starts with a backslash ("\")
     * or a drive letter and a colon (":").
     *
     * @param string $path  The path to test.
     *
     * @return bool         true if path contains a root; otherwise, false.
     */
    public static function isPathRooted(string $path): bool
    {
        if ($path != null) {
            self::checkInvalidPathChars($path);

            $pathLength = mb_strlen($path);
            if (($pathLength >= 1 &&
                    (
                        $path[0] == self::DIRECTORY_SEPARATOR_CHAR
                        || $path[0] == self::ALTDIRECTORY_SEPARATOR_CHAR
                    )
                )
                || ($pathLength >= 2 && $path[1] == self::VOLUME_SEPARATOR_CHAR)
            ) {
                return true;
            }
        }

        return false;
    }

    /**
     * Combines two strings into a path.
     *
     * @param string $path1 The first path to combine.
     * @param string $path2 The second path to combine.
     *
     * @return string       The combined paths.
     *                      If one of the specified paths is a zero-length string,
     *                      this method returns the other path.
     *                      If path2 contains an absolute path,
     *                      this method returns path2.
     */
    public static function combine(string $path1, string $path2): string
    {
        self::hasIllegalCharacter($path1);
        self::hasIllegalCharacter($path2);

        if (mb_strlen($path2) == 0) {
            return $path1;
        }

        if (mb_strlen($path1) == 0) {
            return $path2;
        }

        if (self::isPathRooted($path2)) {
            return $path2;
        }

        if (!in_array(
            $path1[mb_strlen($path1) - 1],
            [
                self::DIRECTORY_SEPARATOR_CHAR,
                self::ALTDIRECTORY_SEPARATOR_CHAR,
                self::VOLUME_SEPARATOR_CHAR,
            ]
        )
        ) {
            return "$path1" . DIRECTORY_SEPARATOR . "$path2";
        }

        return $path1 . $path2;
    }

    /**
     * Check if contains one or more of the invalid characters
     * defined in invalidPathChars.
     */
    private static function checkInvalidPathChars(string $path): void
    {
        if (self::hasIllegalCharacter($path)) {
            throw new \InvalidArgumentException("'$path': This file name is not valid.");
        }
    }

    /**
     * Indicates if the given path contains invalid characters.
     * (", <, >, or any ASCII char whose integer representation
     * is in the range of 0 through 31)
     */
    private static function hasIllegalCharacter(string $path): bool
    {
        return Collection::from(self::INVALID_PATH_ASCII)
                         ->some(
                             function (string $ascii) use ($path): bool {
                                 return strpos($path, chr($ascii));
                             }
                         );
    }
}


1			<?php
2
3			namespace Roukmoute\IO;
4
5			use DusanKasan\Knapsack\Collection;
6
7			/**
8			* Provides methods for processing directory strings.
9			* The methods will handle most string operations.
10			*/
11			class Path
12			{
13			/**
14			* Platform specific directory separator character.
15			* This is backslash ('\') on Windows, slash ('/') on Unix, and colon (':') on Mac.
16			*/
17			const DIRECTORY_SEPARATOR_CHAR = '\\';
18
19			/**
20			* Platform specific alternate directory separator character.
21			* This is backslash ('\') on Unix, and slash ('/') on Windows and MacOS.
22			*/
23			const ALTDIRECTORY_SEPARATOR_CHAR = '/';
24
25			/**
26			* Platform specific volume separator character.
27			* This is colon (':') on Windows and MacOS, and slash ('/') on Unix.
28			*
29			* This is mostly useful for parsing paths like
30			* "c:\windows" or "MacVolume:System Folder".
31			*/
32			const VOLUME_SEPARATOR_CHAR = ':';
33
34			const INVALID_PATH_ASCII = [
35			0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
36			11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
37			21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
38			31, 34, 60, 62, 124
39			];
40
41			/**
42			* Changes the extension of a path string.
43			*
44			* If path is null, the function returns null.
45			*
46			* @param string $path The path information to modify.
47			* The path cannot contain any of the characters
48			* defined in invalidPathChars.
49			* If it does not contain a file extension,
50			* the new file extension is appended to the path.
51			* @param string $extension The new extension (with or without a leading period).
52			* Specify null to remove an existing extension from path.
53			* If it is null, any existing extension is removed from path.
54			*
55			* @return string A file path with the same root, directory,
56			* and base name parts as path,
57			* but with the file extension changed
58			* to the specified extension.
59			*/
60			public static function changeExtension(string $path, string $extension = null): string
61			{
62			self::checkInvalidPathChars($path);
63
64			$newPath = $path;
65			$pathLength = mb_strlen($path);
66
67			for ($i = $pathLength; --$i >= 0;) {
68			$character = $path[$i];
69
70			if ($character == '.') {
71			$newPath = mb_substr($newPath, 0, $i);
72			break;
73			}
74
75			if (in_array(
76			$character,
77			[
78			self::DIRECTORY_SEPARATOR_CHAR,
79			self::ALTDIRECTORY_SEPARATOR_CHAR,
80			self::VOLUME_SEPARATOR_CHAR,
81			]
82			)) {
83			break;
84			}
85			}
86
87			if ($extension !== null && $pathLength !== 0) {
88			if (mb_strlen($extension) === 0 \|\| $extension[0] !== '.') {
89			$newPath .= ".";
90			}
91			$newPath .= $extension;
92			}
93
94			return $newPath;
95			}
96
97			/**
98			* Gets an array containing the characters that are not allowed in path names.
99			*/
100			public static function invalidPathChars(): array
101			{
102			return Collection::from(self::INVALID_PATH_ASCII)
103			->map(
104			function (string $ascii) {
105			return chr($ascii);
106			}
107			)
108			->toArray();
109			}
110
111			/**
112			* Gets a value indicating whether the specified path string contains a root.
113			*
114			* A path is considered rooted if it starts with a backslash ("\")
115			* or a drive letter and a colon (":").
116			*
117			* @param string $path The path to test.
118			*
119			* @return bool true if path contains a root; otherwise, false.
120			*/
121			public static function isPathRooted(string $path): bool
122			{
123			if ($path != null) {
124			self::checkInvalidPathChars($path);
125
126			$pathLength = mb_strlen($path);
127			if (($pathLength >= 1 &&
128			(
129			$path[0] == self::DIRECTORY_SEPARATOR_CHAR
130			\|\| $path[0] == self::ALTDIRECTORY_SEPARATOR_CHAR
131			)
132			)
133			\|\| ($pathLength >= 2 && $path[1] == self::VOLUME_SEPARATOR_CHAR)
134			) {
135			return true;
136			}
137			}
138
139			return false;
140			}
141
142			/**
143			* Combines two strings into a path.
144			*
145			* @param string $path1 The first path to combine.
146			* @param string $path2 The second path to combine.
147			*
148			* @return string The combined paths.
149			* If one of the specified paths is a zero-length string,
150			* this method returns the other path.
151			* If path2 contains an absolute path,
152			* this method returns path2.
153			*/
154			public static function combine(string $path1, string $path2): string
155			{
156			self::hasIllegalCharacter($path1);
157			self::hasIllegalCharacter($path2);
158
159			if (mb_strlen($path2) == 0) {
160			return $path1;
161			}
162
163			if (mb_strlen($path1) == 0) {
164			return $path2;
165			}
166
167			if (self::isPathRooted($path2)) {
168			return $path2;
169			}
170
171			if (!in_array(
172			$path1[mb_strlen($path1) - 1],
173			[
174			self::DIRECTORY_SEPARATOR_CHAR,
175			self::ALTDIRECTORY_SEPARATOR_CHAR,
176			self::VOLUME_SEPARATOR_CHAR,
177			]
178			)
179			) {
180			return "$path1" . DIRECTORY_SEPARATOR . "$path2";
181			}
182
183			return $path1 . $path2;
184			}
185
186			/**
187			* Check if contains one or more of the invalid characters
188			* defined in invalidPathChars.
189			*/
190			private static function checkInvalidPathChars(string $path): void
191			{
192			if (self::hasIllegalCharacter($path)) {
193			throw new \InvalidArgumentException("'$path': This file name is not valid.");
194			}
195			}
196
197			/**
198			* Indicates if the given path contains invalid characters.
199			* (", <, >, or any ASCII char whose integer representation
200			* is in the range of 0 through 31)
201			*/
202			private static function hasIllegalCharacter(string $path): bool
203			{
204			return Collection::from(self::INVALID_PATH_ASCII)
205			->some(
206			function (string $ascii) use ($path): bool {
207			return strpos($path, chr($ascii));
208			}
209			);
210			}
211			}
212

roukmoute / io

Path::checkInvalidPathChars() A last analyzed 2017-04-24 12:37 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Path::checkInvalidPathChars() A
last analyzed 2017-04-24 12:37 UTC