ModelCaching::newBelongsToMany() - Code Metrics - Inspection of "Allow a model to optionally specify a maximum cach..." - GeneaLabs/laravel-model-caching - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#274)

unknown

created 2019-07-23 02:58 UTC

ModelCaching::newBelongsToMany() A

↳ Parent: ModelCaching

Complexity

Conditions	3
Paths	2

Size

Total Lines	34
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	20
nc	2
nop	8
dl	0
loc	34
rs	9.6
c	0
b	0
f	0

How to fix Many Parameters

<?php namespace GeneaLabs\LaravelModelCaching\Traits;

use GeneaLabs\LaravelModelCaching\CachedBelongsToMany;
use GeneaLabs\LaravelModelCaching\CachedBuilder;
use Illuminate\Container\Container;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Support\Carbon;

trait ModelCaching
{
    public function __get($key)
    {
        if ($key === "cachePrefix") {
            return $this->cachePrefix
                ?? "";
        }

        if ($key === "cacheCooldownSeconds") {
            return $this->cacheCooldownSeconds
                ?? 0;
        }

        return parent::__get($key);
    }

    public function __set($key, $value)
    {
        if ($key === "cachePrefix") {
            $this->cachePrefix = $value;
        }

        if ($key === "cacheCooldownSeconds") {
            $this->cacheCooldownSeconds = $value;
        }

        parent::__set($key, $value);
    }

    public static function maxCacheTimeout()
    {
        return static::$maxCacheTimeout ?? 0;

    }

    public static function all($columns = ['*'])
    {
        $isCacheDisabled = Container::getInstance()
            ->make("config")
            ->get("laravel-model-caching.disabled");

        if ($isCacheDisabled) {
            return parent::all($columns);
        }

        $class = get_called_class();
        $instance = new $class;
        $tags = $instance->makeCacheTags();
        $key = $instance->makeCacheKey();

        $cache_callback = function () use ($columns) {
            return parent::all($columns);
        };

        if (static::maxCacheTimeout() > 0) {
            return $instance->cache($tags)
                ->remember(
                    $key,
                    static::maxCacheTimeout(),
                    $cache_callback
                );
        }

        return $instance->cache($tags)
            ->rememberForever($key, $cache_callback);
    }

    public static function bootCachable()
    {
        static::created(function ($instance) {
            $instance->checkCooldownAndFlushAfterPersisting($instance);
        });

        static::deleted(function ($instance) {
            $instance->checkCooldownAndFlushAfterPersisting($instance);
        });

        static::saved(function ($instance) {
            $instance->checkCooldownAndFlushAfterPersisting($instance);
        });

        // TODO: figure out how to add this listener
        // static::restored(function ($instance) {
        //     $instance->checkCooldownAndFlushAfterPersisting($instance);
        // });

        static::pivotAttached(function ($instance, $secondInstance, $relationship) {
            $instance->checkCooldownAndFlushAfterPersisting($instance, $relationship);
        });

        static::pivotDetached(function ($instance, $secondInstance, $relationship) {
            $instance->checkCooldownAndFlushAfterPersisting($instance, $relationship);
        });

        static::pivotUpdated(function ($instance, $secondInstance, $relationship) {
            $instance->checkCooldownAndFlushAfterPersisting($instance, $relationship);
        });
    }

    public static function destroy($ids)
    {
        $class = get_called_class();
        $instance = new $class;
        $instance->flushCache();

        return parent::destroy($ids);
    }

    public function newEloquentBuilder($query)
    {
        if (! $this->isCachable()) {
            $this->isCachable = false;

            return new EloquentBuilder($query);
        }

        return new CachedBuilder($query);
    }

    protected function newBelongsToMany(
        EloquentBuilder $query,
        Model $parent,
        $table,
        $foreignPivotKey,
        $relatedPivotKey,
        $parentKey,
        $relatedKey,
        $relationName = null
    ) {
        if (method_exists($query->getModel(), "isCachable")
            && $query->getModel()->isCachable()
        ) {
            return new CachedBelongsToMany(
                $query,
                $parent,
                $table,
                $foreignPivotKey,
                $relatedPivotKey,
                $parentKey,
                $relatedKey,
                $relationName
            );
        }

        return new BelongsToMany(
            $query,
            $parent,
            $table,
            $foreignPivotKey,
            $relatedPivotKey,
            $parentKey,
            $relatedKey,
            $relationName
        );
    }

    public function scopeDisableCache(EloquentBuilder $query) : EloquentBuilder
    {
        if ($this->isCachable()) {
            $query = $query->disableModelCaching();
        }

        return $query;
    }

    public function scopeWithCacheCooldownSeconds(
        EloquentBuilder $query,
        int $seconds = null
    ) : EloquentBuilder {
        if (! $seconds) {
            $seconds = $this->cacheCooldownSeconds;
        }

        $cachePrefix = $this->getCachePrefix();
        $modelClassName = get_class($this);
        $cacheKey = "{$cachePrefix}:{$modelClassName}-cooldown:seconds";

        $this->cache()
            ->rememberForever($cacheKey, function () use ($seconds) {
                return $seconds;
            });

        $cacheKey = "{$cachePrefix}:{$modelClassName}-cooldown:invalidated-at";
        $this->cache()
            ->rememberForever($cacheKey, function () {
                return (new Carbon)->now();
            });

        return $query;
    }
}


1			<?php namespace GeneaLabs\LaravelModelCaching\Traits;
2
3			use GeneaLabs\LaravelModelCaching\CachedBelongsToMany;
4			use GeneaLabs\LaravelModelCaching\CachedBuilder;
5			use Illuminate\Container\Container;
6			use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
7			use Illuminate\Database\Eloquent\Model;
8			use Illuminate\Database\Eloquent\Relations\BelongsToMany;
9			use Illuminate\Support\Carbon;
10
11			trait ModelCaching
12			{
13			public function __get($key)
14			{
15			if ($key === "cachePrefix") {
16			return $this->cachePrefix
17			?? "";
18			}
19
20			if ($key === "cacheCooldownSeconds") {
21			return $this->cacheCooldownSeconds
22			?? 0;
23			}
24
25			return parent::__get($key);
26			}
27
28			public function __set($key, $value)
29			{
30			if ($key === "cachePrefix") {
31			$this->cachePrefix = $value;
32			}
33
34			if ($key === "cacheCooldownSeconds") {
35			$this->cacheCooldownSeconds = $value;
36			}
37
38			parent::__set($key, $value);
39			}
40
41			public static function maxCacheTimeout()
42			{
43			return static::$maxCacheTimeout ?? 0;
			0 ignored issues – show Bug Best Practice introduced 2019-07-23 03:00 UTC by Report Bug Copy Issue Report The property `maxCacheTimeout` does not exist on `GeneaLabs\LaravelModelCaching\Traits\ModelCaching`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
44			}
45
46			public static function all($columns = ['*'])
47			{
48			$isCacheDisabled = Container::getInstance()
49			->make("config")
50			->get("laravel-model-caching.disabled");
51
52			if ($isCacheDisabled) {
53			return parent::all($columns);
54			}
55
56			$class = get_called_class();
57			$instance = new $class;
58			$tags = $instance->makeCacheTags();
59			$key = $instance->makeCacheKey();
60
61			$cache_callback = function () use ($columns) {
62			return parent::all($columns);
63			};
64
65			if (static::maxCacheTimeout() > 0) {
66			return $instance->cache($tags)
67			->remember(
68			$key,
69			static::maxCacheTimeout(),
70			$cache_callback
71			);
72			}
73
74			return $instance->cache($tags)
75			->rememberForever($key, $cache_callback);
76			}
77
78			public static function bootCachable()
79			{
80			static::created(function ($instance) {
81			$instance->checkCooldownAndFlushAfterPersisting($instance);
82			});
83
84			static::deleted(function ($instance) {
85			$instance->checkCooldownAndFlushAfterPersisting($instance);
86			});
87
88			static::saved(function ($instance) {
89			$instance->checkCooldownAndFlushAfterPersisting($instance);
90			});
91
92			// TODO: figure out how to add this listener
93			// static::restored(function ($instance) {
94			// $instance->checkCooldownAndFlushAfterPersisting($instance);
95			// });
96
97			static::pivotAttached(function ($instance, $secondInstance, $relationship) {
98			$instance->checkCooldownAndFlushAfterPersisting($instance, $relationship);
99			});
100
101			static::pivotDetached(function ($instance, $secondInstance, $relationship) {
102			$instance->checkCooldownAndFlushAfterPersisting($instance, $relationship);
103			});
104
105			static::pivotUpdated(function ($instance, $secondInstance, $relationship) {
106			$instance->checkCooldownAndFlushAfterPersisting($instance, $relationship);
107			});
108			}
109
110			public static function destroy($ids)
111			{
112			$class = get_called_class();
113			$instance = new $class;
114			$instance->flushCache();
115
116			return parent::destroy($ids);
117			}
118
119			public function newEloquentBuilder($query)
120			{
121			if (! $this->isCachable()) {
122			$this->isCachable = false;
123
124			return new EloquentBuilder($query);
125			}
126
127			return new CachedBuilder($query);
128			}
129
130			protected function newBelongsToMany(
131			EloquentBuilder $query,
132			Model $parent,
133			$table,
134			$foreignPivotKey,
135			$relatedPivotKey,
136			$parentKey,
137			$relatedKey,
138			$relationName = null
139			) {
140			if (method_exists($query->getModel(), "isCachable")
141			&& $query->getModel()->isCachable()
142			) {
143			return new CachedBelongsToMany(
144			$query,
145			$parent,
146			$table,
147			$foreignPivotKey,
148			$relatedPivotKey,
149			$parentKey,
150			$relatedKey,
151			$relationName
152			);
153			}
154
155			return new BelongsToMany(
156			$query,
157			$parent,
158			$table,
159			$foreignPivotKey,
160			$relatedPivotKey,
161			$parentKey,
162			$relatedKey,
163			$relationName
164			);
165			}
166
167			public function scopeDisableCache(EloquentBuilder $query) : EloquentBuilder
168			{
169			if ($this->isCachable()) {
170			$query = $query->disableModelCaching();
171			}
172
173			return $query;
174			}
175
176			public function scopeWithCacheCooldownSeconds(
177			EloquentBuilder $query,
178			int $seconds = null
179			) : EloquentBuilder {
180			if (! $seconds) {
181			$seconds = $this->cacheCooldownSeconds;
182			}
183
184			$cachePrefix = $this->getCachePrefix();
185			$modelClassName = get_class($this);
186			$cacheKey = "{$cachePrefix}:{$modelClassName}-cooldown:seconds";
187
188			$this->cache()
189			->rememberForever($cacheKey, function () use ($seconds) {
190			return $seconds;
191			});
192
193			$cacheKey = "{$cachePrefix}:{$modelClassName}-cooldown:invalidated-at";
194			$this->cache()
195			->rememberForever($cacheKey, function () {
196			return (new Carbon)->now();
197			});
198
199			return $query;
200			}
201			}
202

GeneaLabs / laravel-model-caching

Pull Request — master (#274)

ModelCaching::newBelongsToMany() A

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like