ContentBlockHelper::renderUrl() - Code Metrics - Inspection of "new version of fxp/composer-asset-plugin" - DevGroup-ru/dotplant2 - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed
Push — filters ( 8ea8b6...7e9bcd )

unknown
created 2015-12-25 08:47 UTC
ContentBlockHelper::renderUrl() C

↳ Parent: ContentBlockHelper
Complexity

Conditions	8
Paths	8
Size

Total Lines	27
Code Lines	20
Duplication

Lines	10
Ratio	37.04 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
dl	10
loc	27
rs	5.3846
c	1
b	0
f	0
cc	8
eloc	20
nc	8
nop	1
<?php
namespace app\modules\core\helpers;

use app\modules\core\models\ContentBlock;
use devgroup\TagDependencyHelper\ActiveRecordHelper;
use yii\caching\TagDependency;
use yii\helpers\ArrayHelper;
use yii\helpers\Url;
use yii;
use app;

/**
 * Class ContentBlockHelper
 * Main public static method compileContentString() uses submethods to extract chunk calls from model content field,
 * fetch chunks from data base table, then compile it and replace chunk calls with compiled chunks data
 * Example chunk call in model content field should be like: [[$chunk param='value'|'default value' param2=42]].
 * Chunk declaration should be like : <p>String: [[+param]]</p> <p>Float: [[+param2:format, param1, param2]]</p>
 * All supported formats you can find at Yii::$app->formatter
 *
 * @package app\modules\core\helpers
 */
class ContentBlockHelper
{
    private static $chunksByKey = [];

    /**
     * Compiles content string by injecting chunks into content
     * Preloads chunks which have preload = 1
     *
     * @param  string $content Original content with chunk calls
     * @param  string $content_key Key for caching compiled content version
     * @param  yii\caching\Dependency $dependency Cache dependency
     * @return string Compiled content with injected chunks
     */
    public static function compileContentString($content, $content_key, $dependency)
    {
        self::preloadChunks();
        $output = self::processData($content, $content_key, $dependency);
        $output = self::processData($output, $content_key, $dependency, '', false);
        return $output;
    }

    /**
     * Finding chunk calls with regexp
     * Iterate matches
     * While iterating:
     * Extracts single chunk data with sanitizeChunk() method
     * Fetches chunk by key using fetchChunkByKey(), who returns chunk value by key from static array if exists, otherwise from db

     * Compiles single chunk using compileChunk() method
     * Replaces single chunk call with compiled chunk data in the model content
     *
     * @param  string $content_key Key for caching compiled content version
     * @param  yii\caching\Dependency $dependency Cache dependency
     * @param  bool $preprocess flag to separate rendering non cacheable chunks such as Form
     * @param  string $content
     * @param  string $chunk_key ContentBlock key string to prevent endless recursion
     * @return string
     */
    private static function processData($content, $content_key, $dependency, $chunk_key = '', $preprocess = true)
    {
        $matches = [];
        $replacement = '';
        preg_match_all('%\[\[([^\]\[]+)\]\]%ui', $content, $matches);
        if (!empty($matches[0])) {
            foreach ($matches[0] as $k => $rawChunk) {
                $chunkData = self::sanitizeChunk($rawChunk);
                if ($chunkData['key'] == $chunk_key) {
                    $content = str_replace($matches[0][$k], '', $content);
                    continue;
                }
                $cacheKey = $content_key . $chunkData['key'] . serialize($chunkData);
                switch ($chunkData['token']) {
                    case '$':
                        if ($preprocess === false) break;
                        $chunk = self::fetchChunkByKey($chunkData['key']);
                        $replacement = Yii::$app->cache->get($cacheKey);
                        if ($replacement === false) {
                            $replacement = static::compileChunk($chunk, $chunkData, $chunkData['key'], $content_key, $dependency);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
                            Yii::$app->cache->set(
                                $content_key,
                                $replacement,
                                84600,
                                $dependency
                            );
                        }
                        break;
                    case '%':
                        if ($preprocess === true) {
                            $replacement = $rawChunk;
                            break;
                        }
                        $replacement = static::replaceForms($chunkData);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
                        break;
                    case '~' :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                        if ($preprocess === false) break;
                        $replacement = Yii::$app->cache->get($cacheKey);
                        if ($replacement === false) {
                            $replacement = static::renderUrl($chunkData);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
                            Yii::$app->cache->set(
                                $content_key,
                                $replacement,
                                84600,
                                $dependency
                            );
                        }
                        break;
                }
                $content = str_replace($matches[0][$k], $replacement, $content);
            }
        }
        return $content;
    }

    /**
     * @param array $chunkData
     * @return mixed
     */
    private static function replaceForms($chunkData)
    {
        $regexp = '/^(?P<formId>\d+)(#(?P<id>[\w\d\-_]+))?(;(?P<isModal>isModal))?$/Usi';
        return preg_replace_callback(
            $regexp,
            function ($matches) {
                if (isset($matches['formId'])) {
                    $params = ['formId' => intval($matches['formId'])];
                    if (isset($matches['id'])) {
                        $params['id'] = $matches['id'];
                    }
                    if (isset($matches['isModal'])) {
                        $params['isModal'] = true;
                    }
                    return app\widgets\form\Form::widget($params);
                }
                return '';
            },
            $chunkData['key']
        );
    }

    /**
     * renders url according to given data
     * @param $chunkData
     * @return string
     */
    private static function renderUrl($chunkData)
    {
        $expression = '%(?P<objectName>[^#]+?)#(?P<objectId>[\d]+?)$%';
        $output = '';
        preg_match($expression, $chunkData['key'], $m);
        if (true === isset($m['objectName'], $m['objectId'])) {
            $id = (int)$m['objectId'];
            switch (strtolower($m['objectName'])) {
                case "page" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                    if (null !== $model = app\modules\page\models\Page::findById($id)) {
                        $output = Url::to(['@article', 'id' => $id]);
                    }
                    break;
                case "category" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                    if (null !== $model = app\modules\shop\models\Category::findById($id)) {
                        $output = Url::to(['@category', 'last_category_id' => $id]);
                    }
                    break;
                case "product" :
switch ($selector) {
    case "A": //right
        doSomething();
        break;
    case "B" : //wrong
        doSomethingElse();
        break;
}
                    if (null !== $model = app\modules\shop\models\Product::findById($id)) {
                        $output = Url::to(['@product', 'model' => $model]);
                    }
                    break;
            }
        }
        return $output;
    }

    /**
     * Extracts chunk data from chunk call
     * uses regexp to extract param data from placeholder
     * [[$chunk <paramName>='<escapedValue>'|'<escapedDefault>' <paramName>=<unescapedValue>|<unescapedDefault>]]
     * iterate matches.
     * While iterating converts escapedValue and escapedDefault into string, unescapedValue and unescapedDefault - into float

     * Returns chunk data array like:
     *  [
     *      'key' => 'chunkKey',
     *      'firstParam'=> 'string value',
     *      'firstParam-default'=> 'default string value',
     *      'secondParam'=> float value,
     *      'secondParam-default'=> default float value,
     *  ]
     *
     * @param string $rawChunk
     * @return array

     */
    private static function sanitizeChunk($rawChunk)
    {
        $chunk = [];
        preg_match('%(?P<chunkToken>[^\w\[]?)([^\s\]\[]+)[\s\]]%', $rawChunk, $keyMatches);
        $chunk['token'] = $keyMatches['chunkToken'];
        $chunk['key'] = $keyMatches[2];
        $expression = "#\s*(?P<paramName>[\\w\\d]*)=(('(?P<escapedValue>.*[^\\\\])')|(?P<unescapedValue>.*))(\\|(('(?P<escapedDefault>.*[^\\\\])')|(?P<unescapedDefault>.*)))?[\\]\\s]#uUi";

        preg_match_all($expression, $rawChunk, $matches);
        foreach ($matches['paramName'] as $key => $paramName) {
            if (!empty($matches['escapedValue'][$key])) {
                $chunk[$paramName] = strval($matches['escapedValue'][$key]);
            }
            if (!empty($matches['unescapedValue'][$key])) {
                $chunk[$paramName] = floatval($matches['unescapedValue'][$key]);
            }
            if (!empty($matches['escapedDefault'][$key])) {
                $chunk[$paramName . '-default'] = strval($matches['escapedDefault'][$key]);
            }
            if (!empty($matches['unescapedDefault'][$key])) {
                $chunk[$paramName . '-default'] = floatval($matches['unescapedDefault'][$key]);
            }
        }
        return $chunk;
    }

    /**
     * Compiles single chunk
     * uses regexp to find placeholders and extract it's data from chunk value field
     * [[<token><paramName>:<format><params>]]
     * token switch is for future functionality increase
     * now method only recognizes + token and replaces following param with according $arguments array data
     * applies formatter according previously defined param values type if needed
     * if param name from placeholder was not found in arguments array, placeholder in the compiled chunk will be replaced with empty string

     * returns compiled chunk
     *
     * @param  string $content_key Key for caching compiled content version
     * @param  yii\caching\Dependency $dependency Cache dependency
     * @param  string $chunk ContentBlock instance
     * @param  array $arguments Arguments for this chunk from original content
     * @param  string $key ContentBlock key string to prevent endless recursion
     * @return string Result string ready for replacing
     */
    private static function compileChunk($chunk, $arguments, $key, $content_key, $dependency)
    {
        $matches = [];
        preg_match_all('%\[\[(?P<token>[\+\*])(?P<paramName>[^\s\:\]]+)\:?(?P<format>[^\,\]]+)?\,?(?P<params>[^\]]+)?\]\]%ui', $chunk, $matches);

        foreach ($matches[0] as $k => $rawParam) {
            $token = $matches['token'][$k];
            $paramName = trim($matches['paramName'][$k]);
            $format = trim($matches['format'][$k]);
            $params = preg_replace('%[\s]%', '', $matches['params'][$k]);
            $params = explode(',', $params);
            switch ($token) {
                case '+':
                    if (array_key_exists($paramName, $arguments)) {
                        $replacement = static::applyFormatter($arguments[$paramName], $format, $params);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
                        $chunk = str_replace($matches[0][$k], $replacement, $chunk);
                    } else if (array_key_exists($paramName . '-default', $arguments)) {
                        $replacement = static::applyFormatter($arguments[$paramName . '-default'], $format, $params);
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
                        $chunk = str_replace($matches[0][$k], $replacement, $chunk);
                    } else {
                        $chunk = str_replace($matches[0][$k], '', $chunk);
                    }
                    break;
                default:
                    $chunk = str_replace($matches[0][$k], '', $chunk);
            }
        }
        return self::processData($chunk, $content_key, $dependency, $key);
    }

    /**
     * Find formatter declarations in chunk placeholders. if find trying to apply
     * yii\i18n\Formatter formats see yii\i18n\Formatter for details
     *
     * @param string $value single placeholder declaration from chunk
     * @param string $format
     * @param array $params
     * @return string|array
     */
    private static function applyFormatter($value, $format, $params)
    {
        if (false === method_exists(Yii::$app->formatter, $format) || empty($format)) {
            return $value;
        }
        array_unshift($params, $value);
        try {
            $formattedValue = call_user_func_array([Yii::$app->formatter, $format], $params);
        } catch (\Exception $e) {
            $formattedValue = $value;
        }
        return $formattedValue;
    }

    /**
     * Fetches single chunk by key from static var
     * if is no there - get it from db and push to static array
     *
     * @param $key string Chunk key field
     * @return string Chunk value field
     */
    private static function fetchChunkByKey($key)
    {
        if (!array_key_exists($key, static::$chunksByKey)) {
            $dependency = new TagDependency([
                'tags' => [
                    ActiveRecordHelper::getCommonTag(ContentBlock::className()),
                ]
            ]);
            static::$chunksByKey[$key] = ContentBlock::getDb()->cache(function ($db) use ($key) {

                $chunk = ContentBlock::find()
                    ->where(['key' => $key])
                    ->asArray()
                    ->one();
                return static::$chunksByKey[$key] = $chunk['value'];
            }, 86400, $dependency);
        }
        return static::$chunksByKey[$key];
    }

    /**
     * preloads chunks with option preload  = 1
     * and push it to static array
     *
     * @return array|void
     */
    private static function preloadChunks()
    {
        if (is_null(static::$chunksByKey)) {
            $dependency = new TagDependency([
                'tags' => [
                    ActiveRecordHelper::getCommonTag(ContentBlock::className()),
                ]
            ]);
            static::$chunksByKey = ContentBlock::getDb()->cache(function ($db) {

                $chunks = ContentBlock::find()
                    ->where(['preload' => 1])
                    ->asArray()
                    ->all();
                return ArrayHelper::map($chunks, 'key', 'value');
            }, 86400, $dependency);
        }
        return static::$chunksByKey;
    }

    /**
     * renders chunks in template files
     * @param string $key ContentBlock key
     * @param array $params . Array of params to be replaced while render
     * @param yii\base\Model $model . Caller model instance to use in caching

     * @return mixed

     */
    public static function getChunk($key, $params = [], yii\base\Model $model = null)
    {
        if (null === $rawChunk = self::fetchChunkByKey($key)) {
            return '';
        }
        $tags = [
            ActiveRecordHelper::getCommonTag(app\modules\core\models\ContentBlock::className()),
        ];
        $content_key = 'templateChunkRender' . $key;
        if (null !== $model) {
            $content_key .= $model->id;
            $tags[] = ActiveRecordHelper::getObjectTag(get_class($model), $model->id);
        }
        $dependency = new TagDependency(['tags' => $tags]);
        if (false === empty($params)) {
            $rawChunk = self::compileChunk($rawChunk, $params, $key, $content_key, $dependency);
        }
        return self::compileContentString($rawChunk, $content_key, $dependency);
    }
}

DevGroup-ru / dotplant2

GitHub Access Token became invalid

Push — filters ( 8ea8b6...7e9bcd )

ContentBlockHelper::renderUrl() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
