UFileSystem::cleanPathname() - Code Metrics - Inspection of "Fix UFileSystem bug (getLines)" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — master ( 58ced6...beb6a4 )

by Jean-Christophe

created 2019-02-09 17:12 UTC

UFileSystem::cleanPathname() A

↳ Parent: UFileSystem

Complexity

Conditions	4
Paths	5

Size

Total Lines	12
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	6

Importance

Changes

Metric	Value
eloc	9
dl	0
loc	12
ccs	3
cts	6
cp	0.5
rs	9.9666
c	0
b	0
f	0
cc	4
nc	5
nop	1
crap	6

<?php

namespace Ubiquity\utils\base;

use Ubiquity\utils\base\traits\UFileSystemWriter;

/**
 * File system utilities
 * Ubiquity\utils\base$UFileSystem
 * This class is part of Ubiquity
 *
 * @author jcheron <[email protected]>
 * @version 1.0.2
 *
 */
class UFileSystem {
	use UFileSystemWriter;

	/**
	 * Find recursively pathnames matching a pattern
	 *
	 * @param string $pattern
	 * @param integer $flags
	 * @return array
	 */
	public static function glob_recursive($pattern, $flags = 0) {
		$files = \glob ( $pattern, $flags );
		foreach ( \glob ( \dirname ( $pattern ) . '/*', GLOB_ONLYDIR | GLOB_NOSORT ) as $dir ) {
			$files = \array_merge ( $files, self::glob_recursive ( $dir . '/' . \basename ( $pattern ), $flags ) );
		}
		return $files;
	}

	/**
	 * Deletes all files from a folder
	 *
	 * @param string $folder
	 */
	public static function deleteAllFilesFromFolder($folder) {
		$files = \glob ( $folder . '/*' );
		foreach ( $files as $file ) {
			if (\is_file ( $file ))
				\unlink ( $file );
		}
	}

	/**
	 * Deletes a file, in safe mode
	 *
	 * @param string $filename
	 * @return boolean
	 */
	public static function deleteFile($filename) {
		if (\file_exists ( $filename ))
			return \unlink ( $filename );
		return false;
	}

	/**
	 * Tests the existance and eventually creates a directory
	 *
	 * @param string $dir
	 * @param int $mode
	 * @param boolean $recursive
	 * @return boolean
	 */
	public static function safeMkdir($dir, $mode = 0777, $recursive = true) {
		if (! \is_dir ( $dir ))
			return \mkdir ( $dir, $mode, $recursive );
		return true;
	}

	/**
	 * Cleans a directory path by removing double backslashes or slashes and using DIRECTORY_SEPARATOR
	 *
	 * @param string $path
	 * @return string
	 */
	public static function cleanPathname($path) {
		if (UString::isNotNull ( $path )) {
			if (\DS === "/")
				$path = \str_replace ( "\\", \DS, $path );
			else
				$path = \str_replace ( "/", \DS, $path );
			$path = \str_replace ( \DS . \DS, \DS, $path );
			if (! UString::endswith ( $path, \DS )) {
				$path = $path . \DS;
			}
		}
		return $path;
	}

	/**
	 * Cleans a file path by removing double backslashes or slashes and using DIRECTORY_SEPARATOR
	 *
	 * @param string $path
	 * @return string
	 */
	public static function cleanFilePathname($path) {
		if (UString::isNotNull ( $path )) {
			if (\DS === "/")
				$path = \str_replace ( "\\", \DS, $path );
			else
				$path = \str_replace ( "/", \DS, $path );
			$path = \str_replace ( \DS . \DS, \DS, $path );
		}
		return $path;
	}

	/**
	 * Try to require a file, in safe mode
	 *
	 * @param string $file
	 * @return boolean
	 */
	public static function tryToRequire($file) {
		if (\file_exists ( $file )) {
			require_once ($file);
			return true;
		}
		return false;
	}

	/**
	 * Gets file modification time
	 *
	 * @param string $filename
	 * @return number
	 */
	public static function lastModified($filename) {
		return \filemtime ( $filename );
	}

	/**
	 * Reads entire file into a string in safe mode
	 *
	 * @param string $filename
	 * @return string|boolean
	 */
	public static function load($filename) {
		if (\file_exists ( $filename )) {
			return \file_get_contents ( $filename );
		}
		return false;
	}

	/**
	 * Returns the directory base on ROOT, corresponding to a namespace
	 *
	 * @param string $ns
	 * @return string
	 */
	public static function getDirFromNamespace($ns) {
		return \ROOT . \DS . str_replace ( "\\", \DS, $ns );
	}

	/**
	 * Deletes recursivly a folder and its content
	 *
	 * @param string $dir
	 * @return boolean
	 */
	public static function delTree($dir) {
		$files = array_diff ( scandir ( $dir ), array ('.','..' ) );
		foreach ( $files as $file ) {
			(is_dir ( "$dir/$file" )) ? self::delTree ( "$dir/$file" ) : unlink ( "$dir/$file" );
		}
		return rmdir ( $dir );
	}

	/**
	 * Returns the lines of a file in an array
	 *
	 * @param string $filename
	 * @param boolean $reverse
	 * @param null|int $maxLines
	 * @param callback $lineCallback
	 * @return array
	 */
	public static function getLines($filename, $reverse = false, $maxLines = null, $lineCallback = null) {
		if (file_exists ( $filename )) {
			$result = [ ];
			if ($reverse && isset ( $maxLines )) {
				$fl = fopen ( $filename, "r" );
				for($x_pos = 0, $ln = 0, $lines = [ ]; fseek ( $fl, $x_pos, SEEK_END ) !== - 1; $x_pos --) {
					$char = fgetc ( $fl );
					if ($char === "\n") {
						if (is_callable ( $lineCallback )) {
							$lineCallback ( $result, $lines [$ln] );
						} else {
							$result [] = $lines [$ln];
						}
						if (isset ( $maxLines ) && sizeof ( $result ) >= $maxLines) {
							fclose ( $fl );
							return $result;
						}
						$ln ++;
						continue;
					}
					$lines [$ln] = $char . ((array_key_exists ( $ln, $lines )) ? $lines [$ln] : '');
				}
				fclose ( $fl );
				return $result;
			} else {
				$handle = fopen ( $filename, "r" );
				if ($handle) {
					while ( ($line = fgets ( $handle )) !== false ) {
						if (is_callable ( $lineCallback )) {
							$lineCallback ( $result, $line );
						} else {
							$result [] = $line;
						}
						if (isset ( $maxLines ) && sizeof ( $result ) >= $maxLines) {
							fclose ( $handle );
							if (is_array ( $result ) && $reverse) {
								$result = array_reverse ( $result );
							}
							return $result;
						}
					}
					fclose ( $handle );
				} else {
					// error opening the file.
				}
				if ($reverse) {
					$result = array_reverse ( $result );
				}
				return $result;
			}
		}
		return [ ];
	}
}


1		<?php
2
3		namespace Ubiquity\utils\base;
4
5		use Ubiquity\utils\base\traits\UFileSystemWriter;
6
7		/**
8		* File system utilities
9		* Ubiquity\utils\base$UFileSystem
10		* This class is part of Ubiquity
11		*
12		* @author jcheron <[email protected]>
13		* @version 1.0.2
14		*
15		*/
16	11	class UFileSystem {
17	11	use UFileSystemWriter;
18	11
19	4	/**
20		* Find recursively pathnames matching a pattern
21	11	*
22		* @param string $pattern
23		* @param integer $flags
24		* @return array
25		*/
26		public static function glob_recursive($pattern, $flags = 0) {
27		$files = \glob ( $pattern, $flags );
28		foreach ( \glob ( \dirname ( $pattern ) . '/*', GLOB_ONLYDIR \| GLOB_NOSORT ) as $dir ) {
29		$files = \array_merge ( $files, self::glob_recursive ( $dir . '/' . \basename ( $pattern ), $flags ) );
30		}
31		return $files;
32		}
33
34		/**
35		* Deletes all files from a folder
36		*
37		* @param string $folder
38	9	*/
39	9	public static function deleteAllFilesFromFolder($folder) {
40	4	$files = \glob ( $folder . '/*' );
41	6	foreach ( $files as $file ) {
42		if (\is_file ( $file ))
43		\unlink ( $file );
44	7	}
45	7	}
46	7
47	7	/**
48		* Deletes a file, in safe mode
49		*
50	7	* @param string $filename
51	7	* @return boolean
52	3	*/
53		public static function deleteFile($filename) {
54		if (\file_exists ( $filename ))
55	7	return \unlink ( $filename );
56		return false;
57		}
58	4
59	4	/**
60	4	* Tests the existance and eventually creates a directory
61	4	*
62		* @param string $dir
63		* @param int $mode
64	4	* @param boolean $recursive
65		* @return boolean
66	4	*/
67		public static function safeMkdir($dir, $mode = 0777, $recursive = true) {
68		if (! \is_dir ( $dir ))
69		return \mkdir ( $dir, $mode, $recursive );
70		return true;
71		}
72
73		/**
74		* Cleans a directory path by removing double backslashes or slashes and using DIRECTORY_SEPARATOR
75		*
76		* @param string $path
77	1	* @return string
78	1	*/
79		public static function cleanPathname($path) {
80		if (UString::isNotNull ( $path )) {
81	1	if (\DS === "/")
82	1	$path = \str_replace ( "\\", \DS, $path );
83	1	else
84		$path = \str_replace ( "/", \DS, $path );
85		$path = \str_replace ( \DS . \DS, \DS, $path );
86		if (! UString::endswith ( $path, \DS )) {
87		$path = $path . \DS;
88		}
89		}
90		return $path;
91		}
92
93		/**
94		* Cleans a file path by removing double backslashes or slashes and using DIRECTORY_SEPARATOR
95		*
96		* @param string $path
97		* @return string
98		*/
99		public static function cleanFilePathname($path) {
100	1	if (UString::isNotNull ( $path )) {
101	1	if (\DS === "/")
102		$path = \str_replace ( "\\", \DS, $path );
103		else
104		$path = \str_replace ( "/", \DS, $path );
105		$path = \str_replace ( \DS . \DS, \DS, $path );
106		}
107		return $path;
108		}
109
110		/**
111		* Try to require a file, in safe mode
112		*
113		* @param string $file
114		* @return boolean
115		*/
116		public static function tryToRequire($file) {
117		if (\file_exists ( $file )) {
118		require_once ($file);
119		return true;
120		}
121		return false;
122		}
123
124		/**
125		* Gets file modification time
126		*
127		* @param string $filename
128		* @return number
129		*/
130		public static function lastModified($filename) {
131		return \filemtime ( $filename );
132		}
133
134		/**
135		* Reads entire file into a string in safe mode
136		*
137		* @param string $filename
138		* @return string\|boolean
139		*/
140		public static function load($filename) {
141		if (\file_exists ( $filename )) {
142		return \file_get_contents ( $filename );
143		}
144		return false;
145		}
146
147		/**
148		* Returns the directory base on ROOT, corresponding to a namespace
149		*
150		* @param string $ns
151	1	* @return string
152		*/
153		public static function getDirFromNamespace($ns) {
154		return \ROOT . \DS . str_replace ( "\\", \DS, $ns );
155		}
156
157		/**
158		* Deletes recursivly a folder and its content
159		*
160		* @param string $dir
161		* @return boolean
162		*/
163		public static function delTree($dir) {
164		$files = array_diff ( scandir ( $dir ), array ('.','..' ) );
165		foreach ( $files as $file ) {
166		(is_dir ( "$dir/$file" )) ? self::delTree ( "$dir/$file" ) : unlink ( "$dir/$file" );
167		}
168		return rmdir ( $dir );
169		}
170
171		/**
172		* Returns the lines of a file in an array
173		*
174		* @param string $filename
175		* @param boolean $reverse
176		* @param null\|int $maxLines
177		* @param callback $lineCallback
178		* @return array
179		*/
180		public static function getLines($filename, $reverse = false, $maxLines = null, $lineCallback = null) {
181		if (file_exists ( $filename )) {
182		$result = [ ];
183		if ($reverse && isset ( $maxLines )) {
184		$fl = fopen ( $filename, "r" );
185		for($x_pos = 0, $ln = 0, $lines = [ ]; fseek ( $fl, $x_pos, SEEK_END ) !== - 1; $x_pos --) {
186		$char = fgetc ( $fl );
187		if ($char === "\n") {
188		if (is_callable ( $lineCallback )) {
189		$lineCallback ( $result, $lines [$ln] );
190		} else {
191		$result [] = $lines [$ln];
192		}
193		if (isset ( $maxLines ) && sizeof ( $result ) >= $maxLines) {
194		fclose ( $fl );
195		return $result;
196		}
197		$ln ++;
198		continue;
199		}
200		$lines [$ln] = $char . ((array_key_exists ( $ln, $lines )) ? $lines [$ln] : '');
201		}
202		fclose ( $fl );
203		return $result;
204		} else {
205		$handle = fopen ( $filename, "r" );
206		if ($handle) {
207		while ( ($line = fgets ( $handle )) !== false ) {
208		if (is_callable ( $lineCallback )) {
209		$lineCallback ( $result, $line );
210		} else {
211		$result [] = $line;
212		}
213		if (isset ( $maxLines ) && sizeof ( $result ) >= $maxLines) {
214		fclose ( $handle );
215		if (is_array ( $result ) && $reverse) {
216		$result = array_reverse ( $result );
217		}
218		return $result;
219		}
220		}
221		fclose ( $handle );
222		} else {
223		// error opening the file.
224		}
225		if ($reverse) {
226		$result = array_reverse ( $result );
227		}
228		return $result;
229		}
230		}
231		return [ ];
232		}
233		}
234

phpMv / ubiquity

Push — master ( 58ced6...beb6a4 )

UFileSystem::cleanPathname() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like