LocalDriver - Code Metrics - Inspection of "updated again" - phossa2/storage - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 159bd4...9ef354 )

by Hong

created 2016-08-08 02:34 UTC

LocalDriver B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	309
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
wmc	40
c	4
b	0
f	0
lcom	2
cbo	3
dl	0
loc	309
rs	8.2608

19 Methods

Rating	Name	Size	Complexity
A	__construct()	9	2
A	realPath()	5	2
A	realExists()	4	1
A	isDir()	4	1
A	readDir()	20	4
A	openReadStream()	13	2
A	readFile()	14	2
A	getRealMeta()	18	2
A	ensurePath()	8	2
A	writeStream()	13	3
A	writeFile()	13	1
A	setRealMeta()	13	3
A	renameDir()	6	1
A	renameFile()	6	1
A	copyDir()	21	4
A	copyFile()	6	1
A	deleteDir()	19	4
A	deleteFile()	4	1
A	makeDirectory()	17	3

How to fix Complexity

<?php
/**
 * Phossa Project
 *
 * PHP version 5.4
 *
 * @category  Library
 * @package   Phossa2\Storage
 * @copyright Copyright (c) 2016 phossa.com
 * @license   http://mit-license.org/ MIT License
 * @link      http://www.phossa.com/
 */
/*# declare(strict_types=1); */

namespace Phossa2\Storage\Driver;

use Phossa2\Storage\Message\Message;
use Phossa2\Storage\Exception\LogicException;

/**
 * LocalDriver
 *
 * @package Phossa2\Storage
 * @author  Hong Zhang <[email protected]>
 * @see     DriverAbstract
 * @version 2.0.0
 * @since   2.0.0 added
 */
class LocalDriver extends DriverAbstract
{
    /**
     * driver root
     *
     * @var    string
     * @access protected
     */
    protected $root;

    /**
     * @param  string $rootDir
     * @throws LogicException
     * @access public
     */
    public function __construct(/*# string */ $rootDir)
    {
        if (!$this->makeDirectory($rootDir)) {
            throw new LogicException(
                $this->getError(), $this->getErrorCode()
            );
        }
        $this->root = rtrim($rootDir, "/\\") . \DIRECTORY_SEPARATOR;
    }

    /**
     * {@inheritDoc}
     */
    protected function realPath(/*# string */ $path)/*# : string */
    {
        return $this->root . ('/' !== \DIRECTORY_SEPARATOR ?
            str_replace('/', \DIRECTORY_SEPARATOR, $path) : $path);
    }

    /**
     * {@inheritDoc}
     */
    protected function realExists(/*# string */ $realPath)/*# : bool */
    {
        return file_exists($realPath);
    }

    /**
     * {@inheritDoc}
     */
    protected function isDir(/*# string */ $realPath)/*# : bool */
    {
        return is_dir($realPath);
    }

    /**
     * {@inheritDoc}
     */
    protected function readDir(
        /*# string */ $realPath,
        /*# string */ $prefix = ''
    )/*# : array */ {
        try {
            $res = [];
            foreach (new \DirectoryIterator($realPath) as $fileInfo) {
                if($fileInfo->isDot()) continue;
                $res[] = $prefix . $fileInfo->getFilename();
            }
            return $res;

        } catch (\Exception $e) {
            $this->setError(
                Message::get(Message::STR_READDIR_FAIL, $realPath),
                Message::STR_READDIR_FAIL
            );
            return [];
        }
    }

    /**
     * {@inheritDoc}
     */
    protected function openReadStream(/*# string */ $realPath)
    {
        $stream = fopen($realPath, 'r');
        if (is_resource($stream)) {
            return $stream;
        } else {
            $this->setError(
                Message::get(Message::STR_OPENSTREAM_FAIL, $realPath),
                Message::STR_OPENSTREAM_FAIL
            );
            return null;
        }
    }

    /**
     * {@inheritDoc}
     */
    protected function readFile(/*# string */ $realPath)
    {
        $str = file_get_contents($realPath);

        if (false === $str) {
            $this->setError(
                Message::get(Message::STR_OPENSTREAM_FAIL, $realPath),
                Message::STR_OPENSTREAM_FAIL
            );
            return null;
        }

        return $str;
    }

    /**
     * {@inheritDoc}
     */
    protected function getRealMeta(/*# string */ $realPath)/*# : array */
    {
        try {
            $info = new \SplFileInfo($realPath);
            return [
                'size'  => $info->getSize(),
                'perm'  => $info->getPerms(),
                'ctime' => $info->getCTime(),
                'mtime' => $info->getMTime(),
            ];
        } catch (\Exception $e) {
            $this->setError(
                Message::get(Message::STR_GETMETA_FAIL, $realPath),
                Message::STR_GETMETA_FAIL
            );
            return [];
        }
    }

    /**
     * {@inheritDoc}
     */
    protected function ensurePath(/*# string */ $realPath)/*# : bool */
    {
        $parent = dirname($realPath);
        if (!$this->makeDirectory($parent)) {
            return false;
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    protected function writeStream(
        /*# string */ $realPath,
        $resource
    )/*# : bool */ {
        $tmpfname = tempnam(dirname($realPath), 'FOO');
        $stream = fopen($tmpfname, 'w+b');

        if (is_resource($stream)) {
            stream_copy_to_stream($resource, $stream);
            return fclose($stream) && rename($tmpfname, $realPath);
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    protected function writeFile(
        /*# string */ $realPath,
        /*# string */ $content
    )/*# : bool */ {
        // write to a temp file
        $tmpfname = tempnam(dirname($realPath), 'FOO');
        $handle = fopen($tmpfname, 'w');
        fwrite($handle, $content);
        fclose($handle);

        // rename to $realPath
        return rename($tmpfname, $realPath);
    }

    /**
     * Write meta data
     *
     * @param  string $realPath
     * @param  array $meta
     * @return bool
     * @access protected
     */
    protected function setRealMeta(
        /*# string */ $realPath,
        array $meta
    )/*# : bool */ {
        if (isset($meta['mtime'])) {
            touch($realPath, $meta['mtime']);
        }

        if (isset($meta['perm'])) {
            chmod($realPath, (int) $meta['perm']);
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    protected function renameDir(
        /*# string */ $from,
        /*# string */ $to
    )/*# : bool */ {
        return rename($from, $to);
    }

    /**
     * {@inheritDoc}
     */
    protected function renameFile(
        /*# string */ $from,
        /*# string */ $to
    )/*# : bool */ {
        return rename($from, $to);
    }

    /**
     * {@inheritDoc}
     */
    protected function copyDir(
        /*# string */ $from,
        /*# string */ $to
    )/*# : bool */ {
        $files = $this->readDir($from);

        foreach ($files as $file) {
            $f = $from . \DIRECTORY_SEPARATOR . $file;
            $t = $to . \DIRECTORY_SEPARATOR . $file;
            if (is_dir($f)) {
                $this->makeDirectory($t);
                $res = $this->copyDir($f, $t);
            } else {
                $res = $this->copyFile($f, $t);
            }
            if (false === $res) {
                return false;
            }
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    protected function copyFile(
        /*# string */ $from,
        /*# string */ $to
    )/*# : bool */ {
        return copy($from, $to);
    }

    /**
     * {@inheritDoc}
     */
    protected function deleteDir(/*# string */ $realPath)/*# : bool */
    {
        $files = $this->readDir($realPath, $realPath);

        foreach ($files as $file) {
            if (is_dir($file)) {
                $res = $this->deleteDir($file);
            } else {
                $res = unlink($file);
            }
            if (false === $res) {
                return $this->setError(
                    Message::get(Message::STR_DELETE_FAIL, $file),
                    Message::STR_DELETE_FAIL
                );
            }
        }
        return rmdir($realPath);
    }

    /**
     * {@inheritDoc}
     */
    protected function deleteFile(/*# string */ $realPath)/*# : bool */
    {
        return unlink($realPath);
    }

    /**
     * create directory
     *
     * @param  string $dir
     * @access protected
     */
    protected function makeDirectory(/*# string */ $dir)/*# : bool */
    {
        if (!is_dir($dir)) {
            $umask = umask(0);
            mkdir($dir, 0755, true);
            umask($umask);

            if (!is_dir($dir)) {
                $this->setError(
                    Message::get(Message::STR_MKDIR_FAIL, $dir),
                    Message::STR_MKDIR_FAIL
                );
                return false;
            }
        }
        return true;
    }
}


1			<?php
2			/**
3			* Phossa Project
4			*
5			* PHP version 5.4
6			*
7			* @category Library
8			* @package Phossa2\Storage
9			* @copyright Copyright (c) 2016 phossa.com
10			* @license http://mit-license.org/ MIT License
11			* @link http://www.phossa.com/
12			*/
13			/# declare(strict_types=1); /
14
15			namespace Phossa2\Storage\Driver;
16
17			use Phossa2\Storage\Message\Message;
18			use Phossa2\Storage\Exception\LogicException;
19
20			/**
21			* LocalDriver
22			*
23			* @package Phossa2\Storage
24			* @author Hong Zhang <[email protected]>
25			* @see DriverAbstract
26			* @version 2.0.0
27			* @since 2.0.0 added
28			*/
29			class LocalDriver extends DriverAbstract
30			{
31			/**
32			* driver root
33			*
34			* @var string
35			* @access protected
36			*/
37			protected $root;
38
39			/**
40			* @param string $rootDir
41			* @throws LogicException
42			* @access public
43			*/
44			public function __construct(/# string / $rootDir)
45			{
46			if (!$this->makeDirectory($rootDir)) {
47			throw new LogicException(
48			$this->getError(), $this->getErrorCode()
49			);
50			}
51			$this->root = rtrim($rootDir, "/\\") . \DIRECTORY_SEPARATOR;
52			}
53
54			/**
55			* {@inheritDoc}
56			*/
57			protected function realPath(/# string / $path)/# : string /
58			{
59			return $this->root . ('/' !== \DIRECTORY_SEPARATOR ?
60			str_replace('/', \DIRECTORY_SEPARATOR, $path) : $path);
61			}
62
63			/**
64			* {@inheritDoc}
65			*/
66			protected function realExists(/# string / $realPath)/# : bool /
67			{
68			return file_exists($realPath);
69			}
70
71			/**
72			* {@inheritDoc}
73			*/
74			protected function isDir(/# string / $realPath)/# : bool /
75			{
76			return is_dir($realPath);
77			}
78
79			/**
80			* {@inheritDoc}
81			*/
82			protected function readDir(
83			/# string / $realPath,
84			/# string / $prefix = ''
85			)/# : array / {
86			try {
87			$res = [];
88			foreach (new \DirectoryIterator($realPath) as $fileInfo) {
89			if($fileInfo->isDot()) continue;
90			$res[] = $prefix . $fileInfo->getFilename();
91			}
92			return $res;
93
94			} catch (\Exception $e) {
95			$this->setError(
96			Message::get(Message::STR_READDIR_FAIL, $realPath),
97			Message::STR_READDIR_FAIL
98			);
99			return [];
100			}
101			}
102
103			/**
104			* {@inheritDoc}
105			*/
106			protected function openReadStream(/# string / $realPath)
107			{
108			$stream = fopen($realPath, 'r');
109			if (is_resource($stream)) {
110			return $stream;
111			} else {
112			$this->setError(
113			Message::get(Message::STR_OPENSTREAM_FAIL, $realPath),
114			Message::STR_OPENSTREAM_FAIL
115			);
116			return null;
117			}
118			}
119
120			/**
121			* {@inheritDoc}
122			*/
123			protected function readFile(/# string / $realPath)
124			{
125			$str = file_get_contents($realPath);
126
127			if (false === $str) {
128			$this->setError(
129			Message::get(Message::STR_OPENSTREAM_FAIL, $realPath),
130			Message::STR_OPENSTREAM_FAIL
131			);
132			return null;
133			}
134
135			return $str;
136			}
137
138			/**
139			* {@inheritDoc}
140			*/
141			protected function getRealMeta(/# string / $realPath)/# : array /
142			{
143			try {
144			$info = new \SplFileInfo($realPath);
145			return [
146			'size' => $info->getSize(),
147			'perm' => $info->getPerms(),
148			'ctime' => $info->getCTime(),
149			'mtime' => $info->getMTime(),
150			];
151			} catch (\Exception $e) {
152			$this->setError(
153			Message::get(Message::STR_GETMETA_FAIL, $realPath),
154			Message::STR_GETMETA_FAIL
155			);
156			return [];
157			}
158			}
159
160			/**
161			* {@inheritDoc}
162			*/
163			protected function ensurePath(/# string / $realPath)/# : bool /
164			{
165			$parent = dirname($realPath);
166			if (!$this->makeDirectory($parent)) {
167			return false;
168			}
169			return true;
170			}
171
172			/**
173			* {@inheritDoc}
174			*/
175			protected function writeStream(
176			/# string / $realPath,
177			$resource
178			)/# : bool / {
179			$tmpfname = tempnam(dirname($realPath), 'FOO');
180			$stream = fopen($tmpfname, 'w+b');
181
182			if (is_resource($stream)) {
183			stream_copy_to_stream($resource, $stream);
184			return fclose($stream) && rename($tmpfname, $realPath);
185			}
186			return false;
187			}
188
189			/**
190			* {@inheritDoc}
191			*/
192			protected function writeFile(
193			/# string / $realPath,
194			/# string / $content
195			)/# : bool / {
196			// write to a temp file
197			$tmpfname = tempnam(dirname($realPath), 'FOO');
198			$handle = fopen($tmpfname, 'w');
199			fwrite($handle, $content);
200			fclose($handle);
201
202			// rename to $realPath
203			return rename($tmpfname, $realPath);
204			}
205
206			/**
207			* Write meta data
208			*
209			* @param string $realPath
210			* @param array $meta
211			* @return bool
212			* @access protected
213			*/
214			protected function setRealMeta(
215			/# string / $realPath,
216			array $meta
217			)/# : bool / {
218			if (isset($meta['mtime'])) {
219			touch($realPath, $meta['mtime']);
220			}
221
222			if (isset($meta['perm'])) {
223			chmod($realPath, (int) $meta['perm']);
224			}
225			return true;
226			}
227
228			/**
229			* {@inheritDoc}
230			*/
231			protected function renameDir(
232			/# string / $from,
233			/# string / $to
234			)/# : bool / {
235			return rename($from, $to);
236			}
237
238			/**
239			* {@inheritDoc}
240			*/
241			protected function renameFile(
242			/# string / $from,
243			/# string / $to
244			)/# : bool / {
245			return rename($from, $to);
246			}
247
248			/**
249			* {@inheritDoc}
250			*/
251			protected function copyDir(
252			/# string / $from,
253			/# string / $to
254			)/# : bool / {
255			$files = $this->readDir($from);
256
257			foreach ($files as $file) {
258			$f = $from . \DIRECTORY_SEPARATOR . $file;
259			$t = $to . \DIRECTORY_SEPARATOR . $file;
260			if (is_dir($f)) {
261			$this->makeDirectory($t);
262			$res = $this->copyDir($f, $t);
263			} else {
264			$res = $this->copyFile($f, $t);
265			}
266			if (false === $res) {
267			return false;
268			}
269			}
270			return true;
271			}
272
273			/**
274			* {@inheritDoc}
275			*/
276			protected function copyFile(
277			/# string / $from,
278			/# string / $to
279			)/# : bool / {
280			return copy($from, $to);
281			}
282
283			/**
284			* {@inheritDoc}
285			*/
286			protected function deleteDir(/# string / $realPath)/# : bool /
287			{
288			$files = $this->readDir($realPath, $realPath);
289
290			foreach ($files as $file) {
291			if (is_dir($file)) {
292			$res = $this->deleteDir($file);
293			} else {
294			$res = unlink($file);
295			}
296			if (false === $res) {
297			return $this->setError(
298			Message::get(Message::STR_DELETE_FAIL, $file),
299			Message::STR_DELETE_FAIL
300			);
301			}
302			}
303			return rmdir($realPath);
304			}
305
306			/**
307			* {@inheritDoc}
308			*/
309			protected function deleteFile(/# string / $realPath)/# : bool /
310			{
311			return unlink($realPath);
312			}
313
314			/**
315			* create directory
316			*
317			* @param string $dir
318			* @access protected
319			*/
320			protected function makeDirectory(/# string / $dir)/# : bool /
321			{
322			if (!is_dir($dir)) {
323			$umask = umask(0);
324			mkdir($dir, 0755, true);
325			umask($umask);
326
327			if (!is_dir($dir)) {
328			$this->setError(
329			Message::get(Message::STR_MKDIR_FAIL, $dir),
330			Message::STR_MKDIR_FAIL
331			);
332			return false;
333			}
334			}
335			return true;
336			}
337			}
338

phossa2 / storage

Push — master ( 159bd4...9ef354 )

LocalDriver B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

19 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like