Koch\Files\Directory

Complexity

Total Complexity

53

Size/Duplication

Total Lines	289
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	2
A	setFilter()	0	6	1
A	setDirectory()	0	15	2
A	filePath()	0	10	2
A	getDirectory()	0	13	3
B	getFiles()	0	38	4
B	size()	0	30	6
C	dirCopy()	0	55	19
A	deleteDir()	0	17	4
D	chmod()	0	41	10

<?php

/**
 * Koch Framework
 * Jens-André Koch © 2005 - onwards.
 *
 * This file is part of "Koch Framework".
 *
 * License: GNU/GPL v2 or any later version, see LICENSE file.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

namespace Koch\Files;

class Directory
{
    private $filtername = 'ImagesOnly';
    private $directory  = '';

    public function __construct($directory = null)
    {
        if ($directory !== null) {
            $this->setDirectory($directory);
        }

        return $this;

Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct?

    }

    /**
     * Available Filter types: image.
     */
    public function setFilter($filtername)
    {
        $this->filtername = $filtername;

        return $this;
    }

    public function setDirectory($directory)
    {
        // slash fix
        $directory = str_replace('/', DIRECTORY_SEPARATOR, $directory);
        $directory = str_replace('\\', DIRECTORY_SEPARATOR, $directory);

        // prefix directory with ROOT for security purposes
        if (stristr($directory, ROOT) === false) {
            $directory = APPLICATION_PATH . $directory;
        }

        $this->directory = $directory;

        return $this;
    }

    public function getDirectory($directory = '')
    {
        if ($directory !== '') {
            $this->directory = $directory;
        }

        if (empty($this->directory) === false) {
            return $this->directory;
        } else { // default path

            return APPLICATION_PATH . 'uploads/images/gallery';
        }
    }

    public function getFiles($return_as_array = false)

$return_as_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    {
        // compose the full name of the filter class
        $classname = 'Koch_' . $this->filtername . 'FilterIterator';

        // wrap the iterator in a filter class, when looking for a specific file type, like imagesOnly
        $iterator = new $classname(new \DirectoryIterator($this->getDirectory()));

        // return objects
        if ($return_as_array === false) {

$return_as_array does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            // create new array to take the SPL FileInfo Objects
            $data = new \ArrayObject();

            // while iterating
            foreach ($iterator as $file) {
                /*
                 * push the SPL FileInfo Objects into the array
                 * @see http://www.php.net/~helly/php/ext/spl/classSplFileInfo.html
                 */
                $data[$file->getFilename()] = $file->getFileInfo();
            }

            $data->ksort();
        } else { // return array
            // create array
            $data = [];

            // while iterating
            foreach ($iterator as $file) {
                $wwwpath        = WWW_ROOT . '/' . $this->getDirectory() . '/' . $file->getFilename();
                $wwwpath        = str_replace('//', '/', $wwwpath);
                $data[$wwwpath] = $file->getFilename();
            }
        }

        // return the array with SPL FileInfo Objects
        return $data;
    }

    /**
     * Returns the filePath with filename.
     *
     * @return array pathinfo
     */
    public function filePath($filePath)
    {
        $fileParts = pathinfo($filePath);

        if (!isset($fileParts['filename'])) {
            $fileParts['filename'] = mb_substr($fileParts['basename'], 0, mb_strrpos($fileParts['basename'], '.'));
        }

        return $fileParts;
    }

    /**
     * Calculates the size of a directory (recursiv).
     *
     * @param $dir Directory Path
     *
     * @return $size size of directory in bytes

The doc-type $size could not be parsed: Unknown type name "$size" at position 0. (view supported doc-types)

     */
    public static function size($dir)
    {
        if (is_dir($dir) === false) {
            return false;
        }

        $size = 0;
        $dh   = opendir($dir);
        while (($entry = readdir($dh)) !== false) {
            // exclude ./..
            if ($entry === '.' or $entry === '..') {

Using logical operators such as or instead of || is generally not recommended.

                continue;
            }

            $direntry = $dir . '/' . $entry;

            if (is_dir($direntry) === false) {
                // recursion
                $size += self::size($direntry);
            } else {
                $size += filesize($direntry);
            }

            unset($direntry);
        }

        closedir($dh);

        return $size;
    }

    /**
     * Copy a directory recursively.
     *
     * @param $source
     * @param $destination
     * @param $overwrite boolean
     */
    public function dirCopy($source, $destination, $overwrite = true)
    {
        $folder_path = '';

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

$folder_path is not used, you could remove the assignment.

        $handle = opendir($source);

        if ($handle) {
            while (false !== ($file = readdir($handle))) {
                if (mb_substr($file, 0, 1) !== '.') {
                    $source_path = $source . $file;

$source_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    $target_path = $destination . $file;

$target_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                    if (is_file($target_path) === false or $overwrite) {

$target_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Using logical operators such as or instead of || is generally not recommended.

                        if ([mb_strstr($target_path, '.') === true]) {

$target_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            $folder_path = dirname($target_path);

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        } else {
                            $folder_path = $target_path;

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        }

                        while (is_dir(dirname(end($folder_path)))

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        and dirname(end($folder_path)) !== '/'

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Using logical operators such as and instead of && is generally not recommended.

                        and dirname(end($folder_path)) !== '.'

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Using logical operators such as and instead of && is generally not recommended.

                        and dirname(end($folder_path)) !== ''

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Using logical operators such as and instead of && is generally not recommended.

                        and !preg_match('#^[A-Za-z]+\:\\\$#', dirname(end($folder_path)))) {

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Using logical operators such as and instead of && is generally not recommended.

                            array_push($folder_path, dirname(end($folder_path)));

$folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        }

                        while ($parent_folder_path = array_pop($folder_path)) {

$parent_folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            if (false === is_dir($parent_folder_path) and

$parent_folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

Using logical operators such as and instead of && is generally not recommended.

                                false === @mkdir($parent_folder_path, fileperms($parent_folder_path))) {

$parent_folder_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                                throw new \Exception(
                                    _('Could not create the directory that should be copied (destination).' .
                                      'Probably a permission problem.')
                                );
                            }
                        }

                        $old = ini_set('error_reporting', 0);
                        if (copy($source_path, $target_path) === false) {

$source_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            throw new \Exception('Could not copy the directory. Probably a permission problem.');
                        }
                        ini_set('error_reporting', $old);
                    } elseif (is_dir($source_path)) {

$source_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                        if (is_dir($target_path) === false) {

$target_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                            if (@mkdir($target_path, fileperms($source_path)) === false) {

$target_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

This if statement is empty and can be removed.

                                // nope, not an empty if statement :)
                            }
                        }
                        $this->dir_copy($source_path, $target_path, $overwrite);

$source_path does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

The method dir_copy() does not seem to exist on object<Koch\Files\Directory>.

                    }
                }
            }
            closedir($handle);
        }
    }

    /**
     * Recursively delete directory using PHP iterators.
     *
     * Uses a CHILD_FIRST RecursiveIteratorIterator to sort files
     * before directories, creating a single non-recursive loop
     * to delete files/directories in the correct order.
     *
     * @param string $directory
     * @param bool   $delete_dir_itself
     *
     * @return bool|null
     */
    public function deleteDir($directory, $delete_dir_itself = false)

$delete_dir_itself does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

    {
        $it = new RecursiveDirectoryIterator($directory, RecursiveDirectoryIterator::SKIP_DOTS);
        $ri = new RecursiveIteratorIterator($it, RecursiveIteratorIterator::CHILD_FIRST);

        foreach ($ri as $file) {
            if ($file->isDir()) {
                rmdir($file->getPathname());
            } else {
                unlink($file->getPathname());
            }
        }

        if ($delete_dir_itself === true) {

$delete_dir_itself does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            return rmdir($directory);
        }
    }

    /**
     * Performs a chmod operation.
     *
     * @param $path
     * @param $chmod
     * @param $recursive
     */
    public function chmod($path = '', $chmod = '755', $recursive = false)

function chmod() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        if (is_dir($path) === false) {
            $file_mode = '0' . $chmod;

$file_mode does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $file_mode = octdec($file_mode);

$file_mode does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (chmod($path, $file_mode) === false) {

$file_mode does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                return false;
            }
        } else {
            $dir_mode_r = '0' . $chmod;

$dir_mode_r does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            $dir_mode_r = octdec($dir_mode_r);

$dir_mode_r does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

            if (chmod($path, $dir_mode_r) === false) {

$dir_mode_r does not seem to conform to the naming convention (^[a-z][a-zA-Z0-9]*$).

                return false;
            }

            if ($recursive === false) {
                $dh = opendir($path);
                while ($file = readdir($dh)) {
                    if (mb_substr($file, 0, 1) !== '.') {
                        $fullpath = $path . '/' . $file;
                        if (!is_dir($fullpath)) {
                            $mode = '0' . $chmod;
                            $mode = octdec($mode);
                            if (chmod($fullpath, $mode) === false) {
                                return false;
                            }
                        } else {
                            if ($this->chmod($fullpath, $chmod, true) === false) {
                                return false;
                            }
                        }
                    }
                }
                closedir($dh);
            }
        }

        return true;
    }
}