CachedBuilder::preventHashCollision() - Code Metrics - Inspection of "Fixes #85, fixes #86, fixes #87" - GeneaLabs/laravel-model-caching - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( d418fd...9098a2 )

by Mike
created 2018-02-23 04:32 UTC
CachedBuilder::preventHashCollision() A

↳ Parent: CachedBuilder
Complexity

Conditions	2
Paths	2
Size

Total Lines	23
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	23
rs	9.0856
c	0
b	0
f	0
cc	2
eloc	11
nc	2
nop	6
<?php namespace GeneaLabs\LaravelModelCaching;

use GeneaLabs\LaravelModelCaching\Traits\Cachable;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;

/**
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 */
class CachedBuilder extends EloquentBuilder
{
    use Cachable;

    public function avg($column)
    {
        if (! $this->isCachable) {
            return parent::avg($column);
            return parent::/** @scrutinizer ignore-call */ avg($column);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-avg_{$column}");
        $method = 'avg';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function count($columns = ['*'])
    {
        if (! $this->isCachable) {
            return parent::count($columns);
            return parent::/** @scrutinizer ignore-call */ count($columns);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-count");
        $method = 'count';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function cursor()
    {
        if (! $this->isCachable) {
            return collect(parent::cursor());
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-cursor");
        $method = 'cursor';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function delete()
    {
        $this->cache($this->makeCacheTags())
            ->flush();

        return parent::delete();
    }

    /**
     * @SuppressWarnings(PHPMD.ShortVariable)
     */
    public function find($id, $columns = ['*'])
    {
        if (! $this->isCachable) {
            return parent::find($id, $columns);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-find_{$id}");
        $method = 'find';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function first($columns = ['*'])
    {
        if (! $this->isCachable) {
            return parent::first($columns);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey($columns);
        $method = 'first';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function get($columns = ['*'])
    {
        if (! $this->isCachable) {
            return parent::get($columns);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey($columns);
        $method = 'get';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function max($column)
    {
        if (! $this->isCachable) {
            return parent::max($column);
            return parent::/** @scrutinizer ignore-call */ max($column);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-max_{$column}");
        $method = 'max';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function min($column)
    {
        if (! $this->isCachable) {
            return parent::min($column);
            return parent::/** @scrutinizer ignore-call */ min($column);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-min_{$column}");
        $method = 'min';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function paginate(
        $perPage = null,
        $columns = ['*'],
        $pageName = 'page',
        $page = null
    ) {
        if (! $this->isCachable) {
            return parent::paginate($perPage, $columns, $pageName, $page);
        }

        $arguments = func_get_args();
        $page = $page ?: 1;
        $cacheKey = $this->makeCacheKey($columns, null, "-paginate_by_{$perPage}_{$pageName}_{$page}");
        $method = 'paginate';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function pluck($column, $key = null)
    {
        if (! $this->isCachable) {
            return parent::pluck($column, $key);
        }

        $keyDifferentiator = "-pluck_{$column}" . ($key ? "_{$key}" : "");
        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey([$column], null, $keyDifferentiator);
        $method = 'pluck';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function sum($column)
    {
        if (! $this->isCachable) {
            return parent::sum($column);
            return parent::/** @scrutinizer ignore-call */ sum($column);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-sum_{$column}");
        $method = 'sum';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function value($column)
    {
        if (! $this->isCachable) {
            return parent::value($column);
        }

        $arguments = func_get_args();
        $cacheKey = $this->makeCacheKey(['*'], null, "-value_{$column}");
        $method = 'value';

        return $this->cachedValue($arguments, $cacheKey, $method);
    }

    public function cachedValue(array $arguments, string $cacheKey, string $method)
    {
        $cacheTags = $this->makeCacheTags();
        $hashedCacheKey = sha1($cacheKey);

        $result = $this->retrieveCachedValue(
            $arguments,
            $cacheKey,
            $cacheTags,
            $hashedCacheKey,
            $method
        );

        return $this->preventHashCollision(
            $result,
            $arguments,
            $cacheKey,
            $cacheTags,
            $hashedCacheKey,
            $method
        );
    }

    protected function preventHashCollision(
        array $result,
        array $arguments,
        string $cacheKey,
        array $cacheTags,
        string $hashedCacheKey,
        string $method
    ) {
        if ($result['key'] !== $cacheKey) {
            $this->cache()
                ->tags($cacheTags)
                ->forget($hashedCacheKey);

            $result = $this->retrieveCachedValue(
                $arguments,
                $cacheKey,
                $cacheTags,
                $hashedCacheKey,
                $method
            );
        }

        return $result['value'];
    }

    protected function retrieveCachedValue(
        array $arguments,
        string $cacheKey,
        array $cacheTags,
        string $hashedCacheKey,
        string $method
    ) {
        return $this->cache($cacheTags)
            ->rememberForever(
                $hashedCacheKey,
                function () use ($arguments, $cacheKey, $method) {
                    return [
                        'key' => $cacheKey,
                        'value' => parent::{$method}(...$arguments),
                    ];
                }
            );
    }
}

GeneaLabs / laravel-model-caching

Push — master ( d418fd...9098a2 )

CachedBuilder::preventHashCollision() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
