CachedBuilder::max() - Code Metrics - Inspection of "Optimize caching to prevent unneeded nested cachin..." - GeneaLabs/laravel-model-caching - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( fa70a6...b71a5d )

by Mike
created 2017-09-25 03:03 UTC
CachedBuilder::max() A

↳ Parent: CachedBuilder
Complexity

Conditions	2
Paths	2
Size

Total Lines	17
Code Lines	10
Duplication

Lines	17
Ratio	100 %
Importance

Changes
Metric	Value
cc	2
eloc	10
nc	2
nop	1
dl	17
loc	17
rs	9.4285
c	0
b	0
f	0
<?php namespace GeneaLabs\LaravelModelCaching;

use Closure;
use Illuminate\Cache\TaggableStore;
use Illuminate\Database\Eloquent\Builder as EloquentBuilder;
use Illuminate\Database\Eloquent\Relations\Pivot;
use Illuminate\Support\Collection;
use Illuminate\Database\Eloquent\Relations\Relation;
use Ramsey\Uuid\Uuid;

class CachedBuilder extends EloquentBuilder
{
    protected function cache(array $tags = [])
    {
        $cache = cache();

        if (is_subclass_of($cache->getStore(), TaggableStore::class)) {
            $cache = $cache->tags($tags);
        }

        return $cache;
    }

    protected function getCacheKey(array $columns = ['*'], $idColumn = null) : string
    {
        $key = $this->getModelSlug();
        $key .= $this->getIdColumn($idColumn ?: '');
        $key .= $this->getQueryColumns($columns);
        $key .= $this->getWhereClauses();
        $key .= $this->getWithModels();
        $key .= $this->getOffsetClause();
        $key .= $this->getLimitClause();

        return $key;
    }

    protected function getIdColumn(string $idColumn) : string
    {
        return $idColumn ? "_{$idColumn}" : '';
    }

    protected function getLimitClause() : string
    {
        if (! $this->query->limit) {
            return '';
        }

        return "-limit_{$this->query->limit}";
    }

    protected function getModelSlug() : string
    {
        return str_slug(get_class($this->model));
    }

    protected function getOffsetClause() : string
    {
        if (! $this->query->offset) {
            return '';
        }

        return "-offset_{$this->query->offset}";
    }

    protected function getQueryColumns(array $columns) : string
    {
        if ($columns === ['*'] || $columns === []) {
            return '';
        }

        return '_' . implode('_', $columns);
    }

    protected function getWhereClauses() : string
    {
        return collect($this->query->wheres)->reduce(function ($carry, $where) {
            $value = $where['value'] ?? implode('_', ($where['values'] ?? []));

            return "{$carry}-{$where['column']}_{$value}";
        }) ?: '';
    }

    protected function getWithModels() : string
    {
        $eagerLoads = collect($this->eagerLoad);

        if ($eagerLoads->isEmpty()) {
            return '';
        }

        return '-' . implode('-', $eagerLoads->keys()->toArray());
    }

    protected function getCacheTags() : array
    {
        return collect($this->eagerLoad)->keys()
            ->map(function ($relationName) {
                $relation = collect(explode('.', $relationName))
                    ->reduce(function ($carry, $name) {
                        if (! $carry) {
                            $carry = $this->model;
                        }

                        if ($carry instanceof Relation) {
                            $carry = $carry->getQuery()->model;

                        }

                        return $carry->{$name}();
                    });

                return str_slug(get_class($relation->getQuery()->model));
            })
            ->prepend(str_slug(get_class($this->model)))
            ->values()
            ->toArray();
    }

    protected function isCaching() : bool
    {
        return (session('genealabs-laravel-model-is-caching') !== null);
    }

    protected function setCachingFlag() : string
    {

        $cachingFlag = UUID::uuid4()->toString();
        session(['genealabs-laravel-model-is-caching' => $cachingFlag]);

        return $cachingFlag;
    }

    protected function clearCachingFlag(string $cachingFlag)
    {
        if (session('genealabs-laravel-model-is-caching') === $cachingFlag) {
            session()->forget('genealabs-laravel-model-is-caching');
        }
    }

    public function avg($column)

    {
        $tags = [str_slug(get_class($this->model))];
        $key = str_slug(get_class($this->model)) ."-avg_{$column}";

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

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($column) {
                return parent::avg($column);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function count($columns = ['*'])
    {
        $tags = [str_slug(get_class($this->model))];
        $key = str_slug(get_class($this->model)) ."-count";

        if ($this->isCaching()) {
            return parent::count($columns);
            return parent::/** @scrutinizer ignore-call */ count($columns);
        }

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($columns) {
                return parent::count($columns);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function cursor()
    {
        $tags = [str_slug(get_class($this->model))];
        $key = str_slug(get_class($this->model)) ."-cursor";

        if ($this->isCaching()) {
            return collect(parent::cursor());
        }

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () {
                return collect(parent::cursor());
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    /**
     * @SuppressWarnings(PHPMD.ShortVariable)
     */
    public function find($id, $columns = ['*'])
    {
        $tags = $this->getCacheTags();
        $key = $this->getCacheKey($columns, $id);

        if ($this->isCaching()) {
            return parent::find($id, $columns);
        }

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($id, $columns) {
                return parent::find($id, $columns);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function first($columns = ['*'])
    {
        $tags = $this->getCacheTags();
        $key = $this->getCacheKey($columns) . '-first';

        if ($this->isCaching()) {
            return parent::first($columns);
        }

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($columns) {
                return parent::first($columns);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function get($columns = ['*'])
    {
        $tags = $this->getCacheTags();
        $key = $this->getCacheKey($columns);

        if ($this->isCaching()) {
            return parent::get($columns);
        }

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($columns) {
                return parent::get($columns);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function max($column)
    {
        $tags = [str_slug(get_class($this->model))];
        $key = str_slug(get_class($this->model)) ."-max_{$column}";

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

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($column) {
                return parent::max($column);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function min($column)
    {
        $tags = [str_slug(get_class($this->model))];
        $key = str_slug(get_class($this->model)) ."-min_{$column}";

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

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($column) {
                return parent::min($column);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function pluck($column, $key = null)
    {
        $tags = $this->getCacheTags();
        $cacheKey = $this->getCacheKey([$column]) . "-pluck_{$column}";

        if ($key) {
            $cacheKey .= "_{$key}";
        }

        if ($this->isCaching()) {
            return parent::pluck($column, $key);
        }

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($cacheKey, function () use ($column, $key) {
                return parent::pluck($column, $key);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }

    public function sum($column)
    {
        $tags = [str_slug(get_class($this->model))];
        $key = str_slug(get_class($this->model)) ."-sum_{$column}";

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

        $cachingFlag = $this->setCachingFlag();
        $result = $this->cache($tags)
            ->rememberForever($key, function () use ($column) {
                return parent::sum($column);
            });
        $this->clearCachingFlag($cachingFlag);

        return $result;
    }
}

GeneaLabs / laravel-model-caching

Push — master ( fa70a6...b71a5d )

CachedBuilder::max() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
