Smarty_Template_Cached::render() - Code Metrics - Inspection of "Merge pull request #1322 from geekwright/merge_sma..." - XOOPS/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( df16df...18f15c )

by Richard

created 2023-04-02 18:36 UTC

Smarty_Template_Cached::render() A

↳ Parent: Smarty_Template_Cached

Complexity

Conditions	6
Paths	13

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	13
c	1
b	0
f	0
nc	13
nop	2
dl	0
loc	19
rs	9.2222

<?php
/**
 * Created by PhpStorm.
 * User: Uwe Tews
 * Date: 04.12.2014
 * Time: 06:08
 */

/**
 * Smarty Resource Data Object
 * Cache Data Container for Template Files
 *
 * @package    Smarty
 * @subpackage TemplateResources
 * @author     Rodney Rehm
 */
class Smarty_Template_Cached extends Smarty_Template_Resource_Base
{
    /**
     * Cache Is Valid
     *
     * @var boolean
     */
    public $valid = null;

    /**
     * CacheResource Handler
     *
     * @var Smarty_CacheResource
     */
    public $handler = null;

    /**
     * Template Cache Id (Smarty_Internal_Template::$cache_id)
     *
     * @var string
     */
    public $cache_id = null;

    /**
     * saved cache lifetime in seconds
     *
     * @var integer
     */
    public $cache_lifetime = 0;

    /**
     * Id for cache locking
     *
     * @var string
     */
    public $lock_id = null;

    /**
     * flag that cache is locked by this instance
     *
     * @var bool
     */
    public $is_locked = false;

    /**
     * Source Object
     *
     * @var Smarty_Template_Source
     */
    public $source = null;

    /**
     * Nocache hash codes of processed compiled templates
     *
     * @var array
     */
    public $hashes = array();

    /**
     * Flag if this is a cache resource
     *
     * @var bool
     */
    public $isCache = true;

    /**
     * create Cached Object container
     *
     * @param Smarty_Internal_Template $_template template object
     *
     * @throws \SmartyException
     */
    public function __construct(Smarty_Internal_Template $_template)
    {
        $this->compile_id = $_template->compile_id;
        $this->cache_id = $_template->cache_id;
        $this->source = $_template->source;
        if (!class_exists('Smarty_CacheResource', false)) {
            include SMARTY_SYSPLUGINS_DIR . 'smarty_cacheresource.php';
        }
        $this->handler = Smarty_CacheResource::load($_template->smarty);
    }

    /**
     * @param Smarty_Internal_Template $_template
     *
     * @return Smarty_Template_Cached
     */
    public static function load(Smarty_Internal_Template $_template)
    {
        $_template->cached = new Smarty_Template_Cached($_template);
        $_template->cached->handler->populate($_template->cached, $_template);
        // caching enabled ?
        if (!$_template->caching || $_template->source->handler->recompiled
        ) {
            $_template->cached->valid = false;
        }
        return $_template->cached;
    }

    /**
     * Render cache template
     *
     * @param \Smarty_Internal_Template $_template
     * @param bool                      $no_output_filter
     *
     * @throws \Exception
     */
    public function render(Smarty_Internal_Template $_template, $no_output_filter = true)
    {
        if ($this->isCached($_template)) {
            if ($_template->smarty->debugging) {
                if (!isset($_template->smarty->_debug)) {
                    $_template->smarty->_debug = new Smarty_Internal_Debug();
                }
                $_template->smarty->_debug->start_cache($_template);
            }
            if (!$this->processed) {
                $this->process($_template);
            }
            $this->getRenderedTemplateCode($_template);
            if ($_template->smarty->debugging) {
                $_template->smarty->_debug->end_cache($_template);
            }
            return;
        } else {
            $_template->smarty->ext->_updateCache->updateCache($this, $_template, $no_output_filter);
        }
    }

    /**
     * Check if cache is valid, lock cache if required
     *
     * @param \Smarty_Internal_Template $_template
     *
     * @return bool flag true if cache is valid
     */
    public function isCached(Smarty_Internal_Template $_template)
    {
        if ($this->valid !== null) {
            return $this->valid;
        }
        while (true) {
            while (true) {
                if ($this->exists === false || $_template->smarty->force_compile || $_template->smarty->force_cache) {
                    $this->valid = false;
                } else {
                    $this->valid = true;
                }
                if ($this->valid && $_template->caching === Smarty::CACHING_LIFETIME_CURRENT
                    && $_template->cache_lifetime >= 0 && time() > ($this->timestamp + $_template->cache_lifetime)
                ) {
                    // lifetime expired
                    $this->valid = false;
                }
                if ($this->valid && $_template->compile_check === Smarty::COMPILECHECK_ON
                    && $_template->source->getTimeStamp() > $this->timestamp
                ) {
                    $this->valid = false;
                }
                if ($this->valid || !$_template->smarty->cache_locking) {
                    break;
                }
                if (!$this->handler->locked($_template->smarty, $this)) {
$a = canBeFalseAndNull();

// Instead of
if ( ! $a) { }

// Better use one of the explicit versions:
if ($a !== null) { }
if ($a !== false) { }
if ($a !== null && $a !== false) { }
                    $this->handler->acquireLock($_template->smarty, $this);
                    break 2;
                }
                $this->handler->populate($this, $_template);
            }
            if ($this->valid) {
                if (!$_template->smarty->cache_locking || $this->handler->locked($_template->smarty, $this) === null) {
                    // load cache file for the following checks
                    if ($_template->smarty->debugging) {
                        $_template->smarty->_debug->start_cache($_template);
                    }
                    if ($this->handler->process($_template, $this) === false) {
                        $this->valid = false;
                    } else {
                        $this->processed = true;
                    }
                    if ($_template->smarty->debugging) {
                        $_template->smarty->_debug->end_cache($_template);
                    }
                } else {
                    $this->is_locked = true;
                    continue;
                }
            } else {
                return $this->valid;
            }
            if ($this->valid && $_template->caching === Smarty::CACHING_LIFETIME_SAVED
                && $_template->cached->cache_lifetime >= 0
                && (time() > ($_template->cached->timestamp + $_template->cached->cache_lifetime))
            ) {
                $this->valid = false;
            }
            if ($_template->smarty->cache_locking) {
                if (!$this->valid) {
                    $this->handler->acquireLock($_template->smarty, $this);
                } elseif ($this->is_locked) {
                    $this->handler->releaseLock($_template->smarty, $this);
                }
            }
            return $this->valid;
        }
        return $this->valid;
    }

    /**
     * Process cached template
     *
     * @param Smarty_Internal_Template $_template template object
     * @param bool                     $update    flag if called because cache update
     */
    public function process(Smarty_Internal_Template $_template, $update = false)
    {
        if ($this->handler->process($_template, $this, $update) === false) {
            $this->valid = false;
        }
        if ($this->valid) {
            $this->processed = true;
        } else {
            $this->processed = false;
        }
    }

    /**
     * Read cache content from handler
     *
     * @param Smarty_Internal_Template $_template template object
     *
     * @return string|false content
     */
    public function read(Smarty_Internal_Template $_template)
    {
        if (!$_template->source->handler->recompiled) {
            return $this->handler->readCachedContent($_template);
        }
        return false;
    }
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: Uwe Tews
5			* Date: 04.12.2014
6			* Time: 06:08
7			*/
8
9			/**
10			* Smarty Resource Data Object
11			* Cache Data Container for Template Files
12			*
13			* @package Smarty
14			* @subpackage TemplateResources
15			* @author Rodney Rehm
16			*/
17			class Smarty_Template_Cached extends Smarty_Template_Resource_Base
18			{
19			/**
20			* Cache Is Valid
21			*
22			* @var boolean
23			*/
24			public $valid = null;
25
26			/**
27			* CacheResource Handler
28			*
29			* @var Smarty_CacheResource
30			*/
31			public $handler = null;
32
33			/**
34			* Template Cache Id (Smarty_Internal_Template::$cache_id)
35			*
36			* @var string
37			*/
38			public $cache_id = null;
39
40			/**
41			* saved cache lifetime in seconds
42			*
43			* @var integer
44			*/
45			public $cache_lifetime = 0;
46
47			/**
48			* Id for cache locking
49			*
50			* @var string
51			*/
52			public $lock_id = null;
53
54			/**
55			* flag that cache is locked by this instance
56			*
57			* @var bool
58			*/
59			public $is_locked = false;
60
61			/**
62			* Source Object
63			*
64			* @var Smarty_Template_Source
65			*/
66			public $source = null;
67
68			/**
69			* Nocache hash codes of processed compiled templates
70			*
71			* @var array
72			*/
73			public $hashes = array();
74
75			/**
76			* Flag if this is a cache resource
77			*
78			* @var bool
79			*/
80			public $isCache = true;
81
82			/**
83			* create Cached Object container
84			*
85			* @param Smarty_Internal_Template $_template template object
86			*
87			* @throws \SmartyException
88			*/
89			public function __construct(Smarty_Internal_Template $_template)
90			{
91			$this->compile_id = $_template->compile_id;
92			$this->cache_id = $_template->cache_id;
93			$this->source = $_template->source;
94			if (!class_exists('Smarty_CacheResource', false)) {
95			include SMARTY_SYSPLUGINS_DIR . 'smarty_cacheresource.php';
96			}
97			$this->handler = Smarty_CacheResource::load($_template->smarty);
98			}
99
100			/**
101			* @param Smarty_Internal_Template $_template
102			*
103			* @return Smarty_Template_Cached
104			*/
105			public static function load(Smarty_Internal_Template $_template)
106			{
107			$_template->cached = new Smarty_Template_Cached($_template);
108			$_template->cached->handler->populate($_template->cached, $_template);
109			// caching enabled ?
110			if (!$_template->caching \|\| $_template->source->handler->recompiled
111			) {
112			$_template->cached->valid = false;
113			}
114			return $_template->cached;
115			}
116
117			/**
118			* Render cache template
119			*
120			* @param \Smarty_Internal_Template $_template
121			* @param bool $no_output_filter
122			*
123			* @throws \Exception
124			*/
125			public function render(Smarty_Internal_Template $_template, $no_output_filter = true)
126			{
127			if ($this->isCached($_template)) {
128			if ($_template->smarty->debugging) {
129			if (!isset($_template->smarty->_debug)) {
130			$_template->smarty->_debug = new Smarty_Internal_Debug();
131			}
132			$_template->smarty->_debug->start_cache($_template);
133			}
134			if (!$this->processed) {
135			$this->process($_template);
136			}
137			$this->getRenderedTemplateCode($_template);
138			if ($_template->smarty->debugging) {
139			$_template->smarty->_debug->end_cache($_template);
140			}
141			return;
142			} else {
143			$_template->smarty->ext->_updateCache->updateCache($this, $_template, $no_output_filter);
144			}
145			}
146
147			/**
148			* Check if cache is valid, lock cache if required
149			*
150			* @param \Smarty_Internal_Template $_template
151			*
152			* @return bool flag true if cache is valid
153			*/
154			public function isCached(Smarty_Internal_Template $_template)
155			{
156			if ($this->valid !== null) {
157			return $this->valid;
158			}
159			while (true) {
160			while (true) {
161			if ($this->exists === false \|\| $_template->smarty->force_compile \|\| $_template->smarty->force_cache) {
162			$this->valid = false;
163			} else {
164			$this->valid = true;
165			}
166			if ($this->valid && $_template->caching === Smarty::CACHING_LIFETIME_CURRENT
167			&& $_template->cache_lifetime >= 0 && time() > ($this->timestamp + $_template->cache_lifetime)
168			) {
169			// lifetime expired
170			$this->valid = false;
171			}
172			if ($this->valid && $_template->compile_check === Smarty::COMPILECHECK_ON
173			&& $_template->source->getTimeStamp() > $this->timestamp
174			) {
175			$this->valid = false;
176			}
177			if ($this->valid \|\| !$_template->smarty->cache_locking) {
178			break;
179			}
180			if (!$this->handler->locked($_template->smarty, $this)) {
			0 ignored issues – show Bug Best Practice introduced 2022-12-27 20:26 UTC by Report Bug Copy Issue Report The expression `$this->handler->locked($_template->smarty, $this)` of type `boolean\|null` is loosely compared to `false`; this is ambiguous if the boolean can be false. You might want to explicitly use `!== null` instead. If an expression can have both `false`, and `null` as possible values. It is generally a good practice to always use strict comparison to clearly distinguish between those two values. $a = canBeFalseAndNull(); // Instead of if ( ! $a) { } // Better use one of the explicit versions: if ($a !== null) { } if ($a !== false) { } if ($a !== null && $a !== false) { } Loading history...
181			$this->handler->acquireLock($_template->smarty, $this);
182			break 2;
183			}
184			$this->handler->populate($this, $_template);
185			}
186			if ($this->valid) {
187			if (!$_template->smarty->cache_locking \|\| $this->handler->locked($_template->smarty, $this) === null) {
188			// load cache file for the following checks
189			if ($_template->smarty->debugging) {
190			$_template->smarty->_debug->start_cache($_template);
191			}
192			if ($this->handler->process($_template, $this) === false) {
193			$this->valid = false;
194			} else {
195			$this->processed = true;
196			}
197			if ($_template->smarty->debugging) {
198			$_template->smarty->_debug->end_cache($_template);
199			}
200			} else {
201			$this->is_locked = true;
202			continue;
203			}
204			} else {
205			return $this->valid;
206			}
207			if ($this->valid && $_template->caching === Smarty::CACHING_LIFETIME_SAVED
208			&& $_template->cached->cache_lifetime >= 0
209			&& (time() > ($_template->cached->timestamp + $_template->cached->cache_lifetime))
210			) {
211			$this->valid = false;
212			}
213			if ($_template->smarty->cache_locking) {
214			if (!$this->valid) {
215			$this->handler->acquireLock($_template->smarty, $this);
216			} elseif ($this->is_locked) {
217			$this->handler->releaseLock($_template->smarty, $this);
218			}
219			}
220			return $this->valid;
221			}
222			return $this->valid;
223			}
224
225			/**
226			* Process cached template
227			*
228			* @param Smarty_Internal_Template $_template template object
229			* @param bool $update flag if called because cache update
230			*/
231			public function process(Smarty_Internal_Template $_template, $update = false)
232			{
233			if ($this->handler->process($_template, $this, $update) === false) {
234			$this->valid = false;
235			}
236			if ($this->valid) {
237			$this->processed = true;
238			} else {
239			$this->processed = false;
240			}
241			}
242
243			/**
244			* Read cache content from handler
245			*
246			* @param Smarty_Internal_Template $_template template object
247			*
248			* @return string\|false content
249			*/
250			public function read(Smarty_Internal_Template $_template)
251			{
252			if (!$_template->source->handler->recompiled) {
253			return $this->handler->readCachedContent($_template);
254			}
255			return false;
256			}
257			}
258

XOOPS / XoopsCore25

Push — master ( df16df...18f15c )

Smarty_Template_Cached::render() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like