CacheableEloquent - Code Metrics - SierraTecnologia/Transmissor - Measure and Improve Code Quality continuously with Scrutinizer

CacheableEloquent A
last analyzed 2020-10-20 08:55 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	329
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	3

Importance

Changes

Metric	Value
dl	0
loc	329
rs	9.52
c	0
b	0
f	0
wmc	36
lcom	3
cbo	3

18 Methods

Rating	Name	Size	Complexity
	updated()	1	?
	created()	1	?
	deleted()	1	?
A	bootCacheableEloquent()	20	4
A	storeCacheKey()	10	3
A	getCacheKeys()	10	4
A	flushCacheKeys()	16	2
A	setCacheLifetime()	6	1
A	getCacheLifetime()	4	1
A	setCacheDriver()	6	1
A	getCacheDriver()	4	1
A	isCacheClearEnabled()	4	1
A	forgetCache()	16	3
A	fireCacheFlushEvent()	15	3
A	resetCacheConfig()	7	3
A	generateCacheKey()	37	3
A	cacheQuery()	28	5
A	newEloquentBuilder()	4	1

<?php

declare(strict_types=1);

namespace Transmissor\Cacheable;

use Closure;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;

trait CacheableEloquent
{
    /**
     * Register an updated model event with the dispatcher.
     *
     * @param \Closure|string $callback
     *
     * @return void
     */
    abstract public static function updated($callback);

    /**
     * Register a created model event with the dispatcher.
     *
     * @param \Closure|string $callback
     *
     * @return void
     */
    abstract public static function created($callback);

    /**
     * Register a deleted model event with the dispatcher.
     *
     * @param \Closure|string $callback
     *
     * @return void
     */
    abstract public static function deleted($callback);

    /**
     * Boot the cacheable eloquent trait for a model.
     *
     * @return void
     */
    public static function bootCacheableEloquent(): void
    {
        static::updated(
            function (Model $cachedModel) {
                ! $cachedModel->isCacheClearEnabled() || $cachedModel::forgetCache();
            }
        );

        static::created(
            function (Model $cachedModel) {
                ! $cachedModel->isCacheClearEnabled() || $cachedModel::forgetCache();
            }
        );

        static::deleted(
            function (Model $cachedModel) {
                ! $cachedModel->isCacheClearEnabled() || $cachedModel::forgetCache();
            }
        );
    }

    /**
     * Store the given cache key for the given model by mimicking cache tags.
     *
     * @param string $modelName
     * @param string $cacheKey
     *
     * @return void
     */
    protected static function storeCacheKey(string $modelName, string $cacheKey): void
    {
        $keysFile = storage_path('framework/cache/data/sierratecnologia.cacheable.json');
        $cacheKeys = static::getCacheKeys($keysFile);

        if (! isset($cacheKeys[$modelName]) || ! in_array($cacheKey, $cacheKeys[$modelName])) {
            $cacheKeys[$modelName][] = $cacheKey;
            file_put_contents($keysFile, json_encode($cacheKeys));
        }
    }

    /**
     * Get cache keys from the given file.
     *
     * @param string $file
     *
     * @return array
     */
    protected static function getCacheKeys($file): array
    {
        if (! file_exists($file)) {
            $dir = dirname($file);
            is_dir($dir) || mkdir($dir);
            file_put_contents($file, null);
        }

        return json_decode(file_get_contents($file), true) ?: [];
    }

    /**
     * Flush cache keys of the given model by mimicking cache tags.
     *
     * @param string $modelName
     *
     * @return array
     */
    protected static function flushCacheKeys(string $modelName): array
    {
        $flushedKeys = [];
        $keysFile = storage_path('framework/cache/data/sierratecnologia.cacheable.json');
        $cacheKeys = static::getCacheKeys($keysFile);

        if (isset($cacheKeys[$modelName])) {
            $flushedKeys = $cacheKeys[$modelName];

            unset($cacheKeys[$modelName]);

            file_put_contents($keysFile, json_encode($cacheKeys));
        }

        return $flushedKeys;
    }

    /**
     * Set the model cache lifetime.
     *
     * @param int $cacheLifetime
     *
     * @return $this
     */
    public function setCacheLifetime(int $cacheLifetime)
    {
        $this->cacheLifetime = $cacheLifetime;
class MyClass { }

$x = new MyClass();
$x->foo = true;

        return $this;
    }

    /**
     * Get the model cache lifetime.
     *
     * @return int
     */
    public function getCacheLifetime(): int
    {
        return $this->cacheLifetime ?? -1;
    }

    /**
     * Set the model cache driver.
     *
     * @param string $cacheDriver
     *
     * @return $this
     */
    public function setCacheDriver($cacheDriver)
    {
        $this->cacheDriver = $cacheDriver;
class MyClass { }

$x = new MyClass();
$x->foo = true;

        return $this;
    }

    /**
     * Get the model cache driver.
     *
     * @return string|null
     */
    public function getCacheDriver(): ?string
    {
        return $this->cacheDriver ?? null;
    }

    /**
     * Determine if model cache clear is enabled.
     *
     * @return bool
     */
    public function isCacheClearEnabled(): bool
    {
        return $this->cacheClearEnabled ?? true;
class MyClass { }

$x = new MyClass();
$x->foo = true;
    }

    /**
     * Forget the model cache.
     *
     * @return void
     */
    public static function forgetCache()
    {
        static::fireCacheFlushEvent('cache.flushing');

        // Flush cache tags
        if (method_exists(app('cache')->getStore(), 'tags')) {
            app('cache')->tags(static::class)->flush();
        } else {
            // Flush cache keys, then forget actual cache
            foreach (static::flushCacheKeys(static::class) as $cacheKey) {
                app('cache')->forget($cacheKey);
            }
        }

        static::fireCacheFlushEvent('cache.flushed', false);
    }

    /**
     * Fire the given event for the model.
     *
     * @param string $event
     * @param bool   $halt
     *
     * @return mixed
     */
    protected static function fireCacheFlushEvent($event, $halt = true)
    {
        if (! isset(static::$dispatcher)) {
            return true;
        }

        // We will append the names of the class to the event to distinguish it from
        // other model events that are fired, allowing us to listen on each model
        // event set individually instead of catching event for all the models.
        $event = "eloquent.{$event}: ".static::class;

        $method = $halt ? 'until' : 'dispatch';

        return static::$dispatcher->{$method}($event, static::class);
    }

    /**
     * Reset cached model to its defaults.
     *
     * @return $this
     */
    public function resetCacheConfig()
    {
        ! $this->cacheDriver || $this->cacheDriver = null;
        ! $this->cacheLifetime || $this->cacheLifetime = -1;

        return $this;
    }

    /**
     * Generate unique cache key.
     *
     * @param \Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $builder
     * @param array                                                                    $columns
     *
     * @return string
     */
    protected function generateCacheKey($builder, array $columns): string
    {
        $query = $builder instanceof Builder ? $builder->getQuery() : $builder;
        $vars = [
            'aggregate' => $query->aggregate,
            'columns' => $query->columns,
            'distinct' => $query->distinct,
            'from' => $query->from,
            'joins' => $query->joins,
            'wheres' => $query->wheres,
            'groups' => $query->groups,
            'havings' => $query->havings,
            'orders' => $query->orders,
            'limit' => $query->limit,
            'offset' => $query->offset,
            'unions' => $query->unions,
            'unionLimit' => $query->unionLimit,
            'unionOffset' => $query->unionOffset,
            'unionOrders' => $query->unionOrders,
            'lock' => $query->lock,
        ];

        return md5(
            json_encode(
                [
                $vars,
                $columns,
                static::class,
                $this->getCacheDriver(),
                $this->getCacheLifetime(),
                $builder instanceof Builder ? $builder->getEagerLoads() : null,
                $builder->getBindings(),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                $builder->toSql(),
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
                ]
            )
        );
    }

    /**
     * Cache given callback.
     *
     * @param \Illuminate\Database\Query\Builder|\Illuminate\Database\Eloquent\Builder $builder
     * @param array                                                                    $columns
     * @param \Closure                                                                 $closure
     *
     * @return mixed
     */
    public function cacheQuery($builder, array $columns, Closure $closure)
    {
        $modelName = $this->getMorphClass();
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}
        $lifetime = $this->getCacheLifetime();
        $cacheKey = $this->generateCacheKey($builder, $columns);

        // Switch cache driver on runtime
        if ($driver = $this->getCacheDriver()) {
            app('cache')->setDefaultDriver($driver);
        }

        // We need cache tags, check if default driver supports it
        if (method_exists(app('cache')->getStore(), 'tags')) {
            $result = $lifetime === -1 ? app('cache')->tags($modelName)->rememberForever($cacheKey, $closure) : app('cache')->tags($modelName)->remember($cacheKey, $lifetime, $closure);

            return $result;
        }

        $result = $lifetime === -1 ? app('cache')->rememberForever($cacheKey, $closure) : app('cache')->remember($cacheKey, $lifetime, $closure);

        // Default cache driver doesn't support tags, let's do it manually
        static::storeCacheKey($modelName, $cacheKey);

        // We're done, let's clean up!
        $this->resetCacheConfig();

        return $result;
    }

    /**
     * Create a new Eloquent query builder for the model.
     *
     * @param \Illuminate\Database\Query\Builder $query
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function newEloquentBuilder($query)
    {
        return new EloquentBuilder($query);
    }
}

CacheableEloquent A
last analyzed 2020-10-20 08:55 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

Available Fixes

Available Fixes

1			<?php
2
3			declare(strict_types=1);
4
5			namespace Transmissor\Cacheable;
6
7			use Closure;
8			use Illuminate\Database\Eloquent\Model;
9			use Illuminate\Database\Eloquent\Builder;
10
11			trait CacheableEloquent
12			{
13			/**
14			* Register an updated model event with the dispatcher.
15			*
16			* @param \Closure\|string $callback
17			*
18			* @return void
19			*/
20			abstract public static function updated($callback);
21
22			/**
23			* Register a created model event with the dispatcher.
24			*
25			* @param \Closure\|string $callback
26			*
27			* @return void
28			*/
29			abstract public static function created($callback);
30
31			/**
32			* Register a deleted model event with the dispatcher.
33			*
34			* @param \Closure\|string $callback
35			*
36			* @return void
37			*/
38			abstract public static function deleted($callback);
39
40			/**
41			* Boot the cacheable eloquent trait for a model.
42			*
43			* @return void
44			*/
45			public static function bootCacheableEloquent(): void
46			{
47			static::updated(
48			function (Model $cachedModel) {
49			! $cachedModel->isCacheClearEnabled() \|\| $cachedModel::forgetCache();
50			}
51			);
52
53			static::created(
54			function (Model $cachedModel) {
55			! $cachedModel->isCacheClearEnabled() \|\| $cachedModel::forgetCache();
56			}
57			);
58
59			static::deleted(
60			function (Model $cachedModel) {
61			! $cachedModel->isCacheClearEnabled() \|\| $cachedModel::forgetCache();
62			}
63			);
64			}
65
66			/**
67			* Store the given cache key for the given model by mimicking cache tags.
68			*
69			* @param string $modelName
70			* @param string $cacheKey
71			*
72			* @return void
73			*/
74			protected static function storeCacheKey(string $modelName, string $cacheKey): void
75			{
76			$keysFile = storage_path('framework/cache/data/sierratecnologia.cacheable.json');
77			$cacheKeys = static::getCacheKeys($keysFile);
78
79			if (! isset($cacheKeys[$modelName]) \|\| ! in_array($cacheKey, $cacheKeys[$modelName])) {
80			$cacheKeys[$modelName][] = $cacheKey;
81			file_put_contents($keysFile, json_encode($cacheKeys));
82			}
83			}
84
85			/**
86			* Get cache keys from the given file.
87			*
88			* @param string $file
89			*
90			* @return array
91			*/
92			protected static function getCacheKeys($file): array
93			{
94			if (! file_exists($file)) {
95			$dir = dirname($file);
96			is_dir($dir) \|\| mkdir($dir);
97			file_put_contents($file, null);
98			}
99
100			return json_decode(file_get_contents($file), true) ?: [];
101			}
102
103			/**
104			* Flush cache keys of the given model by mimicking cache tags.
105			*
106			* @param string $modelName
107			*
108			* @return array
109			*/
110			protected static function flushCacheKeys(string $modelName): array
111			{
112			$flushedKeys = [];
113			$keysFile = storage_path('framework/cache/data/sierratecnologia.cacheable.json');
114			$cacheKeys = static::getCacheKeys($keysFile);
115
116			if (isset($cacheKeys[$modelName])) {
117			$flushedKeys = $cacheKeys[$modelName];
118
119			unset($cacheKeys[$modelName]);
120
121			file_put_contents($keysFile, json_encode($cacheKeys));
122			}
123
124			return $flushedKeys;
125			}
126
127			/**
128			* Set the model cache lifetime.
129			*
130			* @param int $cacheLifetime
131			*
132			* @return $this
133			*/
134			public function setCacheLifetime(int $cacheLifetime)
135			{
136			$this->cacheLifetime = $cacheLifetime;
			0 ignored issues – show Bug introduced 2020-09-09 11:04 UTC by Report Bug Copy Issue Report The property `cacheLifetime` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
137
138			return $this;
139			}
140
141			/**
142			* Get the model cache lifetime.
143			*
144			* @return int
145			*/
146			public function getCacheLifetime(): int
147			{
148			return $this->cacheLifetime ?? -1;
149			}
150
151			/**
152			* Set the model cache driver.
153			*
154			* @param string $cacheDriver
155			*
156			* @return $this
157			*/
158			public function setCacheDriver($cacheDriver)
159			{
160			$this->cacheDriver = $cacheDriver;
			0 ignored issues – show Bug introduced 2020-09-09 11:04 UTC by Report Bug Copy Issue Report The property `cacheDriver` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
161
162			return $this;
163			}
164
165			/**
166			* Get the model cache driver.
167			*
168			* @return string\|null
169			*/
170			public function getCacheDriver(): ?string
171			{
172			return $this->cacheDriver ?? null;
173			}
174
175			/**
176			* Determine if model cache clear is enabled.
177			*
178			* @return bool
179			*/
180			public function isCacheClearEnabled(): bool
181			{
182			return $this->cacheClearEnabled ?? true;
			0 ignored issues – show Bug introduced 2020-09-09 11:04 UTC by Report Bug Copy Issue Report The property `cacheClearEnabled` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
183			}
184
185			/**
186			* Forget the model cache.
187			*
188			* @return void
189			*/
190			public static function forgetCache()
191			{
192			static::fireCacheFlushEvent('cache.flushing');
193
194			// Flush cache tags
195			if (method_exists(app('cache')->getStore(), 'tags')) {
196			app('cache')->tags(static::class)->flush();
197			} else {
198			// Flush cache keys, then forget actual cache
199			foreach (static::flushCacheKeys(static::class) as $cacheKey) {
200			app('cache')->forget($cacheKey);
201			}
202			}
203
204			static::fireCacheFlushEvent('cache.flushed', false);
205			}
206
207			/**
208			* Fire the given event for the model.
209			*
210			* @param string $event
211			* @param bool $halt
212			*
213			* @return mixed
214			*/
215			protected static function fireCacheFlushEvent($event, $halt = true)
216			{
217			if (! isset(static::$dispatcher)) {
218			return true;
219			}
220
221			// We will append the names of the class to the event to distinguish it from
222			// other model events that are fired, allowing us to listen on each model
223			// event set individually instead of catching event for all the models.
224			$event = "eloquent.{$event}: ".static::class;
225
226			$method = $halt ? 'until' : 'dispatch';
227
228			return static::$dispatcher->{$method}($event, static::class);
229			}
230
231			/**
232			* Reset cached model to its defaults.
233			*
234			* @return $this
235			*/
236			public function resetCacheConfig()
237			{
238			! $this->cacheDriver \|\| $this->cacheDriver = null;
239			! $this->cacheLifetime \|\| $this->cacheLifetime = -1;
240
241			return $this;
242			}
243
244			/**
245			* Generate unique cache key.
246			*
247			* @param \Illuminate\Database\Query\Builder\|\Illuminate\Database\Eloquent\Builder $builder
248			* @param array $columns
249			*
250			* @return string
251			*/
252			protected function generateCacheKey($builder, array $columns): string
253			{
254			$query = $builder instanceof Builder ? $builder->getQuery() : $builder;
255			$vars = [
256			'aggregate' => $query->aggregate,
257			'columns' => $query->columns,
258			'distinct' => $query->distinct,
259			'from' => $query->from,
260			'joins' => $query->joins,
261			'wheres' => $query->wheres,
262			'groups' => $query->groups,
263			'havings' => $query->havings,
264			'orders' => $query->orders,
265			'limit' => $query->limit,
266			'offset' => $query->offset,
267			'unions' => $query->unions,
268			'unionLimit' => $query->unionLimit,
269			'unionOffset' => $query->unionOffset,
270			'unionOrders' => $query->unionOrders,
271			'lock' => $query->lock,
272			];
273
274			return md5(
275			json_encode(
276			[
277			$vars,
278			$columns,
279			static::class,
280			$this->getCacheDriver(),
281			$this->getCacheLifetime(),
282			$builder instanceof Builder ? $builder->getEagerLoads() : null,
283			$builder->getBindings(),
			0 ignored issues – show Bug introduced 2020-09-09 11:04 UTC by Report Bug Copy Issue Report The method `getBindings` does only exist in `Illuminate\Database\Query\Builder`, but not in `Illuminate\Database\Eloquent\Builder`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
284			$builder->toSql(),
			0 ignored issues – show Bug introduced 2020-09-09 11:04 UTC by Report Bug Copy Issue Report The method `toSql` does only exist in `Illuminate\Database\Query\Builder`, but not in `Illuminate\Database\Eloquent\Builder`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
285			]
286			)
287			);
288			}
289
290			/**
291			* Cache given callback.
292			*
293			* @param \Illuminate\Database\Query\Builder\|\Illuminate\Database\Eloquent\Builder $builder
294			* @param array $columns
295			* @param \Closure $closure
296			*
297			* @return mixed
298			*/
299			public function cacheQuery($builder, array $columns, Closure $closure)
300			{
301			$modelName = $this->getMorphClass();
			0 ignored issues – show Bug introduced 2020-09-09 11:04 UTC by Report Bug Copy Issue Report It seems like `getMorphClass()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
302			$lifetime = $this->getCacheLifetime();
303			$cacheKey = $this->generateCacheKey($builder, $columns);
304
305			// Switch cache driver on runtime
306			if ($driver = $this->getCacheDriver()) {
307			app('cache')->setDefaultDriver($driver);
308			}
309
310			// We need cache tags, check if default driver supports it
311			if (method_exists(app('cache')->getStore(), 'tags')) {
312			$result = $lifetime === -1 ? app('cache')->tags($modelName)->rememberForever($cacheKey, $closure) : app('cache')->tags($modelName)->remember($cacheKey, $lifetime, $closure);
313
314			return $result;
315			}
316
317			$result = $lifetime === -1 ? app('cache')->rememberForever($cacheKey, $closure) : app('cache')->remember($cacheKey, $lifetime, $closure);
318
319			// Default cache driver doesn't support tags, let's do it manually
320			static::storeCacheKey($modelName, $cacheKey);
321
322			// We're done, let's clean up!
323			$this->resetCacheConfig();
324
325			return $result;
326			}
327
328			/**
329			* Create a new Eloquent query builder for the model.
330			*
331			* @param \Illuminate\Database\Query\Builder $query
332			*
333			* @return \Illuminate\Database\Eloquent\Builder\|static
334			*/
335			public function newEloquentBuilder($query)
336			{
337			return new EloquentBuilder($query);
338			}
339			}

SierraTecnologia / Transmissor

CacheableEloquent A last analyzed 2020-10-20 08:55 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

18 Methods

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

CacheableEloquent A
last analyzed 2020-10-20 08:55 UTC