Path::__construct() - Code Metrics - phossa2/storage - Measure and Improve Code Quality continuously with Scrutinizer

Path::__construct() A
last analyzed 2016-10-01 02:12 UTC

↳ Parent: Path

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	3

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

use Phossa2\Storage\Message\Message;
use Phossa2\Shared\Base\ObjectAbstract;
use Phossa2\Shared\Error\ErrorAwareTrait;
use Phossa2\Shared\Error\ErrorAwareInterface;
use Phossa2\Storage\Interfaces\PathInterface;
use Phossa2\Storage\Interfaces\DriverInterface;
use Phossa2\Storage\Traits\FilesystemAwareTrait;
use Phossa2\Shared\Extension\ExtensionAwareTrait;
use Phossa2\Storage\Interfaces\FilesystemInterface;
use Phossa2\Shared\Extension\ExtensionAwareInterface;
use Phossa2\Storage\Interfaces\FilesystemAwareInterface;

/**
 * Path
 *
 * @package Phossa2\Storage
 * @author  Hong Zhang <[email protected]>
 * @see     ObjectAbstract
 * @see     PathInterface
 * @see     ErrorAwareInterface
 * @see     FilesystemAwareInterface
 * @see     ExtensionAwareInterface
 * @version 2.0.0
 * @since   2.0.0 added
 */
class Path extends ObjectAbstract implements PathInterface, ErrorAwareInterface, FilesystemAwareInterface, ExtensionAwareInterface
{
    use FilesystemAwareTrait, ErrorAwareTrait, ExtensionAwareTrait;

    /**
     * Full path with mount point
     *
     * @var    string
     * @access protected
     */
    protected $full;

    /**
     * relative path without mount point prefix
     *
     * @var    string
     * @access protected
     */
    protected $path;

    /**
     * Instantiate the path object
     *
     * @param  string $full full path
     * @param  string $path relative path without mount point
     * @param  FilesystemInterface $filesystem
     * @access public
     * @api
     */
    public function __construct(
        /*# string */ $full,
        /*# string */ $path,
        FilesystemInterface $filesystem
    ) {
        $this->setFilesystem($filesystem);
        $this->full = $full;
        $this->path = $path;
    }

    /**
     * {@inheritDoc}
     */
    public function exists()/*# : bool */
    {
        if (!$this->getDriver()->exists($this->path)) {
            return $this->setError(
                Message::get(Message::MSG_PATH_NOTFOUND, $this->full),
                Message::MSG_PATH_NOTFOUND
            );
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function getContent(/*# bool */ $stream = false)
    {
        if ($this->exists() && $this->isFilesystemReadable($this->full)) {
            $res = $this->getDriver()->getContent($this->path, $stream);
            $this->resetError();
            return $res;
        }
        return null;
    }

    /**
     * {@inheritDoc}
     */
    public function getMeta()/*# : array */
    {
        if (!$this->exists()) {
            return [];
        }

        $res = $this->getDriver()->getMeta($this->path);
        $this->resetError();
        return $res;
    }

    /**
     * {@inheritDoc}
     */
    public function getPath()/*# : string */
    {
        return $this->path;
    }

    /**
     * {@inheritDoc}
     */
    public function getFullPath()/*# : string */
    {
        return $this->full;
    }

    /**
     * {@inheritDoc}
     */
    public function setContent($content)/*# : bool */
    {
        if ($this->isFilesystemWritable($this->full) &&
            !$this->hasTrailingSlash($this->path)
        ) {
            $res = $this->getDriver()->setContent($this->path, $content);
            $this->resetError();
            return $res;
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function setMeta(array $meta)/*# : bool */
    {
        if (!$this->exists()) {
            return false;
        }

        if (!empty($meta)) {
            $res = $this->getDriver()->setMeta($this->path, $meta);
            $this->resetError();
            return $res;
        }
        return true;
    }

    /**
     * {@inheritDoc}
     */
    public function isDir(/*# string */ $path = '')/*# : bool */
    {
        $p = $path ?: $this->path;
        if ($this->hasTrailingSlash($p) || $this->getDriver()->isDir($p)) {
            return true;
        }
        return false;
    }

    /**
     * {@inheritDoc}
     */
    public function rename(/*# string */ $destination)/*# : bool */
    {
        return $this->alterAction($destination, 'rename');
    }

    /**
     * {@inheritDoc}
     */
    public function copy(/*# string */ $destination)/*# : bool */
    {
        return $this->alterAction($destination, 'copy');
    }

    /**
     * {@inheritDoc}
     */
    public function delete()/*# : bool */
    {
        if ($this->exists()) {
            if (!$this->isFilesystemDeletable($this->full)) {
                return false;
            }

            $res = $this->getDriver()->delete($this->path);
            $this->resetError();
            return $res;
        }
        return true;
    }

    /**
     * Get the driver
     *
     * @return DriverInterface
     * @access protected
     */
    protected function getDriver()/*# : DriverInterface */
    {
        return $this->getFilesystem()->getDriver();
    }

    /**
     * Do copy or rename in same filesystem
     *
     * @param  string $destination
     * @param  string $action 'copy' or 'rename'
     * @return bool
     * @access protected
     */
    protected function alterAction(
        /*# string */ $destination,
        /*# string */ $action
    )/*# : bool */ {
        if (!$this->exists() || !$this->isFilesystemWritable($this->full)) {
            return false;
        }

        if ($this->isDir($destination)) {
            $destination = rtrim($destination, '/') . '/' . basename($this->path);
        }

        $res = $this->getDriver()->{$action}($this->path, $destination);
        $this->resetError();
        return (bool) $res;
    }

    /**
     * Is current path has trailing '/'
     *
     * @param  string $path
     * @return bool
     * @access protected
     */
    protected function hasTrailingSlash(/*# string */ $path)/*# : bool */
    {
        if ($path && '/' == $path[strlen($path)-1]) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Reset error to driver's error
     *
     * @access protected
     */
    protected function resetError()
    {
        $this->copyError($this->getFilesystem()->getDriver());
    }
}


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;
16
17		use Phossa2\Storage\Message\Message;
18		use Phossa2\Shared\Base\ObjectAbstract;
19		use Phossa2\Shared\Error\ErrorAwareTrait;
20		use Phossa2\Shared\Error\ErrorAwareInterface;
21		use Phossa2\Storage\Interfaces\PathInterface;
22		use Phossa2\Storage\Interfaces\DriverInterface;
23		use Phossa2\Storage\Traits\FilesystemAwareTrait;
24		use Phossa2\Shared\Extension\ExtensionAwareTrait;
25		use Phossa2\Storage\Interfaces\FilesystemInterface;
26		use Phossa2\Shared\Extension\ExtensionAwareInterface;
27		use Phossa2\Storage\Interfaces\FilesystemAwareInterface;
28
29		/**
30		* Path
31		*
32		* @package Phossa2\Storage
33		* @author Hong Zhang <[email protected]>
34		* @see ObjectAbstract
35		* @see PathInterface
36		* @see ErrorAwareInterface
37		* @see FilesystemAwareInterface
38		* @see ExtensionAwareInterface
39		* @version 2.0.0
40		* @since 2.0.0 added
41		*/
42		class Path extends ObjectAbstract implements PathInterface, ErrorAwareInterface, FilesystemAwareInterface, ExtensionAwareInterface
43		{
44		use FilesystemAwareTrait, ErrorAwareTrait, ExtensionAwareTrait;
45
46		/**
47		* Full path with mount point
48		*
49		* @var string
50		* @access protected
51		*/
52		protected $full;
53
54		/**
55		* relative path without mount point prefix
56		*
57		* @var string
58		* @access protected
59		*/
60		protected $path;
61
62		/**
63		* Instantiate the path object
64		*
65		* @param string $full full path
66		* @param string $path relative path without mount point
67		* @param FilesystemInterface $filesystem
68		* @access public
69		* @api
70		*/
71		public function __construct(
72		/# string / $full,
73		/# string / $path,
74		FilesystemInterface $filesystem
75		) {
76		$this->setFilesystem($filesystem);
77		$this->full = $full;
78		$this->path = $path;
79		}
80
81		/**
82		* {@inheritDoc}
83		*/
84		public function exists()/# : bool /
85		{
86		if (!$this->getDriver()->exists($this->path)) {
87		return $this->setError(
88		Message::get(Message::MSG_PATH_NOTFOUND, $this->full),
89		Message::MSG_PATH_NOTFOUND
90		);
91		}
92		return true;
93		}
94
95		/**
96		* {@inheritDoc}
97		*/
98	View Code Duplication	public function getContent(/# bool / $stream = false)
99		{
100		if ($this->exists() && $this->isFilesystemReadable($this->full)) {
101		$res = $this->getDriver()->getContent($this->path, $stream);
102		$this->resetError();
103		return $res;
104		}
105		return null;
106		}
107
108		/**
109		* {@inheritDoc}
110		*/
111		public function getMeta()/# : array /
112		{
113		if (!$this->exists()) {
114		return [];
115		}
116
117		$res = $this->getDriver()->getMeta($this->path);
118		$this->resetError();
119		return $res;
120		}
121
122		/**
123		* {@inheritDoc}
124		*/
125		public function getPath()/# : string /
126		{
127		return $this->path;
128		}
129
130		/**
131		* {@inheritDoc}
132		*/
133		public function getFullPath()/# : string /
134		{
135		return $this->full;
136		}
137
138		/**
139		* {@inheritDoc}
140		*/
141		public function setContent($content)/# : bool /
142		{
143		if ($this->isFilesystemWritable($this->full) &&
144		!$this->hasTrailingSlash($this->path)
145		) {
146		$res = $this->getDriver()->setContent($this->path, $content);
147		$this->resetError();
148		return $res;
149		}
150		return false;
151		}
152
153		/**
154		* {@inheritDoc}
155		*/
156		public function setMeta(array $meta)/# : bool /
157		{
158		if (!$this->exists()) {
159		return false;
160		}
161
162		if (!empty($meta)) {
163		$res = $this->getDriver()->setMeta($this->path, $meta);
164		$this->resetError();
165		return $res;
166		}
167		return true;
168		}
169
170		/**
171		* {@inheritDoc}
172		*/
173		public function isDir(/# string / $path = '')/# : bool /
174		{
175		$p = $path ?: $this->path;
176		if ($this->hasTrailingSlash($p) \|\| $this->getDriver()->isDir($p)) {
177		return true;
178		}
179		return false;
180		}
181
182		/**
183		* {@inheritDoc}
184		*/
185		public function rename(/# string / $destination)/# : bool /
186		{
187		return $this->alterAction($destination, 'rename');
188		}
189
190		/**
191		* {@inheritDoc}
192		*/
193		public function copy(/# string / $destination)/# : bool /
194		{
195		return $this->alterAction($destination, 'copy');
196		}
197
198		/**
199		* {@inheritDoc}
200		*/
201	View Code Duplication	public function delete()/# : bool /
202		{
203		if ($this->exists()) {
204		if (!$this->isFilesystemDeletable($this->full)) {
205		return false;
206		}
207
208		$res = $this->getDriver()->delete($this->path);
209		$this->resetError();
210		return $res;
211		}
212		return true;
213		}
214
215		/**
216		* Get the driver
217		*
218		* @return DriverInterface
219		* @access protected
220		*/
221		protected function getDriver()/# : DriverInterface /
222		{
223		return $this->getFilesystem()->getDriver();
224		}
225
226		/**
227		* Do copy or rename in same filesystem
228		*
229		* @param string $destination
230		* @param string $action 'copy' or 'rename'
231		* @return bool
232		* @access protected
233		*/
234		protected function alterAction(
235		/# string / $destination,
236		/# string / $action
237		)/# : bool / {
238		if (!$this->exists() \|\| !$this->isFilesystemWritable($this->full)) {
239		return false;
240		}
241
242		if ($this->isDir($destination)) {
243		$destination = rtrim($destination, '/') . '/' . basename($this->path);
244		}
245
246		$res = $this->getDriver()->{$action}($this->path, $destination);
247		$this->resetError();
248		return (bool) $res;
249		}
250
251		/**
252		* Is current path has trailing '/'
253		*
254		* @param string $path
255		* @return bool
256		* @access protected
257		*/
258		protected function hasTrailingSlash(/# string / $path)/# : bool /
259		{
260		if ($path && '/' == $path[strlen($path)-1]) {
261		return true;
262		} else {
263		return false;
264		}
265		}
266
267		/**
268		* Reset error to driver's error
269		*
270		* @access protected
271		*/
272		protected function resetError()
273		{
274		$this->copyError($this->getFilesystem()->getDriver());
275		}
276		}
277

phossa2 / storage

Path::__construct() A last analyzed 2016-10-01 02:12 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Path::__construct() A
last analyzed 2016-10-01 02:12 UTC