AbstractStorageNode::getParentNode() - 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

AbstractStorageNode::getParentNode() A

↳ Parent: AbstractStorageNode

Complexity

Conditions	5
Paths	5

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	11
c	1
b	0
f	0
dl	0
loc	19
ccs	0
cts	11
cp	0
rs	9.6111
cc	5
nc	5
nop	0
crap	30

<?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\Files\File as OCFile;
use OCP\Files\Folder as OCFolder;
use OCP\Files\InvalidPathException;
use OCP\Files\Node as OCNode;
use OCP\Files\NotFoundException;

abstract class AbstractStorageNode extends AbstractNode implements NodeInterface
{
	/** @var OCNode */
	protected $node;

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

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

	/**
	 * StorageNode constructor.
	 *
	 * @param OCNode      $node
	 * @param string|null $basePath
	 *
	 * @throws InvalidPathException
	 */
	public function __construct(OCNode $node, string $basePath = null)
	{
		parent::__construct();

		$this->node = $node;

		if ($basePath !== null) {
			$basePath = $this->normalizePath($basePath);
			$nodePath = $this->normalizePath($node->getPath());

			$path = (($basePath !== '/') ? $basePath : '') . '/' . basename($nodePath);
			if (substr_compare($nodePath, $path, -strlen($path)) !== 0) {
				throw new InvalidPathException();
			}

			$this->path = $path;
		}
	}

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

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

			/** @var OCFolder $ocNode */
			$ocNode = $this->node->copy($targetPath->getOCNode()->getPath() . '/' . ($name ?: $this->getName()));
			return $this->repackNode($ocNode, $targetPath->getPath());
		} else {
			return parent::copy($targetPath, $name);
		}
	}

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

			/** @var OCFolder $ocNode */
			$ocNode = $this->node->move($targetPath->getOCNode()->getPath() . '/' . ($name ?: $this->getName()));
			return $this->repackNode($ocNode, $targetPath->getPath());
		} else {
			return parent::move($targetPath, $name);
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public function delete()
	{
		$this->node->delete();
	}

	/**
	 * @return OCNode
	 */
	public function getOCNode(): OCNode
	{
		return $this->node;
	}

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

	/**
	 * {@inheritDoc}
	 */
	public function getLocalPath(): string
	{
		try {
			$storage = $this->node->getStorage();
			$internalPath = $this->node->getInternalPath();
			$localPath = $storage->getLocalFile($internalPath);
		} catch (\Exception $e) {
			$localPath = null;
		}

		if ($localPath && file_exists($localPath)) {
			if ($this->isFolder() ? is_dir($localPath) : is_file($localPath)) {
				return $localPath;
			}

			throw new InvalidPathException();
		}

		throw new NotFoundException();
	}

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

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

	/**
	 * {@inheritDoc}
	 */
	public function getParentNode(): FolderInterface
	{
		if ($this->parentFolder === null) {
			if ($this->path === null) {
				throw new InvalidPathException();
			}

			try {
				$ocNode = $this->node->getParent();
			} catch (NotFoundException $e) {
				throw new InvalidPathException();
			}

			$parentBasePath = dirname($this->path);
			$parentBasePath = ($parentBasePath !== '/') ? dirname($parentBasePath) : null;
			$this->parentFolder = new StorageFolder($ocNode, $parentBasePath);
		}

		return $this->parentFolder;
	}

	/**
	 * {@inheritDoc}
	 */
	public function isFile(): bool
	{
		return ($this->node instanceof OCFile);
	}

	/**
	 * {@inheritDoc}
	 */
	public function isFolder(): bool
	{
		return ($this->node instanceof OCFolder);
	}

	/**
	 * {@inheritDoc}
	 */
	public function isLocal(): bool
	{
		try {
			return $this->getOCNode()->getStorage()->isLocal();
		} catch (\Exception $e) {
			return false;
		}
	}

	/**
	 * {@inheritDoc}
	 */
	public function getPermissions(): int
	{
		try {
			return $this->node->getPermissions();
		} catch (\Exception $e) {
			return 0;
		}
	}

	/**
	 * @param OCNode      $node
	 * @param string|null $basePath
	 *
	 * @return AbstractStorageNode
	 * @throws InvalidPathException
	 */
	protected function repackNode(OCNode $node, string $basePath = null): AbstractStorageNode
	{
		if ($node instanceof OCFile) {
			return new StorageFile($node, $basePath);
		} elseif ($node instanceof OCFolder) {
			return new StorageFolder($node, $basePath);
		} else {
			throw new \UnexpectedValueException();
		}
	}
}


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\Files\File as OCFile;
28		use OCP\Files\Folder as OCFolder;
29		use OCP\Files\InvalidPathException;
30		use OCP\Files\Node as OCNode;
31		use OCP\Files\NotFoundException;
32
33		abstract class AbstractStorageNode extends AbstractNode implements NodeInterface
34		{
35		/** @var OCNode */
36		protected $node;
37
38		/** @var string */
39		protected $path;
40
41		/** @var StorageFolder */
42		protected $parentFolder;
43
44		/**
45		* StorageNode constructor.
46		*
47		* @param OCNode $node
48		* @param string\|null $basePath
49		*
50		* @throws InvalidPathException
51		*/
52	7	public function __construct(OCNode $node, string $basePath = null)
53		{
54	7	parent::__construct();
55
56	7	$this->node = $node;
57
58	7	if ($basePath !== null) {
59	7	$basePath = $this->normalizePath($basePath);
60	7	$nodePath = $this->normalizePath($node->getPath());
61
62	7	$path = (($basePath !== '/') ? $basePath : '') . '/' . basename($nodePath);
63	7	if (substr_compare($nodePath, $path, -strlen($path)) !== 0) {
64		throw new InvalidPathException();
65		}
66
67	7	$this->path = $path;
68		}
69	7	}
70
71		/**
72		* {@inheritDoc}
73		*/
74		public function rename(string $name): NodeInterface
75		{
76		return $this->move($this->getParentNode(), $name);
77		}
78
79		/**
80		* {@inheritDoc}
81		*/
82	1	public function copy(FolderInterface $targetPath, string $name = null): NodeInterface
83		{
84	1	if ($targetPath instanceof StorageFolder) {
85		if ($name !== null) {
86		$this->assertValidFileName($name);
87		}
88
89		/** @var OCFolder $ocNode */
90		$ocNode = $this->node->copy($targetPath->getOCNode()->getPath() . '/' . ($name ?: $this->getName()));
91		return $this->repackNode($ocNode, $targetPath->getPath());
92		} else {
93	1	return parent::copy($targetPath, $name);
94		}
95		}
96
97		/**
98		* {@inheritDoc}
99		*/
100		public function move(FolderInterface $targetPath, string $name = null): NodeInterface
101		{
102		if ($targetPath instanceof StorageFolder) {
103		if ($name !== null) {
104		$this->assertValidFileName($name);
105		}
106
107		/** @var OCFolder $ocNode */
108		$ocNode = $this->node->move($targetPath->getOCNode()->getPath() . '/' . ($name ?: $this->getName()));
109		return $this->repackNode($ocNode, $targetPath->getPath());
110		} else {
111		return parent::move($targetPath, $name);
112		}
113		}
114
115		/**
116		* {@inheritDoc}
117		*/
118	2	public function delete()
119		{
120	2	$this->node->delete();
121	2	}
122
123		/**
124		* @return OCNode
125		*/
126	5	public function getOCNode(): OCNode
127		{
128	5	return $this->node;
129		}
130
131		/**
132		* {@inheritDoc}
133		*/
134	7	public function getPath(): string
135		{
136	7	return $this->path ?: ($this->isFolder() ? '/' : '/' . $this->getName());
137		}
138
139		/**
140		* {@inheritDoc}
141		*/
142	2	public function getLocalPath(): string
143		{
144		try {
145	2	$storage = $this->node->getStorage();
146	2	$internalPath = $this->node->getInternalPath();
147	2	$localPath = $storage->getLocalFile($internalPath);
148		} catch (\Exception $e) {
149		$localPath = null;
150		}
151
152	2	if ($localPath && file_exists($localPath)) {
153	2	if ($this->isFolder() ? is_dir($localPath) : is_file($localPath)) {
154	2	return $localPath;
155		}
156
157		throw new InvalidPathException();
158		}
159
160		throw new NotFoundException();
161		}
162
163		/**
164		* {@inheritDoc}
165		*/
166	2	public function getName(): string
167		{
168	2	return $this->node->getName();
169		}
170
171		/**
172		* {@inheritDoc}
173		*/
174		public function getParent(): string
175		{
176		return $this->getParentNode()->getPath();
177		}
178
179		/**
180		* {@inheritDoc}
181		*/
182		public function getParentNode(): FolderInterface
183		{
184		if ($this->parentFolder === null) {
185		if ($this->path === null) {
186		throw new InvalidPathException();
187		}
188
189		try {
190		$ocNode = $this->node->getParent();
191		} catch (NotFoundException $e) {
192		throw new InvalidPathException();
193		}
194
195		$parentBasePath = dirname($this->path);
196		$parentBasePath = ($parentBasePath !== '/') ? dirname($parentBasePath) : null;
197		$this->parentFolder = new StorageFolder($ocNode, $parentBasePath);
198		}
199
200		return $this->parentFolder;
201		}
202
203		/**
204		* {@inheritDoc}
205		*/
206	2	public function isFile(): bool
207		{
208	2	return ($this->node instanceof OCFile);
209		}
210
211		/**
212		* {@inheritDoc}
213		*/
214	7	public function isFolder(): bool
215		{
216	7	return ($this->node instanceof OCFolder);
217		}
218
219		/**
220		* {@inheritDoc}
221		*/
222	5	public function isLocal(): bool
223		{
224		try {
225	5	return $this->getOCNode()->getStorage()->isLocal();
226		} catch (\Exception $e) {
227		return false;
228		}
229		}
230
231		/**
232		* {@inheritDoc}
233		*/
234		public function getPermissions(): int
235		{
236		try {
237		return $this->node->getPermissions();
238		} catch (\Exception $e) {
239		return 0;
240		}
241		}
242
243		/**
244		* @param OCNode $node
245		* @param string\|null $basePath
246		*
247		* @return AbstractStorageNode
248		* @throws InvalidPathException
249		*/
250	7	protected function repackNode(OCNode $node, string $basePath = null): AbstractStorageNode
251		{
252	7	if ($node instanceof OCFile) {
253	3	return new StorageFile($node, $basePath);
254	7	} elseif ($node instanceof OCFolder) {
255	7	return new StorageFolder($node, $basePath);
256		} else {
257		throw new \UnexpectedValueException();
258		}
259		}
260		}
261

nextcloud / cms_pico

Pull Request — master (#77)

AbstractStorageNode::getParentNode() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like