mirror of
https://github.com/kamilwylegala/cakephp2-php8.git
synced 2024-11-15 19:38:26 +00:00
d44a364285
git-svn-id: https://svn.cakephp.org/repo/trunk/cake@1057 3807eeeb-6ff5-0310-8944-8be069107fe0
439 lines
No EOL
9.4 KiB
PHP
439 lines
No EOL
9.4 KiB
PHP
<?php
|
|
/* SVN FILE: $Id$ */
|
|
|
|
/**
|
|
* Convenience class for handling directories.
|
|
*
|
|
*
|
|
* PHP versions 4 and 5
|
|
*
|
|
* CakePHP : Rapid Development Framework <http://www.cakephp.org/>
|
|
* Copyright (c) 2005, CakePHP Authors/Developers
|
|
*
|
|
* Author(s): Michal Tatarynowicz aka Pies <tatarynowicz@gmail.com>
|
|
* Larry E. Masters aka PhpNut <nut@phpnut.com>
|
|
* Kamil Dzielinski aka Brego <brego.dk@gmail.com>
|
|
*
|
|
* Licensed under The MIT License
|
|
* Redistributions of files must retain the above copyright notice.
|
|
*
|
|
* @filesource
|
|
* @author CakePHP Authors/Developers
|
|
* @copyright Copyright (c) 2005, CakePHP Authors/Developers
|
|
* @link https://trac.cakephp.org/wiki/Authors Authors/Developers
|
|
* @package cake
|
|
* @subpackage cake.libs
|
|
* @since CakePHP v 0.2.9
|
|
* @version $Revision$
|
|
* @modifiedby $LastChangedBy$
|
|
* @lastmodified $Date$
|
|
* @license http://www.opensource.org/licenses/mit-license.php The MIT License
|
|
*/
|
|
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
*/
|
|
uses('object');
|
|
|
|
/**
|
|
* Folder structure browser, lists folders and files.
|
|
*
|
|
* Long description for class
|
|
*
|
|
* @package cake
|
|
* @subpackage cake.libs
|
|
* @since CakePHP v 0.2.9
|
|
*/
|
|
class Folder extends Object {
|
|
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @var string
|
|
*/
|
|
var $path = null;
|
|
|
|
/**
|
|
* Enter description here...
|
|
*
|
|
* @var boolean
|
|
*/
|
|
var $sort = false;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param string $path
|
|
* @param bollean $path
|
|
*/
|
|
function Folder ($path=false , $create = false)
|
|
{
|
|
if (empty($path))
|
|
{
|
|
$path = getcwd();
|
|
}
|
|
|
|
if ( !file_exists( $path ) && $create==true )
|
|
{
|
|
$this->mkdirr($path);
|
|
}
|
|
$this->cd($path);
|
|
}
|
|
|
|
/**
|
|
* Return current path.
|
|
*
|
|
* @return string Current path
|
|
*/
|
|
function pwd ()
|
|
{
|
|
return $this->path;
|
|
}
|
|
|
|
/**
|
|
* Change directory to $desired_path.
|
|
*
|
|
* @param string $desired_path Path to the directory to change to
|
|
* @return string The new path. Returns false on failure
|
|
*/
|
|
function cd ($desired_path)
|
|
{
|
|
$desired_path = realpath($desired_path);
|
|
$new_path = Folder::isAbsolute($desired_path)?
|
|
$desired_path:
|
|
Folder::addPathElement($this->path, $desired_path);
|
|
|
|
return is_dir($new_path)? $this->path = $new_path: false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an array of the contents of the current directory, or false on failure.
|
|
* The returned array holds two arrays: one of dirs and one of files.
|
|
*
|
|
* @param boolean $sort
|
|
* @param boolean $noDotFiles
|
|
* @return array
|
|
*/
|
|
function ls($sort=true , $noDotFiles = false)
|
|
{
|
|
$dir = opendir($this->path);
|
|
|
|
if ($dir)
|
|
{
|
|
$dirs = $files = array();
|
|
while (false !== ($n = readdir($dir)))
|
|
{
|
|
if ( (!preg_match('#^\.+$#', $n) && $noDotFiles == false) || ( $noDotFiles == true && !preg_match('#^\.(.*)$#', $n) ) )
|
|
{
|
|
if (is_dir($this->addPathElement($this->path, $n)))
|
|
{
|
|
$dirs[] = $n;
|
|
}
|
|
else
|
|
{
|
|
$files[] = $n;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($sort || $this->sort)
|
|
{
|
|
sort($dirs);
|
|
sort($files);
|
|
}
|
|
|
|
closedir($dir);
|
|
|
|
return array($dirs,$files);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an array of all matching files in current directory
|
|
*
|
|
* @param string $pattern Preg_match pattern (Defaults to: .*)
|
|
* @return array
|
|
*/
|
|
function find ($regexp_pattern='.*')
|
|
{
|
|
$data = $this->ls();
|
|
|
|
if (!is_array($data))
|
|
{
|
|
return array();
|
|
}
|
|
|
|
list($dirs, $files) = $data;
|
|
|
|
$found = array();
|
|
foreach ($files as $file)
|
|
{
|
|
if (preg_match("/^{$regexp_pattern}$/i", $file))
|
|
{
|
|
$found[] = $file;
|
|
}
|
|
}
|
|
|
|
return $found;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns an array of all matching files in and below current directory
|
|
*
|
|
* @param string $pattern Preg_match pattern (Defaults to: .*)
|
|
* @return array Files matching $pattern
|
|
*/
|
|
function findRecursive ($pattern='.*')
|
|
{
|
|
$starts_on = $this->path;
|
|
$out = $this->_findRecursive($pattern);
|
|
$this->cd($starts_on);
|
|
return $out;
|
|
}
|
|
|
|
/**
|
|
* Private helper function for findRecursive.
|
|
*
|
|
* @param string $pattern
|
|
* @return array Files matching pattern
|
|
* @access private
|
|
*/
|
|
function _findRecursive ($pattern)
|
|
{
|
|
list($dirs, $files) = $this->ls();
|
|
|
|
$found = array();
|
|
foreach ($files as $file)
|
|
{
|
|
if (preg_match("/^{$pattern}$/i", $file))
|
|
{
|
|
$found[] = $this->addPathElement($this->path, $file);
|
|
}
|
|
}
|
|
|
|
$start = $this->path;
|
|
foreach ($dirs as $dir)
|
|
{
|
|
$this->cd($this->addPathElement($start, $dir));
|
|
$found = array_merge($found, $this->findRecursive($pattern));
|
|
}
|
|
|
|
return $found;
|
|
}
|
|
|
|
/**
|
|
* Returns true if given $path is a Windows path.
|
|
*
|
|
* @param string $path Path to check
|
|
* @return boolean
|
|
* @static
|
|
*/
|
|
function isWindowsPath ($path)
|
|
{
|
|
return preg_match('#^[A-Z]:\\\#i', $path)? true: false;
|
|
}
|
|
|
|
/**
|
|
* Returns true if given $path is an absolute path.
|
|
*
|
|
* @param string $path Path to check
|
|
* @return boolean
|
|
* @static
|
|
*/
|
|
function isAbsolute ($path)
|
|
{
|
|
return preg_match('#^\/#', $path) || preg_match('#^[A-Z]:\\\#i', $path);
|
|
}
|
|
|
|
/**
|
|
* Returns true if given $path ends in a slash (i.e. is slash-terminated).
|
|
*
|
|
* @param string $path Path to check
|
|
* @return boolean
|
|
* @static
|
|
*/
|
|
function isSlashTerm ($path)
|
|
{
|
|
return preg_match('#[\\\/]$#', $path)? true: false;
|
|
}
|
|
|
|
/**
|
|
* Returns a correct set of slashes for given $path. (\\ for Windows paths and / for other paths.)
|
|
*
|
|
* @param string $path Path to check
|
|
* @return string Set of slashes ("\\" or "/")
|
|
* @static
|
|
*/
|
|
function correctSlashFor ($path)
|
|
{
|
|
return Folder::isWindowsPath($path)? '\\': '/';
|
|
}
|
|
|
|
/**
|
|
* Returns $path with added terminating slash (corrected for Windows or other OS).
|
|
*
|
|
* @param string $path Path to check
|
|
* @return string
|
|
* @static
|
|
*/
|
|
function slashTerm ($path)
|
|
{
|
|
return $path . (Folder::isSlashTerm($path)? null: Folder::correctSlashFor($path));
|
|
}
|
|
|
|
/**
|
|
* Returns $path with $element added, with correct slash in-between.
|
|
*
|
|
* @param string $path
|
|
* @param string $element
|
|
* @return string
|
|
* @static
|
|
*/
|
|
function addPathElement ($path, $element)
|
|
{
|
|
return Folder::slashTerm($path).$element;
|
|
}
|
|
|
|
/**
|
|
* check if the File is in a given CakePath
|
|
*
|
|
* @return boolean
|
|
*/
|
|
function inCakePath ( $path = '' )
|
|
{
|
|
$dir = substr( Folder::slashTerm(ROOT) , 0 , -1 );
|
|
|
|
$newdir = Folder::slashTerm($dir.$path);
|
|
|
|
return $this->inPath( $newdir );
|
|
}
|
|
|
|
/**
|
|
* check if the File is in a given Path
|
|
*
|
|
* @return boolean
|
|
*/
|
|
function inPath ( $path = '' )
|
|
{
|
|
$dir = substr( Folder::slashTerm($path) , 0 , -1 );
|
|
|
|
$return = preg_match('/^'.preg_quote(Folder::slashTerm($dir),'/').'(.*)/' , Folder::slashTerm($this->pwd()) );
|
|
|
|
if ( $return == 1 )
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a directory structure recursively
|
|
*
|
|
* @author Aidan Lister <aidan@php.net>
|
|
* @version 1.0.0
|
|
* @param string $pathname The directory structure to create
|
|
* @return bool Returns TRUE on success, FALSE on failure
|
|
*/
|
|
function mkdirr($pathname, $mode = null)
|
|
{
|
|
// Check if directory already exists
|
|
if (is_dir($pathname) || empty($pathname))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Ensure a file does not already exist with the same name
|
|
if (is_file($pathname))
|
|
{
|
|
trigger_error('mkdirr() File exists', E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
// Crawl up the directory tree
|
|
$next_pathname = substr($pathname, 0, strrpos($pathname, DIRECTORY_SEPARATOR));
|
|
if (mkdirr($next_pathname, $mode))
|
|
{
|
|
if (!file_exists($pathname))
|
|
{
|
|
return mkdir($pathname, $mode);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Get the size of a directory.
|
|
*
|
|
* @author Aidan Lister <aidan@php.net>
|
|
* @version 1.0.0
|
|
* @param string $directory Path to directory
|
|
*/
|
|
function dirsize()
|
|
{
|
|
// Init
|
|
$size = 0;
|
|
|
|
$directory = Folder::slashTerm($this->path);
|
|
|
|
// Creating the stack array
|
|
$stack = array($directory);
|
|
|
|
// Iterate stack
|
|
for ($i = 0, $j = count($stack); $i < $j; ++$i)
|
|
{
|
|
|
|
// Add to total size
|
|
if (is_file($stack[$i]))
|
|
{
|
|
$size += filesize($stack[$i]);
|
|
|
|
}
|
|
|
|
// Add to stack
|
|
elseif (is_dir($stack[$i]))
|
|
{
|
|
// Read directory
|
|
$dir = dir($stack[$i]);
|
|
while (false !== ($entry = $dir->read()))
|
|
{
|
|
// No pointers
|
|
if ($entry == '.' || $entry == '..')
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// Add to stack
|
|
$add = $stack[$i] . $entry;
|
|
if (is_dir($stack[$i] . $entry))
|
|
{
|
|
$add = Folder::slashTerm($add);
|
|
}
|
|
$stack[] = $add;
|
|
|
|
}
|
|
|
|
// Clean up
|
|
$dir->close();
|
|
}
|
|
|
|
// Recount stack
|
|
$j = count($stack);
|
|
}
|
|
|
|
return $size;
|
|
}
|
|
}
|
|
|
|
?>
|