class CSSCompression_Compress in Advanced CSS/JS Aggregation 7

CSS Compressor [VERSION] [DATE] Corey Hart @ http://www.codenothing.com

Hierarchy

• class \CSSCompression_Compress

File

advagg_css_compress/css-compressor-3.x/src/lib/Compress.inc, line 8

class CSSCompression_Compress {

  /**
   * Trim Patterns
   *
   * @param (array) options: Reference to options
   * @param (array) stats: Reference to stats
   * @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 (regex) rspace: Checks for space without an escape '\' character before it
   */
  private $options = array();
  private $stats = array();
  private $rsemicolon = "/(?<!\\\\);/";
  private $rcolon = "/(?<!\\\\):/";
  private $rspace = "/(?<!\\\\)\\s/";

  /**
   * Other inner classes that get used within compression
   *
   * @class Control: Compression Controller
   * @class Trim: Trim Instance
   * @class Setup: Setup Instance
   * @class Format: Formatting Instance
   * @class Combine: Combine Instance
   * @class Cleanup: Cleanup Instance
   * @class Organize: Organize Instance
   * @class Selectors: Selectors Instance
   * @param (array) others: List of above classes for copying
   */
  private $Control;
  private $Trim;
  private $Setup;
  private $Format;
  private $Combine;
  private $Cleanup;
  private $Organize;
  private $Selectors;
  private $others = array(
    'Trim',
    'Setup',
    'Format',
    'Combine',
    'Cleanup',
    'Organize',
    'Selectors',
  );

  /**
   * Stash a reference to the controller on each instantiation
   *
   * @param (class) control: CSSCompression Controller
   */
  public function __construct(CSSCompression_Control $control) {
    $this->Control = $control;
    $this->options =& $control->Option->options;
    $this->stats =& $control->stats;
    foreach ($this->others as $class) {
      $this->{$class} = $control->{$class};
    }
  }

  /**
   * Centralized function to run css compression.
   *
   * @param (string) css: Stylesheet to compresss
   */
  public function compress($css) {
    $setup = $this
      ->setup($css);
    $setup = $this
      ->rulesets($setup);
    $css = $this
      ->readability($setup);

    // Attach plea to top of page with unknown blocks
    if ($this->options['add-unknown'] && count($setup['unknown'])) {
      $css = "/*\nThere are unknown blocks in the sheet, please please please open an issue with your sheet attached to it:\n" . "https://github.com/codenothing/css-compressor/issues\n" . "Thank You --\n\n" . implode("\n", $setup['unknown']) . "\n*/\n" . $css;
    }

    // Mark final file size
    $this->stats['after']['size'] = strlen($css = trim($css));

    // Return compressed css
    return $css;
  }

  /**
   * Runs css through initial setup handlers
   *
   * @param (string) css: Sheet to compress
   */
  private function setup($css) {

    // Initial stats
    $this->stats['before']['time'] = microtime(true);
    $this->stats['before']['size'] = strlen($css);

    // Initial trimming
    $css = $this->Trim
      ->trim($css);

    // Do a little tokenizing, compress each property individually
    $setup = $this->Setup
      ->setup($css);

    // Mark number of selectors pre-combine
    $this->stats['before']['selectors'] = count($setup['selectors']);
    return $setup;
  }

  /**
   * Focus compressions on each rule set
   *
   * @param (array) setup: Array containing selectors and rule sets
   */
  private function rulesets($setup) {

    // Do selector specific compressions
    $this->Selectors
      ->selectors($setup['selectors']);

    // Look at each group of properties as a whole, and compress/combine similiar definitions
    $this->Combine
      ->combine($setup['selectors'], $setup['details']);

    // If order isn't important, run comination functions before and after compressions to catch all instances
    // Be sure to prune before hand for higher chance of matching
    if ($this->options['organize']) {
      $this->Cleanup
        ->cleanup($setup['selectors'], $setup['details']);
      $this->Organize
        ->organize($setup['selectors'], $setup['details']);
      $this->Combine
        ->combine($setup['selectors'], $setup['details']);
    }

    // Do final maintenace work, remove injected property/values
    $this->Cleanup
      ->cleanup($setup['selectors'], $setup['details']);

    // Run final counters before full cleanup
    $this
      ->finalCount($setup['selectors'], $setup['details']);
    return $setup;
  }

  /**
   * Runs final counts on selectors and props
   *
   * @param (array) selectors: Selector rules
   * @param (array) details: Rule sets
   */
  private function finalCount($selectors, $details) {

    // Selectors and props
    $this->stats['after']['selectors'] = count($selectors);
    foreach ($details as $item) {
      $props = preg_split($this->rsemicolon, $item);

      // Make sure count is true
      foreach ($props as $k => $v) {
        if (!isset($v) || $v == '') {
          unset($props[$k]);
        }
      }
      $this->stats['after']['props'] += count($props);
    }

    // Final count for stats
    $this->stats['after']['time'] = microtime(true);
  }

  /**
   * Formats the compressed rule sets into a stylesheet
   *
   * @param (array) setup: Array containing selectors and rule sets
   */
  private function readability($setup) {

    // Format css to users preference
    $css = $this->Format
      ->readability($this->options['readability'], $setup['selectors'], $setup['details']);

    // Intros
    foreach ($setup as $value) {
      if ($value && is_string($value)) {
        $css = $value . $css;
      }
    }

    // Remove escapables
    $css = $this->Cleanup
      ->removeInjections($css);
    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 Compress Class - " . $method);
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
CSSCompression_Compress::$Cleanup	private	property
CSSCompression_Compress::$Combine	private	property
CSSCompression_Compress::$Control	private	property	Other inner classes that get used within compression
CSSCompression_Compress::$Format	private	property
CSSCompression_Compress::$options	private	property	Trim Patterns
CSSCompression_Compress::$Organize	private	property
CSSCompression_Compress::$others	private	property
CSSCompression_Compress::$rcolon	private	property
CSSCompression_Compress::$rsemicolon	private	property
CSSCompression_Compress::$rspace	private	property
CSSCompression_Compress::$Selectors	private	property
CSSCompression_Compress::$Setup	private	property
CSSCompression_Compress::$stats	private	property
CSSCompression_Compress::$Trim	private	property
CSSCompression_Compress::access	public	function	Access to private methods for testing
CSSCompression_Compress::compress	public	function	Centralized function to run css compression.
CSSCompression_Compress::finalCount	private	function	Runs final counts on selectors and props
CSSCompression_Compress::readability	private	function	Formats the compressed rule sets into a stylesheet
CSSCompression_Compress::rulesets	private	function	Focus compressions on each rule set
CSSCompression_Compress::setup	private	function	Runs css through initial setup handlers
CSSCompression_Compress::__construct	public	function	Stash a reference to the controller on each instantiation