LocalDriver::openReadStream() - Code Metrics - Inspection of "updated" - phossa2/storage - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 95bf49...159bd4 )

by Hong

created 2016-08-05 06:07 UTC

LocalDriver::openReadStream() A

↳ Parent: LocalDriver

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	13
rs	9.4285
cc	2
eloc	9
nc	2
nop	1

<?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 . str_replace('/', \DIRECTORY_SEPARATOR, $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 [
                'type'  => $info->getType(),
                '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 fixPath()/*# : bool */
    {
        foreach (func_get_args() as $realPath) {
            $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 . str_replace('/', \DIRECTORY_SEPARATOR, $path);
60			}
61
62			/**
63			* {@inheritDoc}
64			*/
65			protected function realExists(/# string / $realPath)/# : bool /
66			{
67			return file_exists($realPath);
68			}
69
70			/**
71			* {@inheritDoc}
72			*/
73			protected function isDir(/# string / $realPath)/# : bool /
74			{
75			return is_dir($realPath);
76			}
77
78			/**
79			* {@inheritDoc}
80			*/
81			protected function readDir(
82			/# string / $realPath,
83			/# string / $prefix = ''
84			)/# : array / {
85			try {
86			$res = [];
87			foreach (new \DirectoryIterator($realPath) as $fileInfo) {
88			if($fileInfo->isDot()) continue;
89			$res[] = $prefix . $fileInfo->getFilename();
90			}
91			return $res;
92
93			} catch (\Exception $e) {
94			$this->setError(
95			Message::get(Message::STR_READDIR_FAIL, $realPath),
96			Message::STR_READDIR_FAIL
97			);
98			return [];
99			}
100			}
101
102			/**
103			* {@inheritDoc}
104			*/
105			protected function openReadStream(/# string / $realPath)
106			{
107			$stream = fopen($realPath, 'r');
108			if (is_resource($stream)) {
109			return $stream;
110			} else {
111			$this->setError(
112			Message::get(Message::STR_OPENSTREAM_FAIL, $realPath),
113			Message::STR_OPENSTREAM_FAIL
114			);
115			return null;
116			}
117			}
118
119			/**
120			* {@inheritDoc}
121			*/
122			protected function readFile(/# string / $realPath)
123			{
124			$str = file_get_contents($realPath);
125
126			if (false === $str) {
127			$this->setError(
128			Message::get(Message::STR_OPENSTREAM_FAIL, $realPath),
129			Message::STR_OPENSTREAM_FAIL
130			);
131			return null;
132			}
133
134			return $str;
135			}
136
137			/**
138			* {@inheritDoc}
139			*/
140			protected function getRealMeta(/# string / $realPath)/# : array /
141			{
142			try {
143			$info = new \SplFileInfo($realPath);
144			return [
145			'type' => $info->getType(),
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 fixPath()/# : bool /
164			{
165			foreach (func_get_args() as $realPath) {
166			$parent = dirname($realPath);
167			if (!$this->makeDirectory($parent)) {
168			return false;
169			}
170			}
171			return true;
172			}
173
174			/**
175			* {@inheritDoc}
176			*/
177			protected function writeStream(
178			/# string / $realPath,
179			$resource
180			)/# : bool / {
181			$tmpfname = tempnam(dirname($realPath), 'FOO');
182			$stream = fopen($tmpfname, 'w+b');
183
184			if (is_resource($stream)) {
185			stream_copy_to_stream($resource, $stream);
186			return fclose($stream) && rename($tmpfname, $realPath);
187			}
188			return false;
189			}
190
191			/**
192			* {@inheritDoc}
193			*/
194			protected function writeFile(
195			/# string / $realPath,
196			/# string / $content
197			)/# : bool / {
198			// write to a temp file
199			$tmpfname = tempnam(dirname($realPath), 'FOO');
200			$handle = fopen($tmpfname, 'w');
201			fwrite($handle, $content);
202			fclose($handle);
203
204			// rename to $realPath
205			return rename($tmpfname, $realPath);
206			}
207
208			/**
209			* Write meta data
210			*
211			* @param string $realPath
212			* @param array $meta
213			* @return bool
214			* @access protected
215			*/
216			protected function setRealMeta(
217			/# string / $realPath,
218			array $meta
219			)/# : bool / {
220			if (isset($meta['mtime'])) {
221			touch($realPath, $meta['mtime']);
222			}
223
224			if (isset($meta['perm'])) {
225			chmod($realPath, (int) $meta['perm']);
226			}
227			return true;
228			}
229
230			/**
231			* {@inheritDoc}
232			*/
233			protected function renameDir(
234			/# string / $from,
235			/# string / $to
236			)/# : bool / {
237			return rename($from, $to);
238			}
239
240			/**
241			* {@inheritDoc}
242			*/
243			protected function renameFile(
244			/# string / $from,
245			/# string / $to
246			)/# : bool / {
247			return rename($from, $to);
248			}
249
250			/**
251			* {@inheritDoc}
252			*/
253			protected function copyDir(
254			/# string / $from,
255			/# string / $to
256			)/# : bool / {
257			$files = $this->readDir($from);
258
259			foreach ($files as $file) {
260			$f = $from . \DIRECTORY_SEPARATOR . $file;
261			$t = $to . \DIRECTORY_SEPARATOR . $file;
262			if (is_dir($f)) {
263			$this->makeDirectory($t);
264			$res = $this->copyDir($f, $t);
265			} else {
266			$res = $this->copyFile($f, $t);
267			}
268			if (false === $res) {
269			return false;
270			}
271			}
272			return true;
273			}
274
275			/**
276			* {@inheritDoc}
277			*/
278			protected function copyFile(
279			/# string / $from,
280			/# string / $to
281			)/# : bool / {
282			return copy($from, $to);
283			}
284
285			/**
286			* {@inheritDoc}
287			*/
288			protected function deleteDir(/# string / $realPath)/# : bool /
289			{
290			$files = $this->readDir($realPath, $realPath);
291
292			foreach ($files as $file) {
293			if (is_dir($file)) {
294			$res = $this->deleteDir($file);
295			} else {
296			$res = unlink($file);
297			}
298			if (false === $res) {
299			return $this->setError(
300			Message::get(Message::STR_DELETE_FAIL, $file),
301			Message::STR_DELETE_FAIL
302			);
303			}
304			}
305			return rmdir($realPath);
306			}
307
308			/**
309			* {@inheritDoc}
310			*/
311			protected function deleteFile(/# string / $realPath)/# : bool /
312			{
313			return unlink($realPath);
314			}
315
316			/**
317			* create directory
318			*
319			* @param string $dir
320			* @access protected
321			*/
322			protected function makeDirectory(/# string / $dir)/# : bool /
323			{
324			if (!is_dir($dir)) {
325			$umask = umask(0);
326			mkdir($dir, 0755, true);
327			umask($umask);
328
329			if (!is_dir($dir)) {
330			$this->setError(
331			Message::get(Message::STR_MKDIR_FAIL, $dir),
332			Message::STR_MKDIR_FAIL
333			);
334			return false;
335			}
336			}
337			return true;
338			}
339			}
340

phossa2 / storage

Push — master ( 95bf49...159bd4 )

LocalDriver::openReadStream() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like