Directory::filePath() - Code Metrics - KSST/KF - Measure and Improve Code Quality continuously with Scrutinizer

Directory::filePath() A
last analyzed 2017-04-11 14:32 UTC

↳ Parent: Directory
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	2
eloc	5
c	0
b	0
f	0
nc	2
nop	1
dl	0
loc	10
rs	9.4285
<?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;

    }

    /**
     * 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)

    {
        // 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) {

            // 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

     */
    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 === '..') {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                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 = '';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $handle = opendir($source);

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

                    $target_path = $destination . $file;


                    if (is_file($target_path) === false or $overwrite) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                        if ([mb_strstr($target_path, '.') === true]) {

                            $folder_path = dirname($target_path);

                        } else {
                            $folder_path = $target_path;

                        }

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

                        and dirname(end($folder_path)) !== '/'
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                        and dirname(end($folder_path)) !== '.'
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                        and dirname(end($folder_path)) !== ''
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                        and !preg_match('#^[A-Za-z]+\:\\\$#', dirname(end($folder_path)))) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                            array_push($folder_path, dirname(end($folder_path)));

                        }

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

                            if (false === is_dir($parent_folder_path) and
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
                                false === @mkdir($parent_folder_path, fileperms($parent_folder_path))) {

                                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) {

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

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

                            if (@mkdir($target_path, fileperms($source_path)) === false) {
if (rand(1, 6) > 3) {
//print "Check failed";
} else {
    print "Check succeeded";
}
                                // nope, not an empty if statement :)
                            }
                        }
                        $this->dir_copy($source_path, $target_path, $overwrite);

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

    {
        $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) {

            return rmdir($directory);
        }
    }

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

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

            $file_mode = octdec($file_mode);


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

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

            $dir_mode_r = octdec($dir_mode_r);


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

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

Directory::filePath() A
last analyzed 2017-04-11 14:32 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

KSST / KF

Directory::filePath() A last analyzed 2017-04-11 14:32 UTC

Complexity

Size

Duplication

Importance

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Duplication Side-by-Side

Filter issues like

Directory::filePath() A
last analyzed 2017-04-11 14:32 UTC
