folder.php

Go to the documentation of this file.

<?php
class XoopsFolderHandler
{
    var $path = null;

    var $sort = false;

    var $mode = '0755';

    var $messages = array();

    var $errors = false;

    var $directories;

    var $files;

    function __construct($path = false, $create = true, $mode = false)
    {
        if (empty($path)) {
            $path = XOOPS_VAR_PATH . '/caches/xoops_cache';
        }
        if ($mode) {
            $this->mode = intval($mode, 8);
        }
        if (!file_exists($path) && $create == true) {
            $this->create($path, $this->mode);
        }
        if (!$this->isAbsolute($path)) {
            $path = realpath($path);
        }
        $this->cd($path);
    }

    function XoopsFolderHandler($path, $create = false, $mode = false)
    {
        $this->__construct($path, $create, $mode);
    }

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

    function cd($path)
    {
        $path = $this->realpath($path);
        if (is_dir($path) && file_exists($path)) {
            return $this->path = $path;
        }
        return false;
    }

    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);
    }

    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;
    }

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

    function _findRecursive($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;
    }

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

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

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

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

    function slashTerm($path)
    {
        if (XoopsFolderHandler::isSlashTerm($path)) {
            return $path;
        }
        return $path . XoopsFolderHandler::correctSlashFor($path);
    }

    function addPathElement($path, $element)
    {
        return $this->slashTerm($path) . $element;
    }

    function inXoopsPath($path = '')
    {
        $dir = substr($this->slashTerm(XOOPS_ROOT_PATH), 0, - 1);
        $newdir = $dir . $path;
        return $this->inPath($newdir);
    }

    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);
        }
        if ($return == 1) {
            return true;
        } else {
            return false;
        }
    }

    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 $key => $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;
    }

    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->_tree($dir, $hidden);
            array_push($directories, $dir);
        }
        if ($type === null) {
            return array(
                $directories ,
                $this->files);
        }
        if ($type === 'dir') {
            return $directories;
        }
        return $this->files;
    }

    function _tree($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);
        }
    }

    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 (!file_exists($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;
    }

    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;
    }

    function delete($path)
    {
        $path = $this->slashTerm($path);
        if (is_dir($path) === true) {
            $files = glob($path . '*', GLOB_NOSORT);
            $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;
    }

    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) && !file_exists($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;
    }

    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;
    }

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

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

    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;
    }

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

?>