Imanghafoori\Widgets\BaseWidget

Complexity

Total Complexity

50

Size/Duplication

Total Lines	333
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	normalizeControllerMethod()	0	19	4
A	normalizePresenterName()	0	18	4
A	normalizeTemplateName()	0	15	3
A	normalizeContextAs()	0	5	1
A	normalizeCacheLifeTime()	0	6	2
A	normalizeCacheTags()	0	12	4
A	cacheShouldBeTagged()	0	4	2
A	__invoke()	0	4	1
A	renderWidget()	0	9	2
A	generateHtml()	0	19	2
A	prepareDataForView()	0	13	2
A	renderTemplate()	0	18	4
A	widgetShouldBeMinified()	0	4	2
A	minifyHtml()	0	15	1
A	addIdentifierToHtml()	0	5	1
A	cacheState()	0	7	2
A	widgetShouldUseCache()	0	12	3
A	makeCacheKey()	0	4	1
B	cacheResult()	0	16	5
A	__toString()	0	4	1
A	addDebugInfo()	0	4	1
A	addHtmlComments()	0	4	1

<?php


namespace Imanghafoori\Widgets;

abstract class BaseWidget
{
    protected $template = null;
    protected $minifyOutput = true;
    protected $cacheLifeTime = 'env_default';
    protected $contextAs = '$data';
    protected $presenter = 'default';
    protected $controller = null;
    protected $cacheTags = null;
    private $html;
    private $viewData;

    /**
     * BaseWidget constructor.
     */
    public function __construct()
    {
        $this->normalizeControllerMethod();
        $this->normalizePresenterName();
        $this->normalizeTemplateName();
        $this->normalizeContextAs();
        $this->normalizeCacheLifeTime();
        $this->normalizeCacheTags();
    }

    /**
     * Figures out which method should be called as the controller.
     * @return null
     */
    private function normalizeControllerMethod()
    {
        // If the user has explicitly declared controller class path on the sub-class
        if ($this->controller === null) {
            if (!method_exists($this, 'data')) {
                throw new \BadMethodCallException("'data' method not found on " . get_called_class());
            }
            // We decide to call data method on widget object.
            $this->controller = [$this, 'data'];
        } else {
            // If the user has specified the controller class path
            if (!class_exists($this->controller)) {
                throw new \InvalidArgumentException("Controller class: [{$this->controller}] not found.");
            }

            // we decide to call data method on that.
            $this->controller = ($this->controller) . '@data';
        }
    }

    /**
     * Figures out which method should be called as the presenter
     * @return null
     */
    private function normalizePresenterName()
    {
        if ($this->presenter === 'default') {
            $presenter = get_called_class() . 'Presenter';

            if (class_exists($presenter)) {
                $this->presenter = $presenter . '@presenter';
            } else {
                $this->presenter = null;
            }
        } else {
            if (class_exists($this->presenter) === false) {
                throw new \InvalidArgumentException("Presenter Class [{$this->presenter}] not found.");
            }
            $this->presenter = $this->presenter . '@present';
        }

    }

    /**
     * Figures out which template to render.
     * @return null
     */
    private function normalizeTemplateName()
    {
        // class name without namespace.
        $className = str_replace('App\\Widgets\\', '', get_called_class());
        // replace slashes with dots
        $className = str_replace(['\\', '/'], '.', $className);

        if ($this->template === null) {
            $this->template = 'Widgets::' . $className . 'View';
        }

        if (!view()->exists($this->template)) {

The method exists does only exist in Illuminate\Contracts\View\Factory, but not in Illuminate\View\View.

            throw new \InvalidArgumentException("View file [{$className}View] not found by: '" . get_called_class() . " '");
        }
    }

    /**
     * Figures out what the variable name should be in view file.
     * @return null
     */
    private function normalizeContextAs()
    {
        // removes the $ sign.
        $this->contextAs = str_replace('$', '', (string)$this->contextAs);
    }

    /**
     * ّFigures out how long the cache life time should be.
     * @return null
     */
    private function normalizeCacheLifeTime()
    {
        if ($this->cacheLifeTime === 'env_default') {
            $this->cacheLifeTime = (int)(env('WIDGET_DEFAULT_CACHE_LIFETIME', 0));

The property $cacheLifeTime was declared of type string, but (int) env('WIDGET_DEFAULT_CACHE_LIFETIME', 0) is of type integer. Maybe add a type cast?

        };
    }

    /**
     * ّFigures out what the cache tags should be.
     * @return null
     */
    private function normalizeCacheTags()
    {
        if ($this->cacheShouldBeTagged()) {
            if (is_string($this->cacheTags)) {
                $this->cacheTags = [$this->cacheTags];
            }

            if (!is_array($this->cacheTags)) {
                throw new \InvalidArgumentException('Cache Tags should be of type String or Array.');
            }
        }
    }

    /**
     * Determine whether cache tags should be applied or not
     * @return bool
     */
    private function cacheShouldBeTagged()
    {
        return !in_array(env('CACHE_DRIVER', 'file'), ['file', 'database']) and $this->cacheTags;

Using logical operators such as and instead of && is generally not recommended.

    }

    /**
     * This method is called when you try to invoke the object like a function in blade files.
     * like this : {!! $myWidgetObj('param1') !!}
     * @param array $args
     * @return string
     */
    public function __invoke(...$args)
    {
        return $this->renderWidget(...$args);
    }

    /**
     * @param array $args
     * @return string
     */
    private function renderWidget(...$args)
    {
        try {
            $html = $this->generateHtml(...$args);
        } catch (\Exception $e) {
            return app()->make(ExceptionHandler::class)->render(app('request'), $e)->send();
        }
        return $html;
    }

    /**
     * It tries to get the html from cache if possible, otherwise generates it.
     * @param array ...$args
     * @return string
     */
    private function generateHtml(...$args)
    {
        // Everything inside this function is executed only when the cache is not available.
        $expensivePhpCode = function () use ($args) {
            $this->prepareDataForView($args);

            // render the template with the resulting data.
            return $this->renderTemplate();
        };

        $key = $this->makeCacheKey($args);

        // We first try to get the output from the cache before trying to run the expensive $expensivePhpCode...
        if ($this->widgetShouldUseCache()) {
            return $this->cacheResult($key, $expensivePhpCode);
        }

        return $expensivePhpCode();
    }

    /**
     * @param $args
     * @return null
     */
    private function prepareDataForView($args)
    {
        // Here we call the data method on the widget class.
        $viewData = \App::call($this->controller, $args);

        if (($this->presenter)) {
            // We make an object and call the `present` method on it.
            // Piping the data through the presenter before sending it to view.
            $viewData = \App::call($this->presenter, [$viewData]);
        }

        $this->viewData = $viewData;
    }

    private function renderTemplate()
    {
        // Here we render the view file to raw html.
        $this->html = view($this->template, [$this->contextAs => $this->viewData])->render();

The method render does only exist in Illuminate\View\View, but not in Illuminate\Contracts\View\Factory.

        // We try to minify the html before storing it in cache to save space.
        if ($this->widgetShouldBeMinified()) {
            $this->minifyHtml();
        }

        // We add some HTML comments before and after the widget output
        // So then, we will be able to easily identify the widget in browser's developer tool.
        if (env('WIDGET_IDENTIFIER', true) and env('APP_ENV', 'production') === 'local') {

Using logical operators such as and instead of && is generally not recommended.

            $this->addIdentifierToHtml();
        }

        return $this->html;
    }

    /**
     * @return bool
     */
    private function widgetShouldBeMinified()
    {
        return env('WIDGET_MINIFICATION', false) or app()->environment('production');

Using logical operators such as or instead of || is generally not recommended.

    }

    /**
     * @return null
     */
    private function minifyHtml()
    {
        $replace = [
            '<!--(.*?)-->' => '', //remove comments
            "/<\?php/" => '<?php ',
            "/\n([\S])/" => '$1',
            "/\r/" => '', // remove carrage return
            "/\n/" => '', // remove new lines
            "/\t/" => '', // remove tab
            "/\s+/" => ' ', // remove spaces
        ];

        $this->html = preg_replace(array_keys($replace), array_values($replace), $this->html);

    }

    private function addIdentifierToHtml()
    {
        $this->addDebugInfo();
        $this->addHtmlComments();
    }

    /**
     * Generates a string of current cache configurations.
     * @return string
     */
    private function cacheState()
    {
        if ($this->widgetShouldUseCache()) {
            return " || cache: {$this->cacheLifeTime}(min)' ";
        }
        return " || cache : off";
    }

    /**
     * @return bool
     */
    private function widgetShouldUseCache()
    {
        /*
         * ================================== *
         |  The caching is turned off when:   |
         |  1- we are running tests           |
         |  2- have disabled it in .env file  |
         |  3- have set the time to 0 minutes |
         * ================================== *
        */
        return ((env('WIDGET_CACHE', false) !== false) and (!app()->environment('testing')) and ($this->cacheLifeTime !== 0));

The strict comparison !== seems to always evaluate to true as the types of $this->cacheLifeTime (string) and 0 (integer) can never be identical. Maybe you want to use a loose comparison != instead?

Using logical operators such as and instead of && is generally not recommended.

    }

    /**
     * @param $arg
     * @return string
     */
    private function makeCacheKey($arg)
    {
        return md5(json_encode($arg, JSON_FORCE_OBJECT) . $this->template . get_called_class());
    }

    private function cacheResult($key, $phpCode)
    {
        $cache = app()->make('cache');

        if ($this->cacheTags) {

The expression $this->cacheTags of type string[] is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $cache = $cache->tags($this->cacheTags);
        }

        if ($this->cacheLifeTime > 0) {
            return $cache->remember($key, $this->cacheLifeTime, $phpCode);
        }

        if ($this->cacheLifeTime == 'forever' or $this->cacheLifeTime < 0) {

Using logical operators such as or instead of || is generally not recommended.

            return $cache->rememberForever($key, $phpCode);
        }
    }

    /**
     * This method is called when you try to print the object like an string in blade files.
     * like this : {!! $myWidgetObj !!}
     */
    public function __toString()
    {
        return $this->renderWidget();
    }

    private function addDebugInfo()
    {
        $this->html = "<div title='" . get_called_class() . "::class || template : {$this->template}" . $this->cacheState() . "' style='box-shadow: 0px 0px 15px 5px #00c62b inset'>" . $this->html . "</div>";
    }

    private function addHtmlComments()
    {
        $this->html = "<!-- '{$this->friendlyName}' Widget Start -->" . $this->html . "<!-- '{$this->friendlyName}' Widget End -->";

The property friendlyName does not exist. Did you maybe forget to declare it?

    }

}