CachedAdapter::__call() - Code Metrics - Inspection of "flysystem plugin supports with `__call()`" - thephpleague/flysystem-cached-adapter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#16)

by Naoki

created 2016-02-15 08:06 UTC

CachedAdapter::__call() A

↳ Parent: CachedAdapter

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	8
ccs	0
cts	0
cp	0
rs	9.4285
cc	2
eloc	4
nc	2
nop	2
crap	6

<?php

namespace League\Flysystem\Cached;

use League\Flysystem\AdapterInterface;
use League\Flysystem\Config;

class CachedAdapter implements AdapterInterface
{
    /**
     * @var AdapterInterface
     */
    private $adapter;

    /**
     * @var CacheInterface
     */
    private $cache;

    /**
     * Constructor.
     *
     * @param AdapterInterface $adapter
     * @param CacheInterface   $cache
     */
    public function __construct(AdapterInterface $adapter, CacheInterface $cache)
    {
        $this->adapter = $adapter;
        $this->cache = $cache;
        $this->cache->load();
    }

    /**
     * {@inheritdoc}
     */
    public function getAdapter()
    {
        return $this->adapter;
    }

    /**
     * {@inheritdoc}
     */
    public function write($path, $contents, Config $config)
    {
        $result = $this->adapter->write($path, $contents, $config);

        if ($result !== false) {
            $this->cache->updateObject($path, $result + compact('path', 'contents'), true);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function writeStream($path, $resource, Config $config)
    {
        $result = $this->adapter->writeStream($path, $resource, $config);

        if ($result !== false) {
            $contents = false;
            $this->cache->updateObject($path, $result + compact('path', 'contents'), true);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function update($path, $contents, Config $config)
    {
        $result = $this->adapter->update($path, $contents, $config);

        if ($result !== false) {
            $this->cache->updateObject($path, $result + compact('path', 'contents'), true);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function updateStream($path, $resource, Config $config)
    {
        $result = $this->adapter->updateStream($path, $resource, $config);

        if ($result !== false) {
            $contents = false;
            $this->cache->updateObject($path, $result + compact('path', 'contents'), true);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function rename($path, $newPath)
    {
        $result = $this->adapter->rename($path, $newPath);

        if ($result !== false) {
            $this->cache->rename($path, $newPath);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function copy($path, $newpath)
    {
        $result = $this->adapter->copy($path, $newpath);

        if ($result !== false) {
            $this->cache->copy($path, $newpath);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function delete($path)
    {
        $result = $this->adapter->delete($path);

        if ($result !== false) {
            $this->cache->delete($path);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function deleteDir($dirname)
    {
        $result = $this->adapter->deleteDir($dirname);

        if ($result !== false) {
            $this->cache->deleteDir($dirname);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function createDir($dirname, Config $config)
    {
        $result = $this->adapter->createDir($dirname, $config);

        if ($result !== false) {
            $type = 'dir';
            $path = $dirname;
            $this->cache->updateObject($dirname, compact('path', 'type'), true);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function setVisibility($path, $visibility)
    {
        $result = $this->adapter->setVisibility($path, $visibility);

        if ($result !== false) {
            $this->cache->updateObject($path, compact('path', 'visibility'), true);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function has($path)
    {
        $cacheHas = $this->cache->has($path);

        if ($cacheHas !== null) {
            return $cacheHas;
        }

        $adapterResponse = $this->adapter->has($path);

        if (! $adapterResponse) {
            $this->cache->storeMiss($path);
        } else {
            $cacheEntry = is_array($adapterResponse) ? $adapterResponse : compact('path');
            $this->cache->updateObject($path, $cacheEntry, true);
        }

        return $adapterResponse;
    }

    /**
     * {@inheritdoc}
     */
    public function read($path)
    {
        return $this->callWithFallback('read', $path);
    }

    /**
     * {@inheritdoc}
     */
    public function readStream($path)
    {
        return $this->adapter->readStream($path);
    }

    /**
     * {@inheritdoc}
     */
    public function listContents($directory = '', $recursive = false)
    {
        if ($this->cache->isComplete($directory, $recursive)) {
            return $this->cache->listContents($directory, $recursive);
        }

        $result = $this->adapter->listContents($directory, $recursive);

        if ($result) {

            $this->cache->storeContents($directory, $result, $recursive);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getMetadata($path)
    {
        return $this->callWithFallback('getMetadata', $path);
    }

    /**
     * {@inheritdoc}
     */
    public function getSize($path)
    {
        return $this->callWithFallback('getSize', $path);
    }

    /**
     * {@inheritdoc}
     */
    public function getMimetype($path)
    {
        return $this->callWithFallback('getMimetype', $path);
    }

    /**
     * {@inheritdoc}
     */
    public function getTimestamp($path)
    {
        return $this->callWithFallback('getTimestamp', $path);
    }

    /**
     * {@inheritdoc}
     */
    public function getVisibility($path)
    {
        return $this->callWithFallback('getVisibility', $path);
    }

    /**
     * Call a method and cache the response.
     *
     * @param string $method
     * @param string $path
     *
     * @return mixed
     */
    protected function callWithFallback($method, $path)
    {
        $result = $this->cache->{$method}($path);

        if ($result !== false) {
            return $result;
        }

        $result = $this->adapter->{$method}($path);

        if ($result) {
            $object = $result + compact('path');
            $this->cache->updateObject($path, $object, true);
        }

        return $result;
    }

    /**
     * Call any method for plugin features.
     *
     * @param array $arguments [ $path ]
     *
     * @return array|false
     */
    public function __call($method, $arguments)
    {
        if (method_exists($this->adapter, $method)) {
            return $this->callWithFallback($method, $arguments[0]);
        }

        return false;
    }
}


1		<?php
2
3		namespace League\Flysystem\Cached;
4
5		use League\Flysystem\AdapterInterface;
6		use League\Flysystem\Config;
7
8		class CachedAdapter implements AdapterInterface
9		{
10		/**
11		* @var AdapterInterface
12		*/
13		private $adapter;
14
15		/**
16		* @var CacheInterface
17		*/
18		private $cache;
19
20		/**
21		* Constructor.
22		*
23		* @param AdapterInterface $adapter
24		* @param CacheInterface $cache
25		*/
26	144	public function __construct(AdapterInterface $adapter, CacheInterface $cache)
27		{
28	144	$this->adapter = $adapter;
29	144	$this->cache = $cache;
30	144	$this->cache->load();
31	144	}
32
33		/**
34		* {@inheritdoc}
35		*/
36	3	public function getAdapter()
37		{
38	3	return $this->adapter;
39		}
40
41		/**
42		* {@inheritdoc}
43		*/
44	6	public function write($path, $contents, Config $config)
45		{
46	6	$result = $this->adapter->write($path, $contents, $config);
47
48	6	if ($result !== false) {
49	3	$this->cache->updateObject($path, $result + compact('path', 'contents'), true);
50	3	}
51
52	6	return $result;
53		}
54
55		/**
56		* {@inheritdoc}
57		*/
58	6	public function writeStream($path, $resource, Config $config)
59		{
60	6	$result = $this->adapter->writeStream($path, $resource, $config);
61
62	6	if ($result !== false) {
63	3	$contents = false;
64	3	$this->cache->updateObject($path, $result + compact('path', 'contents'), true);
65	3	}
66
67	6	return $result;
68		}
69
70		/**
71		* {@inheritdoc}
72		*/
73	6	public function update($path, $contents, Config $config)
74		{
75	6	$result = $this->adapter->update($path, $contents, $config);
76
77	6	if ($result !== false) {
78	3	$this->cache->updateObject($path, $result + compact('path', 'contents'), true);
79	3	}
80
81	6	return $result;
82		}
83
84		/**
85		* {@inheritdoc}
86		*/
87	6	public function updateStream($path, $resource, Config $config)
88		{
89	6	$result = $this->adapter->updateStream($path, $resource, $config);
90
91	6	if ($result !== false) {
92	3	$contents = false;
93	3	$this->cache->updateObject($path, $result + compact('path', 'contents'), true);
94	3	}
95
96	6	return $result;
97		}
98
99		/**
100		* {@inheritdoc}
101		*/
102	6	public function rename($path, $newPath)
103		{
104	6	$result = $this->adapter->rename($path, $newPath);
105
106	6	if ($result !== false) {
107	3	$this->cache->rename($path, $newPath);
108	3	}
109
110	6	return $result;
111		}
112
113		/**
114		* {@inheritdoc}
115		*/
116	6	public function copy($path, $newpath)
117		{
118	6	$result = $this->adapter->copy($path, $newpath);
119
120	6	if ($result !== false) {
121	3	$this->cache->copy($path, $newpath);
122	3	}
123
124	6	return $result;
125		}
126
127		/**
128		* {@inheritdoc}
129		*/
130	6	public function delete($path)
131		{
132	6	$result = $this->adapter->delete($path);
133
134	6	if ($result !== false) {
135	3	$this->cache->delete($path);
136	3	}
137
138	6	return $result;
139		}
140
141		/**
142		* {@inheritdoc}
143		*/
144	6	public function deleteDir($dirname)
145		{
146	6	$result = $this->adapter->deleteDir($dirname);
147
148	6	if ($result !== false) {
149	3	$this->cache->deleteDir($dirname);
150	3	}
151
152	6	return $result;
153		}
154
155		/**
156		* {@inheritdoc}
157		*/
158	6	public function createDir($dirname, Config $config)
159		{
160	6	$result = $this->adapter->createDir($dirname, $config);
161
162	6	if ($result !== false) {
163	3	$type = 'dir';
164	3	$path = $dirname;
165	3	$this->cache->updateObject($dirname, compact('path', 'type'), true);
166	3	}
167
168	6	return $result;
169		}
170
171		/**
172		* {@inheritdoc}
173		*/
174	6	public function setVisibility($path, $visibility)
175		{
176	6	$result = $this->adapter->setVisibility($path, $visibility);
177
178	6	if ($result !== false) {
179	3	$this->cache->updateObject($path, compact('path', 'visibility'), true);
180	3	}
181
182	6	return $result;
183		}
184
185		/**
186		* {@inheritdoc}
187		*/
188	12	public function has($path)
189		{
190	12	$cacheHas = $this->cache->has($path);
191
192	12	if ($cacheHas !== null) {
193	6	return $cacheHas;
194		}
195
196	6	$adapterResponse = $this->adapter->has($path);
197
198	6	if (! $adapterResponse) {
199	3	$this->cache->storeMiss($path);
200	3	} else {
201	3	$cacheEntry = is_array($adapterResponse) ? $adapterResponse : compact('path');
202	3	$this->cache->updateObject($path, $cacheEntry, true);
203		}
204
205	6	return $adapterResponse;
206		}
207
208		/**
209		* {@inheritdoc}
210		*/
211	9	public function read($path)
212		{
213	9	return $this->callWithFallback('read', $path);
214		}
215
216		/**
217		* {@inheritdoc}
218		*/
219	3	public function readStream($path)
220		{
221	3	return $this->adapter->readStream($path);
222		}
223
224		/**
225		* {@inheritdoc}
226		*/
227	9	public function listContents($directory = '', $recursive = false)
228		{
229	9	if ($this->cache->isComplete($directory, $recursive)) {
230	3	return $this->cache->listContents($directory, $recursive);
231		}
232
233	6	$result = $this->adapter->listContents($directory, $recursive);
234
235	6	if ($result) {
		0 ignored issues – show Bug Best Practice introduced 2016-01-05 16:42 UTC by Report Bug Copy Issue Report The expression `$result` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
236	3	$this->cache->storeContents($directory, $result, $recursive);
237	3	}
238
239	6	return $result;
240		}
241
242		/**
243		* {@inheritdoc}
244		*/
245	9	public function getMetadata($path)
246		{
247	9	return $this->callWithFallback('getMetadata', $path);
248		}
249
250		/**
251		* {@inheritdoc}
252		*/
253	9	public function getSize($path)
254		{
255	9	return $this->callWithFallback('getSize', $path);
256		}
257
258		/**
259		* {@inheritdoc}
260		*/
261	9	public function getMimetype($path)
262		{
263	9	return $this->callWithFallback('getMimetype', $path);
264		}
265
266		/**
267		* {@inheritdoc}
268		*/
269	9	public function getTimestamp($path)
270		{
271	9	return $this->callWithFallback('getTimestamp', $path);
272		}
273
274		/**
275		* {@inheritdoc}
276		*/
277	9	public function getVisibility($path)
278		{
279	9	return $this->callWithFallback('getVisibility', $path);
280		}
281
282		/**
283		* Call a method and cache the response.
284		*
285		* @param string $method
286		* @param string $path
287		*
288		* @return mixed
289		*/
290	54	protected function callWithFallback($method, $path)
291		{
292	54	$result = $this->cache->{$method}($path);
293
294	54	if ($result !== false) {
295	18	return $result;
296		}
297
298	36	$result = $this->adapter->{$method}($path);
299
300	36	if ($result) {
301	18	$object = $result + compact('path');
302	18	$this->cache->updateObject($path, $object, true);
303	18	}
304
305	36	return $result;
306		}
307
308		/**
309		* Call any method for plugin features.
310		*
311		* @param array $arguments [ $path ]
312		*
313		* @return array\|false
314		*/
315		public function __call($method, $arguments)
316		{
317		if (method_exists($this->adapter, $method)) {
318		return $this->callWithFallback($method, $arguments[0]);
319		}
320
321		return false;
322		}
323		}
324

thephpleague / flysystem-cached-adapter

Pull Request — master (#16)

CachedAdapter::__call() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like