folder.php

Go to the documentation of this file.

<?php
/*
 You may not change or alter any portion of this comment or credits
 of supporting developers from this source code or any supporting source code
 which is considered copyrighted (c) material of the original comment or credit authors.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*/
/*
 * Convenience class for handling directories.
 *
 *
 * CakePHP(tm) :  Rapid Development Framework <http://www.cakephp.org/>
 * Copyright 2005-2008, 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.
 */

class XoopsFolderHandler
{
    public $path = null;

    public $sort = false;

    public $mode = '0755';

    private $messages = array();

    private $errors = false;

    private $directories;

    private $files;

    public function __construct($path = '', $create = true, $mode = false)
    {
        if (empty($path)) {
            $path = \XoopsBaseConfig::get('var-path') . '/caches/xoops_cache';
        }
        if ($mode) {
            $this->mode = intval($mode, 8);
        }
        if (!XoopsLoad::fileExists($path) && $create == true) {
            $this->create($path, $this->mode);
        }
        if (!$this->isAbsolute($path)) {
            $path = realpath($path);
        }
        $this->cd($path);
    }

    public function pwd()
    {
        return $this->path;
    }

    public function cd($path)
    {
        $path = $this->realpath($path);
        if (is_dir($path) && XoopsLoad::fileExists($path)) {
            return $this->path = $path;
        }
        return false;
    }

    public function read($sort = true, $exceptions = false)
    {
        $dirs = $files = array();
        $dir = opendir($this->path);
        if ($dir !== false) {
            while (false !== ($n = readdir($dir))) {
                $item = false;
                if (is_array($exceptions)) {
                    if (!in_array($n, $exceptions)) {
                        $item = $n;
                    }
                } else {
                    if ((!preg_match('/^\\.+$/', $n) && $exceptions == false)
                        || ($exceptions == true && !preg_match('/^\\.(.*)$/', $n))
                    ) {
                        $item = $n;
                    }
                }
                if ($item !== false) {
                    if (is_dir($this->addPathElement($this->path, $item))) {
                        $dirs[] = $item;
                    } else {
                        $files[] = $item;
                    }
                }
            }
            if ($sort || $this->sort) {
                sort($dirs);
                sort($files);
            }
            closedir($dir);
        }
        return array(
            $dirs, $files
        );
    }

    public function find($regexp_pattern = '.*', $sort = false)
    {
        $data = $this->read($sort);
        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;
    }

    public function findRecursive($pattern = '.*', $sort = false)
    {
        $startsOn = $this->path;
        $out = $this->findRecursiveHelper($pattern, $sort);
        $this->cd($startsOn);
        return $out;
    }

    private function findRecursiveHelper($pattern, $sort = false)
    {
        list ($dirs, $files) = $this->read($sort);
        $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;
    }

    public static function isWindowsPath($path)
    {
        if (preg_match('/^[A-Z]:\\\\/i', $path)) {
            return true;
        }
        return false;
    }

    public static function isAbsolute($path)
    {
        $match = preg_match('/^(\/|[A-Z]:)/', $path);
        return ($match == 1);
    }

    public static function normalizePath($path)
    {
        if (self::isWindowsPath($path)) {
            return '\\';
        }
        return '/';
    }

    public static function correctSlashFor($path)
    {
        if (self::isWindowsPath($path)) {
            return '\\';
        }
        return '/';
    }

    public static function slashTerm($path)
    {
        if (self::isSlashTerm($path)) {
            return $path;
        }
        return $path . self::correctSlashFor($path);
    }

    public static function addPathElement($path, $element)
    {
        return self::slashTerm($path) . $element;
    }

    public function inXoopsPath($path = '')
    {
                $xoops_root_path = \XoopsBaseConfig::get('root-path');
        $dir = substr($this->slashTerm($xoops_root_path), 0, -1);
        $newdir = $dir . $path;
        return $this->inPath($newdir);
    }

    public function inPath($path = '', $reverse = false)
    {
        $dir = $this->slashTerm($path);
        $current = $this->slashTerm($this->pwd());
        if (!$reverse) {
            $return = preg_match('/^(.*)' . preg_quote($dir, '/') . '(.*)/', $current);
        } else {
            $return = preg_match('/^(.*)' . preg_quote($current, '/') . '(.*)/', $dir);
        }
        return ($return == 1);
    }

    public function chmod($path, $mode = false, $recursive = true, $exceptions = array())
    {
        if (!$mode) {
            $mode = $this->mode;
        }
        if ($recursive === false && is_dir($path)) {
            if (chmod($path, intval($mode, 8))) {
                $this->messages[] = sprintf('%s changed to %s', $path, $mode);
                return true;
            } else {
                $this->errors[] = sprintf('%s NOT changed to %s', $path, $mode);
                return false;
            }
        }
        if (is_dir($path)) {
            list ($paths) = $this->tree($path);
            foreach ($paths as $fullpath) {
                $check = explode('/', $fullpath);
                $count = count($check);

                if (in_array($check[$count - 1], $exceptions)) {
                    continue;
                }

                if (chmod($fullpath, intval($mode, 8))) {
                    $this->messages[] = sprintf('%s changed to %s', $fullpath, $mode);
                } else {
                    $this->errors[] = sprintf('%s NOT changed to %s', $fullpath, $mode);
                }
            }
            if (empty($this->errors)) {
                return true;
            }
        }
        return false;
    }

    public function tree($path, $hidden = true, $type = null)
    {
        $path = rtrim($path, '/');
        $this->files = array();
        $this->directories = array(
            $path
        );
        $directories = array();
        while (count($this->directories)) {
            $dir = array_pop($this->directories);
            $this->treeHelper($dir, $hidden);
            array_push($directories, $dir);
        }
        if ($type === null) {
            return array(
                $directories, $this->files
            );
        }
        if ($type === 'dir') {
            return $directories;
        }
        return $this->files;
    }

    private function treeHelper($path, $hidden)
    {
        if (is_dir($path)) {
            $dirHandle = opendir($path);
            while (false !== ($item = readdir($dirHandle))) {
                $found = false;
                if (($hidden === true && $item != '.' && $item != '..')
                    || ($hidden === false && !preg_match('/^\\.(.*)$/', $item))
                ) {
                    $found = $path . '/' . $item;
                }
                if ($found !== false) {
                    if (is_dir($found)) {
                        array_push($this->directories, $found);
                    } else {
                        array_push($this->files, $found);
                    }
                }
            }
            closedir($dirHandle);
        }
    }

    public function create($pathname, $mode = false)
    {
        if (is_dir($pathname) || empty($pathname)) {
            return true;
        }
        if (!$mode) {
            $mode = $this->mode;
        }
        if (is_file($pathname)) {
            $this->errors[] = sprintf('%s is a file', $pathname);
            return true;
        }
        $nextPathname = substr($pathname, 0, strrpos($pathname, '/'));
        if ($this->create($nextPathname, $mode)) {
            if (!XoopsLoad::fileExists($pathname)) {
                if (mkdir($pathname, intval($mode, 8))) {
                    $this->messages[] = sprintf('%s created', $pathname);
                    return true;
                } else {
                    $this->errors[] = sprintf('%s NOT created', $pathname);
                    return false;
                }
            }
        }
        return true;
    }

    public function dirsize()
    {
        $size = 0;
        $directory = $this->slashTerm($this->path);
        $stack = array($directory);
        $count = count($stack);
        for ($i = 0, $j = $count; $i < $j; ++$i) {
            if (is_file($stack[$i])) {
                $size += filesize($stack[$i]);
            } else {
                if (is_dir($stack[$i])) {
                    $dir = dir($stack[$i]);
                    if ($dir) {
                        while (false !== ($entry = $dir->read())) {
                            if ($entry == '.' || $entry == '..') {
                                continue;
                            }
                            $add = $stack[$i] . $entry;
                            if (is_dir($stack[$i] . $entry)) {
                                $add = $this->slashTerm($add);
                            }
                            $stack[] = $add;
                        }
                        $dir->close();
                    }
                }
            }
            $j = count($stack);
        }
        return $size;
    }

    public function delete($path)
    {
        $path = $this->slashTerm($path);
        if (is_dir($path) === true) {
            $normal_files = glob($path . '*');
            $hidden_files = glob($path . '\.?*');
            $files = array_merge($normal_files, $hidden_files);
            if (is_array($files)) {
                foreach ($files as $file) {
                    if (preg_match("/(\.|\.\.)$/", $file)) {
                        continue;
                    }
                    if (is_file($file) === true) {
                        if (unlink($file)) {
                            $this->messages[] = sprintf('%s removed', $path);
                        } else {
                            $this->errors[] = sprintf('%s NOT removed', $path);
                        }
                    } else {
                        if (is_dir($file) === true) {
                            if ($this->delete($file) === false) {
                                return false;
                            }
                        }
                    }
                }
            }
            $path = substr($path, 0, strlen($path) - 1);
            if (rmdir($path) === false) {
                $this->errors[] = sprintf('%s NOT removed', $path);
                return false;
            } else {
                $this->messages[] = sprintf('%s removed', $path);
            }
        }
        return true;
    }

    public function copy($options = array())
    {
        $to = null;
        if (is_string($options)) {
            $to = $options;
            $options = array();
        }
        $options = array_merge(
            array(
                'to' => $to,
                'from' => $this->path,
                'mode' => $this->mode,
                'skip' => array()
            ),
            $options
        );

        $fromDir = $options['from'];
        $toDir = $options['to'];
        $mode = $options['mode'];
        if (!$this->cd($fromDir)) {
            $this->errors[] = sprintf('%s not found', $fromDir);
            return false;
        }
        if (!is_dir($toDir)) {
            mkdir($toDir, $mode);
        }
        if (!is_writable($toDir)) {
            $this->errors[] = sprintf('%s not writable', $toDir);
            return false;
        }
        $exceptions = array_merge(array('.', '..', '.svn'), $options['skip']);
        $handle = opendir($fromDir);
        if ($handle) {
            while (false !== ($item = readdir($handle))) {
                if (!in_array($item, $exceptions)) {
                    $from = $this->addPathElement($fromDir, $item);
                    $to = $this->addPathElement($toDir, $item);
                    if (is_file($from)) {
                        if (copy($from, $to)) {
                            chmod($to, intval($mode, 8));
                            touch($to, filemtime($from));
                            $this->messages[] = sprintf('%s copied to %s', $from, $to);
                        } else {
                            $this->errors[] = sprintf('%s NOT copied to %s', $from, $to);
                        }
                    }
                    if (is_dir($from) && !XoopsLoad::fileExists($to)) {
                        if (mkdir($to, intval($mode, 8))) {
                            chmod($to, intval($mode, 8));
                            $this->messages[] = sprintf('%s created', $to);
                            $options = array_merge($options, array('to' => $to, 'from' => $from));
                            $this->copy($options);
                        } else {
                            $this->errors[] = sprintf('%s not created', $to);
                        }
                    }
                }
            }
            closedir($handle);
        } else {
            return false;
        }
        if (!empty($this->errors)) {
            return false;
        }
        return true;
    }

    public function move($options)
    {
        $to = null;
        if (is_string($options)) {
            $to = $options;
            $options = (array)$options;
        }
        $options = array_merge(
            array(
                'to' => $to,
                'from' => $this->path,
                'mode' => $this->mode,
                'skip' => array()
            ),
            $options
        );
        if ($this->copy($options)) {
            if ($this->delete($options['from'])) {
                return $this->cd($options['to']);
            }
        }
        return false;
    }

    public function messages()
    {
        return $this->messages;
    }

    public function errors()
    {
        return $this->errors;
    }

    public function realpath($path)
    {
        $path = trim($path);
        if (strpos($path, '..') === false) {
            if (!$this->isAbsolute($path)) {
                $path = $this->addPathElement($this->path, $path);
            }
            return $path;
        }
        $parts = explode('/', $path);
        $newparts = array();
        $newpath = $path{0} == '/' ? '/' : '';
        while (($part = array_shift($parts)) !== null) {
            if ($part == '.' || $part == '') {
                continue;
            }
            if ($part == '..') {
                if (count($newparts) > 0) {
                    array_pop($newparts);
                    continue;
                } else {
                    return false;
                }
            }
            $newparts[] = $part;
        }
        $newpath .= implode('/', $newparts);
        if (strlen($path > 1) && $path{strlen($path) - 1} == '/') {
            $newpath .= '/';
        }
        return $newpath;
    }

    public static function isSlashTerm($path)
    {
        if (preg_match('/[\/\\\]$/', $path)) {
            return true;
        }
        return false;
    }
}