DevGroup\TagDependencyHelper\TagDependencyTrait

Complexity

Total Complexity

33

Size/Duplication

Total Lines	195
Duplicated Lines	3.59 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

93.33%

Importance

Changes	6
Bugs	1	Features	4

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getTagDependencyCacheComponent()	0	4	1
A	commonTag()	0	5	1
B	objectTag()	0	19	5
C	objectCompositeTag()	7	34	7
A	cacheCompositeTagFields()	0	4	1
C	loadModel()	0	57	14
A	invalidateTags()	0	20	4

<?php

namespace DevGroup\TagDependencyHelper;

use Yii;
use yii\caching\TagDependency;
use yii\db\ActiveRecord;

/**
 * TagDependencyTrait features:
 * - retrieving common and object tags
 * - configuring cache component(through overriding getTagDependencyCacheComponent)
 * - configuring composite tags(through overriding cacheCompositeTagFields)
 * - Identity Map pattern support
 */
trait TagDependencyTrait
{
    /** @var array IdentityMap pattern support */
    public static $identityMap = [];

    /**
     * @return \yii\caching\Cache
     */
    public function getTagDependencyCacheComponent()
    {
        return Yii::$app->cache;
    }

    /**
     * Returns common tag name for model instance
     * @return string tag name
     */
    public static function commonTag()
    {
        /** @var \yii\db\ActiveRecord $this */
        return NamingHelper::getCommonTag(static::className());
    }

    /**
     * Returns object tag name including it's id
     * @return string tag name
     */
    public function objectTag()
    {
        /** @var \yii\db\ActiveRecord $this */
        $primary_key;

The variable $primary_key seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

        if (count($this->primaryKey()) == 1)
        {
            $key = $this->primaryKey()[0];
            $primary_key = isset($oldfields[$key]) ? $oldfields[$key] : $this->$key;

The variable $oldfields seems to never exist, and therefore isset should always return false. Did you maybe rename this variable?

        }
        else
        {
            $primary_key = [];
            foreach ($this->primaryKey() as $key)
            {
                $primary_key[$key] = isset($oldfields[$key]) ? $oldfields[$key] : $this->$key;
            }
        }
        return NamingHelper::getObjectTag($this->className(), $primary_key);
    }

    /**
     * Returns composite tags name including fields
     * @return array tag names
     */
    public function objectCompositeTag()
    {
        /** @var \yii\db\ActiveRecord|TagDependencyTrait $this */
        $cacheFields = $this->cacheCompositeTagFields();

        if(empty($cacheFields)) {
            return [];
        }

        $tags = [];

        foreach ($cacheFields as $tagFields) {
            $tag = [];
            $changed = false;

            foreach ($tagFields as $tagField) {

This code seems to be duplicated across your project.

                $tag[$tagField] = $this->$tagField;
                $changed |= isset($oldfields[$tagField]);
            }

            $tags[] = NamingHelper::getCompositeTag($this->className(), $tag);

            if ($changed)
            {
                $tag = [];
                foreach ($tagFields as $tagField) {

This code seems to be duplicated across your project.

                    $tag[$tagField] = isset($oldfields[$tagField]) ? $oldfields[$tagField] : $this->$tagField;
                }
                $tags[] = NamingHelper::getCompositeTag($this->className(), $tag);

It seems like className() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            }
        }

        return $tags;
    }

    /**
     * Specific fields from model for build composite tags for invalidate
     * Example:
     * return [
     *  ['field1', 'field2'],
     *  ['field1', 'field2', 'field3'],
     * ];
     * @return array
     */
    protected function cacheCompositeTagFields()
    {
        return [];
    }

    /**
     * Finds or creates new model using or not using cache(objectTag is applied)
     * @param string|int $id ID of model to find
     * @param bool $createIfEmptyId Create new model instance(record) if id is empty
     * @param bool $useCache Use cache
     * @param int $cacheLifetime Cache lifetime in seconds
     * @param bool|\Exception $throwException False or exception instance to throw if model not found or (empty id AND createIfEmptyId==false)

This line exceeds maximum limit of 120 characters; contains 142 characters

     * @param bool $useIdentityMap True if we want to use identity map
     * @return \yii\db\ActiveRecord|null|self|TagDependencyTrait
     * @throws \Exception
     */
    public static function loadModel(
        $id,
        $createIfEmptyId = false,
        $useCache = true,
        $cacheLifetime = 86400,
        $throwException = false,
        $useIdentityMap = false
    ) {
        /** @var \yii\db\ActiveRecord|TagDependencyTrait $model */
        $model = null;
        if (empty($id)) {
            if ($createIfEmptyId === true) {
                $model = new static;
            } else {
                if ($throwException !== false) {
                    throw $throwException;
                } else {
                    return null;
                }
            }
        } elseif ($useIdentityMap === true) {
            if (isset(static::$identityMap[$id])) {
                return static::$identityMap[$id];
            }
        }

        if ($useCache === true && $model===null) {
            $model = Yii::$app->cache->get(static::className() . ":" . $id);
        }
        if (!is_object($model)) {
            $model = static::findOne($id);

            if ($model !== null) {
                if ($useIdentityMap === true) {
                    static::$identityMap[$model->id] = &$model;
                }
                if ($useCache === true) {
                    Yii::$app->cache->set(
                        static::className() . ":" . $id,
                        $model,
                        $cacheLifetime,
                        new TagDependency([
                            'tags' => $model->objectTag(),
                        ])
                    );
                }
            }
        }
        if (!is_object($model)) {
            if ($throwException) {
                throw $throwException;
            } else {
                return null;
            }
        }
        return $model;
    }

    /**
     * Invalidate model tags.
     * @return bool
     */
    public function invalidateTags($event)
    {
        /** @var TagDependencyTrait $this */
        \yii\caching\TagDependency::invalidate(
            $this->getTagDependencyCacheComponent(),
            [
                static::commonTag(),
                $this->objectTag($event->name == ActiveRecord::EVENT_AFTER_UPDATE ? $event->changedAttributes : [])

The call to TagDependencyTrait::objectTag() has too many arguments starting with $event->name == \yii\db\ActiveRecord::EVENT_AFTER_UPDATE ? $event->changedAttributes : array().

            ]
        );

        if (!empty($this->cacheCompositeTagFields())) {
            \yii\caching\TagDependency::invalidate(
                $this->getTagDependencyCacheComponent(),
                $this->objectCompositeTag($event->name == ActiveRecord::EVENT_AFTER_UPDATE ? $event->changedAttributes : [])

The call to TagDependencyTrait::objectCompositeTag() has too many arguments starting with $event->name == \yii\db\ActiveRecord::EVENT_AFTER_UPDATE ? $event->changedAttributes : array().

This line exceeds maximum limit of 120 characters; contains 124 characters

            );
        }

        return true;
    }

}