AbstractLocalNode::copy() - Code Metrics - Inspection of "Pico CMS for Nextcloud v1.0.0 (WIP)" - nextcloud/cms_pico - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#77)

by Daniel

created 2019-11-21 20:26 UTC

AbstractLocalNode::copy() B

↳ Parent: AbstractLocalNode

Complexity

Conditions	8
Paths	9

Size

Total Lines	21
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	72

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	12
c	1
b	0
f	0
dl	0
loc	21
ccs	0
cts	12
cp	0
rs	8.4444
cc	8
nc	9
nop	2
crap	72

<?php
/**
 * CMS Pico - Create websites using Pico CMS for Nextcloud.
 *
 * @copyright Copyright (c) 2019, Daniel Rudolf (<[email protected]>)
 *
 * @license GNU AGPL version 3 or any later version
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace OCA\CMSPico\Files;

use OCP\Constants;
use OCP\Files\AlreadyExistsException;
use OCP\Files\GenericFileException;
use OCP\Files\InvalidPathException;
use OCP\Files\NotFoundException;
use OCP\Files\NotPermittedException;

abstract class AbstractLocalNode extends AbstractNode implements NodeInterface
{
	/** @var string */
	protected $path;

	/** @var string */
	protected $basePath;

	/** @var LocalFolder */
	protected $parentFolder;

	/** @var int */
	protected $permissions;

	/**
	 * AbstractLocalNode constructor.
	 *
	 * @param string $path
	 * @param string $basePath
	 *
	 * @throws InvalidPathException
	 * @throws NotFoundException
	 */
	public function __construct(string $path, string $basePath)
	{
		parent::__construct();

		$this->path = $this->normalizePath($path);
		$this->basePath = realpath($basePath ?: \OC::$SERVERROOT);

		if (!file_exists($this->getLocalPath())) {
			throw new NotFoundException();
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public function rename(string $name): NodeInterface
	{
		$this->assertValidFileName($name);

		$parentNode = $this->getParentNode();
		if ($parentNode->exists($name)) {
			throw new AlreadyExistsException();
		}
		if (!$parentNode->isCreatable()) {
			throw new NotPermittedException();
		}

		if (!rename($this->getLocalPath(), dirname($this->getLocalPath()) . '/' . $name)) {
			throw new GenericFileException();
		}

		$parentPath = dirname($this->path);
		$this->path = (($parentPath !== '/') ? $parentPath : '') . '/' . $name;

		return $this;
	}

	/**
	 * {@inheritDoc}
	 */
	public function copy(FolderInterface $targetPath, string $name = null): NodeInterface
	{
		if (($targetPath instanceof LocalFolder) && $this->isFile()) {
			if ($name !== null) {
				$this->assertValidFileName($name);
			}

			if ($targetPath->exists($this->getName())) {
				throw new AlreadyExistsException();
			}
			if (!$targetPath->isCreatable()) {
				throw new NotPermittedException();
			}

			if (!@copy($this->getLocalPath(), $targetPath->getLocalPath() . '/' . ($name ?: $this->getName()))) {
				throw new GenericFileException();
			}

			return new LocalFile($targetPath->getPath() . '/' . $this->getName(), $targetPath->basePath);
		} else {
			return parent::copy($targetPath, $name);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public function move(FolderInterface $targetPath, string $name = null): NodeInterface
	{
		if (($targetPath instanceof LocalFolder) && $this->isFile()) {
			if ($name !== null) {
				$this->assertValidFileName($name);
			}

			if ($targetPath->exists($this->getName())) {
				throw new AlreadyExistsException();
			}
			if (!$targetPath->isCreatable()) {
				throw new NotPermittedException();
			}

			if (!@rename($this->getLocalPath(), $targetPath->getLocalPath() . '/' . ($name ?: $this->getName()))) {
				throw new GenericFileException();
			}

			return new LocalFile($targetPath->getPath() . '/' . $this->getName(), $targetPath->getBasePath());
		} else {
			return parent::move($targetPath, $name);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public function delete()
	{
		if (!$this->isDeletable()) {
			throw new NotPermittedException();
		}

		if (!@unlink($this->getLocalPath())) {
			throw new GenericFileException();
		}
	}

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

	/**
	 * @return string
	 */
	public function getBasePath(): string
	{
		return $this->basePath;
	}

	/**
	 * {@inheritDoc}
	 */
	public function getLocalPath(): string
	{
		return $this->basePath . (($this->path !== '/') ? $this->path : '');
	}

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

	/**
	 * {@inheritDoc}
	 */
	public function getParent(): string
	{
		if ($this->path === '/') {
			throw new InvalidPathException();
		}

		return dirname($this->path);
	}

	/**
	 * {@inheritDoc}
	 */
	public function getParentNode(): FolderInterface
	{
		if ($this->parentFolder === null) {
			$this->parentFolder = new LocalFolder($this->getParent(), $this->basePath);
		}

		return $this->parentFolder;
	}

	/**
	 * {@inheritDoc}
	 */
	public function isFile(): bool
	{
		return is_file($this->getLocalPath());
	}

	/**
	 * {@inheritDoc}
	 */
	public function isFolder(): bool
	{
		return is_dir($this->getLocalPath());
	}

	/**
	 * {@inheritDoc}
	 */
	public function isLocal(): bool
	{
		return true;
	}

	/**
	 * {@inheritDoc}
	 */
	public function getPermissions(): int
	{
		if ($this->permissions === null) {
			$this->permissions = 0;

			try {
				$localPath = $this->getLocalPath();
			} catch (\Exception $e) {
				// can't read a node's permissions without its local path
				return $this->permissions;
			}

			if (is_readable($localPath)) {
				$this->permissions |= Constants::PERMISSION_READ;
			}

			if (is_writable($localPath)) {
				$this->permissions |= Constants::PERMISSION_UPDATE;

				if ($this->isFolder()) {
					$this->permissions |= Constants::PERMISSION_CREATE;
				}
			}

			try {
				if (is_writable($this->getParentNode()->getLocalPath())) {
					$this->permissions |= Constants::PERMISSION_DELETE;
				}
			} catch (\Exception $e) {
				// this is either the root folder or we can't read the parent folder's local path
				// in neither case we can delete this node
			}
		}

		return $this->permissions;
	}
}


1		<?php
2		/**
3		* CMS Pico - Create websites using Pico CMS for Nextcloud.
4		*
5		* @copyright Copyright (c) 2019, Daniel Rudolf (<[email protected]>)
6		*
7		* @license GNU AGPL version 3 or any later version
8		*
9		* This program is free software: you can redistribute it and/or modify
10		* it under the terms of the GNU Affero General Public License as
11		* published by the Free Software Foundation, either version 3 of the
12		* License, or (at your option) any later version.
13		*
14		* This program is distributed in the hope that it will be useful,
15		* but WITHOUT ANY WARRANTY; without even the implied warranty of
16		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		* GNU Affero General Public License for more details.
18		*
19		* You should have received a copy of the GNU Affero General Public License
20		* along with this program. If not, see <http://www.gnu.org/licenses/>.
21		*/
22
23		declare(strict_types=1);
24
25		namespace OCA\CMSPico\Files;
26
27		use OCP\Constants;
28		use OCP\Files\AlreadyExistsException;
29		use OCP\Files\GenericFileException;
30		use OCP\Files\InvalidPathException;
31		use OCP\Files\NotFoundException;
32		use OCP\Files\NotPermittedException;
33
34		abstract class AbstractLocalNode extends AbstractNode implements NodeInterface
35		{
36		/** @var string */
37		protected $path;
38
39		/** @var string */
40		protected $basePath;
41
42		/** @var LocalFolder */
43		protected $parentFolder;
44
45		/** @var int */
46		protected $permissions;
47
48		/**
49		* AbstractLocalNode constructor.
50		*
51		* @param string $path
52		* @param string $basePath
53		*
54		* @throws InvalidPathException
55		* @throws NotFoundException
56		*/
57	6	public function __construct(string $path, string $basePath)
58		{
59	6	parent::__construct();
60
61	6	$this->path = $this->normalizePath($path);
62	6	$this->basePath = realpath($basePath ?: \OC::$SERVERROOT);
63
64	6	if (!file_exists($this->getLocalPath())) {
65		throw new NotFoundException();
66		}
67	6	}
68
69		/**
70		* {@inheritDoc}
71		*/
72	1	public function rename(string $name): NodeInterface
73		{
74	1	$this->assertValidFileName($name);
75
76	1	$parentNode = $this->getParentNode();
77	1	if ($parentNode->exists($name)) {
78		throw new AlreadyExistsException();
79		}
80	1	if (!$parentNode->isCreatable()) {
81		throw new NotPermittedException();
82		}
83
84	1	if (!rename($this->getLocalPath(), dirname($this->getLocalPath()) . '/' . $name)) {
85		throw new GenericFileException();
86		}
87
88	1	$parentPath = dirname($this->path);
89	1	$this->path = (($parentPath !== '/') ? $parentPath : '') . '/' . $name;
90
91	1	return $this;
92		}
93
94		/**
95		* {@inheritDoc}
96		*/
97		public function copy(FolderInterface $targetPath, string $name = null): NodeInterface
98		{
99		if (($targetPath instanceof LocalFolder) && $this->isFile()) {
100		if ($name !== null) {
101		$this->assertValidFileName($name);
102		}
103
104		if ($targetPath->exists($this->getName())) {
105		throw new AlreadyExistsException();
106		}
107		if (!$targetPath->isCreatable()) {
108		throw new NotPermittedException();
109		}
110
111		if (!@copy($this->getLocalPath(), $targetPath->getLocalPath() . '/' . ($name ?: $this->getName()))) {
112		throw new GenericFileException();
113		}
114
115		return new LocalFile($targetPath->getPath() . '/' . $this->getName(), $targetPath->basePath);
116		} else {
117		return parent::copy($targetPath, $name);
118		}
119		}
120
121		/**
122		* {@inheritDoc}
123		*/
124		public function move(FolderInterface $targetPath, string $name = null): NodeInterface
125		{
126		if (($targetPath instanceof LocalFolder) && $this->isFile()) {
127		if ($name !== null) {
128		$this->assertValidFileName($name);
129		}
130
131		if ($targetPath->exists($this->getName())) {
132		throw new AlreadyExistsException();
133		}
134		if (!$targetPath->isCreatable()) {
135		throw new NotPermittedException();
136		}
137
138		if (!@rename($this->getLocalPath(), $targetPath->getLocalPath() . '/' . ($name ?: $this->getName()))) {
139		throw new GenericFileException();
140		}
141
142		return new LocalFile($targetPath->getPath() . '/' . $this->getName(), $targetPath->getBasePath());
143		} else {
144		return parent::move($targetPath, $name);
145		}
146		}
147
148		/**
149		* {@inheritDoc}
150		*/
151	1	public function delete()
152		{
153	1	if (!$this->isDeletable()) {
154		throw new NotPermittedException();
155		}
156
157	1	if (!@unlink($this->getLocalPath())) {
158		throw new GenericFileException();
159		}
160	1	}
161
162		/**
163		* {@inheritDoc}
164		*/
165		public function getPath(): string
166		{
167		return $this->path;
168		}
169
170		/**
171		* @return string
172		*/
173		public function getBasePath(): string
174		{
175		return $this->basePath;
176		}
177
178		/**
179		* {@inheritDoc}
180		*/
181	6	public function getLocalPath(): string
182		{
183	6	return $this->basePath . (($this->path !== '/') ? $this->path : '');
184		}
185
186		/**
187		* {@inheritDoc}
188		*/
189	4	public function getName(): string
190		{
191	4	return basename($this->path);
192		}
193
194		/**
195		* {@inheritDoc}
196		*/
197	4	public function getParent(): string
198		{
199	4	if ($this->path === '/') {
200	4	throw new InvalidPathException();
201		}
202
203	4	return dirname($this->path);
204		}
205
206		/**
207		* {@inheritDoc}
208		*/
209	4	public function getParentNode(): FolderInterface
210		{
211	4	if ($this->parentFolder === null) {
212	4	$this->parentFolder = new LocalFolder($this->getParent(), $this->basePath);
213		}
214
215	4	return $this->parentFolder;
216		}
217
218		/**
219		* {@inheritDoc}
220		*/
221	1	public function isFile(): bool
222		{
223	1	return is_file($this->getLocalPath());
224		}
225
226		/**
227		* {@inheritDoc}
228		*/
229	6	public function isFolder(): bool
230		{
231	6	return is_dir($this->getLocalPath());
232		}
233
234		/**
235		* {@inheritDoc}
236		*/
237		public function isLocal(): bool
238		{
239		return true;
240		}
241
242		/**
243		* {@inheritDoc}
244		*/
245	4	public function getPermissions(): int
246		{
247	4	if ($this->permissions === null) {
248	4	$this->permissions = 0;
249
250		try {
251	4	$localPath = $this->getLocalPath();
252		} catch (\Exception $e) {
253		// can't read a node's permissions without its local path
254		return $this->permissions;
255		}
256
257	4	if (is_readable($localPath)) {
258	4	$this->permissions \|= Constants::PERMISSION_READ;
259		}
260
261	4	if (is_writable($localPath)) {
262	4	$this->permissions \|= Constants::PERMISSION_UPDATE;
263
264	4	if ($this->isFolder()) {
265	4	$this->permissions \|= Constants::PERMISSION_CREATE;
266		}
267		}
268
269		try {
270	4	if (is_writable($this->getParentNode()->getLocalPath())) {
271	4	$this->permissions \|= Constants::PERMISSION_DELETE;
272		}
273	4	} catch (\Exception $e) {
274		// this is either the root folder or we can't read the parent folder's local path
275		// in neither case we can delete this node
276		}
277		}
278
279	4	return $this->permissions;
280		}
281		}
282

nextcloud / cms_pico

Pull Request — master (#77)

AbstractLocalNode::copy() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like