elFinderVolumeLocalFileSystem - Code Metrics - Inspection of "refactoring" - recca0120/laravel-elfinder - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 61c24d...075a0d )

by recca
created 2017-06-16 17:58 UTC
elFinderVolumeLocalFileSystem D

↳ Parent: Project
Complexity

Total Complexity
274
Size/Duplication

Total Lines	1296
Duplicated Lines	11.19 %
Coupling/Cohesion

Components	2
Dependencies	4
Importance

Changes
Metric	Value
dl	145
loc	1296
rs	4.4102
c	0
b	0
f	0
wmc	274
lcom	2
cbo	4
39 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	11	1
D	localFileSystemInotify()	0	38	9
B	localFileSystemSearchIteratorFilter()	10	20	8
C	init()	0	37	13
F	configure()	5	75	24
A	_dirname()	0	4	1
A	_basename()	0	4	1
A	_joinPath()	0	4	1
F	_normpath()	18	57	20
A	_relpath()	13	13	3
A	_abspath()	0	13	3
A	_path()	0	4	2
A	_inpath()	0	11	4
F	_stat()	3	72	23
D	getOwnerStat()	18	42	10
C	_subdirs()	0	36	8
A	_dimensions()	0	8	4
A	readlink()	0	16	4
F	_scandir()	3	99	27
A	_fopen()	0	4	1
A	_fclose()	0	4	2
A	_mkdir()	13	13	2
A	_mkfile()	14	14	2
A	_symlink()	0	4	1
A	_copy()	11	11	4
B	_move()	11	11	5
A	_unlink()	0	7	2
A	_rmdir()	0	7	2
C	_save()	0	37	15
A	_getContents()	0	4	1
A	_filePutContents()	0	10	2
A	_checkArchivers()	0	4	1
A	_chmod()	0	8	3
A	_findSymlinks()	0	4	1
F	_extract()	13	105	32
A	_archive()	0	4	1
A	getWorkFile()	0	4	1
A	delTree()	0	4	1
D	doSearch()	13	81	29
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like elFinderVolumeLocalFileSystem often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use elFinderVolumeLocalFileSystem, and based on these observations, apply Extract Interface, too.
<?php

// Implement similar functionality in PHP 5.2 or 5.3
// http://php.net/manual/class.recursivecallbackfilteriterator.php#110974
if (! class_exists('RecursiveCallbackFilterIterator', false)) {
    class RecursiveCallbackFilterIterator extends RecursiveFilterIterator
namespace YourVendor;

class YourClass { }
    {
        public function __construct(RecursiveIterator $iterator, $callback)
        {
            $this->callback = $callback;
class MyClass { }

$x = new MyClass();
$x->foo = true;
            parent::__construct($iterator);
        }

        public function accept()
        {
            return call_user_func($this->callback, parent::current(), parent::key(), parent::getInnerIterator());
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
        }

        public function getChildren()
        {
            return new self($this->getInnerIterator()->getChildren(), $this->callback);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }
    }
}

/**
 * elFinder driver for local filesystem.
 *
 * @author Dmitry (dio) Levashov
 * @author Troex Nevelin
 **/
class elFinderVolumeLocalFileSystem extends elFinderVolumeDriver
namespace YourVendor;

class YourClass { }
{
    /**
	 * Driver id
	 * Must be started from letter and contains [a-z0-9]
	 * Used as part of volume id.
	 *
	 * @var string
	 **/
	protected $driverId = 'l';

	/**
	 * Required to count total archive files size.
	 *
	 * @var int
	 **/
	protected $archiveSize = 0;

	/**
	 * Constructor
	 * Extend options with required fields.
	 *
	 * @author Dmitry (dio) Levashov
	 */
	public function __construct()
	{
	    $this->options['alias'] = '';              // alias to replace root dir name
		$this->options['dirMode'] = 0755;            // new dirs mode
		$this->options['fileMode'] = 0644;            // new files mode
		$this->options['quarantine'] = '.quarantine'; // quarantine folder name - required to check archive (must be hidden)
		$this->options['rootCssClass'] = 'elfinder-navbar-root-local';
	    $this->options['followSymLinks'] = true;
	    $this->options['detectDirIcon'] = '';         // file name that is detected as a folder icon e.g. '.diricon.png'
		$this->options['keepTimestamp'] = ['copy', 'move']; // keep timestamp at inner filesystem allowed 'copy', 'move' and 'upload'
	}

	/**
	 * Long pooling sync checker
	 * This function require server command `inotifywait`
	 * If `inotifywait` need full path, Please add `define('ELFINER_INOTIFYWAIT_PATH', '/PATH_TO/inotifywait');` into connector.php.
	 *
	 * @param string     $path
	 * @param int        $standby
	 * @param number     $compare
	 * @return number|bool
	 */
	public function localFileSystemInotify($path, $standby, $compare)
	{
	    if (isset($this->sessionCache['localFileSystemInotify_disable'])) {
	        return false;
	    }
	    $path = realpath($path);
	    $mtime = filemtime($path);
	    if (! $mtime) {
	        return false;
	    }
	    if ($mtime != $compare) {
	        return $mtime;
	    }
	    $inotifywait = defined('ELFINER_INOTIFYWAIT_PATH') ? ELFINER_INOTIFYWAIT_PATH : 'inotifywait';
	    $standby = max(1, intval($standby));
	    $cmd = $inotifywait.' '.escapeshellarg($path).' -t '.$standby.' -e moved_to,moved_from,move,close_write,delete,delete_self';
	    $this->procExec($cmd, $o, $r);
	    if ($r === 0) {
	        // changed
			clearstatcache();
	        if (file_exists($path)) {
	            $mtime = filemtime($path); // error on busy?
				return $mtime ? $mtime : time();
	        } else {
	            // target was removed
				return 0;
	        }
	    } elseif ($r === 2) {
	        // not changed (timeout)
			return $compare;
	    }
		// error
		// cache to $_SESSION
		$this->sessionCache['localFileSystemInotify_disable'] = true;
	    $this->session->set($this->id, $this->sessionCache, true);


	    return false;
	}

	/******************** Original local functions ************************
	 * @param $file
	 * @param $key
	 * @param $iterator
	 * @return bool
	 */

	public function localFileSystemSearchIteratorFilter($file, $key, $iterator)
	{
	    $name = $file->getFilename();
	    if ($this->doSearchCurrentQuery['excludes']) {

	        foreach ($this->doSearchCurrentQuery['excludes'] as $exclude) {

	            if ($this->stripos($name, $exclude) !== false) {
	                return false;
	            }
	        }
	    }
	    if ($iterator->hasChildren()) {
	        if ($this->options['searchExDirReg'] && preg_match($this->options['searchExDirReg'], $key)) {

	            return false;
	        }

	        return (bool) $this->attr($key, 'read', null, true);
	    }

	    return ($this->stripos($name, $this->doSearchCurrentQuery['q']) === false) ? false : true;
	}

	/*********************************************************************/
	/*                        INIT AND CONFIGURE                         */
	/*********************************************************************/

	/**
	 * Prepare driver before mount volume.
	 * Return true if volume is ready.
	 *
	 * @return bool
	 **/
	protected function init()
	{
	    // Normalize directory separator for windows
		if (DIRECTORY_SEPARATOR !== '/') {
		    foreach (['path', 'tmbPath', 'tmpPath', 'quarantine'] as $key) {
		        if (! empty($this->options[$key])) {
		            $this->options[$key] = str_replace('/', DIRECTORY_SEPARATOR, $this->options[$key]);
		        }
		    }
		}
	    if (! $cwd = getcwd()) {
	        return $this->setError('elFinder LocalVolumeDriver requires a result of getcwd().');
	    }
		// detect systemRoot
		if (! isset($this->options['systemRoot'])) {
		    if ($cwd[0] === $this->separator || $this->root[0] === $this->separator) {
		        $this->systemRoot = $this->separator;
		    } elseif (preg_match('/^([a-zA-Z]:'.preg_quote($this->separator, '/').')/', $this->root, $m)) {
		        $this->systemRoot = $m[1];
		    } elseif (preg_match('/^([a-zA-Z]:'.preg_quote($this->separator, '/').')/', $cwd, $m)) {
		        $this->systemRoot = $m[1];
		    }
		}
	    $this->root = $this->getFullPath($this->root, $cwd);
	    if (! empty($this->options['startPath'])) {
	        $this->options['startPath'] = $this->getFullPath($this->options['startPath'], $this->root);
	    }

	    if (is_null($this->options['syncChkAsTs'])) {
	        $this->options['syncChkAsTs'] = true;
	    }
	    if (is_null($this->options['syncCheckFunc'])) {
	        $this->options['syncCheckFunc'] = [$this, 'localFileSystemInotify'];
	    }

	    return true;
	}

	/**
	 * Configure after successfull mount.
	 *
	 * @return void
	 * @author Dmitry (dio) Levashov
	 **/
	protected function configure()
	{
	    $root = $this->stat($this->root);

		// chek thumbnails path
		if ($this->options['tmbPath']) {
		    $this->options['tmbPath'] = strpos($this->options['tmbPath'], DIRECTORY_SEPARATOR) === false
				// tmb path set as dirname under root dir
				? $this->_abspath($this->options['tmbPath'])
				// tmb path as full path
				: $this->_normpath($this->options['tmbPath']);
		}

	    parent::configure();

		// set $this->tmp by options['tmpPath']

		$this->tmp = '';
class MyClass { }

$x = new MyClass();
$x->foo = true;
	    if (! empty($this->options['tmpPath'])) {

	        if ((is_dir($this->options['tmpPath']) || mkdir($this->options['tmpPath'], 0755, true)) && is_writable($this->options['tmpPath'])) {
	            $this->tmp = $this->options['tmpPath'];
	        }
	    }
	    if (! $this->tmp && ($tmp = elFinder::getStaticVar('commonTempPath'))) {
	        $this->tmp = $tmp;
	    }

		// if no thumbnails url - try detect it
		if ($root['read'] && ! $this->tmbURL && $this->URL) {
		    if (strpos($this->tmbPath, $this->root) === 0) {
		        $this->tmbURL = $this->URL.str_replace(DIRECTORY_SEPARATOR, '/', substr($this->tmbPath, strlen($this->root) + 1));
		        if (preg_match('|[^/?&=]$|', $this->tmbURL)) {
		            $this->tmbURL .= '/';
		        }
		    }
		}

		// check quarantine dir
		$this->quarantine = '';
class MyClass { }

$x = new MyClass();
$x->foo = true;
	    if (! empty($this->options['quarantine'])) {
	        if (is_dir($this->options['quarantine'])) {
	            if (is_writable($this->options['quarantine'])) {
	                $this->quarantine = $this->options['quarantine'];
	            }
	            $this->options['quarantine'] = '';
	        } else {
	            $this->quarantine = $this->_abspath($this->options['quarantine']);
	            if ((! is_dir($this->quarantine) && ! mkdir($this->quarantine)) || ! is_writable($this->quarantine)) {
	                $this->options['quarantine'] = $this->quarantine = '';
	            }
	        }
	    }

	    if (! $this->quarantine) {
	        if (! $this->tmp) {
	            $this->archivers['extract'] = [];
	            $this->disabled[] = 'extract';
	        } else {
	            $this->quarantine = $this->tmp;
	        }
	    }

	    if ($this->options['quarantine']) {
	        $this->attributes[] = [
					'pattern' => '~^'.preg_quote(DIRECTORY_SEPARATOR.$this->options['quarantine']).'$~',
					'read' => false,
					'write' => false,
					'locked' => true,
					'hidden' => true,
			];
	    }

	    if (! empty($this->options['keepTimestamp'])) {
	        $this->options['keepTimestamp'] = array_flip($this->options['keepTimestamp']);
	    }
	}

	/*********************************************************************/
	/*                               FS API                              */
	/*********************************************************************/

	/*********************** paths/urls *************************/

	/**
	 * Return parent directory path.
	 *
	 * @param  string  $path  file path
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _dirname($path)
	{
	    return dirname($path);
	}

	/**
	 * Return file name.
	 *
	 * @param  string  $path  file path
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _basename($path)
	{
	    return basename($path);
	}

	/**
	 * Join dir name and file name and retur full path.
	 *
	 * @param  string  $dir
	 * @param  string  $name
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _joinPath($dir, $name)
	{
	    return rtrim($dir, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.$name;
	}

	/**
	 * Return normalized path, this works the same as os.path.normpath() in Python.
	 *
	 * @param  string  $path  path
	 * @return string
	 * @author Troex Nevelin
	 **/
	protected function _normpath($path)
	{
	    if (empty($path)) {
	        return '.';
	    }

	    $changeSep = (DIRECTORY_SEPARATOR !== '/');
	    if ($changeSep) {
	        $drive = '';
	        if (preg_match('/^([a-zA-Z]:)(.*)/', $path, $m)) {
	            $drive = $m[1];
	            $path = $m[2] ? $m[2] : '/';
	        }
	        $path = str_replace(DIRECTORY_SEPARATOR, '/', $path);
	    }

	    if (strpos($path, '/') === 0) {
	        $initial_slashes = true;
	    } else {
	        $initial_slashes = false;
	    }

	    if (($initial_slashes)

		&& (strpos($path, '//') === 0)
		&& (strpos($path, '///') === false)) {
	        $initial_slashes = 2;
	    }

	    $initial_slashes = (int) $initial_slashes;

	    $comps = explode('/', $path);
	    $new_comps = [];
	    foreach ($comps as $comp) {

	        if (in_array($comp, ['', '.'])) {
	            continue;
	        }

	        if (($comp != '..')
			|| (! $initial_slashes && ! $new_comps)

			|| ($new_comps && (end($new_comps) == '..'))) {

	            array_push($new_comps, $comp);
	        } elseif ($new_comps) {

	            array_pop($new_comps);
	        }
	    }
	    $comps = $new_comps;
	    $path = implode('/', $comps);
	    if ($initial_slashes) {
	        $path = str_repeat('/', $initial_slashes).$path;
	    }

	    if ($changeSep) {
	        $path = $drive.str_replace('/', DIRECTORY_SEPARATOR, $path);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
	    }

	    return $path ? $path : '.';
	}

	/**
	 * Return file path related to root dir.
	 *
	 * @param  string  $path  file path
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _relpath($path)

	{
	    if ($path === $this->root) {
	        return '';
	    } else {
	        if (strpos($path, $this->root) === 0) {
	            return ltrim(substr($path, strlen($this->root)), DIRECTORY_SEPARATOR);
	        } else {
	            // for link
				return $path;
	        }
	    }
	}

	/**
	 * Convert path related to root dir into real path.
	 *
	 * @param  string  $path  file path
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _abspath($path)
	{
	    if ($path === DIRECTORY_SEPARATOR) {
	        return $this->root;
	    } else {
	        if ($path[0] === DIRECTORY_SEPARATOR) {
	            // for link
				return $path;
	        } else {
	            return $this->_joinPath($this->root, $path);
	        }
	    }
	}

	/**
	 * Return fake path started from root dir.
	 *
	 * @param  string  $path  file path
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _path($path)
	{
	    return $this->rootName.($path == $this->root ? '' : $this->separator.$this->_relpath($path));
	}

	/**
	 * Return true if $path is children of $parent.
	 *
	 * @param  string  $path    path to check
	 * @param  string  $parent  parent path
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _inpath($path, $parent)
	{
	    $cwd = getcwd();
	    $real_path = $this->getFullPath($path, $cwd);
	    $real_parent = $this->getFullPath($parent, $cwd);
	    if ($real_path && $real_parent) {
	        return $real_path === $real_parent || strpos($real_path, rtrim($real_parent, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR) === 0;
	    }

	    return false;
	}

	/***************** file stat ********************/

	/**
	 * Return stat for given path.
	 * Stat contains following fields:
	 * - (int)    size    file size in b. required
	 * - (int)    ts      file modification time in unix time. required
	 * - (string) mime    mimetype. required for folders, others - optionally
	 * - (bool)   read    read permissions. required
	 * - (bool)   write   write permissions. required
	 * - (bool)   locked  is object locked. optionally
	 * - (bool)   hidden  is object hidden. optionally
	 * - (string) alias   for symlinks - link target path relative to root path. optionally
	 * - (string) target  for symlinks - link target path. optionally.
	 *
	 * If file does not exists - returns empty array or false.
	 *
	 * @param  string  $path    file path
	 * @return array|false
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _stat($path)
	{
	    static $statOwner;
	    if (is_null($statOwner)) {
	        $statOwner = (! empty($this->options['statOwner']));
	    }

	    $stat = [];

	    if (! file_exists($path) && ! is_link($path)) {
	        return $stat;
	    }

		//Verifies the given path is the root or is inside the root. Prevents directory traveral.
		if (! $this->_inpath($path, $this->root)) {
		    return $stat;
		}

	    $gid = $uid = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
	    $stat['isowner'] = false;
	    $linkreadable = false;
	    if ($path != $this->root && is_link($path)) {
	        if (! $this->options['followSymLinks']) {
	            return [];
	        }
	        if (! ($target = $this->readlink($path))
			|| $target == $path) {
	            if (is_null($target)) {
	                $stat = [];

	                return $stat;
	            } else {
	                $stat['mime'] = 'symlink-broken';
	                $target = readlink($path);
	                $lstat = lstat($path);
	                $ostat = $this->getOwnerStat($lstat['uid'], $lstat['gid']);
	                $linkreadable = ! empty($ostat['isowner']);
	            }
	        }
	        $stat['alias'] = $this->_path($target);
	        $stat['target'] = $target;
	    }
	    $size = sprintf('%u', filesize($path));
	    $stat['ts'] = filemtime($path);
	    if ($statOwner) {
	        $fstat = stat($path);
	        $uid = $fstat['uid'];
	        $gid = $fstat['gid'];
	        $stat['perm'] = substr((string) decoct($fstat['mode']), -4);
	        $stat = array_merge($stat, $this->getOwnerStat($uid, $gid));
	    }

	    if (($dir = is_dir($path)) && $this->options['detectDirIcon']) {
	        $favicon = $path.DIRECTORY_SEPARATOR.$this->options['detectDirIcon'];
	        if ($this->URL && file_exists($favicon)) {

	            $stat['icon'] = $this->URL.str_replace(DIRECTORY_SEPARATOR, '/', substr($favicon, strlen($this->root) + 1));
	        }
	    }

	    if (! isset($stat['mime'])) {
	        $stat['mime'] = $dir ? 'directory' : $this->mimetype($path);
	    }
		//logical rights first
		$stat['read'] = ($linkreadable || is_readable($path)) ? null : false;
	    $stat['write'] = is_writable($path) ? null : false;

	    if (is_null($stat['read'])) {
	        $stat['size'] = $dir ? 0 : $size;
	    }

	    return $stat;
	}

	/**
	 * Get stat `owner`, `group` and `isowner` by `uid` and `gid`
	 * Sub-fuction of _stat() and _scandir().
	 *
	 * @param int $uid
	 * @param int $gid
	 * @return array  stat
	 */
	protected function getOwnerStat($uid, $gid)
	{
	    static $names = null;
	    static $phpuid = null;

	    if (is_null($names)) {
	        $names = ['uid' => [], 'gid' => []];
	    }
	    if (is_null($phpuid)) {
	        if (is_callable('posix_getuid')) {
	            $phpuid = posix_getuid();
	        } else {
	            $phpuid = 0;
	        }
	    }

	    $stat = [];

	    if ($uid) {
	        $stat['isowner'] = ($phpuid == $uid);
	        if (isset($names['uid'][$uid])) {

	            $stat['owner'] = $names['uid'][$uid];
	        } elseif (is_callable('posix_getpwuid')) {
	            $pwuid = posix_getpwuid($uid);
	            $stat['owner'] = $names['uid'][$uid] = $pwuid['name'];
	        } else {
	            $stat['owner'] = $names['uid'][$uid] = $uid;
	        }
	    }
	    if ($gid) {

	        if (isset($names['gid'][$gid])) {
	            $stat['group'] = $names['gid'][$gid];
	        } elseif (is_callable('posix_getgrgid')) {
	            $grgid = posix_getgrgid($gid);
	            $stat['group'] = $names['gid'][$gid] = $grgid['name'];
	        } else {
	            $stat['group'] = $names['gid'][$gid] = $gid;
	        }
	    }

	    return $stat;
	}

	/**
	 * Return true if path is dir and has at least one childs directory.
	 *
	 * @param  string  $path  dir path
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _subdirs($path)
	{
	    $dirs = false;
	    if (is_dir($path) && is_readable($path)) {
	        if (class_exists('FilesystemIterator', false)) {
	            $dirItr = new ParentIterator(
					new RecursiveDirectoryIterator($path,
						FilesystemIterator::SKIP_DOTS |
						(defined('RecursiveDirectoryIterator::FOLLOW_SYMLINKS') ?
							RecursiveDirectoryIterator::FOLLOW_SYMLINKS : 0)
					)
				);
	            $dirItr->rewind();
	            if ($dirItr->hasChildren()) {
	                $dirs = true;
	                $name = $dirItr->getSubPathName();
	                while ($name) {
	                    if (! $this->attr($path.DIRECTORY_SEPARATOR.$name, 'read', null, true)) {
	                        $dirs = false;
	                        $dirItr->next();
	                        $name = $dirItr->getSubPathName();
	                        continue;
	                    }
	                    $dirs = true;
	                    break;
	                }
	            }
	        } else {
	            $path = strtr($path, ['[' => '\\[', ']' => '\\]', '*' => '\\*', '?' => '\\?']);

	            return (bool) glob(rtrim($path, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.'*', GLOB_ONLYDIR);
	        }
	    }

	    return $dirs;
	}

	/**
	 * Return object width and height
	 * Usualy used for images, but can be realize for video etc...
	 *
	 * @param  string  $path  file path
	 * @param  string  $mime  file mime type
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _dimensions($path, $mime)
	{
	    clearstatcache();

	    return strpos($mime, 'image') === 0 && is_readable($path) && ($s = getimagesize($path)) !== false
			? $s[0].'x'.$s[1]
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
			: false;
	}

	/******************** file/dir content *********************/

	/**
	 * Return symlink target file.
	 *
	 * @param  string  $path  link path
	 * @return string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function readlink($path)
	{
	    if (! ($target = readlink($path))) {
	        return;
	    }

	    if (strpos($target, $this->systemRoot) !== 0) {
	        $target = $this->_joinPath(dirname($path), $target);
	    }

	    if (! file_exists($target)) {
	        return false;
	    }

	    return $target;
	}

	/**
	 * Return files list in directory.
	 *
	 * @param  string  $path  dir path
	 * @return array
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _scandir($path)
	{
	    elFinder::extendTimeLimit();
	    $files = [];
	    $cache = [];
	    $dirWritable = is_writable($path);
	    $statOwner = (! empty($this->options['statOwner']));
	    $dirItr = [];
	    $followSymLinks = $this->options['followSymLinks'];
	    try {
	        $dirItr = new DirectoryIterator($path);
	    } catch (UnexpectedValueException $e) {

	    }

	    foreach ($dirItr as $file) {
	        try {
	            if ($file->isDot()) {
	                continue;
	            }

	            $files[] = $fpath = $file->getPathname();

	            $br = false;
	            $stat = [];

	            $gid = $uid = 0;
	            $stat['isowner'] = false;
	            $linkreadable = false;
	            if ($file->isLink()) {
	                if (! $followSymLinks) {
	                    continue;
	                }
	                if (! ($target = $this->readlink($fpath))
					|| $target == $fpath) {
	                    if (is_null($target)) {
	                        $stat = [];
	                        $br = true;
	                    } else {
	                        $_path = $fpath;
	                        $stat['mime'] = 'symlink-broken';
	                        $target = readlink($_path);
	                        $lstat = lstat($_path);
	                        $ostat = $this->getOwnerStat($lstat['uid'], $lstat['gid']);
	                        $linkreadable = ! empty($ostat['isowner']);
	                        $dir = false;
	                        $stat['alias'] = $this->_path($target);
	                        $stat['target'] = $target;
	                    }
	                } else {
	                    $dir = is_dir($target);
	                    $stat['alias'] = $this->_path($target);
	                    $stat['target'] = $target;
	                    $stat['mime'] = $dir ? 'directory' : $this->mimetype($stat['alias']);
	                }
	            } else {
	                if (($dir = $file->isDir()) && $this->options['detectDirIcon']) {
	                    $path = $file->getPathname();
	                    $favicon = $path.DIRECTORY_SEPARATOR.$this->options['detectDirIcon'];
	                    if ($this->URL && file_exists($favicon)) {

	                        $stat['icon'] = $this->URL.str_replace(DIRECTORY_SEPARATOR, '/', substr($favicon, strlen($this->root) + 1));
	                    }
	                }
	                $stat['mime'] = $dir ? 'directory' : $this->mimetype($fpath);
	            }
	            $size = sprintf('%u', $file->getSize());
	            $stat['ts'] = $file->getMTime();
	            if (! $br) {
	                if ($statOwner && ! $linkreadable) {
	                    $uid = $file->getOwner();
	                    $gid = $file->getGroup();
	                    $stat['perm'] = substr((string) decoct($file->getPerms()), -4);
	                    $stat = array_merge($stat, $this->getOwnerStat($uid, $gid));
	                }

					//logical rights first
					$stat['read'] = ($linkreadable || $file->isReadable()) ? null : false;
	                $stat['write'] = $file->isWritable() ? null : false;
	                $stat['locked'] = $dirWritable ? null : true;

	                if (is_null($stat['read'])) {
	                    $stat['size'] = $dir ? 0 : $size;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
	                }
	            }

	            $cache[] = [$fpath, $stat];
	        } catch (RuntimeException $e) {
	            continue;
	        }
	    }

	    if ($cache) {

	        $cache = $this->convEncOut($cache, false);
	        foreach ($cache as $d) {
	            $this->updateCache($d[0], $d[1]);
	        }
	    }

	    return $files;
	}

	/**
	 * Open file and return file pointer.
	 *
	 * @param  string $path file path
	 * @param string $mode
	 * @return false|resource
	 * @internal param bool $write open file for writing
	 * @author Dmitry (dio) Levashov
	 */
	protected function _fopen($path, $mode = 'rb')
	{
	    return fopen($path, $mode);
	}

	/**
	 * Close opened file.
	 *
	 * @param  resource $fp file pointer
	 * @param string $path
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 */
	protected function _fclose($fp, $path = '')
	{
	    return is_resource($fp) && fclose($fp);
	}

	/********************  file/dir manipulations *************************/

	/**
	 * Create dir and return created dir path or false on failed.
	 *
	 * @param  string  $path  parent dir path
	 * @param string  $name  new directory name
	 * @return string|bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _mkdir($path, $name)

	{
	    $path = $this->_joinPath($path, $name);

	    if (mkdir($path)) {
	        chmod($path, $this->options['dirMode']);
	        clearstatcache();

	        return $path;
	    }

	    return false;
	}

	/**
	 * Create file and return it's path or false on failed.
	 *
	 * @param  string  $path  parent dir path
	 * @param string  $name  new file name
	 * @return string|bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _mkfile($path, $name)

	{
	    $path = $this->_joinPath($path, $name);

	    if (($fp = fopen($path, 'w'))) {
	        fclose($fp);
	        chmod($path, $this->options['fileMode']);
	        clearstatcache();

	        return $path;
	    }

	    return false;
	}

	/**
	 * Create symlink.
	 *
	 * @param  string  $source     file to link to
	 * @param  string  $targetDir  folder to create link in
	 * @param  string  $name       symlink name
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _symlink($source, $targetDir, $name)
	{
	    return symlink($source, $this->_joinPath($targetDir, $name));
	}

	/**
	 * Copy file into another file.
	 *
	 * @param  string  $source     source file path
	 * @param  string  $targetDir  target directory path
	 * @param  string  $name       new file name
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _copy($source, $targetDir, $name)

	{
	    $mtime = filemtime($source);
	    $target = $this->_joinPath($targetDir, $name);
	    if ($ret = copy($source, $target)) {
	        isset($this->options['keepTimestamp']['copy']) && $mtime && touch($target, $mtime);
	        clearstatcache();
	    }

	    return $ret;
	}

	/**
	 * Move file into another parent dir.
	 * Return new file path or false.
	 *
	 * @param  string $source source file path
	 * @param $targetDir
	 * @param  string $name file name
	 * @return bool|string
	 * @internal param string $target target dir path
	 * @author Dmitry (dio) Levashov
	 */
	protected function _move($source, $targetDir, $name)

	{
	    $mtime = filemtime($source);
	    $target = $this->_joinPath($targetDir, $name);
	    if ($ret = rename($source, $target) ? $target : false) {
	        isset($this->options['keepTimestamp']['move']) && $mtime && touch($target, $mtime);
	        clearstatcache();
	    }

	    return $ret;
	}

	/**
	 * Remove file.
	 *
	 * @param  string  $path  file path
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _unlink($path)
	{
	    $ret = unlink($path);
	    $ret && clearstatcache();

	    return $ret;
	}

	/**
	 * Remove dir.
	 *
	 * @param  string  $path  dir path
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _rmdir($path)
	{
	    $ret = rmdir($path);
	    $ret && clearstatcache();

	    return $ret;
	}

	/**
	 * Create new file and write into it from file pointer.
	 * Return new file path or false on error.
	 *
	 * @param  resource  $fp   file pointer
	 * @param  string    $dir  target dir path
	 * @param  string    $name file name
	 * @param  array     $stat file stat (required by some virtual fs)
	 * @return bool|string
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _save($fp, $dir, $name, $stat)
	{
	    $path = $this->_joinPath($dir, $name);

	    $meta = stream_get_meta_data($fp);
	    $uri = isset($meta['uri']) ? $meta['uri'] : '';
	    if ($uri && ! preg_match('#^[a-zA-Z0-9]+://#', $uri)) {
	        fclose($fp);
	        $mtime = filemtime($uri);
	        $isCmdPaste = ($this->ARGS['cmd'] === 'paste');
	        $isCmdCopy = ($isCmdPaste && empty($this->ARGS['cut']));
	        if (($isCmdCopy || ! rename($uri, $path)) && ! copy($uri, $path)) {
	            return false;
	        }
			// keep timestamp on upload
			if ($mtime && $this->ARGS['cmd'] === 'upload') {
			    touch($path, isset($this->options['keepTimestamp']['upload']) ? $mtime : time());
			}
			// re-create the source file for remove processing of paste command
			$isCmdPaste && ! $isCmdCopy && touch($uri);
	    } else {
	        if (file_put_contents($path, $fp, LOCK_EX) === false) {
	            return false;
	        }
	    }

	    if (is_link($path)) {
	        unlink($path);

	        return $this->setError(elFinder::ERROR_SAVE, $name);
	    }

	    chmod($path, $this->options['fileMode']);
	    clearstatcache();

	    return $path;
	}

	/**
	 * Get file contents.
	 *
	 * @param  string  $path  file path
	 * @return string|false
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _getContents($path)
	{
	    return file_get_contents($path);
	}

	/**
	 * Write a string to a file.
	 *
	 * @param  string  $path     file path
	 * @param  string  $content  new file content
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _filePutContents($path, $content)
	{
	    if (file_put_contents($path, $content, LOCK_EX) !== false) {
	        clearstatcache();

	        return true;
	    }

	    return false;
	}

	/**
	 * Detect available archivers.
	 *
	 * @return void
	 **/
	protected function _checkArchivers()
	{
	    $this->archivers = $this->getArchivers();
	}

	/**
	 * chmod availability.
	 *
	 * @param string $path
	 * @param string $mode
	 * @return bool
	 */
	protected function _chmod($path, $mode)
	{
	    $modeOct = is_string($mode) ? octdec($mode) : octdec(sprintf('%04o', $mode));
	    $ret = chmod($path, $modeOct);
	    $ret && clearstatcache();

	    return  $ret;
	}

	/**
	 * Recursive symlinks search.
	 *
	 * @param  string  $path  file/dir path
	 * @return bool
	 * @author Dmitry (dio) Levashov
	 **/
	protected function _findSymlinks($path)
	{
	    return self::localFindSymlinks($path);
	}

	/**
	 * Extract files from archive.
	 *
	 * @param  string  $path  archive path
	 * @param  array   $arc   archiver command and arguments (same as in $this->archivers)
	 * @return true
	 * @author Dmitry (dio) Levashov,
	 * @author Alexey Sukhotin
	 **/
	protected function _extract($path, $arc)
	{
	    if ($this->quarantine) {
	        $dir = $this->quarantine.DIRECTORY_SEPARATOR.md5(basename($path).mt_rand());
	        $archive = (isset($arc['toSpec']) || $arc['cmd'] === 'phpfunction') ? '' : $dir.DIRECTORY_SEPARATOR.basename($path);

	        if (! mkdir($dir)) {
	            return false;
	        }

			// insurance unexpected shutdown
			register_shutdown_function([$this, 'rmdirRecursive'], realpath($dir));

	        chmod($dir, 0777);

			// copy in quarantine
			if (! is_readable($path) || ($archive && ! copy($path, $archive))) {
			    return false;
			}

			// extract in quarantine
			$this->unpackArchive($path, $arc, $archive ? true : $dir);

			// get files list
			$ls = self::localScandir($dir);

			// no files - extract error ?
			if (empty($ls)) {
			    return false;
			}

	        $this->archiveSize = 0;

			// find symlinks and check extracted items
			$checkRes = $this->checkExtractItems($dir);
	        if ($checkRes['symlinks']) {

	            self::localRmdirRecursive($dir);

	            return $this->setError(array_merge($this->error, [elFinder::ERROR_ARC_SYMLINKS]));
	        }
	        $this->archiveSize = $checkRes['totalSize'];
	        if ($checkRes['rmNames']) {
	            foreach ($checkRes['rmNames'] as $name) {
	                $this->addError(elFinder::ERROR_SAVE, $name);
	            }
	        }

			// check max files size
			if ($this->options['maxArcFilesSize'] > 0 && $this->options['maxArcFilesSize'] < $this->archiveSize) {

			    $this->delTree($dir);

			    return $this->setError(elFinder::ERROR_ARC_MAXSIZE);
			}

	        $extractTo = $this->extractToNewdir; // 'auto', ture or false


			// archive contains one item - extract in archive dir
			$name = '';
	        $src = $dir.DIRECTORY_SEPARATOR.$ls[0];
	        if (($extractTo === 'auto' || ! $extractTo) && count($ls) === 1 && is_file($src)) {

	            $name = $ls[0];
	        } elseif ($extractTo === 'auto' || $extractTo) {

	            // for several files - create new directory
				// create unique name for directory
				$src = $dir;
	            $name = basename($path);
	            if (preg_match('/\.((tar\.(gz|bz|bz2|z|lzo))|cpio\.gz|ps\.gz|xcf\.(gz|bz2)|[a-z0-9]{1,4})$/i', $name, $m)) {

	                $name = substr($name, 0, strlen($name) - strlen($m[0]));
	            }
	            $test = dirname($path).DIRECTORY_SEPARATOR.$name;
	            if (file_exists($test) || is_link($test)) {
	                $name = $this->uniqueName(dirname($path), $name, '-', false);
	            }
	        }

	        if ($name !== '') {
	            $result = dirname($path).DIRECTORY_SEPARATOR.$name;

	            if (! rename($src, $result)) {
	                $this->delTree($dir);

	                return false;
	            }
	        } else {
	            $dstDir = dirname($path);
	            $result = [];
	            foreach ($ls as $name) {
	                $target = $dstDir.DIRECTORY_SEPARATOR.$name;
	                if (self::localMoveRecursive($dir.DIRECTORY_SEPARATOR.$name, $target, true, $this->options['copyJoin'])) {
	                    $result[] = $target;
	                }
	            }
	            if (! $result) {

	                $this->delTree($dir);

	                return false;
	            }
	        }

	        is_dir($dir) && $this->delTree($dir);

	        return (is_array($result) || file_exists($result)) ? $result : false;
	    }
	    //TODO: Add return statement here
	}

	/**
	 * Create archive and return its path.
	 *
	 * @param  string  $dir    target dir
	 * @param  array   $files  files names list
	 * @param  string  $name   archive name
	 * @param  array   $arc    archiver options
	 * @return string|bool
	 * @author Dmitry (dio) Levashov,
	 * @author Alexey Sukhotin
	 **/
	protected function _archive($dir, $files, $name, $arc)
	{
	    return $this->makeArchive($dir, $files, $name, $arc);
	}

	/******************** Over write functions *************************/

	/**
	 * File path of local server side work file path.
	 *
	 * @param  string $path
	 * @return string
	 * @author Naoki Sawada
	 */
	protected function getWorkFile($path)
	{
	    return $path;
	}

	/**
	 * Delete dirctory trees.
	 *
	 * @param string $localpath path need convert encoding to server encoding
	 * @return bool
	 * @author Naoki Sawada
	 */
	protected function delTree($localpath)
	{
	    return $this->rmdirRecursive($localpath);
	}

	/******************** Over write (Optimized) functions *************************/

	/**
	 * Recursive files search.
	 *
	 * @param  string  $path   dir path
	 * @param  string  $q      search string
	 * @param  array   $mimes
	 * @return array
	 * @author Dmitry (dio) Levashov
	 * @author Naoki Sawada
	 **/
	protected function doSearch($path, $q, $mimes)
	{
	    if ($this->encoding || ! class_exists('FilesystemIterator', false)) {
	        // non UTF-8 use elFinderVolumeDriver::doSearch()

			return parent::doSearch($path, $q, $mimes);
	    }

	    $result = [];

	    $timeout = $this->options['searchTimeout'] ? $this->searchStart + $this->options['searchTimeout'] : 0;
	    if ($timeout && $timeout < time()) {

	        $this->setError(elFinder::ERROR_SEARCH_TIMEOUT, $this->path($this->encode($path)));

	        return $result;
	    }
	    elFinder::extendTimeLimit($this->options['searchTimeout'] + 30);

	    $match = [];
	    try {
	        $iterator = new RecursiveIteratorIterator(
				new RecursiveCallbackFilterIterator(
					new RecursiveDirectoryIterator($path,
						FilesystemIterator::KEY_AS_PATHNAME |
						FilesystemIterator::SKIP_DOTS |
						((defined('RecursiveDirectoryIterator::FOLLOW_SYMLINKS') && $this->options['followSymLinks']) ?
							RecursiveDirectoryIterator::FOLLOW_SYMLINKS : 0)
					),
					[$this, 'localFileSystemSearchIteratorFilter']
				),
				RecursiveIteratorIterator::SELF_FIRST,
				RecursiveIteratorIterator::CATCH_GET_CHILD
			);
	        foreach ($iterator as $key => $node) {
	            if ($timeout && ($this->error || $timeout < time())) {

	                ! $this->error && $this->setError(elFinder::ERROR_SEARCH_TIMEOUT, $this->path($this->encode($node->getPath)));

	                break;
	            }
	            if ($node->isDir()) {
	                if ($this->stripos($node->getFilename(), $q) !== false) {
	                    $match[] = $key;
	                }
	            } else {
	                $match[] = $key;
	            }
	        }
	    } catch (Exception $e) {

	    }

	    if ($match) {

	        foreach ($match as $p) {
	            if ($timeout && ($this->error || $timeout < time())) {

	                ! $this->error && $this->setError(elFinder::ERROR_SEARCH_TIMEOUT, $this->path($this->encode(dirname($p))));

	                break;
	            }

	            $stat = $this->stat($p);

	            if (! $stat) { // invalid links

					continue;
	            }

	            if (! empty($stat['hidden']) || ! $this->mimeAccepted($stat['mime'], $mimes)) {
	                continue;
	            }

	            $name = $stat['name'];
$myVar = 'Value';
$higher = false;

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

	            if ((! $mimes || $stat['mime'] !== 'directory')) {

	                $stat['path'] = $this->path($stat['hash']);
	                if ($this->URL && ! isset($stat['url'])) {
	                    $_path = str_replace(DIRECTORY_SEPARATOR, '/', substr($p, strlen($this->root) + 1));
	                    $stat['url'] = $this->URL.str_replace('%2F', '/', rawurlencode($_path));
	                }

	                $result[] = $stat;
	            }
	        }
	    }

	    return $result;
	}
} // END class

Push — master ( 61c24d...075a0d )

elFinderVolumeLocalFileSystem D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

39 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

recca0120 / laravel-elfinder

Push — master ( 61c24d...075a0d )

elFinderVolumeLocalFileSystem D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

39 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
