pictcode / lib / Cake / Utility / Folder.php @ 635eef61
履歴 | 表示 | アノテート | ダウンロード (23.755 KB)
| 1 |
<?php
|
|---|---|
| 2 |
/**
|
| 3 |
* CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
|
| 4 |
* Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
|
| 5 |
*
|
| 6 |
* Licensed under The MIT License
|
| 7 |
* For full copyright and license information, please see the LICENSE.txt
|
| 8 |
* Redistributions of files must retain the above copyright notice.
|
| 9 |
*
|
| 10 |
* @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
|
| 11 |
* @link http://cakephp.org CakePHP(tm) Project
|
| 12 |
* @package Cake.Utility
|
| 13 |
* @since CakePHP(tm) v 0.2.9
|
| 14 |
* @license http://www.opensource.org/licenses/mit-license.php MIT License
|
| 15 |
*/
|
| 16 |
|
| 17 |
/**
|
| 18 |
* Folder structure browser, lists folders and files.
|
| 19 |
* Provides an Object interface for Common directory related tasks.
|
| 20 |
*
|
| 21 |
* @package Cake.Utility
|
| 22 |
*/
|
| 23 |
class Folder { |
| 24 |
|
| 25 |
/**
|
| 26 |
* Default scheme for Folder::copy
|
| 27 |
* Recursively merges subfolders with the same name
|
| 28 |
*
|
| 29 |
* @var string
|
| 30 |
*/
|
| 31 |
const MERGE = 'merge'; |
| 32 |
|
| 33 |
/**
|
| 34 |
* Overwrite scheme for Folder::copy
|
| 35 |
* subfolders with the same name will be replaced
|
| 36 |
*
|
| 37 |
* @var string
|
| 38 |
*/
|
| 39 |
const OVERWRITE = 'overwrite'; |
| 40 |
|
| 41 |
/**
|
| 42 |
* Skip scheme for Folder::copy
|
| 43 |
* if a subfolder with the same name exists it will be skipped
|
| 44 |
*
|
| 45 |
* @var string
|
| 46 |
*/
|
| 47 |
const SKIP = 'skip'; |
| 48 |
|
| 49 |
/**
|
| 50 |
* Path to Folder.
|
| 51 |
*
|
| 52 |
* @var string
|
| 53 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::$path
|
| 54 |
*/
|
| 55 |
public $path = null; |
| 56 |
|
| 57 |
/**
|
| 58 |
* Sortedness. Whether or not list results
|
| 59 |
* should be sorted by name.
|
| 60 |
*
|
| 61 |
* @var bool
|
| 62 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::$sort
|
| 63 |
*/
|
| 64 |
public $sort = false; |
| 65 |
|
| 66 |
/**
|
| 67 |
* Mode to be used on create. Does nothing on Windows platforms.
|
| 68 |
*
|
| 69 |
* @var int
|
| 70 |
* http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::$mode
|
| 71 |
*/
|
| 72 |
public $mode = 0755; |
| 73 |
|
| 74 |
/**
|
| 75 |
* Holds messages from last method.
|
| 76 |
*
|
| 77 |
* @var array
|
| 78 |
*/
|
| 79 |
protected $_messages = array(); |
| 80 |
|
| 81 |
/**
|
| 82 |
* Holds errors from last method.
|
| 83 |
*
|
| 84 |
* @var array
|
| 85 |
*/
|
| 86 |
protected $_errors = array(); |
| 87 |
|
| 88 |
/**
|
| 89 |
* Holds array of complete directory paths.
|
| 90 |
*
|
| 91 |
* @var array
|
| 92 |
*/
|
| 93 |
protected $_directories; |
| 94 |
|
| 95 |
/**
|
| 96 |
* Holds array of complete file paths.
|
| 97 |
*
|
| 98 |
* @var array
|
| 99 |
*/
|
| 100 |
protected $_files; |
| 101 |
|
| 102 |
/**
|
| 103 |
* Constructor.
|
| 104 |
*
|
| 105 |
* @param string $path Path to folder
|
| 106 |
* @param bool $create Create folder if not found
|
| 107 |
* @param string|bool $mode Mode (CHMOD) to apply to created folder, false to ignore
|
| 108 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder
|
| 109 |
*/
|
| 110 |
public function __construct($path = false, $create = false, $mode = false) { |
| 111 |
if (empty($path)) { |
| 112 |
$path = TMP; |
| 113 |
} |
| 114 |
if ($mode) { |
| 115 |
$this->mode = $mode; |
| 116 |
} |
| 117 |
|
| 118 |
if (!file_exists($path) && $create === true) { |
| 119 |
$this->create($path, $this->mode); |
| 120 |
} |
| 121 |
if (!Folder::isAbsolute($path)) { |
| 122 |
$path = realpath($path); |
| 123 |
} |
| 124 |
if (!empty($path)) { |
| 125 |
$this->cd($path); |
| 126 |
} |
| 127 |
} |
| 128 |
|
| 129 |
/**
|
| 130 |
* Return current path.
|
| 131 |
*
|
| 132 |
* @return string Current path
|
| 133 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::pwd
|
| 134 |
*/
|
| 135 |
public function pwd() { |
| 136 |
return $this->path; |
| 137 |
} |
| 138 |
|
| 139 |
/**
|
| 140 |
* Change directory to $path.
|
| 141 |
*
|
| 142 |
* @param string $path Path to the directory to change to
|
| 143 |
* @return string The new path. Returns false on failure
|
| 144 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::cd
|
| 145 |
*/
|
| 146 |
public function cd($path) { |
| 147 |
$path = $this->realpath($path); |
| 148 |
if (is_dir($path)) { |
| 149 |
return $this->path = $path; |
| 150 |
} |
| 151 |
return false; |
| 152 |
} |
| 153 |
|
| 154 |
/**
|
| 155 |
* Returns an array of the contents of the current directory.
|
| 156 |
* The returned array holds two arrays: One of directories and one of files.
|
| 157 |
*
|
| 158 |
* @param bool $sort Whether you want the results sorted, set this and the sort property
|
| 159 |
* to false to get unsorted results.
|
| 160 |
* @param array|bool $exceptions Either an array or boolean true will not grab dot files
|
| 161 |
* @param bool $fullPath True returns the full path
|
| 162 |
* @return mixed Contents of current directory as an array, an empty array on failure
|
| 163 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::read
|
| 164 |
*/
|
| 165 |
public function read($sort = true, $exceptions = false, $fullPath = false) { |
| 166 |
$dirs = $files = array(); |
| 167 |
|
| 168 |
if (!$this->pwd()) { |
| 169 |
return array($dirs, $files); |
| 170 |
} |
| 171 |
if (is_array($exceptions)) { |
| 172 |
$exceptions = array_flip($exceptions); |
| 173 |
} |
| 174 |
$skipHidden = isset($exceptions['.']) || $exceptions === true; |
| 175 |
|
| 176 |
try {
|
| 177 |
$iterator = new DirectoryIterator($this->path); |
| 178 |
} catch (Exception $e) { |
| 179 |
return array($dirs, $files); |
| 180 |
} |
| 181 |
|
| 182 |
foreach ($iterator as $item) { |
| 183 |
if ($item->isDot()) { |
| 184 |
continue;
|
| 185 |
} |
| 186 |
$name = $item->getFileName(); |
| 187 |
if ($skipHidden && $name[0] === '.' || isset($exceptions[$name])) { |
| 188 |
continue;
|
| 189 |
} |
| 190 |
if ($fullPath) { |
| 191 |
$name = $item->getPathName(); |
| 192 |
} |
| 193 |
if ($item->isDir()) { |
| 194 |
$dirs[] = $name; |
| 195 |
} else {
|
| 196 |
$files[] = $name; |
| 197 |
} |
| 198 |
} |
| 199 |
if ($sort || $this->sort) { |
| 200 |
sort($dirs); |
| 201 |
sort($files); |
| 202 |
} |
| 203 |
return array($dirs, $files); |
| 204 |
} |
| 205 |
|
| 206 |
/**
|
| 207 |
* Returns an array of all matching files in current directory.
|
| 208 |
*
|
| 209 |
* @param string $regexpPattern Preg_match pattern (Defaults to: .*)
|
| 210 |
* @param bool $sort Whether results should be sorted.
|
| 211 |
* @return array Files that match given pattern
|
| 212 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::find
|
| 213 |
*/
|
| 214 |
public function find($regexpPattern = '.*', $sort = false) { |
| 215 |
list(, $files) = $this->read($sort); |
| 216 |
return array_values(preg_grep('/^' . $regexpPattern . '$/i', $files)); |
| 217 |
} |
| 218 |
|
| 219 |
/**
|
| 220 |
* Returns an array of all matching files in and below current directory.
|
| 221 |
*
|
| 222 |
* @param string $pattern Preg_match pattern (Defaults to: .*)
|
| 223 |
* @param bool $sort Whether results should be sorted.
|
| 224 |
* @return array Files matching $pattern
|
| 225 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::findRecursive
|
| 226 |
*/
|
| 227 |
public function findRecursive($pattern = '.*', $sort = false) { |
| 228 |
if (!$this->pwd()) { |
| 229 |
return array(); |
| 230 |
} |
| 231 |
$startsOn = $this->path; |
| 232 |
$out = $this->_findRecursive($pattern, $sort); |
| 233 |
$this->cd($startsOn); |
| 234 |
return $out; |
| 235 |
} |
| 236 |
|
| 237 |
/**
|
| 238 |
* Private helper function for findRecursive.
|
| 239 |
*
|
| 240 |
* @param string $pattern Pattern to match against
|
| 241 |
* @param bool $sort Whether results should be sorted.
|
| 242 |
* @return array Files matching pattern
|
| 243 |
*/
|
| 244 |
protected function _findRecursive($pattern, $sort = false) { |
| 245 |
list($dirs, $files) = $this->read($sort); |
| 246 |
$found = array(); |
| 247 |
|
| 248 |
foreach ($files as $file) { |
| 249 |
if (preg_match('/^' . $pattern . '$/i', $file)) { |
| 250 |
$found[] = Folder::addPathElement($this->path, $file); |
| 251 |
} |
| 252 |
} |
| 253 |
$start = $this->path; |
| 254 |
|
| 255 |
foreach ($dirs as $dir) { |
| 256 |
$this->cd(Folder::addPathElement($start, $dir)); |
| 257 |
$found = array_merge($found, $this->findRecursive($pattern, $sort)); |
| 258 |
} |
| 259 |
return $found; |
| 260 |
} |
| 261 |
|
| 262 |
/**
|
| 263 |
* Returns true if given $path is a Windows path.
|
| 264 |
*
|
| 265 |
* @param string $path Path to check
|
| 266 |
* @return bool true if Windows path, false otherwise
|
| 267 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::isWindowsPath
|
| 268 |
*/
|
| 269 |
public static function isWindowsPath($path) { |
| 270 |
return (preg_match('/^[A-Z]:\\\\/i', $path) || substr($path, 0, 2) === '\\\\'); |
| 271 |
} |
| 272 |
|
| 273 |
/**
|
| 274 |
* Returns true if given $path is an absolute path.
|
| 275 |
*
|
| 276 |
* @param string $path Path to check
|
| 277 |
* @return bool true if path is absolute.
|
| 278 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::isAbsolute
|
| 279 |
*/
|
| 280 |
public static function isAbsolute($path) { |
| 281 |
if (empty($path)) { |
| 282 |
return false; |
| 283 |
} |
| 284 |
|
| 285 |
return $path[0] === '/' || |
| 286 |
preg_match('/^[A-Z]:\\\\/i', $path) || |
| 287 |
substr($path, 0, 2) === '\\\\' || |
| 288 |
static::isRegisteredStreamWrapper($path); |
| 289 |
} |
| 290 |
|
| 291 |
/**
|
| 292 |
* Returns true if given $path is a registered stream wrapper.
|
| 293 |
*
|
| 294 |
* @param string $path Path to check
|
| 295 |
* @return boo true If path is registered stream wrapper.
|
| 296 |
*/
|
| 297 |
public static function isRegisteredStreamWrapper($path) { |
| 298 |
if (preg_match('/^[A-Z]+(?=:\/\/)/i', $path, $matches) && |
| 299 |
in_array($matches[0], stream_get_wrappers()) |
| 300 |
) {
|
| 301 |
return true; |
| 302 |
} |
| 303 |
return false; |
| 304 |
} |
| 305 |
|
| 306 |
/**
|
| 307 |
* Returns a correct set of slashes for given $path. (\\ for Windows paths and / for other paths.)
|
| 308 |
*
|
| 309 |
* @param string $path Path to check
|
| 310 |
* @return string Set of slashes ("\\" or "/")
|
| 311 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::normalizePath
|
| 312 |
*/
|
| 313 |
public static function normalizePath($path) { |
| 314 |
return Folder::correctSlashFor($path); |
| 315 |
} |
| 316 |
|
| 317 |
/**
|
| 318 |
* Returns a correct set of slashes for given $path. (\\ for Windows paths and / for other paths.)
|
| 319 |
*
|
| 320 |
* @param string $path Path to check
|
| 321 |
* @return string Set of slashes ("\\" or "/")
|
| 322 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::correctSlashFor
|
| 323 |
*/
|
| 324 |
public static function correctSlashFor($path) { |
| 325 |
return (Folder::isWindowsPath($path)) ? '\\' : '/'; |
| 326 |
} |
| 327 |
|
| 328 |
/**
|
| 329 |
* Returns $path with added terminating slash (corrected for Windows or other OS).
|
| 330 |
*
|
| 331 |
* @param string $path Path to check
|
| 332 |
* @return string Path with ending slash
|
| 333 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::slashTerm
|
| 334 |
*/
|
| 335 |
public static function slashTerm($path) { |
| 336 |
if (Folder::isSlashTerm($path)) { |
| 337 |
return $path; |
| 338 |
} |
| 339 |
return $path . Folder::correctSlashFor($path); |
| 340 |
} |
| 341 |
|
| 342 |
/**
|
| 343 |
* Returns $path with $element added, with correct slash in-between.
|
| 344 |
*
|
| 345 |
* @param string $path Path
|
| 346 |
* @param string|array $element Element to add at end of path
|
| 347 |
* @return string Combined path
|
| 348 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::addPathElement
|
| 349 |
*/
|
| 350 |
public static function addPathElement($path, $element) { |
| 351 |
$element = (array)$element; |
| 352 |
array_unshift($element, rtrim($path, DS)); |
| 353 |
return implode(DS, $element); |
| 354 |
} |
| 355 |
|
| 356 |
/**
|
| 357 |
* Returns true if the File is in a given CakePath.
|
| 358 |
*
|
| 359 |
* @param string $path The path to check.
|
| 360 |
* @return bool
|
| 361 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::inCakePath
|
| 362 |
*/
|
| 363 |
public function inCakePath($path = '') { |
| 364 |
$dir = substr(Folder::slashTerm(ROOT), 0, -1); |
| 365 |
$newdir = $dir . $path; |
| 366 |
|
| 367 |
return $this->inPath($newdir); |
| 368 |
} |
| 369 |
|
| 370 |
/**
|
| 371 |
* Returns true if the File is in given path.
|
| 372 |
*
|
| 373 |
* @param string $path The path to check that the current pwd() resides with in.
|
| 374 |
* @param bool $reverse Reverse the search, check that pwd() resides within $path.
|
| 375 |
* @return bool
|
| 376 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::inPath
|
| 377 |
*/
|
| 378 |
public function inPath($path = '', $reverse = false) { |
| 379 |
$dir = Folder::slashTerm($path); |
| 380 |
$current = Folder::slashTerm($this->pwd()); |
| 381 |
|
| 382 |
if (!$reverse) { |
| 383 |
$return = preg_match('/^(.*)' . preg_quote($dir, '/') . '(.*)/', $current); |
| 384 |
} else {
|
| 385 |
$return = preg_match('/^(.*)' . preg_quote($current, '/') . '(.*)/', $dir); |
| 386 |
} |
| 387 |
return (bool)$return; |
| 388 |
} |
| 389 |
|
| 390 |
/**
|
| 391 |
* Change the mode on a directory structure recursively. This includes changing the mode on files as well.
|
| 392 |
*
|
| 393 |
* @param string $path The path to chmod.
|
| 394 |
* @param int $mode Octal value, e.g. 0755.
|
| 395 |
* @param bool $recursive Chmod recursively, set to false to only change the current directory.
|
| 396 |
* @param array $exceptions Array of files, directories to skip.
|
| 397 |
* @return bool Success.
|
| 398 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::chmod
|
| 399 |
*/
|
| 400 |
public function chmod($path, $mode = false, $recursive = true, $exceptions = array()) { |
| 401 |
if (!$mode) { |
| 402 |
$mode = $this->mode; |
| 403 |
} |
| 404 |
|
| 405 |
if ($recursive === false && is_dir($path)) { |
| 406 |
//@codingStandardsIgnoreStart
|
| 407 |
if (@chmod($path, intval($mode, 8))) { |
| 408 |
//@codingStandardsIgnoreEnd
|
| 409 |
$this->_messages[] = __d('cake_dev', '%s changed to %s', $path, $mode); |
| 410 |
return true; |
| 411 |
} |
| 412 |
|
| 413 |
$this->_errors[] = __d('cake_dev', '%s NOT changed to %s', $path, $mode); |
| 414 |
return false; |
| 415 |
} |
| 416 |
|
| 417 |
if (is_dir($path)) { |
| 418 |
$paths = $this->tree($path); |
| 419 |
|
| 420 |
foreach ($paths as $type) { |
| 421 |
foreach ($type as $fullpath) { |
| 422 |
$check = explode(DS, $fullpath); |
| 423 |
$count = count($check); |
| 424 |
|
| 425 |
if (in_array($check[$count - 1], $exceptions)) { |
| 426 |
continue;
|
| 427 |
} |
| 428 |
|
| 429 |
//@codingStandardsIgnoreStart
|
| 430 |
if (@chmod($fullpath, intval($mode, 8))) { |
| 431 |
//@codingStandardsIgnoreEnd
|
| 432 |
$this->_messages[] = __d('cake_dev', '%s changed to %s', $fullpath, $mode); |
| 433 |
} else {
|
| 434 |
$this->_errors[] = __d('cake_dev', '%s NOT changed to %s', $fullpath, $mode); |
| 435 |
} |
| 436 |
} |
| 437 |
} |
| 438 |
|
| 439 |
if (empty($this->_errors)) { |
| 440 |
return true; |
| 441 |
} |
| 442 |
} |
| 443 |
return false; |
| 444 |
} |
| 445 |
|
| 446 |
/**
|
| 447 |
* Returns an array of nested directories and files in each directory
|
| 448 |
*
|
| 449 |
* @param string $path the directory path to build the tree from
|
| 450 |
* @param array|bool $exceptions Either an array of files/folder to exclude
|
| 451 |
* or boolean true to not grab dot files/folders
|
| 452 |
* @param string $type either 'file' or 'dir'. null returns both files and directories
|
| 453 |
* @return mixed array of nested directories and files in each directory
|
| 454 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::tree
|
| 455 |
*/
|
| 456 |
public function tree($path = null, $exceptions = false, $type = null) { |
| 457 |
if (!$path) { |
| 458 |
$path = $this->path; |
| 459 |
} |
| 460 |
$files = array(); |
| 461 |
$directories = array($path); |
| 462 |
|
| 463 |
if (is_array($exceptions)) { |
| 464 |
$exceptions = array_flip($exceptions); |
| 465 |
} |
| 466 |
$skipHidden = false; |
| 467 |
if ($exceptions === true) { |
| 468 |
$skipHidden = true; |
| 469 |
} elseif (isset($exceptions['.'])) { |
| 470 |
$skipHidden = true; |
| 471 |
unset($exceptions['.']); |
| 472 |
} |
| 473 |
|
| 474 |
try {
|
| 475 |
$directory = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::KEY_AS_PATHNAME | RecursiveDirectoryIterator::CURRENT_AS_SELF); |
| 476 |
$iterator = new RecursiveIteratorIterator($directory, RecursiveIteratorIterator::SELF_FIRST); |
| 477 |
} catch (Exception $e) { |
| 478 |
if ($type === null) { |
| 479 |
return array(array(), array()); |
| 480 |
} |
| 481 |
return array(); |
| 482 |
} |
| 483 |
|
| 484 |
foreach ($iterator as $itemPath => $fsIterator) { |
| 485 |
if ($skipHidden) { |
| 486 |
$subPathName = $fsIterator->getSubPathname(); |
| 487 |
if ($subPathName{0} === '.' || strpos($subPathName, DS . '.') !== false) { |
| 488 |
continue;
|
| 489 |
} |
| 490 |
} |
| 491 |
$item = $fsIterator->current(); |
| 492 |
if (!empty($exceptions) && isset($exceptions[$item->getFilename()])) { |
| 493 |
continue;
|
| 494 |
} |
| 495 |
|
| 496 |
if ($item->isFile()) { |
| 497 |
$files[] = $itemPath; |
| 498 |
} elseif ($item->isDir() && !$item->isDot()) { |
| 499 |
$directories[] = $itemPath; |
| 500 |
} |
| 501 |
} |
| 502 |
if ($type === null) { |
| 503 |
return array($directories, $files); |
| 504 |
} |
| 505 |
if ($type === 'dir') { |
| 506 |
return $directories; |
| 507 |
} |
| 508 |
return $files; |
| 509 |
} |
| 510 |
|
| 511 |
/**
|
| 512 |
* Create a directory structure recursively.
|
| 513 |
*
|
| 514 |
* Can be used to create deep path structures like `/foo/bar/baz/shoe/horn`
|
| 515 |
*
|
| 516 |
* @param string $pathname The directory structure to create. Either an absolute or relative
|
| 517 |
* path. If the path is relative and exists in the process' cwd it will not be created.
|
| 518 |
* Otherwise relative paths will be prefixed with the current pwd().
|
| 519 |
* @param int $mode octal value 0755
|
| 520 |
* @return bool Returns TRUE on success, FALSE on failure
|
| 521 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::create
|
| 522 |
*/
|
| 523 |
public function create($pathname, $mode = false) { |
| 524 |
if (is_dir($pathname) || empty($pathname)) { |
| 525 |
return true; |
| 526 |
} |
| 527 |
|
| 528 |
if (!static::isAbsolute($pathname)) { |
| 529 |
$pathname = static::addPathElement($this->pwd(), $pathname); |
| 530 |
} |
| 531 |
|
| 532 |
if (!$mode) { |
| 533 |
$mode = $this->mode; |
| 534 |
} |
| 535 |
|
| 536 |
if (is_file($pathname)) { |
| 537 |
$this->_errors[] = __d('cake_dev', '%s is a file', $pathname); |
| 538 |
return false; |
| 539 |
} |
| 540 |
$pathname = rtrim($pathname, DS); |
| 541 |
$nextPathname = substr($pathname, 0, strrpos($pathname, DS)); |
| 542 |
|
| 543 |
if ($this->create($nextPathname, $mode)) { |
| 544 |
if (!file_exists($pathname)) { |
| 545 |
$old = umask(0); |
| 546 |
if (mkdir($pathname, $mode)) { |
| 547 |
umask($old); |
| 548 |
$this->_messages[] = __d('cake_dev', '%s created', $pathname); |
| 549 |
return true; |
| 550 |
} |
| 551 |
umask($old); |
| 552 |
$this->_errors[] = __d('cake_dev', '%s NOT created', $pathname); |
| 553 |
return false; |
| 554 |
} |
| 555 |
} |
| 556 |
return false; |
| 557 |
} |
| 558 |
|
| 559 |
/**
|
| 560 |
* Returns the size in bytes of this Folder and its contents.
|
| 561 |
*
|
| 562 |
* @return int size in bytes of current folder
|
| 563 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::dirsize
|
| 564 |
*/
|
| 565 |
public function dirsize() { |
| 566 |
$size = 0; |
| 567 |
$directory = Folder::slashTerm($this->path); |
| 568 |
$stack = array($directory); |
| 569 |
$count = count($stack); |
| 570 |
for ($i = 0, $j = $count; $i < $j; ++$i) { |
| 571 |
if (is_file($stack[$i])) { |
| 572 |
$size += filesize($stack[$i]); |
| 573 |
} elseif (is_dir($stack[$i])) { |
| 574 |
$dir = dir($stack[$i]); |
| 575 |
if ($dir) { |
| 576 |
while (false !== ($entry = $dir->read())) { |
| 577 |
if ($entry === '.' || $entry === '..') { |
| 578 |
continue;
|
| 579 |
} |
| 580 |
$add = $stack[$i] . $entry; |
| 581 |
|
| 582 |
if (is_dir($stack[$i] . $entry)) { |
| 583 |
$add = Folder::slashTerm($add); |
| 584 |
} |
| 585 |
$stack[] = $add; |
| 586 |
} |
| 587 |
$dir->close();
|
| 588 |
} |
| 589 |
} |
| 590 |
$j = count($stack); |
| 591 |
} |
| 592 |
return $size; |
| 593 |
} |
| 594 |
|
| 595 |
/**
|
| 596 |
* Recursively Remove directories if the system allows.
|
| 597 |
*
|
| 598 |
* @param string $path Path of directory to delete
|
| 599 |
* @return bool Success
|
| 600 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::delete
|
| 601 |
*/
|
| 602 |
public function delete($path = null) { |
| 603 |
if (!$path) { |
| 604 |
$path = $this->pwd(); |
| 605 |
} |
| 606 |
if (!$path) { |
| 607 |
return false; |
| 608 |
} |
| 609 |
$path = Folder::slashTerm($path); |
| 610 |
if (is_dir($path)) { |
| 611 |
try {
|
| 612 |
$directory = new RecursiveDirectoryIterator($path, RecursiveDirectoryIterator::CURRENT_AS_SELF); |
| 613 |
$iterator = new RecursiveIteratorIterator($directory, RecursiveIteratorIterator::CHILD_FIRST); |
| 614 |
} catch (Exception $e) { |
| 615 |
return false; |
| 616 |
} |
| 617 |
|
| 618 |
foreach ($iterator as $item) { |
| 619 |
$filePath = $item->getPathname(); |
| 620 |
if ($item->isFile() || $item->isLink()) { |
| 621 |
//@codingStandardsIgnoreStart
|
| 622 |
if (@unlink($filePath)) { |
| 623 |
//@codingStandardsIgnoreEnd
|
| 624 |
$this->_messages[] = __d('cake_dev', '%s removed', $filePath); |
| 625 |
} else {
|
| 626 |
$this->_errors[] = __d('cake_dev', '%s NOT removed', $filePath); |
| 627 |
} |
| 628 |
} elseif ($item->isDir() && !$item->isDot()) { |
| 629 |
//@codingStandardsIgnoreStart
|
| 630 |
if (@rmdir($filePath)) { |
| 631 |
//@codingStandardsIgnoreEnd
|
| 632 |
$this->_messages[] = __d('cake_dev', '%s removed', $filePath); |
| 633 |
} else {
|
| 634 |
$this->_errors[] = __d('cake_dev', '%s NOT removed', $filePath); |
| 635 |
return false; |
| 636 |
} |
| 637 |
} |
| 638 |
} |
| 639 |
|
| 640 |
$path = rtrim($path, DS); |
| 641 |
//@codingStandardsIgnoreStart
|
| 642 |
if (@rmdir($path)) { |
| 643 |
//@codingStandardsIgnoreEnd
|
| 644 |
$this->_messages[] = __d('cake_dev', '%s removed', $path); |
| 645 |
} else {
|
| 646 |
$this->_errors[] = __d('cake_dev', '%s NOT removed', $path); |
| 647 |
return false; |
| 648 |
} |
| 649 |
} |
| 650 |
return true; |
| 651 |
} |
| 652 |
|
| 653 |
/**
|
| 654 |
* Recursive directory copy.
|
| 655 |
*
|
| 656 |
* ### Options
|
| 657 |
*
|
| 658 |
* - `to` The directory to copy to.
|
| 659 |
* - `from` The directory to copy from, this will cause a cd() to occur, changing the results of pwd().
|
| 660 |
* - `mode` The mode to copy the files/directories with as integer, e.g. 0775.
|
| 661 |
* - `skip` Files/directories to skip.
|
| 662 |
* - `scheme` Folder::MERGE, Folder::OVERWRITE, Folder::SKIP
|
| 663 |
*
|
| 664 |
* @param array|string $options Either an array of options (see above) or a string of the destination directory.
|
| 665 |
* @return bool Success.
|
| 666 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::copy
|
| 667 |
*/
|
| 668 |
public function copy($options) { |
| 669 |
if (!$this->pwd()) { |
| 670 |
return false; |
| 671 |
} |
| 672 |
$to = null; |
| 673 |
if (is_string($options)) { |
| 674 |
$to = $options; |
| 675 |
$options = array(); |
| 676 |
} |
| 677 |
$options += array( |
| 678 |
'to' => $to, |
| 679 |
'from' => $this->path, |
| 680 |
'mode' => $this->mode, |
| 681 |
'skip' => array(), |
| 682 |
'scheme' => Folder::MERGE |
| 683 |
); |
| 684 |
|
| 685 |
$fromDir = $options['from']; |
| 686 |
$toDir = $options['to']; |
| 687 |
$mode = $options['mode']; |
| 688 |
|
| 689 |
if (!$this->cd($fromDir)) { |
| 690 |
$this->_errors[] = __d('cake_dev', '%s not found', $fromDir); |
| 691 |
return false; |
| 692 |
} |
| 693 |
|
| 694 |
if (!is_dir($toDir)) { |
| 695 |
$this->create($toDir, $mode); |
| 696 |
} |
| 697 |
|
| 698 |
if (!is_writable($toDir)) { |
| 699 |
$this->_errors[] = __d('cake_dev', '%s not writable', $toDir); |
| 700 |
return false; |
| 701 |
} |
| 702 |
|
| 703 |
$exceptions = array_merge(array('.', '..', '.svn'), $options['skip']); |
| 704 |
//@codingStandardsIgnoreStart
|
| 705 |
if ($handle = @opendir($fromDir)) { |
| 706 |
//@codingStandardsIgnoreEnd
|
| 707 |
while (($item = readdir($handle)) !== false) { |
| 708 |
$to = Folder::addPathElement($toDir, $item); |
| 709 |
if (($options['scheme'] != Folder::SKIP || !is_dir($to)) && !in_array($item, $exceptions)) { |
| 710 |
$from = Folder::addPathElement($fromDir, $item); |
| 711 |
if (is_file($from) && (!is_file($to) || $options['scheme'] != Folder::SKIP)) { |
| 712 |
if (copy($from, $to)) { |
| 713 |
chmod($to, intval($mode, 8)); |
| 714 |
touch($to, filemtime($from)); |
| 715 |
$this->_messages[] = __d('cake_dev', '%s copied to %s', $from, $to); |
| 716 |
} else {
|
| 717 |
$this->_errors[] = __d('cake_dev', '%s NOT copied to %s', $from, $to); |
| 718 |
} |
| 719 |
} |
| 720 |
|
| 721 |
if (is_dir($from) && file_exists($to) && $options['scheme'] === Folder::OVERWRITE) { |
| 722 |
$this->delete($to); |
| 723 |
} |
| 724 |
|
| 725 |
if (is_dir($from) && !file_exists($to)) { |
| 726 |
$old = umask(0); |
| 727 |
if (mkdir($to, $mode)) { |
| 728 |
umask($old); |
| 729 |
$old = umask(0); |
| 730 |
chmod($to, $mode); |
| 731 |
umask($old); |
| 732 |
$this->_messages[] = __d('cake_dev', '%s created', $to); |
| 733 |
$options = array('to' => $to, 'from' => $from) + $options; |
| 734 |
$this->copy($options); |
| 735 |
} else {
|
| 736 |
$this->_errors[] = __d('cake_dev', '%s not created', $to); |
| 737 |
} |
| 738 |
} elseif (is_dir($from) && $options['scheme'] === Folder::MERGE) { |
| 739 |
$options = array('to' => $to, 'from' => $from) + $options; |
| 740 |
$this->copy($options); |
| 741 |
} |
| 742 |
} |
| 743 |
} |
| 744 |
closedir($handle); |
| 745 |
} else {
|
| 746 |
return false; |
| 747 |
} |
| 748 |
|
| 749 |
if (!empty($this->_errors)) { |
| 750 |
return false; |
| 751 |
} |
| 752 |
return true; |
| 753 |
} |
| 754 |
|
| 755 |
/**
|
| 756 |
* Recursive directory move.
|
| 757 |
*
|
| 758 |
* ### Options
|
| 759 |
*
|
| 760 |
* - `to` The directory to copy to.
|
| 761 |
* - `from` The directory to copy from, this will cause a cd() to occur, changing the results of pwd().
|
| 762 |
* - `chmod` The mode to copy the files/directories with.
|
| 763 |
* - `skip` Files/directories to skip.
|
| 764 |
* - `scheme` Folder::MERGE, Folder::OVERWRITE, Folder::SKIP
|
| 765 |
*
|
| 766 |
* @param array $options (to, from, chmod, skip, scheme)
|
| 767 |
* @return bool Success
|
| 768 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::move
|
| 769 |
*/
|
| 770 |
public function move($options) { |
| 771 |
$to = null; |
| 772 |
if (is_string($options)) { |
| 773 |
$to = $options; |
| 774 |
$options = (array)$options; |
| 775 |
} |
| 776 |
$options += array('to' => $to, 'from' => $this->path, 'mode' => $this->mode, 'skip' => array()); |
| 777 |
|
| 778 |
if ($this->copy($options)) { |
| 779 |
if ($this->delete($options['from'])) { |
| 780 |
return (bool)$this->cd($options['to']); |
| 781 |
} |
| 782 |
} |
| 783 |
return false; |
| 784 |
} |
| 785 |
|
| 786 |
/**
|
| 787 |
* get messages from latest method
|
| 788 |
*
|
| 789 |
* @param bool $reset Reset message stack after reading
|
| 790 |
* @return array
|
| 791 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::messages
|
| 792 |
*/
|
| 793 |
public function messages($reset = true) { |
| 794 |
$messages = $this->_messages; |
| 795 |
if ($reset) { |
| 796 |
$this->_messages = array(); |
| 797 |
} |
| 798 |
return $messages; |
| 799 |
} |
| 800 |
|
| 801 |
/**
|
| 802 |
* get error from latest method
|
| 803 |
*
|
| 804 |
* @param bool $reset Reset error stack after reading
|
| 805 |
* @return array
|
| 806 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::errors
|
| 807 |
*/
|
| 808 |
public function errors($reset = true) { |
| 809 |
$errors = $this->_errors; |
| 810 |
if ($reset) { |
| 811 |
$this->_errors = array(); |
| 812 |
} |
| 813 |
return $errors; |
| 814 |
} |
| 815 |
|
| 816 |
/**
|
| 817 |
* Get the real path (taking ".." and such into account)
|
| 818 |
*
|
| 819 |
* @param string $path Path to resolve
|
| 820 |
* @return string The resolved path
|
| 821 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::realpath
|
| 822 |
*/
|
| 823 |
public function realpath($path) { |
| 824 |
if (strpos($path, '..') === false) { |
| 825 |
if (!Folder::isAbsolute($path)) { |
| 826 |
$path = Folder::addPathElement($this->path, $path); |
| 827 |
} |
| 828 |
return $path; |
| 829 |
} |
| 830 |
$path = str_replace('/', DS, trim($path)); |
| 831 |
$parts = explode(DS, $path); |
| 832 |
$newparts = array(); |
| 833 |
$newpath = ''; |
| 834 |
if ($path[0] === DS) { |
| 835 |
$newpath = DS; |
| 836 |
} |
| 837 |
|
| 838 |
while (($part = array_shift($parts)) !== null) { |
| 839 |
if ($part === '.' || $part === '') { |
| 840 |
continue;
|
| 841 |
} |
| 842 |
if ($part === '..') { |
| 843 |
if (!empty($newparts)) { |
| 844 |
array_pop($newparts); |
| 845 |
continue;
|
| 846 |
} |
| 847 |
return false; |
| 848 |
} |
| 849 |
$newparts[] = $part; |
| 850 |
} |
| 851 |
$newpath .= implode(DS, $newparts); |
| 852 |
|
| 853 |
return Folder::slashTerm($newpath); |
| 854 |
} |
| 855 |
|
| 856 |
/**
|
| 857 |
* Returns true if given $path ends in a slash (i.e. is slash-terminated).
|
| 858 |
*
|
| 859 |
* @param string $path Path to check
|
| 860 |
* @return bool true if path ends with slash, false otherwise
|
| 861 |
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/file-folder.html#Folder::isSlashTerm
|
| 862 |
*/
|
| 863 |
public static function isSlashTerm($path) { |
| 864 |
$lastChar = $path[strlen($path) - 1]; |
| 865 |
return $lastChar === '/' || $lastChar === '\\'; |
| 866 |
} |
| 867 |
|
| 868 |
} |