DynamicCSSCompiler

Complexity

Total Complexity

36

Size/Duplication

Total Lines	327
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	1

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	get_instance()	0	7	2
A	enqueue_styles()	0	8	3
A	enqueue_style()	0	20	3
A	ajax_callback()	0	13	3
A	register_style()	0	12	1
A	register_callback()	0	4	1
A	register_filter()	0	7	2
B	get_compiled_style()	0	27	4
A	add_meta_info()	0	8	1
A	get_ajax_callback_url()	0	9	1
A	minify_css()	0	4	1
A	callback_exists()	0	11	2
B	compile_css()	0	32	3
A	apply_filters()	0	19	4
B	strtoval()	0	15	5

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

/**
 * Dynamic CSS Compiler Utility Class
 *
 *
 * Dynamic CSS Syntax
 * ------------------
 * <pre>
 * body {color: $body_color;}
 * </pre>
 * In the above example, the variable $body_color is replaced by a value
 * retrieved by the value callback function. The function is passed the variable
 * name without the dollar sign, which can be used with get_option() or
 * get_theme_mod() etc.
 */
class DynamicCSSCompiler {

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

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

	/**
	 * @var array The list of dynamic styles paths to compile
	 */
	private $stylesheets = [];

	/**
	 * @var array The list of registered callbacks
	 */
	private $callbacks = [];

	/**
	 * @var aray The list of registered filters
	 */
	private $filters = [];

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

		if ( null === static::$instance ) {

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.

			static::$instance = new static();

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.

		}
		return static::$instance;

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.

	}

	/**
	 * Enqueue all registered stylesheets.
	 */
	public function enqueue_styles() {

		foreach ( $this->stylesheets as $stylesheet ) {
			if ( $this->callback_exists( $stylesheet['handle'] ) ) {
				$this->enqueue_style( $stylesheet );
			}
		}
	}

	/**
	 * Enqueue a single registered stylesheet.
	 *
	 * @param array $stylesheet
	 */
	public function enqueue_style( $stylesheet ) {

		$handle = 'wp-dynamic-css-' . $stylesheet['handle'];
		$print  = $stylesheet['print'];

		wp_register_style(
			$handle,
			// Don't pass a URL if this style is to be printed
			$print ? false : $this->get_ajax_callback_url( $stylesheet['handle'] ),
			$stylesheet['deps']
		);

		wp_enqueue_style( $handle, $stylesheet['handle'], $stylesheet['deps'] );

		// Add inline styles for styles that are set to be printed
		if ( $print ) {
			// Inline styles only work if the handle has already been registered and enqueued
			wp_add_inline_style( $handle, $this->get_compiled_style( $stylesheet ), $stylesheet['deps'] );
		}
	}

	/**
	 * This is the AJAX callback used for loading styles externally via an http
	 * request.
	 */
	public function ajax_callback() {

		header( 'Content-type: text/css; charset: UTF-8' );
		$handle = filter_input( INPUT_GET, 'handle' );

		foreach ( $this->stylesheets as $stylesheet ) {
			if ( $handle === $stylesheet['handle'] ) {
				echo $this->get_compiled_style( $stylesheet );
			}
		}

		wp_die();
	}

	/**
	 * Add a style path to the pool of styles to be compiled
	 *
	 * @param string $handle The stylesheet's name/id
	 * @param string $path The absolute path to the dynamic style
	 * @param boolean $print Whether to print the compiled CSS to the document
	 * head, or include it as an external CSS file
	 * @param boolean $minify Whether to minify the CSS output
	 * @param boolean $cache Whether to store the compiled version of this
	 * stylesheet in cache to avoid compilation on every page load.
	 */
	public function register_style( $handle, $path, $deps, $print, $minify, $cache, $expiration ) {

		$this->stylesheets[] = [
			'handle'     => $handle,
			'path'       => $path,
			'deps'       => $deps,
			'print'      => $print,
			'minify'     => $minify,
			'cache'      => $cache,
			'cache_time' => $expiration,
		];
	}

	/**
	 * Register a value retrieval function and associate it with the given handle
	 *
	 * @param string $handle The stylesheet's name/id
	 * @param callable $callback
	 */
	public function register_callback( $handle, $callback ) {

		$this->callbacks[ $handle ] = $callback;
	}

	/**
	 * Register a filter function for a given stylesheet handle.
	 */
	public function register_filter( $handle, $filter_name, $callback ) {

		if ( ! array_key_exists( $handle, $this->filters ) ) {
			$this->filters[ $handle ] = [];
		}
		$this->filters[ $handle ][ $filter_name ] = $callback;
	}

	/**
	 * Get the compiled CSS for the given style. Skips compilation if the compiled
	 * version can be found in cache.
	 *
	 * @param array $style List of styles with the same structure as they are
	 * stored in $this->stylesheets
	 * @return string The compiled CSS for this stylesheet
	 */
	protected function get_compiled_style( $style ) {

		$cache = DynamicCSSCache::get_instance();

		// Use cached compiled CSS if applicable
		if ( $style['cache'] ) {
			$cached_css = $cache->get( $style['handle'] );
			if ( false !== $cached_css ) {
				return $cached_css;
			}
		}

		$css = file_get_contents( $style['path'] );
		if ( $style['minify'] ) {
			$css = $this->minify_css( $css );
		}

		// Compile the dynamic CSS
		$compiled_css = $this->compile_css(
			$css,
			$this->callbacks[ $style['handle'] ],
			(array) @$this->filters[ $style['handle'] ]
		);

		$cache->update( $style['handle'], $compiled_css, $style['cache_time'] );
		return $this->add_meta_info( $compiled_css );
	}

	/**
	 * Add meta information to the compiled CSS
	 *
	 * @param string $compiled_css The compiled CSS
	 * @return string The compiled CSS with the meta information added to it
	 */
	protected function add_meta_info( $compiled_css ) {

		return "/**\n" .
			   " * Compiled using wp-dynamic-css\n" .
			   " * https://github.com/askupasoftware/wp-dynamic-css\n" .
			   " */\n\n" .
			   $compiled_css;
	}

	/**
	 * Get the callback URL for enqueuing the stylesheet extrnally
	 *
	 * @param string $handle The stylesheet's handle
	 * @return string The URL for the given handle
	 */
	protected function get_ajax_callback_url( $handle ) {

		return esc_url_raw(
			add_query_arg( [
				'action' => 'wp_dynamic_css',
				'handle' => $handle,
			], admin_url( 'admin-ajax.php' ) )
		);
	}

	/**
	 * Minify a given CSS string by removing comments, whitespaces and newlines
	 *
	 * @see http://stackoverflow.com/a/6630103/1096470
	 * @param string $css CSS style to minify
	 * @return string Minified CSS
	 */
	protected function minify_css( $css ) {

		return preg_replace( '@({)\s+|(\;)\s+|/\*.+?\*\/|\R@is', '$1$2 ', $css );
	}

	/**
	 * Check if a callback function has been register for the given handle.
	 *
	 * @param string $handle
	 * @return boolean
	 */
	protected function callback_exists( $handle ) {

		if ( array_key_exists( $handle, $this->callbacks ) ) {
			return true;
		}
		trigger_error(
			"There is no callback function associated with the handle '$handle'. " .
			'Use <b>wp_dynamic_css_set_callback()</b> to register a callback function for this handle.'
		);
		return false;
	}

	/**
	 * Parse the given CSS string by converting the variables to their
	 * corresponding values retrieved by applying the callback function
	 *
	 * @param callable $callback A function that replaces the variables with
	 * their values. The function accepts the variable's name as a parameter
	 * @param string $css A string containing dynamic CSS (pre-compiled CSS with
	 * variables)
	 * @return string The compiled CSS after converting the variables to their
	 * corresponding values
	 */
	protected function compile_css( $css, $callback, $filters ) {

		return preg_replace_callback(

			'#' . // Begin
			'\\$' . // Must start with $
			'([\\w-]+)' . // Match alphanumeric characters and dashes
			"((?:\\['?[\\w-]+'?\\])*)" . // Optionally match array subscripts i.e. $myVar['index']
			'((?:' . // Optionally match pipe filters i.e. $myVar|myFilter
				'\\|[\\w-]+' . // Starting with the | character
				"(\([\w\.,']+\))?" . // Filters can have strings and numbers i.e myFilter('string',1,2.5)
			')*)' . // Allow for 0 or more piped filters
			'#',                        // End
			function( $matches ) use ( $callback, $filters ) {
				$subscripts = [];

				// If this variable is an array, get the subscripts
				if ( '' !== $matches[2] ) {
					preg_match_all( '/[\w-]+/i', $matches[2], $subscripts );
				}

				$val = call_user_func_array( $callback, [ $matches[1], @$subscripts[0] ] );

				// If there are filters, apply them
				if ( '' !== $matches[3] ) {
					$val = $this->apply_filters( substr( $matches[3], 1 ), $val, $filters );
				}

				return $val;
			}, $css
		);
	}

	/**
	 * Apply the filters specified in $filters_string to the given $value.
	 *
	 * @param string $filters_string
	 * @param string $value
	 * @param array $filters Array of callback functions
	 * @return string The value after all filters have been applied
	 */
	protected function apply_filters( $filters_string, $value, $filters = [] ) {

		foreach ( explode( '|', $filters_string ) as $filter ) {
			$args = [ $value ];

			if ( false !== strrpos( $filters_string, '(' ) ) {
				$pieces = explode( '(', $filter );
				$filter = $pieces[0];
				$params = explode( ',', str_replace( ')', '', $pieces[1] ) );
				array_walk( $params, [ $this, 'strtoval' ] ); // Convert string values to actual values
				$args = array_merge( $args, $params );
			}

			if ( key_exists( $filter, $filters ) ) {
				$value = call_user_func_array( $filters[ $filter ], $args );
			}
		}
		return $value;
	}

	/**
	 * Convert the given string to its actual value.
	 *
	 * @param string $str The string to be converted (passed by reference)
	 */
	protected function strtoval( &$str ) {

		if ( 'false' === strtolower( $str ) ) {
			$str = false;
		}
		if ( 'true' === strtolower( $str ) ) {
			$str = true;
		}
		if ( false !== strrpos( $str, "'" ) ) {
			$str = str_replace( "'", '', $str );
		}
		if ( is_numeric( $str ) ) {
			$str = floatval( $str );
		}
	}
}