DynamicCSSCache::get() - Code Metrics - Inspection of "Use transient instead of option as cache" - askupasoftware/wp-dynamic-css - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#13)

by Per

created 2017-10-12 20:23 UTC

DynamicCSSCache::get() A

↳ Parent: DynamicCSSCache

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	4
nc	2
nop	1
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * @package   WordPress Dynamic CSS
 * @version   1.0.5
 * @author    Askupa Software <[email protected]>
 * @link      https://github.com/askupasoftware/wp-dynamic-css
 * @copyright 2016 Askupa Software
 */

/**
 * Dynamic CSS Cache Handler
 */
class DynamicCSSCache {
namespace YourVendor;

class YourClass { }

	/**
	 * @var DynamicCSSCache The reference to *Singleton* instance of this class
	 */
	private static $instance;

	/**
	 * @var array The reference to the cached compiled CSS that is stored in the database
	 */
	private static $cache;

	/**
	 * Returns the *Singleton* instance of this class.
	 *
	 * @return DynamicCSSCache The *Singleton* instance.
	 */
	public static function get_instance() {

		if ( null === static::$instance ) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
			static::$instance = new static();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
			self::load_cache();
		}
		return static::$instance;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
	}

	/**
	 * Returns the compiled CSS for the given handle if it exists in the cache.
	 * Returns false otherwise.
	 *
	 * @param string $handle The handle of the stylesheet
	 * @return boolean|string
	 */
	public function get( $handle ) {

		if ( array_key_exists( $handle, self::$cache ) ) {
			return self::$cache[ $handle ];
		}
		return false;
	}

	/**
	 * Update the compiled CSS for the given handle.
	 *
	 * @param string $handle The handle of the stylesheet
	 * @param string $compiled_css
	 */
	public function update( $handle, $compiled_css, $expiration ) {

		self::$cache[ $handle ] = $compiled_css;
		$this->update_option( $expiration );
	}

	/**
	 * Clear the compiled CSS from cache for the given handle.
	 *
	 * @param string $handle The handle of the stylesheet
	 */
	public function clear( $handle ) {

		unset( self::$cache[ $handle ] );
		delete_transient( 'wp-dynamic-css-cache' );
	}

	/**
	 * Load the cache value from the database or create an empty array if the
	 * cache is empty.
	 */
	private static function load_cache() {

		if ( false === ( self::$cache = get_transient( 'wp-dynamic-css-cache' ) ) ) {
			self::$cache = [];
		}
		// self::$cache = get_option('wp-dynamic-css-cache');

		//
		// if( false === self::$cache )

		// {
		//     self::$cache = array();

		// }
	}

	/**
	 * Update the database option with the local cache value.
	 */
	private function update_option( $expiration ) {

		// update_option('wp-dynamic-css-cache', self::$cache);

		set_transient( 'wp-dynamic-css-cache', self::$cache, $expiration );
	}
}


1			<?php
2			/**
3			* @package WordPress Dynamic CSS
4			* @version 1.0.5
5			* @author Askupa Software <[email protected]>
6			* @link https://github.com/askupasoftware/wp-dynamic-css
7			* @copyright 2016 Askupa Software
8			*/
9
10			/**
11			* Dynamic CSS Cache Handler
12			*/
13			class DynamicCSSCache {
			0 ignored issues – show Coding Style Compatibility introduced 2016-08-04 18:19 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
14
15			/**
16			* @var DynamicCSSCache The reference to Singleton instance of this class
17			*/
18			private static $instance;
19
20			/**
21			* @var array The reference to the cached compiled CSS that is stored in the database
22			*/
23			private static $cache;
24
25			/**
26			* Returns the Singleton instance of this class.
27			*
28			* @return DynamicCSSCache The Singleton instance.
29			*/
30			public static function get_instance() {
31
32			if ( null === static::$instance ) {
			0 ignored issues – show Bug introduced 2016-08-04 18:19 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
33			static::$instance = new static();
			0 ignored issues – show Bug introduced 2016-08-04 18:19 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
34			self::load_cache();
35			}
36			return static::$instance;
			0 ignored issues – show Bug introduced 2016-08-04 18:19 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
37			}
38
39			/**
40			* Returns the compiled CSS for the given handle if it exists in the cache.
41			* Returns false otherwise.
42			*
43			* @param string $handle The handle of the stylesheet
44			* @return boolean\|string
45			*/
46			public function get( $handle ) {
47
48			if ( array_key_exists( $handle, self::$cache ) ) {
49			return self::$cache[ $handle ];
50			}
51			return false;
52			}
53
54			/**
55			* Update the compiled CSS for the given handle.
56			*
57			* @param string $handle The handle of the stylesheet
58			* @param string $compiled_css
59			*/
60			public function update( $handle, $compiled_css, $expiration ) {
61
62			self::$cache[ $handle ] = $compiled_css;
63			$this->update_option( $expiration );
64			}
65
66			/**
67			* Clear the compiled CSS from cache for the given handle.
68			*
69			* @param string $handle The handle of the stylesheet
70			*/
71			public function clear( $handle ) {
72
73			unset( self::$cache[ $handle ] );
74			delete_transient( 'wp-dynamic-css-cache' );
75			}
76
77			/**
78			* Load the cache value from the database or create an empty array if the
79			* cache is empty.
80			*/
81			private static function load_cache() {
82
83			if ( false === ( self::$cache = get_transient( 'wp-dynamic-css-cache' ) ) ) {
84			self::$cache = [];
85			}
86			// self::$cache = get_option('wp-dynamic-css-cache');
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-10-12 20:25 UTC by Report Bug Copy Issue Report `59%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
87			//
88			// if( false === self::$cache )
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-10-12 20:25 UTC by Report Bug Copy Issue Report `54%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
89			// {
90			// self::$cache = array();
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-10-12 20:25 UTC by Report Bug Copy Issue Report `64%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
91			// }
92			}
93
94			/**
95			* Update the database option with the local cache value.
96			*/
97			private function update_option( $expiration ) {
98
99			// update_option('wp-dynamic-css-cache', self::$cache);
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-10-12 20:25 UTC by Report Bug Copy Issue Report `73%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
100			set_transient( 'wp-dynamic-css-cache', self::$cache, $expiration );
101			}
102			}
103

askupasoftware / wp-dynamic-css

GitHub Access Token became invalid

Pull Request — master (#13)

DynamicCSSCache::get() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like