cakephp2-php8/cake/libs/folder.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) 2006, Cake Software Foundation, Inc.
 *                     1785 E. Sahara Avenue, Suite 490-204
 *                     Las Vegas, Nevada 89104
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @filesource
 * @copyright    Copyright (c) 2006, Cake Software Foundation, Inc.
 * @link         http://www.cakefoundation.org/projects/info/cakephp CakePHP Project
 * @package      cake
 * @subpackage   cake.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
 */

/**
  * Included libraries.
  *
  */
if(!class_exists('Object'))
{
    uses('object');
}
/**
 * Folder structure browser, lists folders and files.
 *
 * Long description for class
 *
 * @package    cake
 * @subpackage cake.cake.libs
 * @since      CakePHP v 0.2.9
 */
class Folder extends Object {

/**
  * Path to Folder.
  *
  * @var string
  */
   var $path = null;

/**
  * Sortedness.
  *
  * @var boolean
  */
   var $sort = false;

/**
  * Constructor.
  *
  * @param string $path
  * @param boolean $path
  */
   function Folder ($path = false , $create = false, $mode = false)
   {
      if (empty($path))
      {
         $path = getcwd();
      }

      if ( !file_exists( $path ) && $create==true )
      {
          $this->mkdirr($path, $mode);
      }
      $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;
   }

/**
 * Returns true 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 );
   }

/**
 * Returns true if the File is in 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.
 *
 * @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 ($this->mkdirr($next_pathname, $mode))
      {
         if (!file_exists($pathname))
         {
            umask(0);
            return mkdir($pathname, $mode);
         }
      }

      return false;
   }

/**
 * Returns the size in bytes of this Folder.
 *
 * @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;
   }
}

?>