FragmentCache::content() - Code Metrics - Inspection of "Improvements." - yiisoft/yii-widgets - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#10)

by Wilmer

created 2020-10-07 23:24 UTC

FragmentCache::content() A

↳ Parent: FragmentCache

Complexity

Conditions	1
Paths	1

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	2
c	1
b	0
f	0
nc	1
nop	1
dl	0
loc	5
ccs	3
cts	3
cp	1
crap	1
rs	10

<?php

declare(strict_types=1);

namespace Yiisoft\Yii\Widgets;

use Yiisoft\Cache\CacheInterface;
use Yiisoft\Cache\Dependency\Dependency;
use Yiisoft\View\DynamicContentAwareInterface;
use Yiisoft\View\DynamicContentAwareTrait;
use Yiisoft\View\WebView;
use Yiisoft\Widget\Widget;

use function array_merge;
use function ob_get_clean;
use function ob_implicit_flush;
use function ob_start;

final class FragmentCache extends Widget implements DynamicContentAwareInterface
{
    use DynamicContentAwareTrait;

    private string $id;
    private CacheInterface $cache;
    private int $duration = 60;
    private ?Dependency $dependency = null;
    private $variations;
    private ?string $content = null;

    private WebView $webView;

    public function __construct(CacheInterface $cache, WebView $webview)
    {
        $this->cache = $cache;
        $this->webView = $webview;
    }

    /**
     * Initializes the FragmentCache object.
     */
    public function start(): void
    {
        if ($this->getCachedContent() === null) {
            $this->webView->pushDynamicContent($this);
            ob_start();
            PHP_VERSION_ID >= 80000 ? ob_implicit_flush(false) : ob_implicit_flush(0);
            PHP_VERSION_ID >= 80000 ? ob_implicit_flush(/** @scrutinizer ignore-type */ false) : ob_implicit_flush(0);
        }
    }

    /**
     * Marks the end of content to be cached.
     *
     * Content displayed before this method call and after {@see init()} will be captured and saved in cache.
     *
     * This method does nothing if valid content is already found in cache.
     *
     * @return string the result of widget execution to be outputted.
     */
    public function run(): string
    {
        if ($this->getCachedContent() !== null) {
            return $this->getCachedContent();
        }

        $this->webView->popDynamicContent();

        $content = ob_get_clean();

        if ($content === false || $content === '') {
            return '';
        }

        $data = [$content, $this->getDynamicPlaceholders()];

        $this->cache->set($this->calculateKey(), $data, $this->duration, $this->dependency);

        return $this->updateDynamicContent($content, $this->getDynamicPlaceholders());
    }

    /**
     * Returns the cached content if available.
     *
     * @return string|null the cached content. False is returned if valid content is not found in the cache.
     */
    public function getCachedContent(): ?string
    {
        $key = $this->calculateKey();

        if (!$this->cache->has($key)) {
        if (!$this->cache->has(/** @scrutinizer ignore-type */ $key)) {
            return null;
        }

        $data = $this->cache->get($key);
        $data = $this->cache->get(/** @scrutinizer ignore-type */ $key);

        [$this->content, $placeholders] = $data;

        $this->content = $this->updateDynamicContent($this->content, $placeholders, true);
        $this->content = $this->updateDynamicContent(/** @scrutinizer ignore-type */ $this->content, $placeholders, true);

        return $this->content;
    }

    /**
     * Generates a unique key used for storing the content in cache.
     *
     * The key generated depends on both {@see id} and {@see variations}.
     *
     * @return mixed a valid cache key
     */
    public function calculateKey()
    {
        return array_merge([__CLASS__, $this->id], (array) $this->variations);
    }

    /**
     * @param Dependency|null $value the dependency that the cached content depends on.
     *
     * This can be either a {@see Dependency} object or a configuration array for creating the dependency object.
     *
     * Would make the output cache depends on the last modified time of all posts. If any post has its modification time
     * changed, the cached content would be invalidated.
     *
     * @return $this
     */
    public function dependency(?Dependency $value): self
    {
        $this->dependency = $value;

        return $this;
    }

    /**
     * @param int $value number of seconds that the data can remain valid in cache.
     *
     * @return $this
     */
    public function duration(int $value): self
    {
        $this->duration = $value;

        return $this;
    }

    public function id(string $value): self
    {
        $this->id = $value;

        return $this;
    }

    /**
     * @param array|string $value list of factors that would cause the variation of the content being cached.
     *
     * Each factor is a string representing a variation (e.g. the language, a GET parameter). The following variation
     * setting will cause the content to be cached in different versions according to the current application language:
     *
     * @return $this
     */
    public function variations($value): self
    {
        $this->variations = $value;

        return $this;
    }

    protected function getView(): WebView
    {
        return $this->webView;
    }
}


yiisoft / yii-widgets

Pull Request — master (#10)

FragmentCache::content() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like