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