CachedModel

Complexity

Total Complexity

14

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

91.67%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	21	4
A	existsInCache()	0	10	2
A	getFromCache()	0	8	2
A	storeInCache()	0	10	2
A	refresh()	0	6	1
A	getFromDatabase()	0	9	2
A	create()	0	7	1

<?php
/**
 * This file allows models to be cached to prevent unnecessary queries to the database
 *
 * @package    BZiON\Models
 * @license    https://github.com/allejo/bzion/blob/master/LICENSE.md GNU General Public License Version 3
 */

/**
 * A database object with the ability to be cached in the memory
 * @package    BZiON\Models
 */
abstract class CachedModel extends BaseModel
{
    /**
     * {@inheritdoc}
     *
     * @return static
     */
    public static function get($id)
    {
        if (is_object($id)) {
            return parent::get($id);
        }

        $cache = Service::getModelCache();
        $id = (int) $id;

        if (!$cache) {
            // There is no cache, just get the model
            return parent::get($id);
        }

        if ($model = self::getFromCache($id)) {
            // The model exists in the cache, return that to the caller
            return $model;
        } else {
            return parent::get($id)->storeInCache();
        }
    }

    /**
     * Find out whether a model exists in the cache
     *
     * @param  int  $id The ID of the model
     * @return bool     True if the model exists in the cache
     */
    private static function existsInCache($id)
    {
        $cache = Service::getModelCache();

        if (!$cache) {
            return false;
        }

        return $cache->has(get_called_class(), $id);
    }

    /**
     * Get a model from the cache
     *
     * @param  int         $id The ID of the model
     * @return static|null     The model if it's found, null if it doesn't exist
     */
    private static function getFromCache($id)
    {
        if (!self::existsInCache($id)) {
            return null;
        }

        return Service::getModelCache()->get(get_called_class(), $id);
    }

    /**
     * Store the model in the cache
     *
     * @return self
     */
    protected function storeInCache()
    {
        if (!Service::getModelCache()) {
            return $this;
        }

        Service::getModelCache()->save($this);

$this of type object<CachedModel> is not a sub-type of object<Model>. It seems like you assume a child class of the class CachedModel to be always present.

        return $this;
    }

    /**
     * Fetch a model's data from the database again
     * @return static The new model
     */
    public function refresh()
    {
        $this->getFromDatabase();

        return $this;
    }

    /**
     * Get a model's data from the database
     */
    private function getFromDatabase()
    {
        self::__construct($this->id);

        if ($this->loaded) {
            // Reload the lazy parameters of the model if they're loaded already
            $this->lazyLoad(true);
        }
    }

    /**
     * {@inheritdoc}
     */
    protected static function create($params, $now = null, $table = '')
    {
        $model = parent::create($params, $now, $table);
        $model->storeInCache();

        return $model;
    }
}