Directory::offsetSet() - Code Metrics - Inspection of "code style fixer" - oscarotero/fly-crud - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 059a7f...25fd12 )

by Oscar

created 2016-07-30 12:06 UTC

Directory::offsetSet() A

↳ Parent: Directory

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	2

<?php

namespace FlyCrud;

use League\Flysystem\FilesystemInterface;
use League\Flysystem\Filesystem;
use League\Flysystem\Adapter\Local;
use ArrayAccess;

class Directory implements ArrayAccess
{
    protected $path;
    protected $format;
    protected $filesystem;
    protected $documents = [];
    protected $directories = [];

    /**
     * Creates a new directory instance.
     * 
     * @param string          $path
     * @param FormatInterface $format
     * 
     * @return static
     */
    public static function make($path, FormatInterface $format)
    {
        return new static(new Filesystem(new Local($path)), '', $format);
    }

    /**
     * Init the directory.
     * 
     * @param FilesystemInterface $filesystem
     * @param string              $path
     * @param FormatInterface     $format
     */
    public function __construct(FilesystemInterface $filesystem, $path, FormatInterface $format)
    {
        $this->filesystem = $filesystem;
        $this->format = $format;
        $this->path = $path;
    }

    /**
     * Read and return a document.
     * 
     * @param string $id
     * 
     * @return Document
     */
    public function getDocument($id)
    {
        if (isset($this->documents[$id])) {
            return $this->documents[$id];
        }

        if ($this->hasDocument($id)) {
            $path = $this->getDocumentPath($id);
            $source = $this->filesystem->read($path);

            if (is_string($source)) {
                return $this->documents[$id] = new Document($this->format->parse($source));
            }

            throw new Exception(sprintf('Format error in the file "%s"', $path));
        }

        throw new Exception(sprintf('File "%s" not found', $path));
    }

    /**
     * Read and return a directory.
     * 
     * @param string $id
     * 
     * @return Document
     */
    public function getDirectory($id)
    {
        if (isset($this->directories[$id])) {
            return $this->directories[$id];
        }

        if ($this->hasDirectory($id)) {
            return $this->directories[$id] = new static($this->filesystem, $this->getDirectoryPath($id), $this->format);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
        }

        throw new Exception(sprintf('Directory "%s" not found', $path));
    }

    /**
     * Check whether a document exists.
     * 
     * @param string $id
     * 
     * @return bool
     */
    public function hasDocument($id)

    {
        if (isset($this->documents[$id])) {
            return true;
        }

        $path = $this->getDocumentPath($id);

        if ($this->filesystem->has($path)) {
            $info = $this->filesystem->getMetadata($path);

            return $info['type'] === 'file';
        }

        return false;
    }

    /**
     * Check whether a document or directory exists.
     * 
     * @param string $id
     * 
     * @return bool
     */
    public function hasDirectory($id)

    {
        if (isset($this->directories[$id])) {
            return true;
        }

        $path = $this->getDirectoryPath($id);

        if ($this->filesystem->has($path)) {
            $info = $this->filesystem->getMetadata($path);

            return $info['type'] === 'dir';
        }

        return false;
    }

    /**
     * Saves a document.
     * 
     * @param string   $id
     * @param Document $document
     * 
     * @return self
     */
    public function saveDocument($id, Document $document)
    {
        $this->documents[$id] = $document;
        $this->filesystem->put($this->getDocumentPath($id), $this->format->stringify($document->getArrayCopy()));

        return $this;
    }

    /**
     * Creates a new directory.
     * 
     * @param string $id
     * 
     * @return self
     */
    public function createDirectory($id)
    {
        $path = $this->getDirectoryPath($id);
        $this->filesystem->createDir($path);

        return $this->directories[$id] = new static($this->filesystem, $path, $this->format);
    }

    /**
     * Deletes a document.
     * 
     * @param string $id
     * 
     * @return self
     */
    public function deleteDocument($id)
    {
        $this->filesystem->delete($this->getDocumentPath($id));
        unset($this->documents[$id]);

        return $this;
    }

    /**
     * Deletes a directory.
     * 
     * @param string $id
     * 
     * @return self
     */
    public function deleteDirectory($id)
    {
        $this->filesystem->deleteDir($this->getDirectoryPath($id));
        unset($this->directories[$id]);

        return $this;
    }

    /**
     * Returns all documents.
     * 
     * @return array
     */
    public function getAllDocuments()

    {
        $documents = [];

        foreach ($this->filesystem->listContents('/'.$this->path) as $info) {
            $id = $info['filename'];

            if ($this->hasDocument($id)) {
                $documents[$id] = $this->getDocument($id);
            }
        }

        return $documents;
    }

    /**
     * Returns all directories.
     * 
     * @return array
     */
    public function getAllDirectories()

    {
        $directories = [];

        foreach ($this->filesystem->listContents('/'.$this->path) as $info) {
            $id = $info['filename'];

            if ($this->hasDirectory($id)) {
                $directories[$id] = $this->getDirectory($id);
            }
        }

        return $directories;
    }

    /**
     * Returns a file path.
     * 
     * @param string $id
     * 
     * @return string
     */
    private function getDocumentPath($id)
    {
        return $this->getDirectoryPath($id).'.'.$this->format->getExtension();
    }

    /**
     * Returns a directory path.
     * 
     * @param string $id
     * 
     * @return string
     */
    private function getDirectoryPath($id)
    {
        if ($this->path === '') {
            return "/{$id}";
        }

        return "/{$this->path}/{$id}";
    }

    private function getPathType($path)

    {
        if ($this->filesystem->has($path)) {
            $info = $this->filesystem->getMetadata($path);

            return $info['type'];
        }
    }

    /**
     * ArrayAccess used to documents.
     * 
     * @param string $id
     * 
     * @return bool
     */
    public function offsetExists($id)
    {
        return $this->hasDocument($id);
    }

    /**
     * ArrayAccess used to documents.
     * 
     * @param string $id
     * 
     * @return Document
     */
    public function offsetGet($id)
    {
        return $this->getDocument($id);
    }

    /**
     * ArrayAccess used to documents.
     * 
     * @param string   $id
     * @param Document $document
     */
    public function offsetSet($id, $document)
    {
        $this->saveDocument($id, $document);
    }

    /**
     * ArrayAccess used to documents.
     * 
     * @param string $id
     */
    public function offsetUnset($id)
    {
        $this->deleteDocument($id);
    }

    /**
     * Property magic method used to directories.
     * 
     * @param string $offset
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * 
     * @return Directory
     */
    public function __get($id)
    {
        return $this->getDirectory($id);
    }

    /**
     * Property magic method used to directories.
     * 
     * @param string $id
     */
    public function __isset($id)
    {
        return $this->hasDirectory($id);
    }

    /**
     * Property magic method used to directories.
     * 
     * @param string $id
     */
    public function __unset($id)
    {
        $this->deleteDirectory($id);
    }
}


1		<?php
2
3		namespace FlyCrud;
4
5		use League\Flysystem\FilesystemInterface;
6		use League\Flysystem\Filesystem;
7		use League\Flysystem\Adapter\Local;
8		use ArrayAccess;
9
10		class Directory implements ArrayAccess
11		{
12		protected $path;
13		protected $format;
14		protected $filesystem;
15		protected $documents = [];
16		protected $directories = [];
17
18		/**
19		* Creates a new directory instance.
20		*
21		* @param string $path
22		* @param FormatInterface $format
23		*
24		* @return static
25		*/
26		public static function make($path, FormatInterface $format)
27		{
28		return new static(new Filesystem(new Local($path)), '', $format);
29		}
30
31		/**
32		* Init the directory.
33		*
34		* @param FilesystemInterface $filesystem
35		* @param string $path
36		* @param FormatInterface $format
37		*/
38		public function __construct(FilesystemInterface $filesystem, $path, FormatInterface $format)
39		{
40		$this->filesystem = $filesystem;
41		$this->format = $format;
42		$this->path = $path;
43		}
44
45		/**
46		* Read and return a document.
47		*
48		* @param string $id
49		*
50		* @return Document
51		*/
52		public function getDocument($id)
53		{
54		if (isset($this->documents[$id])) {
55		return $this->documents[$id];
56		}
57
58		if ($this->hasDocument($id)) {
59		$path = $this->getDocumentPath($id);
60		$source = $this->filesystem->read($path);
61
62		if (is_string($source)) {
63		return $this->documents[$id] = new Document($this->format->parse($source));
64		}
65
66		throw new Exception(sprintf('Format error in the file "%s"', $path));
67		}
68
69		throw new Exception(sprintf('File "%s" not found', $path));
70		}
71
72		/**
73		* Read and return a directory.
74		*
75		* @param string $id
76		*
77		* @return Document
78		*/
79		public function getDirectory($id)
80		{
81		if (isset($this->directories[$id])) {
82		return $this->directories[$id];
83		}
84
85		if ($this->hasDirectory($id)) {
86		return $this->directories[$id] = new static($this->filesystem, $this->getDirectoryPath($id), $this->format);
		0 ignored issues – show Bug Best Practice introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report The return type of `return $this->directorie...h($id), $this->format);` (`FlyCrud\Directory`) is incompatible with the return type documented by `FlyCrud\Directory::getDirectory` of type `FlyCrud\Document`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
87		}
88
89		throw new Exception(sprintf('Directory "%s" not found', $path));
90		}
91
92		/**
93		* Check whether a document exists.
94		*
95		* @param string $id
96		*
97		* @return bool
98		*/
99	View Code Duplication	public function hasDocument($id)
		0 ignored issues – show Duplication introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
100		{
101		if (isset($this->documents[$id])) {
102		return true;
103		}
104
105		$path = $this->getDocumentPath($id);
106
107		if ($this->filesystem->has($path)) {
108		$info = $this->filesystem->getMetadata($path);
109
110		return $info['type'] === 'file';
111		}
112
113		return false;
114		}
115
116		/**
117		* Check whether a document or directory exists.
118		*
119		* @param string $id
120		*
121		* @return bool
122		*/
123	View Code Duplication	public function hasDirectory($id)
		0 ignored issues – show Duplication introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
124		{
125		if (isset($this->directories[$id])) {
126		return true;
127		}
128
129		$path = $this->getDirectoryPath($id);
130
131		if ($this->filesystem->has($path)) {
132		$info = $this->filesystem->getMetadata($path);
133
134		return $info['type'] === 'dir';
135		}
136
137		return false;
138		}
139
140		/**
141		* Saves a document.
142		*
143		* @param string $id
144		* @param Document $document
145		*
146		* @return self
147		*/
148		public function saveDocument($id, Document $document)
149		{
150		$this->documents[$id] = $document;
151		$this->filesystem->put($this->getDocumentPath($id), $this->format->stringify($document->getArrayCopy()));
152
153		return $this;
154		}
155
156		/**
157		* Creates a new directory.
158		*
159		* @param string $id
160		*
161		* @return self
162		*/
163		public function createDirectory($id)
164		{
165		$path = $this->getDirectoryPath($id);
166		$this->filesystem->createDir($path);
167
168		return $this->directories[$id] = new static($this->filesystem, $path, $this->format);
169		}
170
171		/**
172		* Deletes a document.
173		*
174		* @param string $id
175		*
176		* @return self
177		*/
178		public function deleteDocument($id)
179		{
180		$this->filesystem->delete($this->getDocumentPath($id));
181		unset($this->documents[$id]);
182
183		return $this;
184		}
185
186		/**
187		* Deletes a directory.
188		*
189		* @param string $id
190		*
191		* @return self
192		*/
193		public function deleteDirectory($id)
194		{
195		$this->filesystem->deleteDir($this->getDirectoryPath($id));
196		unset($this->directories[$id]);
197
198		return $this;
199		}
200
201		/**
202		* Returns all documents.
203		*
204		* @return array
205		*/
206	View Code Duplication	public function getAllDocuments()
		0 ignored issues – show Duplication introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
207		{
208		$documents = [];
209
210		foreach ($this->filesystem->listContents('/'.$this->path) as $info) {
211		$id = $info['filename'];
212
213		if ($this->hasDocument($id)) {
214		$documents[$id] = $this->getDocument($id);
215		}
216		}
217
218		return $documents;
219		}
220
221		/**
222		* Returns all directories.
223		*
224		* @return array
225		*/
226	View Code Duplication	public function getAllDirectories()
		0 ignored issues – show Duplication introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
227		{
228		$directories = [];
229
230		foreach ($this->filesystem->listContents('/'.$this->path) as $info) {
231		$id = $info['filename'];
232
233		if ($this->hasDirectory($id)) {
234		$directories[$id] = $this->getDirectory($id);
235		}
236		}
237
238		return $directories;
239		}
240
241		/**
242		* Returns a file path.
243		*
244		* @param string $id
245		*
246		* @return string
247		*/
248		private function getDocumentPath($id)
249		{
250		return $this->getDirectoryPath($id).'.'.$this->format->getExtension();
251		}
252
253		/**
254		* Returns a directory path.
255		*
256		* @param string $id
257		*
258		* @return string
259		*/
260		private function getDirectoryPath($id)
261		{
262		if ($this->path === '') {
263		return "/{$id}";
264		}
265
266		return "/{$this->path}/{$id}";
267		}
268
269		private function getPathType($path)
		0 ignored issues – show Unused Code introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report This method is not used, and could be removed. Loading history...
270		{
271		if ($this->filesystem->has($path)) {
272		$info = $this->filesystem->getMetadata($path);
273
274		return $info['type'];
275		}
276		}
277
278		/**
279		* ArrayAccess used to documents.
280		*
281		* @param string $id
282		*
283		* @return bool
284		*/
285		public function offsetExists($id)
286		{
287		return $this->hasDocument($id);
288		}
289
290		/**
291		* ArrayAccess used to documents.
292		*
293		* @param string $id
294		*
295		* @return Document
296		*/
297		public function offsetGet($id)
298		{
299		return $this->getDocument($id);
300		}
301
302		/**
303		* ArrayAccess used to documents.
304		*
305		* @param string $id
306		* @param Document $document
307		*/
308		public function offsetSet($id, $document)
309		{
310		$this->saveDocument($id, $document);
311		}
312
313		/**
314		* ArrayAccess used to documents.
315		*
316		* @param string $id
317		*/
318		public function offsetUnset($id)
319		{
320		$this->deleteDocument($id);
321		}
322
323		/**
324		* Property magic method used to directories.
325		*
326		* @param string $offset
		0 ignored issues – show Bug introduced 2016-07-30 12:08 UTC by Report Bug Copy Issue Report There is no parameter named `$offset`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
327		*
328		* @return Directory
329		*/
330		public function __get($id)
331		{
332		return $this->getDirectory($id);
333		}
334
335		/**
336		* Property magic method used to directories.
337		*
338		* @param string $id
339		*/
340		public function __isset($id)
341		{
342		return $this->hasDirectory($id);
343		}
344
345		/**
346		* Property magic method used to directories.
347		*
348		* @param string $id
349		*/
350		public function __unset($id)
351		{
352		$this->deleteDirectory($id);
353		}
354		}
355

oscarotero / fly-crud

Push — master ( 059a7f...25fd12 )

Directory::offsetSet() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like