DirHelper::removeFinalSlash() - Code Metrics - Inspection of "1.4.0 - 2016-08-30" - padosoft/io - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4cd89c...f4a2e7 )

by Lorenzo

created 2016-08-30 12:41 UTC

DirHelper::removeFinalSlash() A

↳ Parent: DirHelper

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Padosoft\Io;

/**
 * Helper Class DirHelper
 * @package Padosoft\Io
 */
class DirHelper
{
    /**
     * Check if passed path exists or not.
     * @param string $filePath
     * @return bool
     */
    public static function isDirSafe(string $filePath) : bool
    {
        if (!$filePath) {
            return false;
        }

        return is_dir($filePath);
    }

    /**
     * Check if passed path exists or try to create it.
     * Return false if it fails to create it or if a file (and not a dir) passed as argument.
     * @param string $filePath
     * @param string $modeMask default '0755'
     * @return bool
     */
    public static function checkDirExistOrCreate(string $filePath, string $modeMask = '0755') : bool
    {
        if (self::isDirSafe($filePath)) {
            return true;
        }

        //controllo adesso che non sia un file
        if (FileHelper::fileExistsSafe($filePath)) {
            return false;
        }

        return mkdir($filePath, $modeMask, true) && self::isDirSafe($filePath);
    }

    /**
     * If dir passed, check if finishes with '/' otherwise append a slash to path.
     * If wrong or empty string passed, return '/'.
     * @param string $path
     * @return string
     */
    public static function addFinalSlash(string $path) : string
    {
        if ($path === null || $path == '') {
            return '/';
        }

        $quoted = preg_quote('/', '/');
        $path = preg_replace('/(?:' . $quoted . ')+$/', '', $path) . '/';

        return $path;
    }

    /**
     * for each dir passed in array, check if it finishes with '/' otherwise append a slash to path.
     * If not dir, leave the element untouched.
     * @param array $paths
     * @return array
     */
    public static function addFinalSlashToAllPaths(array $paths) : array
    {
        if (empty($paths)) {
            return [];
        }

        return array_map('self::addFinalSlash', $paths);
    }

    /**
     * Check if path ends with slash '/'
     * @param string $paths
     * @return bool
     */
    public static function endsWithSlash(string $paths) : bool
    {
        return self::endsWith($paths, '/');
    }

    /**
     * Check if path ends with star '*'
     * @param string $paths
     * @return bool
     */
    public static function endsWithStar(string $paths) : bool
    {
        return self::endsWith($paths, '*');
    }

    /**
     * Check if path ends with $needle
     * @param string $paths
     * @param string $needle
     * @return bool
     */
    public static function endsWith(string $paths, string $needle) : bool
    {
        if ($paths === null || $paths == '') {
            return false;
        }
        if ($needle === null || $needle == '') {
            return false;
        }

        // search forward starting from end minus needle length characters
        // see: http://stackoverflow.com/questions/834303/startswith-and-endswith-functions-in-php
        return (($temp = strlen($paths) - strlen($needle)) >= 0 && strpos($paths, $needle, $temp) !== false);
    }

    /**
     * Check if path starts with slash '/'
     * @param string $paths
     * @return bool
     */
    public static function startsWithSlash(string $paths) : bool
    {
        return self::startsWith($paths, '/');
    }

    /**
     * Check if path starts with slash $needle
     * @param string $paths
     * @param string $needle
     * @return bool
     */
    public static function startsWith(string $paths, string $needle) : bool
    {
        if ($paths === null || $paths == '') {
            return false;
        }
        if ($needle === null || $needle == '') {
            return false;
        }

        // search backwards starting from haystack length characters from the end
        // see: http://stackoverflow.com/questions/834303/startswith-and-endswith-functions-in-php
        return strrpos($paths, $needle, -strlen($paths)) !== false;
    }

    /**
     * Find dirs matching a pattern (recursive with subdirs).
     * Returns an array containing the matched dirs (full path and not files),
     * an empty array if no dir matched or on error.
     * @param string $pathPattern if is null it set to base_path()/* if exists otherwise __DIR__/*. It support glob() string pattern.
     * @return array of dirs
     */
    public static function findDirs(string $pathPattern)
    {
        if (($pathPattern === null || $pathPattern == '') && function_exists('base_path')) {
            $pathPattern = base_path() . '/*';
        } elseif ($pathPattern === null || $pathPattern == '') {
            $pathPattern = __DIR__ . '/*';
        } elseif (!self::endsWithStar($pathPattern)) {
            $pathPattern = DirHelper::addFinalSlash($pathPattern);
        }

        $files = glob($pathPattern, GLOB_ONLYDIR);

        foreach (glob(dirname($pathPattern) . '/*', GLOB_ONLYDIR | GLOB_NOSORT) as $dir) {
            $files = array_merge($files, self::findDirs($dir . '/' . basename($pathPattern)));
        }

        return $files;
    }

    /**
     * Dir::Delete()
     * get a dir path and remove all files and subdir in this dir.
     * if $not_remove_dir==TRUE then when finish DO NOT REMOVE THE $directory dir.
     * @param string $directory directory to empty
     * @param bool $not_remove_dir TRUE if DO NOT REMOVE THE $directory dir but only files.
     * @return bool true if success, otherwise false
     **/
    public static function delete($directory, bool $not_remove_dir = false) : bool
    {
        $directory = self::removeFinalSlash($directory);

        if (!self::isDirSafe($directory) || !is_readable($directory)) {
            return false;
        }

        $directoryHandle = opendir($directory);
        while (false !== ($contents = readdir($directoryHandle))) {
            if ($contents == '.' || $contents == '..') {
                continue;
            }
            $path = $directory . "/" . $contents;

            if (is_dir($path)) {
                self::delete($path, $not_remove_dir);
            } else {
                unlink($path);
            }
        }
        closedir($directoryHandle);

        if (!$not_remove_dir) {
            return true;
        }
        return rmdir($directory);
    }

    /**
     * Remove final slash ('/') char in dir if ends with slash.
     * @param $directory
     * @return string
     */
    public static function removeFinalSlash($directory) : string
    {
        if (self::endsWithSlash($directory)) {
            $directory = substr($directory, 0, -1);
        }
        return $directory;
    }

    /**
     * For each dir passed in array, check if not finishes with '/' otherwise remove a slash to path.
     * If not dir, leave the element untouched.
     * @param array $paths
     * @return array
     */
    public static function removeFinalSlashToAllPaths(array $paths) : array
    {
        if (empty($paths)) {
            return [];
        }

        return array_map('self::removeFinalSlash', $paths);
    }

    /**
     * Dir::copy()
     * Copy a source directory (files and all subdirectories) to destination directory.
     * If Destination directory doesn't exists try to create it.
     * @param $directorySource
     * @param $directoryDestination
     * @param array $excludedDirectory array of path to be escluded (i.e. it will not copied to destination folder)
     * @param \Closure|null $copied a function with two arguments  ($directorySource,$directoryDestination).
     * @return bool true if success, otherwise false
     */
    public static function copy(
        $directorySource,
        $directoryDestination,
        array $excludedDirectory = [],
        \Closure $copied = null
    ) : bool
    {
        $directorySource = self::removeFinalSlash($directorySource);
        if (!self::isDirSafe($directorySource) || !is_readable($directorySource)) {
            return false;
        }

        $directoryDestination = self::removeFinalSlash($directoryDestination);
        if (!self::checkDirExistOrCreate($directoryDestination)) {
            return false;
        }
        is_callable($copied) ? $copied($directorySource, $directoryDestination) : '';

        $excludedDirectory = self::removeFinalSlashToAllPaths($excludedDirectory);

        $directorySourceHandle = opendir($directorySource);
        while (false !== ($contents = readdir($directorySourceHandle))) {
            if ($contents == '.' || $contents == '..') {
                continue;
            }
            $path = $directorySource . "/" . $contents;
            if (in_array(DirHelper::removeFinalSlash($path), $excludedDirectory)) {
                continue;
            }
            $pathDest = $directoryDestination . "/" . $contents;

            if (is_dir($path)) {
                self::copy($path, $pathDest, $excludedDirectory);
            } else {
                copy($path, $pathDest);
                is_callable($copied) ? $copied($path, $pathDest) : '';
            }
        }
        closedir($directorySourceHandle);
        return true;
    }
}


1			<?php
2
3			namespace Padosoft\Io;
4
5			/**
6			* Helper Class DirHelper
7			* @package Padosoft\Io
8			*/
9			class DirHelper
10			{
11			/**
12			* Check if passed path exists or not.
13			* @param string $filePath
14			* @return bool
15			*/
16			public static function isDirSafe(string $filePath) : bool
17			{
18			if (!$filePath) {
19			return false;
20			}
21
22			return is_dir($filePath);
23			}
24
25			/**
26			* Check if passed path exists or try to create it.
27			* Return false if it fails to create it or if a file (and not a dir) passed as argument.
28			* @param string $filePath
29			* @param string $modeMask default '0755'
30			* @return bool
31			*/
32			public static function checkDirExistOrCreate(string $filePath, string $modeMask = '0755') : bool
33			{
34			if (self::isDirSafe($filePath)) {
35			return true;
36			}
37
38			//controllo adesso che non sia un file
39			if (FileHelper::fileExistsSafe($filePath)) {
40			return false;
41			}
42
43			return mkdir($filePath, $modeMask, true) && self::isDirSafe($filePath);
44			}
45
46			/**
47			* If dir passed, check if finishes with '/' otherwise append a slash to path.
48			* If wrong or empty string passed, return '/'.
49			* @param string $path
50			* @return string
51			*/
52			public static function addFinalSlash(string $path) : string
53			{
54			if ($path === null \|\| $path == '') {
55			return '/';
56			}
57
58			$quoted = preg_quote('/', '/');
59			$path = preg_replace('/(?:' . $quoted . ')+$/', '', $path) . '/';
60
61			return $path;
62			}
63
64			/**
65			* for each dir passed in array, check if it finishes with '/' otherwise append a slash to path.
66			* If not dir, leave the element untouched.
67			* @param array $paths
68			* @return array
69			*/
70			public static function addFinalSlashToAllPaths(array $paths) : array
71			{
72			if (empty($paths)) {
73			return [];
74			}
75
76			return array_map('self::addFinalSlash', $paths);
77			}
78
79			/**
80			* Check if path ends with slash '/'
81			* @param string $paths
82			* @return bool
83			*/
84			public static function endsWithSlash(string $paths) : bool
85			{
86			return self::endsWith($paths, '/');
87			}
88
89			/**
90			* Check if path ends with star '*'
91			* @param string $paths
92			* @return bool
93			*/
94			public static function endsWithStar(string $paths) : bool
95			{
96			return self::endsWith($paths, '*');
97			}
98
99			/**
100			* Check if path ends with $needle
101			* @param string $paths
102			* @param string $needle
103			* @return bool
104			*/
105			public static function endsWith(string $paths, string $needle) : bool
106			{
107			if ($paths === null \|\| $paths == '') {
108			return false;
109			}
110			if ($needle === null \|\| $needle == '') {
111			return false;
112			}
113
114			// search forward starting from end minus needle length characters
115			// see: http://stackoverflow.com/questions/834303/startswith-and-endswith-functions-in-php
116			return (($temp = strlen($paths) - strlen($needle)) >= 0 && strpos($paths, $needle, $temp) !== false);
117			}
118
119			/**
120			* Check if path starts with slash '/'
121			* @param string $paths
122			* @return bool
123			*/
124			public static function startsWithSlash(string $paths) : bool
125			{
126			return self::startsWith($paths, '/');
127			}
128
129			/**
130			* Check if path starts with slash $needle
131			* @param string $paths
132			* @param string $needle
133			* @return bool
134			*/
135			public static function startsWith(string $paths, string $needle) : bool
136			{
137			if ($paths === null \|\| $paths == '') {
138			return false;
139			}
140			if ($needle === null \|\| $needle == '') {
141			return false;
142			}
143
144			// search backwards starting from haystack length characters from the end
145			// see: http://stackoverflow.com/questions/834303/startswith-and-endswith-functions-in-php
146			return strrpos($paths, $needle, -strlen($paths)) !== false;
147			}
148
149			/**
150			* Find dirs matching a pattern (recursive with subdirs).
151			* Returns an array containing the matched dirs (full path and not files),
152			* an empty array if no dir matched or on error.
153			* @param string $pathPattern if is null it set to base_path()/* if exists otherwise __DIR__/*. It support glob() string pattern.
154			* @return array of dirs
155			*/
156			public static function findDirs(string $pathPattern)
157			{
158			if (($pathPattern === null \|\| $pathPattern == '') && function_exists('base_path')) {
159			$pathPattern = base_path() . '/*';
160			} elseif ($pathPattern === null \|\| $pathPattern == '') {
161			$pathPattern = __DIR__ . '/*';
162			} elseif (!self::endsWithStar($pathPattern)) {
163			$pathPattern = DirHelper::addFinalSlash($pathPattern);
164			}
165
166			$files = glob($pathPattern, GLOB_ONLYDIR);
167
168			foreach (glob(dirname($pathPattern) . '/*', GLOB_ONLYDIR \| GLOB_NOSORT) as $dir) {
169			$files = array_merge($files, self::findDirs($dir . '/' . basename($pathPattern)));
170			}
171
172			return $files;
173			}
174
175			/**
176			* Dir::Delete()
177			* get a dir path and remove all files and subdir in this dir.
178			* if $not_remove_dir==TRUE then when finish DO NOT REMOVE THE $directory dir.
179			* @param string $directory directory to empty
180			* @param bool $not_remove_dir TRUE if DO NOT REMOVE THE $directory dir but only files.
181			* @return bool true if success, otherwise false
182			**/
183			public static function delete($directory, bool $not_remove_dir = false) : bool
184			{
185			$directory = self::removeFinalSlash($directory);
186
187			if (!self::isDirSafe($directory) \|\| !is_readable($directory)) {
188			return false;
189			}
190
191			$directoryHandle = opendir($directory);
192			while (false !== ($contents = readdir($directoryHandle))) {
193			if ($contents == '.' \|\| $contents == '..') {
194			continue;
195			}
196			$path = $directory . "/" . $contents;
197
198			if (is_dir($path)) {
199			self::delete($path, $not_remove_dir);
200			} else {
201			unlink($path);
202			}
203			}
204			closedir($directoryHandle);
205
206			if (!$not_remove_dir) {
207			return true;
208			}
209			return rmdir($directory);
210			}
211
212			/**
213			* Remove final slash ('/') char in dir if ends with slash.
214			* @param $directory
215			* @return string
216			*/
217			public static function removeFinalSlash($directory) : string
218			{
219			if (self::endsWithSlash($directory)) {
220			$directory = substr($directory, 0, -1);
221			}
222			return $directory;
223			}
224
225			/**
226			* For each dir passed in array, check if not finishes with '/' otherwise remove a slash to path.
227			* If not dir, leave the element untouched.
228			* @param array $paths
229			* @return array
230			*/
231			public static function removeFinalSlashToAllPaths(array $paths) : array
232			{
233			if (empty($paths)) {
234			return [];
235			}
236
237			return array_map('self::removeFinalSlash', $paths);
238			}
239
240			/**
241			* Dir::copy()
242			* Copy a source directory (files and all subdirectories) to destination directory.
243			* If Destination directory doesn't exists try to create it.
244			* @param $directorySource
245			* @param $directoryDestination
246			* @param array $excludedDirectory array of path to be escluded (i.e. it will not copied to destination folder)
247			* @param \Closure\|null $copied a function with two arguments ($directorySource,$directoryDestination).
248			* @return bool true if success, otherwise false
249			*/
250			public static function copy(
251			$directorySource,
252			$directoryDestination,
253			array $excludedDirectory = [],
254			\Closure $copied = null
255			) : bool
256			{
257			$directorySource = self::removeFinalSlash($directorySource);
258			if (!self::isDirSafe($directorySource) \|\| !is_readable($directorySource)) {
259			return false;
260			}
261
262			$directoryDestination = self::removeFinalSlash($directoryDestination);
263			if (!self::checkDirExistOrCreate($directoryDestination)) {
264			return false;
265			}
266			is_callable($copied) ? $copied($directorySource, $directoryDestination) : '';
267
268			$excludedDirectory = self::removeFinalSlashToAllPaths($excludedDirectory);
269
270			$directorySourceHandle = opendir($directorySource);
271			while (false !== ($contents = readdir($directorySourceHandle))) {
272			if ($contents == '.' \|\| $contents == '..') {
273			continue;
274			}
275			$path = $directorySource . "/" . $contents;
276			if (in_array(DirHelper::removeFinalSlash($path), $excludedDirectory)) {
277			continue;
278			}
279			$pathDest = $directoryDestination . "/" . $contents;
280
281			if (is_dir($path)) {
282			self::copy($path, $pathDest, $excludedDirectory);
283			} else {
284			copy($path, $pathDest);
285			is_callable($copied) ? $copied($path, $pathDest) : '';
286			}
287			}
288			closedir($directorySourceHandle);
289			return true;
290			}
291			}
292

padosoft / io

Push — master ( 4cd89c...f4a2e7 )

DirHelper::removeFinalSlash() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like