Nip_File_System

Complexity

Total Complexity

52

Size/Duplication

Total Lines	289
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	createDirectory()	0	3	2
A	getExtension()	0	3	1
A	getUploadError()	0	22	5
A	emptyDirectory()	0	19	3
C	getUploadErrorNo()	0	33	14
A	formatSize()	0	10	2
A	instance()	0	8	2
A	copyDirectory()	0	8	2
A	directoryTree()	0	19	4
A	deleteFile()	0	7	2
B	scanDirectory()	0	23	8
A	removeDirectory()	0	19	5
A	chmod()	0	4	2

<?php

use Nip\Filesystem\Exception\IOException;

/**
 * Class Nip_File_System
 */
class Nip_File_System
{
    protected $_uploadErrors = [
        0 => 'There is no error, the file uploaded with success',
        1 => 'The uploaded file exceeds the upload_max_filesize directive in php.ini',
        2 => 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form',
        3 => 'The uploaded file was only partially uploaded',
        4 => 'No file was uploaded',
        6 => 'Missing a temporary folder',
    ];

    /**
     * Singleton.
     *
     * @return self
     */
    public static function instance()
    {
        static $instance;
        if (!($instance instanceof self)) {
            $instance = new self();
        }

        return $instance;
    }

    /**
     * Returns error message on upload, if any.
     *
     * @param string $file
     * @param array $extensions
     *
     * @return mixed
     */
    public function getUploadError($file, $extensions = [])
    {
        $messages = [
            'max_post' => 'POST exceeded maximum allowed size.',
            'no_upload' => 'No upload found in \$_FILES',
            'bad_upload' => 'Upload failed is_uploaded_file test.',
            'no_name' => 'File has no name.',
            'bad_extension' => 'Invalid file extension',
        ];

        $errorCode = $this->getUploadErrorNo($file, $extensions);
        if (is_int($errorCode)) {
            $translateSlug = 'general.errors.upload.code-'.$errorCode;

            return app('translator')->hasTranslation($translateSlug) ? __($translateSlug) : $this->_uploadErrors[$errorCode];

The function __ was not found. Maybe you did not declare it correctly or list all dependencies?

The function app was not found. Maybe you did not declare it correctly or list all dependencies?

        } elseif (is_string($errorCode)) {
            $translateSlug = 'general.errors.upload.'.$errorCode;

            return app('translator')->hasTranslation($translateSlug) ? __($translateSlug) : $messages[$errorCode];
        }

        return false;
    }

    /**
     * Returns error message on upload, if any.
     *
     * @param string $file
     * @param array $extensions
     *
     * @return mixed
     */
    public function getUploadErrorNo($file, $extensions = [])
    {
        $result = false;

        $maxUpload = ini_get('post_max_size');
        $unit = strtoupper(substr($maxUpload, -1));
        $multiplier = $unit == 'M' ? 1048576 : ($unit == 'K' ? 1024 : ($unit == 'G' ? 1073741824 : 1));

        if ($maxUpload && ((int)$_SERVER['CONTENT_LENGTH'] > $multiplier * (int)$maxUpload)) {
            $result = 'max_post';
        }

        if (!isset($file)) {
            $result = 'no_upload';
        } else {
            if (isset($file['error']) && $file['error'] != 0) {
                $result = $file['error'];
            } else {
                if (!isset($file['tmp_name']) || !@is_uploaded_file($file['tmp_name'])) {
                    $result = 'bad_upload';
                } else {
                    if (!isset($file['name'])) {
                        $result = 'no_name';
                    }
                }
            }
        }

        if ($extensions && !in_array($this->getExtension($file['name']), $extensions)) {

The expression $extensions of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $result = 'bad_extension';
        }

        return $result;
    }

    /**
     * Get file extension.
     *
     * @param string $str
     *
     * @return string
     */
    public function getExtension($str)
    {
        return strtolower(pathinfo($str, PATHINFO_EXTENSION));
    }

    /**
     * Gets list of all files within a directory.
     *
     * @param string $dir
     * @param bool $recursive
     *
     * @return array
     */
    public function scanDirectory($dir, $recursive = false, $fullPaths = false)
    {
        $result = [];

        if (is_dir($dir)) {
            if ($recursive) {
                $iterator = new RecursiveDirectoryIterator($dir);
                foreach (new RecursiveIteratorIterator($iterator, RecursiveIteratorIterator::CHILD_FIRST) as $file) {
                    if ($file->isFile()) {
                        $result[] = ($fullPaths ? $file->getPath().DIRECTORY_SEPARATOR : '').$file->getFilename();
                    }
                }
            } else {
                $iterator = new DirectoryIterator($dir);
                foreach ($iterator as $file) {
                    if ($file->isFile()) {
                        $result[] = $file->getFilename();
                    }
                }
            }
        }

        return $result;
    }

    /**
     * Recursively create a directory and set it's permissions.
     *
     * @param string $dir
     * @param int $mode
     *
     * @return bool
     */
    public function createDirectory($dir, $mode = 0777)
    {
        return is_dir($dir) ? true : mkdir($dir, $mode, true);
    }

    /**
     * Builds array-tree of directory, with files as final nodes.
     *
     * @param string $dir
     * @param array $tree
     *
     * @return array
     */
    public function directoryTree($dir, $tree = [])
    {
        $dir = realpath($dir);
        $d = dir($dir);

        while (false != ($entry = $d->read())) {

It seems like you are loosely comparing $entry = $d->read() of type string to the boolean false. If you are specifically checking for a non-empty string, consider using the more explicit !== '' instead.

            $complete = $d->path.'/'.$entry;
            if (!in_array($entry, ['.', '..', '.svn'])) {
                if (is_dir($complete)) {
                    $tree[$entry] = $this->directoryTree($complete, $tree[$dir][$entry]);
                } else {
                    $tree[] = $entry;
                }
            }
        }

        $d->close();

        return $tree;
    }

    /**
     * Recursively empties a directory.
     *
     * @param string $dir
     */
    public function emptyDirectory($dir)
    {
        $dir = rtrim($dir, '/');

        $files = scandir($dir);

        array_shift($files);

It seems like $files can also be of type false; however, parameter $array of array_shift() does only seem to accept array, maybe add an additional type check?

        array_shift($files);

        foreach ($files as $file) {
            $file = $dir.'/'.$file;
            if (is_dir($file)) {
                $this->removeDirectory($file);
            } else {
                unlink($file);
            }
        }

        return $this;
    }

    /**
     * Recursively removes a directory.
     *
     * @param string $dir
     */
    public function removeDirectory($dir)
    {
        $dir = rtrim($dir, '/');

        if (is_dir($dir)) {
            $files = scandir($dir);

            foreach ($files as $file) {
                if (!in_array($file, ['.', '..'])) {
                    $file = $dir.DIRECTORY_SEPARATOR.$file;
                    if (is_dir($file)) {
                        $this->removeDirectory($file);
                    } else {
                        unlink($file);
                    }
                }
            }

            rmdir($dir);
        }
    }

    public function deleteFile($path)
    {
        if (file_exists($path)) {
            unlink($path);
        }

        return $this;
    }

    /**
     * @param $source
     * @param $destination
     * @return mixed
     */
    public function copyDirectory($source, $destination)
    {
        if (!is_dir($destination)) {
            mkdir($destination, 0755, true);
        }
        $process = new Nip_Process("cp -R -f $source/* $destination");

The type Nip_Process was not found. Maybe you did not declare it correctly or list all dependencies?

        return $process->run();
    }

    /**
     * @param $bytes
     * @return string
     */
    public function formatSize($bytes)
    {
        if (!$bytes) {
            return '0 kb';
        }

        $s = ['b', 'kb', 'MB', 'GB', 'TB', 'PB'];
        $e = floor(log($bytes) / log(1024));

        return sprintf('%.2f '.$s[$e], ($bytes / pow(1024, floor($e))));
    }

    /**
     * @param $file
     * @param $mode
     */
    public function chmod($file, $mode)
    {
        if (true !== @chmod($file, $mode)) {
            throw new IOException(sprintf('Failed to chmod file "%s".', $file), 0, null, $file);
        }
    }
}