ManagedCache::restored() - Code Metrics - Inspection of "Refactored to a more Fluent developer UX" - codefocus/managedcache - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 7106e3...456ee0 )

by Menno

created 2017-08-23 05:47 UTC

ManagedCache::restored() A

↳ Parent: ManagedCache

Complexity

Conditions	2
Paths	2

Size

Total Lines	13
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	9
nc	2
nop	2
dl	0
loc	13
rs	9.4285
c	0
b	0
f	0

<?php

namespace Codefocus\ManagedCache;

use BadFunctionCallException;
use Codefocus\ManagedCache\Events\Event;
use Codefocus\ManagedCache\Traits\HandlesEloquentEvents;
use Exception;
use Illuminate\Cache\MemcachedStore;
use Illuminate\Cache\Repository as CacheRepository;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Application;

/**
 * ManagedCache.
 *
 * @method DefinitionChain setForgetConditions(array $conditions)
 */
class ManagedCache
{
    use HandlesEloquentEvents;

    //  Cache keys.
    const TAG_MAP_CACHE_KEY = 'ManagedCache_TagMap';

    /**
     * @var Application
     */
    protected $application;

    /**
     * @var CacheRepository
     */
    protected $store;

    private $isDebugModeEnabled = false;

    /**
     * Maps cache keys to their tags.
     *
     * @var array
     */
    protected $tagMap = [];

    /**
     * Constructor.
     *
     * @param Application $application
     */
    public function __construct(Application $application)
    {
        //  Inject Application.
        $this->application = $application;
        //  Get the configured cache store.
        $this->store = $this->application['cache.store'];
        if ( ! ($this->store->getStore() instanceof MemcachedStore)) {
            throw new Exception('Memcached not configured. Cache store is "' . class_basename($this->store) . '"');
        }
        //  Register the event listeners.
        $this->registerEventListener($this->application['events']);
    }

    public function enableDebugMode()
    {
        $this->isDebugModeEnabled = true;

        return $this;
    }

    public function isDebugModeEnabled()
    {
        return $this->isDebugModeEnabled;
    }

    public function getTagMap(): array
    {
        if (empty($this->tagMap)) {
            $this->tagMap = $this->store->get(self::TAG_MAP_CACHE_KEY, []);
            if ( ! is_array($this->tagMap)) {
                $this->tagMap = [];
            }
        }

        return $this->tagMap;
    }

    public function getTagsForKey(string $key): array
    {
        $tagMap = $this->getTagMap();
        if ( ! isset($tagMap[$key])) {
            return [];
        }

        return $tagMap[$key];
    }

    public function setTagsForKey(string $key, array $tags): void
    {
        $this->getTagMap();
        $this->tagMap[$key] = $tags;
        $this->store->forever(self::TAG_MAP_CACHE_KEY, $this->tagMap);
    }

    public function deleteTagsForKey(string $key)
    {
        $this->getTagMap();
        if (isset($this->tagMap[$key])) {
            unset($this->tagMap[$key]);
            $this->store->forever(self::TAG_MAP_CACHE_KEY, $this->tagMap);
        }
    }

    /**
     * Returns the Cache store instance.
     *
     * @return CacheRepository
     */
    public function getStore(): CacheRepository
    {
        return $this->store;
    }

    /**
     * Returns a Condition instance that tags a cache to get invalidated when
     * a related Model of the specified class is attached.
     *
     * @param mixed $model model instance or class name
     * @param int|null $modelId (default: null) the Model id, if $model is a class name
     * @param mixed|null $relatedModel (default: null) the related Model instance or class name
     * @param int|null $relatedModelId (default: null) the related Model id
     *
     * @return Condition
     */
    public function relationAttached($model, ?int $modelId = null, $relatedModel = null, ?int $relatedModelId = null): Condition
    {
        if ($this->isModel($model)) {
            $modelClassName = get_class($model);
            $modelId = $model->getKey();
        } else {
            $modelClassName = $model;
        }
        if ($this->isModel($relatedModel)) {
            $relatedModelClassName = get_class($relatedModel);
            $relatedModelId = $relatedModel->/* @scrutinizer ignore-call */getKey();
        } else {
            $relatedModelClassName = $relatedModel;
        }

        return new Condition(
            Event::EVENT_ELOQUENT_ATTACHED,
            $modelClassName,
            $modelId,
            $relatedModelClassName,
            $relatedModelId
        );
    }

    /**
     * Returns a Condition instance that tags a cache to get invalidated when
     * a related Model of the specified class is detached.
     *
     * @param mixed $model model instance or class name
     * @param int|null $modelId (default: null) the Model id, if $model is a class name
     * @param mixed|null $relatedModel (default: null) the related Model instance or class name
     * @param int|null $relatedModelId (default: null) the related Model id
     *
     * @return Condition
     */
    public function relationDetached($model, ?int $modelId = null, $relatedModel = null, ?int $relatedModelId = null): Condition
    {
        if ($this->isModel($model)) {
            $modelClassName = get_class($model);
            $modelId = $model->getKey();
        } else {
            $modelClassName = $model;
        }
        if ($this->isModel($relatedModel)) {
            $relatedModelClassName = get_class($relatedModel);
            $relatedModelId = $relatedModel->/* @scrutinizer ignore-call */getKey();
        } else {
            $relatedModelClassName = $relatedModel;
        }

        return new Condition(
            Event::EVENT_ELOQUENT_DETACHED,
            $modelClassName,
            $modelId,
            $relatedModelClassName,
            $relatedModelId
        );
    }

    /**
     * Returns a Condition instance that tags a cache to get invalidated when
     * a related Model of the specified class is updated.
     *
     * @param mixed $model model instance or class name
     * @param int|null $modelId (default: null) the Model id, if $model is a class name
     * @param mixed|null $relatedModel (default: null) the related Model instance or class name
     * @param int|null $relatedModelId (default: null) the related Model id
     *
     * @return Condition
     */
    public function relationUpdated($model, ?int $modelId = null, $relatedModel = null, ?int $relatedModelId = null): Condition
    {
        if ($this->isModel($model)) {
            $modelClassName = get_class($model);
            $modelId = $model->getKey();
        } else {
            $modelClassName = $model;
        }
        if ($this->isModel($relatedModel)) {
            $relatedModelClassName = get_class($relatedModel);
            $relatedModelId = $relatedModel->/* @scrutinizer ignore-call */getKey();
        } else {
            $relatedModelClassName = $relatedModel;
        }

        return new Condition(
            Event::EVENT_ELOQUENT_UPDATED,
            $modelClassName,
            $modelId,
            $relatedModelClassName,
            $relatedModelId
        );
    }

    /**
     * Route function calls to a new DefinitionChain.
     *
     * @param string $name
     * @param array $arguments
     *
     * @throws BadFunctionCallException
     */
    public function __call(string $name, array $arguments)
    {
        $definitionChain = new DefinitionChain($this);
        if ( ! method_exists($definitionChain, $name)) {
            throw new BadFunctionCallException('Function ' . $name . ' does not exist.');
        }

        return call_user_func_array([$definitionChain, $name], $arguments);
    }
}


1			<?php
2
3			namespace Codefocus\ManagedCache;
4
5			use BadFunctionCallException;
6			use Codefocus\ManagedCache\Events\Event;
7			use Codefocus\ManagedCache\Traits\HandlesEloquentEvents;
8			use Exception;
9			use Illuminate\Cache\MemcachedStore;
10			use Illuminate\Cache\Repository as CacheRepository;
11			use Illuminate\Database\Eloquent\Model;
12			use Illuminate\Foundation\Application;
13
14			/**
15			* ManagedCache.
16			*
17			* @method DefinitionChain setForgetConditions(array $conditions)
18			*/
19			class ManagedCache
20			{
21			use HandlesEloquentEvents;
22
23			// Cache keys.
24			const TAG_MAP_CACHE_KEY = 'ManagedCache_TagMap';
25
26			/**
27			* @var Application
28			*/
29			protected $application;
30
31			/**
32			* @var CacheRepository
33			*/
34			protected $store;
35
36			private $isDebugModeEnabled = false;
37
38			/**
39			* Maps cache keys to their tags.
40			*
41			* @var array
42			*/
43			protected $tagMap = [];
44
45			/**
46			* Constructor.
47			*
48			* @param Application $application
49			*/
50			public function __construct(Application $application)
51			{
52			// Inject Application.
53			$this->application = $application;
54			// Get the configured cache store.
55			$this->store = $this->application['cache.store'];
56			if ( ! ($this->store->getStore() instanceof MemcachedStore)) {
57			throw new Exception('Memcached not configured. Cache store is "' . class_basename($this->store) . '"');
58			}
59			// Register the event listeners.
60			$this->registerEventListener($this->application['events']);
61			}
62
63			public function enableDebugMode()
64			{
65			$this->isDebugModeEnabled = true;
66
67			return $this;
68			}
69
70			public function isDebugModeEnabled()
71			{
72			return $this->isDebugModeEnabled;
73			}
74
75			public function getTagMap(): array
76			{
77			if (empty($this->tagMap)) {
78			$this->tagMap = $this->store->get(self::TAG_MAP_CACHE_KEY, []);
79			if ( ! is_array($this->tagMap)) {
80			$this->tagMap = [];
81			}
82			}
83
84			return $this->tagMap;
85			}
86
87			public function getTagsForKey(string $key): array
88			{
89			$tagMap = $this->getTagMap();
90			if ( ! isset($tagMap[$key])) {
91			return [];
92			}
93
94			return $tagMap[$key];
95			}
96
97			public function setTagsForKey(string $key, array $tags): void
98			{
99			$this->getTagMap();
100			$this->tagMap[$key] = $tags;
101			$this->store->forever(self::TAG_MAP_CACHE_KEY, $this->tagMap);
102			}
103
104			public function deleteTagsForKey(string $key)
105			{
106			$this->getTagMap();
107			if (isset($this->tagMap[$key])) {
108			unset($this->tagMap[$key]);
109			$this->store->forever(self::TAG_MAP_CACHE_KEY, $this->tagMap);
110			}
111			}
112
113			/**
114			* Returns the Cache store instance.
115			*
116			* @return CacheRepository
117			*/
118			public function getStore(): CacheRepository
119			{
120			return $this->store;
121			}
122
123			/**
124			* Returns a Condition instance that tags a cache to get invalidated when
125			* a related Model of the specified class is attached.
126			*
127			* @param mixed $model model instance or class name
128			* @param int\|null $modelId (default: null) the Model id, if $model is a class name
129			* @param mixed\|null $relatedModel (default: null) the related Model instance or class name
130			* @param int\|null $relatedModelId (default: null) the related Model id
131			*
132			* @return Condition
133			*/
134			public function relationAttached($model, ?int $modelId = null, $relatedModel = null, ?int $relatedModelId = null): Condition
135			{
136			if ($this->isModel($model)) {
137			$modelClassName = get_class($model);
138			$modelId = $model->getKey();
139			} else {
140			$modelClassName = $model;
141			}
142			if ($this->isModel($relatedModel)) {
143			$relatedModelClassName = get_class($relatedModel);
144			$relatedModelId = $relatedModel->/* @scrutinizer ignore-call */getKey();
145			} else {
146			$relatedModelClassName = $relatedModel;
147			}
148
149			return new Condition(
150			Event::EVENT_ELOQUENT_ATTACHED,
151			$modelClassName,
152			$modelId,
153			$relatedModelClassName,
154			$relatedModelId
155			);
156			}
157
158			/**
159			* Returns a Condition instance that tags a cache to get invalidated when
160			* a related Model of the specified class is detached.
161			*
162			* @param mixed $model model instance or class name
163			* @param int\|null $modelId (default: null) the Model id, if $model is a class name
164			* @param mixed\|null $relatedModel (default: null) the related Model instance or class name
165			* @param int\|null $relatedModelId (default: null) the related Model id
166			*
167			* @return Condition
168			*/
169			public function relationDetached($model, ?int $modelId = null, $relatedModel = null, ?int $relatedModelId = null): Condition
170			{
171			if ($this->isModel($model)) {
172			$modelClassName = get_class($model);
173			$modelId = $model->getKey();
174			} else {
175			$modelClassName = $model;
176			}
177			if ($this->isModel($relatedModel)) {
178			$relatedModelClassName = get_class($relatedModel);
179			$relatedModelId = $relatedModel->/* @scrutinizer ignore-call */getKey();
180			} else {
181			$relatedModelClassName = $relatedModel;
182			}
183
184			return new Condition(
185			Event::EVENT_ELOQUENT_DETACHED,
186			$modelClassName,
187			$modelId,
188			$relatedModelClassName,
189			$relatedModelId
190			);
191			}
192
193			/**
194			* Returns a Condition instance that tags a cache to get invalidated when
195			* a related Model of the specified class is updated.
196			*
197			* @param mixed $model model instance or class name
198			* @param int\|null $modelId (default: null) the Model id, if $model is a class name
199			* @param mixed\|null $relatedModel (default: null) the related Model instance or class name
200			* @param int\|null $relatedModelId (default: null) the related Model id
201			*
202			* @return Condition
203			*/
204			public function relationUpdated($model, ?int $modelId = null, $relatedModel = null, ?int $relatedModelId = null): Condition
205			{
206			if ($this->isModel($model)) {
207			$modelClassName = get_class($model);
208			$modelId = $model->getKey();
209			} else {
210			$modelClassName = $model;
211			}
212			if ($this->isModel($relatedModel)) {
213			$relatedModelClassName = get_class($relatedModel);
214			$relatedModelId = $relatedModel->/* @scrutinizer ignore-call */getKey();
215			} else {
216			$relatedModelClassName = $relatedModel;
217			}
218
219			return new Condition(
220			Event::EVENT_ELOQUENT_UPDATED,
221			$modelClassName,
222			$modelId,
223			$relatedModelClassName,
224			$relatedModelId
225			);
226			}
227
228			/**
229			* Route function calls to a new DefinitionChain.
230			*
231			* @param string $name
232			* @param array $arguments
233			*
234			* @throws BadFunctionCallException
235			*/
236			public function __call(string $name, array $arguments)
237			{
238			$definitionChain = new DefinitionChain($this);
239			if ( ! method_exists($definitionChain, $name)) {
240			throw new BadFunctionCallException('Function ' . $name . ' does not exist.');
241			}
242
243			return call_user_func_array([$definitionChain, $name], $arguments);
244			}
245			}
246

codefocus / managedcache

Push — master ( 7106e3...456ee0 )

ManagedCache::restored() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like