AbstractPathMappingRepository::clear() - Code Metrics - Inspection of "Merge pull request #70 from EmanueleMinotto/mappin..." - puli/repository - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 1.0 ( ca57a4...6b0f55 )

by Bernhard

created 2015-12-14 13:30 UTC

AbstractPathMappingRepository::clear() A

↳ Parent: AbstractPathMappingRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	10
ccs	5
cts	5
cp	1
rs	9.4286
cc	1
eloc	5
nc	1
nop	0
crap	1

<?php

/*
 * This file is part of the puli/repository package.
 *
 * (c) Bernhard Schussek <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Puli\Repository;

use Puli\Repository\Api\Resource\FilesystemResource;
use Puli\Repository\Api\Resource\PuliResource;
use Puli\Repository\Api\ResourceCollection;
use Puli\Repository\Api\UnsupportedResourceException;
use Puli\Repository\Resource\DirectoryResource;
use Puli\Repository\Resource\FileResource;
use Puli\Repository\Resource\GenericResource;
use Puli\Repository\Resource\LinkResource;
use RuntimeException;
use Webmozart\KeyValueStore\Api\CountableStore;
use Webmozart\KeyValueStore\Api\KeyValueStore;
use Webmozart\KeyValueStore\Api\SortableStore;
use Webmozart\KeyValueStore\Decorator\CountableDecorator;
use Webmozart\KeyValueStore\Decorator\SortableDecorator;
use Webmozart\PathUtil\Path;

/**
 * Abstract base for Path mapping repositories.
 *
 * @since  1.0
 *
 * @author Bernhard Schussek <[email protected]>
 * @author Titouan Galopin <[email protected]>
 */
abstract class AbstractPathMappingRepository extends AbstractRepository
{
    /**
     * @var KeyValueStore
     */
    protected $store;

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

    /**
     * Creates a new repository.
     *
     * @param KeyValueStore $store         The store of all the paths.
     * @param string        $baseDirectory The store of all the paths.
     */
    public function __construct(KeyValueStore $store, $baseDirectory)
    {
        $this->store = $store;
        $this->baseDirectory = $baseDirectory;

        $this->createRoot();
    }

    /**
     * {@inheritdoc}
     */
    public function add($path, $resource)
    {
        $path = $this->sanitizePath($path);

        if ($resource instanceof ResourceCollection) {
            $this->ensureDirectoryExists($path);

            foreach ($resource as $child) {
                $this->addResource($path.'/'.$child->getName(), $child);
            }

            $this->sortStore();

            return;
        }

        $this->ensureDirectoryExists(Path::getDirectory($path));
        $this->addResource($path, $resource);
        $this->sortStore();
    }

    /**
     * Add the resource (internal method after checks of add()).
     *
     * @param string       $path
     * @param PuliResource $resource
     */
    private function addResource($path, $resource)
    {
        if (!($resource instanceof FilesystemResource || $resource instanceof LinkResource)) {
            throw new UnsupportedResourceException(sprintf(
                'PathMapping repositories only supports FilesystemResource and LinkedResource. Got: %s',
                is_object($resource) ? get_class($resource) : gettype($resource)
            ));
        }

        // Don't modify resources attached to other repositories
        if ($resource->isAttached()) {
            $resource = clone $resource;
        }

        if ($resource instanceof LinkResource) {
            $this->addLinkResource($path, $resource);
        } elseif (Path::isBasePath($this->baseDirectory, $resource->getFilesystemPath())) {
            $this->addFilesystemResource($path, $resource);
        } else {
            throw new UnsupportedResourceException(sprintf(
                'Can only add resources from %s. Tried to add %s.',
                $this->baseDirectory,
                $resource->getFilesystemPath()
            ));
        }
    }

    /**
     * Add the filesystem resource.
     *
     * @param string             $path
     * @param FilesystemResource $resource
     */
    abstract protected function addFilesystemResource($path, FilesystemResource $resource);

    /**
     * Add the link resource.
     *
     * @param string       $path
     * @param LinkResource $resource
     */
    abstract protected function addLinkResource($path, LinkResource $resource);

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        // Subtract root
        $removed = $this->countStore() - 1;

        $this->store->clear();
        $this->createRoot();

        return $removed;
    }

    /**
     * Recursively creates a directory for a path.
     *
     * @param string $path A directory path.
     */
    protected function ensureDirectoryExists($path)
    {
        if ($this->store->exists($path)) {
            return;
        }

        // Recursively initialize parent directories
        if ('/' !== $path) {
            $this->ensureDirectoryExists(Path::getDirectory($path));
        }

        $this->store->set($path, null);
    }

    /**
     * Create the repository root.
     */
    protected function createRoot()
    {
        if ($this->store->exists('/')) {
            return;
        }

        $this->store->set('/', null);
    }

    /**
     * Count the number of elements in the store.
     *
     * @return int
     */
    protected function countStore()
    {
        if (!$this->store instanceof CountableStore) {
            $this->store = new CountableDecorator($this->store);
        }

        return $this->store->count();
    }

    /**
     * Sort the store by keys.
     */
    protected function sortStore()
    {
        if (!$this->store instanceof SortableStore) {
            $this->store = new SortableDecorator($this->store);
        }

        $this->store->sort();
    }

    /**
     * Create a filesystem or generic resource.
     *
     * @param string|null $filesystemPath
     *
     * @return DirectoryResource|FileResource|GenericResource
     */
    protected function createResource($filesystemPath, $path = null)
    {
        // Link resource
        if (0 === strpos($filesystemPath, 'l:')) {
            return $this->createLinkResource(substr($filesystemPath, 2), $path);
        }

        // Filesystem resource
        if (is_string($filesystemPath)) {
            $filesystemPath = $this->resolveRelativePath($filesystemPath);

            if (file_exists($filesystemPath)) {
                return $this->createFilesystemResource($filesystemPath, $path);
            }
        }

        return $this->createVirtualResource($path);
    }

    /**
     * Create a link resource to another resource of the repository.
     *
     * @param string      $targetPath The target path.
     * @param string|null $path       The repository path.
     *
     * @return LinkResource The link resource.
     *
     * @throws RuntimeException If the targeted resource does not exist.
     */
    protected function createLinkResource($targetPath, $path = null)
    {
        $resource = new LinkResource($targetPath);
        $resource->attachTo($this, $path);

        return $resource;
    }

    /**
     * Create a resource using its filesystem path.
     *
     * If the filesystem path is a directory, a DirectoryResource will be created.
     * If the filesystem path is a file, a FileResource will be created.
     * If the filesystem does not exists, a GenericResource will be created.
     *
     * @param string      $filesystemPath The filesystem path.
     * @param string|null $path           The repository path.
     *
     * @return DirectoryResource|FileResource The created resource.
     *
     * @throws RuntimeException If the file / directory does not exist.
     */
    protected function createFilesystemResource($filesystemPath, $path = null)
    {
        $resource = null;

        if (is_dir($filesystemPath)) {
            $resource = new DirectoryResource($filesystemPath);
        } elseif (is_file($filesystemPath)) {
            $resource = new FileResource($filesystemPath);
        }

        if ($resource) {
            $resource->attachTo($this, $path);

            return $resource;
        }

        throw new RuntimeException(sprintf(
            'Trying to create a FilesystemResource on a non-existing file or directory "%s"',
            $filesystemPath
        ));
    }

    /**
     * @param string|null $path
     *
     * @return GenericResource
     */
    protected function createVirtualResource($path = null)
    {
        $resource = new GenericResource();
        $resource->attachTo($this, $path);

        return $resource;
    }

    /**
     * Transform a relative path into an absolute path.
     *
     * @param string $relativePath
     *
     * @return string
     */
    protected function resolveRelativePath($relativePath)
    {
        if (0 === strpos($relativePath, 'l:')) {
            // Link
            return $relativePath;
        }

        return Path::makeAbsolute($relativePath, $this->baseDirectory);
    }

    /**
     * Transform a collection of relative paths into a collection of absolute paths.
     *
     * @param string[] $relativePaths
     *
     * @return string[]
     */
    protected function resolveRelativePaths($relativePaths)
    {
        foreach ($relativePaths as $key => $relativePath) {
            $relativePaths[$key] = $this->resolveRelativePath($relativePath);
        }

        return $relativePaths;
    }
}


1			<?php
2
3			/*
4			* This file is part of the puli/repository package.
5			*
6			* (c) Bernhard Schussek <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Puli\Repository;
13
14			use Puli\Repository\Api\Resource\FilesystemResource;
15			use Puli\Repository\Api\Resource\PuliResource;
16			use Puli\Repository\Api\ResourceCollection;
17			use Puli\Repository\Api\UnsupportedResourceException;
18			use Puli\Repository\Resource\DirectoryResource;
19			use Puli\Repository\Resource\FileResource;
20			use Puli\Repository\Resource\GenericResource;
21			use Puli\Repository\Resource\LinkResource;
22			use RuntimeException;
23			use Webmozart\KeyValueStore\Api\CountableStore;
24			use Webmozart\KeyValueStore\Api\KeyValueStore;
25			use Webmozart\KeyValueStore\Api\SortableStore;
26			use Webmozart\KeyValueStore\Decorator\CountableDecorator;
27			use Webmozart\KeyValueStore\Decorator\SortableDecorator;
28			use Webmozart\PathUtil\Path;
29
30			/**
31			* Abstract base for Path mapping repositories.
32			*
33			* @since 1.0
34			*
35			* @author Bernhard Schussek <[email protected]>
36			* @author Titouan Galopin <[email protected]>
37			*/
38			abstract class AbstractPathMappingRepository extends AbstractRepository
39			{
40			/**
41			* @var KeyValueStore
42			*/
43			protected $store;
44
45			/**
46			* @var string
47			*/
48			protected $baseDirectory;
49
50			/**
51			* Creates a new repository.
52			*
53			* @param KeyValueStore $store The store of all the paths.
54			* @param string $baseDirectory The store of all the paths.
55			*/
56	169		public function __construct(KeyValueStore $store, $baseDirectory)
57			{
58	169		$this->store = $store;
59	169		$this->baseDirectory = $baseDirectory;
60
61	169		$this->createRoot();
62	169		}
63
64			/**
65			* {@inheritdoc}
66			*/
67	144		public function add($path, $resource)
68			{
69	144		$path = $this->sanitizePath($path);
70
71	138	View Code Duplication	if ($resource instanceof ResourceCollection) {
72	2		$this->ensureDirectoryExists($path);
73
74	2		foreach ($resource as $child) {
75	2		$this->addResource($path.'/'.$child->getName(), $child);
76	2		}
77
78	2		$this->sortStore();
79
80	2		return;
81			}
82
83	136		$this->ensureDirectoryExists(Path::getDirectory($path));
84	136		$this->addResource($path, $resource);
85	132		$this->sortStore();
86	132		}
87
88			/**
89			* Add the resource (internal method after checks of add()).
90			*
91			* @param string $path
92			* @param PuliResource $resource
93			*/
94	138		private function addResource($path, $resource)
95			{
96	138		if (!($resource instanceof FilesystemResource \|\| $resource instanceof LinkResource)) {
97	2		throw new UnsupportedResourceException(sprintf(
98	2		'PathMapping repositories only supports FilesystemResource and LinkedResource. Got: %s',
99	2		is_object($resource) ? get_class($resource) : gettype($resource)
100	2		));
101			}
102
103			// Don't modify resources attached to other repositories
104	136		if ($resource->isAttached()) {
105	2		$resource = clone $resource;
106	2		}
107
108	136		if ($resource instanceof LinkResource) {
109	4		$this->addLinkResource($path, $resource);
110	136		} elseif (Path::isBasePath($this->baseDirectory, $resource->getFilesystemPath())) {
111	134		$this->addFilesystemResource($path, $resource);
112	134		} else {
113	2		throw new UnsupportedResourceException(sprintf(
114	2		'Can only add resources from %s. Tried to add %s.',
115	2		$this->baseDirectory,
116	2		$resource->getFilesystemPath()
117	2		));
118			}
119	134		}
120
121			/**
122			* Add the filesystem resource.
123			*
124			* @param string $path
125			* @param FilesystemResource $resource
126			*/
127			abstract protected function addFilesystemResource($path, FilesystemResource $resource);
128
129			/**
130			* Add the link resource.
131			*
132			* @param string $path
133			* @param LinkResource $resource
134			*/
135			abstract protected function addLinkResource($path, LinkResource $resource);
136
137			/**
138			* {@inheritdoc}
139			*/
140	2		public function clear()
141			{
142			// Subtract root
143	2		$removed = $this->countStore() - 1;
144
145	2		$this->store->clear();
146	2		$this->createRoot();
147
148	2		return $removed;
149			}
150
151			/**
152			* Recursively creates a directory for a path.
153			*
154			* @param string $path A directory path.
155			*/
156	138		protected function ensureDirectoryExists($path)
157			{
158	138		if ($this->store->exists($path)) {
159	138		return;
160			}
161
162			// Recursively initialize parent directories
163	40		if ('/' !== $path) {
164	40		$this->ensureDirectoryExists(Path::getDirectory($path));
165	40		}
166
167	40		$this->store->set($path, null);
168	40		}
169
170			/**
171			* Create the repository root.
172			*/
173	169		protected function createRoot()
174			{
175	169		if ($this->store->exists('/')) {
176	70		return;
177			}
178
179	169		$this->store->set('/', null);
180	169		}
181
182			/**
183			* Count the number of elements in the store.
184			*
185			* @return int
186			*/
187	9		protected function countStore()
188			{
189	9		if (!$this->store instanceof CountableStore) {
190			$this->store = new CountableDecorator($this->store);
191			}
192
193	9		return $this->store->count();
194			}
195
196			/**
197			* Sort the store by keys.
198			*/
199	134		protected function sortStore()
200			{
201	134		if (!$this->store instanceof SortableStore) {
202			$this->store = new SortableDecorator($this->store);
203			}
204
205	134		$this->store->sort();
206	134		}
207
208			/**
209			* Create a filesystem or generic resource.
210			*
211			* @param string\|null $filesystemPath
212			*
213			* @return DirectoryResource\|FileResource\|GenericResource
214			*/
215	90		protected function createResource($filesystemPath, $path = null)
216			{
217			// Link resource
218	90		if (0 === strpos($filesystemPath, 'l:')) {
219	4		return $this->createLinkResource(substr($filesystemPath, 2), $path);
220			}
221
222			// Filesystem resource
223	90		if (is_string($filesystemPath)) {
224	88		$filesystemPath = $this->resolveRelativePath($filesystemPath);
225
226	88		if (file_exists($filesystemPath)) {
227	88		return $this->createFilesystemResource($filesystemPath, $path);
228			}
229	1		}
230
231	12		return $this->createVirtualResource($path);
232			}
233
234			/**
235			* Create a link resource to another resource of the repository.
236			*
237			* @param string $targetPath The target path.
238			* @param string\|null $path The repository path.
239			*
240			* @return LinkResource The link resource.
241			*
242			* @throws RuntimeException If the targeted resource does not exist.
243			*/
244	4		protected function createLinkResource($targetPath, $path = null)
245			{
246	4		$resource = new LinkResource($targetPath);
247	4		$resource->attachTo($this, $path);
248
249	4		return $resource;
250			}
251
252			/**
253			* Create a resource using its filesystem path.
254			*
255			* If the filesystem path is a directory, a DirectoryResource will be created.
256			* If the filesystem path is a file, a FileResource will be created.
257			* If the filesystem does not exists, a GenericResource will be created.
258			*
259			* @param string $filesystemPath The filesystem path.
260			* @param string\|null $path The repository path.
261			*
262			* @return DirectoryResource\|FileResource The created resource.
263			*
264			* @throws RuntimeException If the file / directory does not exist.
265			*/
266	88		protected function createFilesystemResource($filesystemPath, $path = null)
267			{
268	88		$resource = null;
269
270	88		if (is_dir($filesystemPath)) {
271	51		$resource = new DirectoryResource($filesystemPath);
272	88		} elseif (is_file($filesystemPath)) {
273	63		$resource = new FileResource($filesystemPath);
274	63		}
275
276	88		if ($resource) {
277	88		$resource->attachTo($this, $path);
278
279	88		return $resource;
280			}
281
282			throw new RuntimeException(sprintf(
283			'Trying to create a FilesystemResource on a non-existing file or directory "%s"',
284			$filesystemPath
285			));
286			}
287
288			/**
289			* @param string\|null $path
290			*
291			* @return GenericResource
292			*/
293	12		protected function createVirtualResource($path = null)
294			{
295	12		$resource = new GenericResource();
296	12		$resource->attachTo($this, $path);
297
298	12		return $resource;
299			}
300
301			/**
302			* Transform a relative path into an absolute path.
303			*
304			* @param string $relativePath
305			*
306			* @return string
307			*/
308	93		protected function resolveRelativePath($relativePath)
309			{
310	93		if (0 === strpos($relativePath, 'l:')) {
311			// Link
312	2		return $relativePath;
313			}
314
315	93		return Path::makeAbsolute($relativePath, $this->baseDirectory);
316			}
317
318			/**
319			* Transform a collection of relative paths into a collection of absolute paths.
320			*
321			* @param string[] $relativePaths
322			*
323			* @return string[]
324			*/
325	58		protected function resolveRelativePaths($relativePaths)
326			{
327	58		foreach ($relativePaths as $key => $relativePath) {
328	58		$relativePaths[$key] = $this->resolveRelativePath($relativePath);
329	58		}
330
331	58		return $relativePaths;
332			}
333			}
334

puli / repository

Push — 1.0 ( ca57a4...6b0f55 )

AbstractPathMappingRepository::clear() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like