html5-starter 0.1.3b

data/templates/project/files/build/tools/css-compressor/lib/Control.php

@@ -0,0 +1,236 @@
+<?php
+/**
+ * CSS Compressor [VERSION]
+ * [DATE]
+ * Corey Hart @ http://www.codenothing.com
+ */ 
+
+Class CSSCompression_Control
+{
+	/**
+	 * Control Patterns
+	 *
+	 * @param (string) css: Holds compressed css string
+	 * @param (string) mode: Current compression mode state
+	 * @param (array) stats: Holds compression stats
+	 * @param (array) getters: Array of accessible getters
+	 */ 
+	public $css = '';
+	public $mode = '';
+	public $stats = array();
+	private $getters = array(
+		'css',
+		'mode',
+		'stats',
+	);
+
+	/**
+	 * Subclasses that do the ground work for this compressor
+	 *
+	 * @class CSSCompression: Public facing compression class
+	 * @class Option: Option handling
+	 * @class Trim: Does the initial trimming for the css
+	 * @class Format: Formats the output
+	 * @class Numeric: Handles numeric compression
+	 * @class Color: Handles color compression
+	 * @class Individuals: Runs compression algorithms on individual properties and values
+	 * @class Selectors: Runs selector specific compressions
+	 * @class Combine: Handles combining of various properties
+	 * @class Organize: Reorganizes the sheet for futher compression
+	 * @class Cleanup: Cleans out all injected characters during compression
+	 * @class Compress: Central compression unit.
+	 * @param (array) subclasses: Array holding all the subclasses for inlusion
+	 */
+	public $CSSCompression;
+	public $Option;
+	public $Trim;
+	public $Format;
+	public $Numeric;
+	public $Color;
+	public $Individuals;
+	public $Selectors;
+	public $Combine;
+	public $Organize;
+	public $Cleanup;
+	public $Setup;
+	public $Compress;
+	private $subclasses = array(
+		'Option',
+		'Trim',
+		'Format',
+		'Numeric',
+		'Color',
+		'Individuals',
+		'Selectors',
+		'Combine',
+		'Organize',
+		'Cleanup',
+		'Setup',
+		'Compress',
+	);
+
+	/**
+	 * Pull in the Compression instance and build the subclasses
+	 *
+	 * @param (class) CSSCompression: CSSCompression Instance
+	 */
+	public function __construct( CSSCompression $CSSCompression ) {
+		$this->CSSCompression = $CSSCompression;
+
+		// Load all subclasses on demand
+		if ( ! class_exists( "CSSCompression_Option", false ) ) {
+			$path = dirname(__FILE__) . '/';
+			foreach ( $this->subclasses as $class ) {
+				require( $path . $class . '.php' );
+			}
+		}
+
+		// Initialize each subclass
+		foreach ( $this->subclasses as $class ) {
+			$full = "CSSCompression_$class";
+			$this->$class = new $full( $this );
+		}
+	}
+
+	/**
+	 * Control access to properties
+	 *
+	 *	- Getting stats/mode/css returns the current value of that property
+	 *	- Getting options will return the current full options array
+	 *	- Getting anything else returns that current value in the options array or NULL
+	 *
+	 * @param (string) name: Name of property that you want to access
+	 */ 
+	public function get( $name ) {
+		if ( in_array( $name, $this->getters ) ) {
+			return $this->$name;
+		}
+		else if ( $name == 'options' ) {
+			return $this->Option->options;
+		}
+		else {
+			return $this->Option->option( $name );
+		}
+	}
+
+	/**
+	 * The setter method only allows access to setting values in the options array
+	 *
+	 * @param (string) name: Key name of the option you want to set
+	 * @param (mixed) value: Value of the option you want to set
+	 */ 
+	public function set( $name, $value ) {
+		// Allow for passing array of options to merge into current ones
+		if ( $name === 'options' && is_array( $value ) ) {
+			return $this->Option->merge( $value );
+		}
+		else if ( isset( CSSCompression::$defaults[ $name ] ) ) {
+			return $this->Option->option( $name, $value );
+		}
+		else {
+			throw new CSSCompression_Exception( "Invalid Private Access to $name in CSSCompression." );
+		}
+	}
+
+	/**
+	 * Merges a predefined set options
+	 *
+	 * @param (string) mode: Name of mode to use.
+	 */
+	public function mode( $mode = NULL ) {
+		return $this->Options->merge( $mode );
+	}
+
+	/**
+	 * Resets options to their defaults, and flushes out variables
+	 *
+	 * @params none
+	 */
+	public function reset(){
+		$this->Option->reset();
+		return $this->flush();
+	}
+
+	/**
+	 * Cleans out class variables for next run
+	 *
+	 * @params none
+	 */
+	public function flush(){
+		$this->css = '';
+		$this->stats = array(
+			'before' => array(
+				'props' => 0,
+				'selectors' => 0,
+				'size' => 0,
+				'time' => 0,
+			), 
+			'after' => array(
+				'props' => 0,
+				'selectors' => 0,
+				'size' => 0,
+				'time' => 0,
+			),
+		);
+
+		return true;
+	}
+
+	/**
+	 * Proxy to run Compression on the sheet passed. Handle options here.
+	 *
+	 * @param (string) css: Stylesheet to be compressed
+	 * @param (mixed) options: Array of options or mode to use.
+	 */
+	public function compress( $css = NULL, $options = NULL ) {
+		// Flush out old stats and variables
+		$this->flush();
+
+		// If no additional options, just run compression
+		if ( $options === NULL ) {
+			return $this->css = $this->Compress->compress( $css );
+		}
+
+		// Store old params
+		$old = $this->mode == '__custom' ? $this->Option->option() : $this->mode;
+		$readability = $this->Option->option( 'readability' );
+
+		// Compress with new set of options
+		$this->Option->merge( $options );
+		$css = $this->Compress->compress( $css );
+
+		// Reset original options
+		$this->reset();
+		$this->Option->merge( $old );
+
+		// Return the compressed css
+		return $this->css = $css;
+	}
+
+	/**
+	 * Backdoor access to subclasses
+	 * ONLY FOR DEVELOPMENT/TESTING.
+	 *
+	 * @param (string) class: Name of the focus class
+	 * @param (array) config: Contains name reference and test arguments
+	 */
+	public function access( $class, $method, $args ) {
+		if ( $class == 'Control' ) {
+			return call_user_func_array( array( $class, $method ), $args );
+		}
+		else if ( strpos( $class, '.' ) !== false ) {
+			$parts = explode( '.', $class );
+			$class = $parts[ 0 ];
+			$subclass = $parts[ 1 ];
+			return $this->$class->access( $subclass, $method, $args );
+		}
+		else if ( in_array( $class, $this->subclasses ) ) {
+			return $this->$class->access( $method, $args );
+		}
+		else {
+			throw new CSSCompression_Exception( "Unknown Class Access - " . $class );
+		}
+	}
+};
+
+?>

data/templates/project/files/build/tools/css-compressor/lib/Exception.php

@@ -0,0 +1,32 @@
+<?php
+/**
+ * CSS Compressor [VERSION]
+ * [DATE]
+ * Corey Hart @ http://www.codenothing.com
+ */
+
+
+Class CSSCompression_Exception extends Exception
+{
+	/**
+	 * Custom exception handler
+	 *
+	 * @param (string) message: Error message
+	 * @param (int) code: Error code
+	 * @instance (Exception Instance) previous: Previous exception
+	 */
+	public function __construct( $message = 'Unknown Exception', $code = 0, Exception $previous = NULL ) {
+		parent::__construct( $message, $code, $previous );
+	}
+
+	/**
+	 * String version of this custom exception
+	 *
+	 * @params none
+	 */
+	public function __toString(){
+		return "CSSCompression Exception: [" . $this->code . "] " . $this->message . "\n";
+	}
+};
+
+?>

data/templates/project/files/build/tools/css-compressor/lib/Format.php

@@ -0,0 +1,187 @@
+<?php
+/**
+ * CSS Compressor [VERSION]
+ * [DATE]
+ * Corey Hart @ http://www.codenothing.com
+ */ 
+
+Class CSSCompression_Format
+{
+	/**
+	 * Format Patterns
+	 *
+	 * @class Control: Compression Controller
+	 * @param (string) token: Copy of the injection token
+	 * @param (array) options: Reference to options
+	 * @param (regex) rsemicolon: Checks for semicolon without an escape '\' character before it
+	 * @param (regex) rcolon: Checks for colon without an escape '\' character before it
+	 * @param (array) readability: Mapping to readability functions
+	 */
+	private $Control;
+	private $token = '';
+	private $options = array();
+	private $rsemicolon = "/(?<!\\\);/";
+	private $rcolon = "/(?<!\\\):/";
+	private $readability = array(
+		CSSCompression::READ_MAX => 'maximum',
+		CSSCompression::READ_MED => 'medium',
+		CSSCompression::READ_MIN => 'minimum',
+		CSSCompression::READ_NONE => 'none',
+	);
+
+	/**
+	 * Stash a reference to the controller on each instantiation
+	 *
+	 * @param (class) control: CSSCompression Controller
+	 */
+	public function __construct( CSSCompression_Control $control ) {
+		$this->Control = $control;
+		$this->token = CSSCompression::TOKEN;
+		$this->options = &$control->Option->options;
+	}
+
+
+	/**
+	 * Reformats compressed CSS into specified format
+	 *
+	 * @param (int) readability: Readability level of compressed output
+	 * @param (array) selectors: Array of selectors
+	 * @param (array) details: Array of declarations
+	 */ 
+	public function readability( $readability = CSSCompression::READ_NONE, $selectors = array(), $details = array() ) {
+		if ( isset( $this->readability[ $readability ] ) ) {
+			$fn = $this->readability[ $readability ];
+			return trim( $this->$fn( $selectors, $details ) );
+		}
+		else {
+			return 'Invalid Readability Value';
+		}
+	}
+
+	/**
+	 * Returns maxium readability, breaking on every selector, brace, and property
+	 *
+	 * @param (array) selectors: Array of selectors
+	 * @param (array) details: Array of declarations
+	 */ 
+	private function maximum( $selectors, $details ) {
+		$css = '';
+		foreach ( $selectors as $k => $v ) {
+			if ( strpos( $v, $this->token ) === 0 ) {
+				$css .= substr( $v, strlen( $this->token ) );
+				$css .= $details[ $k ];
+				continue;
+			}
+			else if ( ! $details[ $k ] || trim( $details[ $k ] ) == '' ) {
+				continue;
+			}
+
+			$v = str_replace( '>', ' > ', $v );
+			$v = str_replace( '+', ' + ', $v );
+			$v = str_replace( ',', ', ', $v );
+			$css .= "$v {\n";
+			$arr = preg_split( $this->rsemicolon, $details[ $k ] );
+
+			foreach ( $arr as $item ) {
+				if ( ! $item ) {
+					continue;
+				}
+
+				list( $prop, $val ) = preg_split( $this->rcolon, $item, 2 );
+				$css .= "\t$prop: $val;\n";
+			}
+
+			// Kill that last semicolon at users request
+			if ( $this->options['unnecessary-semicolons'] ) {
+				$css = preg_replace( "/;\n$/", "\n", $css );
+			}
+
+			$css .= "}\n\n";
+		}
+
+		return $css;
+	}
+
+	/**
+	 * Returns medium readability, putting selectors and rule sets on new lines
+	 *
+	 * @param (array) selectors: Array of selectors
+	 * @param (array) details: Array of declarations
+	 */ 
+	private function medium( $selectors, $details ) {
+		$css = '';
+		foreach ( $selectors as $k => $v ) {
+			if ( strpos( $v, $this->token ) === 0 ) {
+				$css .= substr( $v, strlen( $this->token ) );
+				$css .= $details[ $k ];
+				continue;
+			}
+			else if ( $details[ $k ] && $details[ $k ] != '' ) {
+				$css .= "$v {\n\t" . $details[ $k ] . "\n}\n";
+			}
+		}
+
+		return $css;
+	}
+
+	/**
+	 * Returns minimum readability, breaking after every selector and it's rule set
+	 *
+	 * @param (array) selectors: Array of selectors
+	 * @param (array) details: Array of declarations
+	 */ 
+	private function minimum( $selectors, $details ) {
+		$css = '';
+		foreach ( $selectors as $k => $v ) {
+			if ( strpos( $v, $this->token ) === 0 ) {
+				$css .= substr( $v, strlen( $this->token ) );
+				$css .= $details[ $k ];
+				continue;
+			}
+			else if ( $details[ $k ] && $details[ $k ] != '' ) {
+				$css .= "$v{" . $details[ $k ] . "}\n";
+			}
+		}
+
+		return $css;
+	}
+	
+	/**
+	 * Returns an unreadable, but fully compressed script
+	 *
+	 * @param (array) selectors: Array of selectors
+	 * @param (array) details: Array of declarations
+	 */ 
+	private function none( $selectors, $details ) {
+		$css = '';
+		foreach ( $selectors as $k => $v ) {
+			if ( strpos( $v, $this->token ) === 0 ) {
+				$css .= substr( $v, strlen( $this->token ) );
+				$css .= $details[ $k ];
+				continue;
+			}
+			else if ( $details[ $k ] && $details[ $k ] != '' ) {
+				$css .= trim( "$v{" . $details[ $k ] . "}" );
+			}
+		}
+
+		return $css;
+	}
+
+	/**
+	 * Access to private methods for testing
+	 *
+	 * @param (string) method: Method to be called
+	 * @param (array) args: Array of paramters to be passed in
+	 */
+	public function access( $method, $args ) {
+		if ( method_exists( $this, $method ) ) {
+			return call_user_func_array( array( $this, $method ), $args );
+		}
+		else {
+			throw new CSSCompression_Exception( "Unknown method in Format Class - " . $method );
+		}
+	}
+};
+
+?>