PackageCompressor.php

<?php
/**
 * PackageCompressor
 *
 * A Javascript and CSS compressor based on Yii's package system.
 *
 * @author Michael Härtl <haertl.mike@gmail.com>
 * @version 1.0.4
 */

Yii::setPathOfAlias('_packagecompressor', dirname(__FILE__));

class PackageCompressor extends CClientScript
{
    /**
     * @var bool wether to enable package compression
     */
    public $enableCompression = true;

    /**
     * @var bool wether to only combine, not compress (useful for debugging)
     */
    public $combineOnly = false;

    /**
     * If this is enabled, during compression all other requests will wait until the compressing
     * process has completed. If disabled, the uncompressed files will be delivered for these
     * requests. This should prevent the thundering herd problem.
     *
     * @var bool wether other requests should pause during compression. On by default.
     */
    public $blockDuringCompression = true;

    /**
     * @var bool whether to add a fingerprint to CSS image urls.
     */
    public $enableCssImageFingerPrinting = false;

    /**
     * @var string name or path of/to the JAVA executable. Default is 'java'.
     */
    public $javaBin = 'java';

    /**
     * @var array names of packages that where registered on current page
     */
    private $_registeredPackages = array();

    /**
     * @var mixed meta information about the compressed packages
     */
    private $_pd;

    /**
     * @var mixed the EMutex component
     */
    private $_mutex;

    // Locking parameter to prevent parallel compression
    const LOCK_ID       = '_PackageCompressor';
    const LOCK_TIMEOUT  = 15;

    // YUI compressor jar name
    const YUI_COMPRESSOR_JAR = 'yuicompressor-2.4.7.jar';

    /**
     * Used internally: Create a compressed version of all package files, publish the
     * compressed file through asset manager and store compressedInfo. Js and CSS will
     * be processed independently.
     *
     * @param string $name of package
     */
    public function compressPackage($name)
    {
        // Backup registered scripts, css and core scripts, as we only want to
        // catch the files contained in the package, not those registered from elsewhere
        $coreScripts        = $this->coreScripts;
        $scriptFiles        = $this->scriptFiles;
        $cssFiles           = $this->cssFiles;

        $this->coreScripts = $this->cssFiles = $this->scriptFiles = array();

        // Now we register only the package and let yii resolve dependencies
        // and expand coreScripts into scriptFiles (usually happens during rendering)
        $this->registerCoreScript($name);
        $this->renderCoreScripts();

        // Copied from CClientScript: process the scriptMap and remove duplicates
        if(!empty($this->scriptMap))
            $this->remapScripts();
        $this->unifyScripts();

        $info       = array();
        $am         = Yii::app()->assetManager;
        $basePath   = Yii::getPathOfAlias('webroot');

        // /www/root/sub -> /www/root   (baseUrl=/sub)
        if(($baseUrl = Yii::app()->request->baseUrl)!=='')
            $basePath = substr($basePath,0,-strlen($baseUrl));

        // Process all JS files from the package (if any)
        if(isset($this->scriptFiles[$this->coreScriptPosition]))
        {
            $scripts    = array();
            $urls       = array();
            foreach($this->scriptFiles[$this->coreScriptPosition] as $script)
                if (strtolower(substr($script,0,4))==='http' || substr($script,0,2)==='//') // Exclude external scripts
                    $urls[] = $script;
                else
                    $scripts[] = $basePath.$script;   // '/www/root'.'/sub/js/some.js'

            if ($scripts!==array())
            {
                $fileName = $this->compressFiles($name,'js',$scripts);
                $urls[] = $am->publish($fileName,true);    // URL to compressed file

                // Remove current package name from meta data
                $core = array_keys($this->coreScripts);
                if(($key = array_search($name,$core))!==false)
                    unset($core[$key]);

                $info['js'] = array(
                    'file'          => $am->getPublishedPath($fileName,true), // path to compressed file
                    'files'         => $scripts,
                    'urls'          => $urls,
                    'coreScripts'   => $core,
                );
                unlink($fileName);
            }
        }

        // Process all CSS files from the package (if any)
        if ($this->cssFiles!==array())
        {
            $files  = array();
            $urls   = array();
            foreach(array_keys($this->cssFiles) as $file)
                $files[] = $basePath.$file;

            $fileName = $this->compressFiles($name,'css',$files);
            if(isset($this->packages[$name]['baseUrl']))
            {
                // If a CSS package uses 'baseUrl' we do not use the asset publisher
                // because this could break CSS URLs. Instead we copy to baseUrl:
                $url = '/'.trim($this->packages[$name]['baseUrl'],'/').'/'.basename($fileName);

                // '/www/root'.'/sub/'.'/css/some.css'
                $destFile = $basePath.$baseUrl.$url;

                copy($fileName, $destFile);
                $urls[] = $baseUrl.$url;  // '/sub'.'/css/some.css'
            }
            else
            {
                $urls[] = $am->publish($fileName,true);    // URL to compressed file
                $destFile = $am->getPublishedPath($fileName,true);
            }

            $info['css'] = array(
                'file'  => $destFile,
                'files' => $files,
                'urls'  => $urls,
                'media' => isset($this->packages[$name]['media']) ? $this->packages[$name]['media'] : '',
            );
            unlink($fileName);
        }

        // Store package meta info
        if($info!==array())
            $this->setCompressedInfo($name,$info);

        // Restore original coreScripts, scriptFiles and cssFiles
        $this->coreScripts  = $coreScripts;
        $this->scriptFiles  = $scriptFiles;
        $this->cssFiles     = $cssFiles;
    }

    /**
     * Override CClientScript::registerPackage() to initialize the compression algorithm
     *
     * @param string $name Name of Package to register
     * @return CClientScript the CClientScript object itself
     */
    public function registerPackage($name)
    {
        if ($this->enableCompression && !in_array($name,$this->_registeredPackages))
        {
            $this->hasScripts = true;
            $this->_registeredPackages[$name] = $name;

            // Create compressed package if not done so yet
            if(($info = $this->getCompressedInfo($name))===null)
            {
                $mutex = $this->getMutex();

                // Compresssion must only be performed once, even for several parallel requests
                while(!$mutex->lock(self::LOCK_ID,self::LOCK_TIMEOUT))
                    if($this->blockDuringCompression)
                        sleep(1);
                    else
                        return parent::registerPackage($name);

                // We have a Mutex lock, now check if another process already compressed this package
                if ($this->getCompressedInfo($name,true)!==null) {
                    $mutex->unlock();
                    return $this;
                }

                $this->compressPackage($name);

                $mutex->unlock();

            }
            return $this;
        } else
            return parent::registerPackage($name);
    }

    /**
     * Override CClientScript::render() to add compressed package files if available.
     *
     * @param string $output the existing output that needs to be inserted with script tags
     */
    public function render(&$output)
    {
        if(!$this->hasScripts)
            return;

        $packages = $this->_registeredPackages;
        if($this->enableCompression)
            foreach($packages as $package)
                $this->unregisterPackagedCoreScripts($package);

        $this->renderCoreScripts();

        if(!empty($this->scriptMap))
            $this->remapScripts();

        // Register package files as *first* files always
        if($this->enableCompression)
            foreach(array_reverse($this->_registeredPackages) as $package)
                $this->renderCompressedPackage($package);

        $this->unifyScripts();

        $this->renderHead($output);
        if($this->enableJavaScript)
        {
            $this->renderBodyBegin($output);
            $this->renderBodyEnd($output);
        }

    }

    /**
     * Delete cached package file
     *
     * @param string (optional) $name of package
     */
    public function resetCompressedPackage($name=null)
    {
        if($this->_pd===null)
            $this->loadPackageData();

        if($name===null)
            $packages = $this->_pd;
        elseif(isset($this->_pd[$name]))
            $packages = array($name=>$this->_pd[$name]);
        else
            $packages = array();

        if($packages===array())
            return false;

        foreach($packages as $package => $info)
        {
            if(isset($info['js']['file']))
                @unlink($info['js']['file']);
            if(isset($info['css']['file']))
                @unlink($info['css']['file']);
            unset($this->_pd[$package]);
        }

        $this->savePackageData();

        return true;
    }

    /**
     * If a compressed package is available, will return an array of this format:
     *
     *  array(
     *      'js'=>array(
     *          'file'          =>'/path/to/compressed/file',
     *          'files'         => <list of original file names>
     *          'urls'          => <list of script URLs (incl. external)>
     *          'coreScripts'   => <list of core scripts contained in this package>
     *      ),
     *      'css'=>array(
     *          'file'          =>'/path/to/compressed/file',
     *          'urls'          => <list of script URLs (incl. external)>
     *      ),
     *
     * @param string name of package to load
     * @param bool wether to enforce that package data is read again from global state
     * @return mixed array with compressed package information or null if none
     */
    public function getCompressedInfo($name,$forceRefresh=false)
    {
        if ($this->_pd===null || $forceRefresh)
            $this->loadPackageData($forceRefresh);

        $i=isset($this->_pd[$name]) ? $this->_pd[$name] : null;

        // Safety check: Verify that compressed files exist
        if( isset($i['js']['file']) && !file_exists($i['js']['file']) ||
            isset($i['css']['file']) && !file_exists($i['css']['file']))
        {
            $this->setCompressedInfo($name,null);
            YII_DEBUG && Yii::trace(
                sprintf(
                    "Remove %s:\n%s\n%s",
                    $name,
                    isset($i['js']) ? $i['js']['file'] : '-',
                    isset($i['css']) ? $i['css']['file'] : '-'
                ),
                'application.components.packagecompressor'
            );
            $i=null;
        }

        return $i;
    }

    /**
     * @return array list of compressed package names
     */
    public function getCompressedPackageNames()
    {
        if ($this->_pd===null)
            $this->loadPackageData();

        return array_keys($this->_pd);
    }

    /**
     * @return EMutex the mutex component from the bundled EMutext extension
     */
    public function getMutex()
    {
        if($this->_mutex===null)
            $this->_mutex = Yii::createComponent(array(
                'class'     => '_packagecompressor.EMutex',
                'mutexFile' => Yii::app()->runtimePath.'/packagecompressor_mutex.bin',
            ));

        return $this->_mutex;
    }

    /**
     * @return string unique key per application
     */
    public function getStateKey()
    {
        return '__packageCompressor:'.Yii::app()->getId();
    }

    /**
     * Combine the set of given text files into one file
     *
     * For js files, we add a semicolon to the end, in case the file forgot it, e.g. jquery.history.js in the yii repo.
     *
     * @param string $name of package
     * @param string $type of package, either js or css
     * @param array  $files List of files to combine (full path)
     * @return string full path name of combined file
     */
    private function combineFiles($name,$type,$files)
    {
        $fileName = tempnam(Yii::app()->runtimePath,'combined_'.$name);

        foreach($files as $f) {
            if($type == 'css' && $this->enableCssImageFingerPrinting)
                $fileContents = $this->addCssImageFingerPrints($f);
            else
                $fileContents = file_get_contents($f);

            if(!file_put_contents($fileName, $fileContents.($type==='js'?';':'')."\n", FILE_APPEND))
                throw new CException(sprintf(
                    'Could not combine file "%s" into "%s"',
                    $f,
                    $fileName
                ));
        }

        return $fileName;
    }

    /**
     * Create a compressed file using YUI compressor (requires JRE!)
     *
     * @param string $name of package
     * @param string $type of package, either js or css
     * @param array $files list of full file paths to files
     * @return string file name of compressed file
     */
    private function compressFiles($name,$type,$files)
    {
        YII_DEBUG && Yii::trace(sprintf(
            "Compressing %s package %s:\n%s",
            $type,
            $name,
            implode(",\n",$files)
        ),'application.components.packagecompressor');

        $inFile = $this->combineFiles($name,$type,$files);
        $outFile = sprintf(
            '%s/%s_pkg_%s_%s.%s',
            Yii::app()->runtimePath,
            $type,
            $name,
            md5_file($inFile),
            $type
        );

        $jar = Yii::getPathOfAlias('_packagecompressor.yuicompressor').DIRECTORY_SEPARATOR.self::YUI_COMPRESSOR_JAR;
        // See http://developer.yahoo.com/yui/compressor/
        $command = sprintf("%s -jar %s --type %s -o %s %s",escapeshellarg($this->javaBin),escapeshellarg($jar),$type,escapeshellarg($outFile),escapeshellarg($inFile));

        if($this->combineOnly)
            copy($inFile,$outFile);
        else
        {
            exec($command,$output,$result);

            if ($result!==0)
                throw new CException(sprintf(
                    "Could not create compressed $type file. Maybe missing a JRE?\nCommand was:\n%s",
                    $command
                ));
        }

        unlink($inFile);
        return $outFile;
    }

    /**
     * Load meta information about compressed packages from global state
     *
     * @param bool wether to enforce that global state is refreshed
     */
    private function loadPackageData($forceRefresh=false)
    {
        // Make sure, statefile is read in again. It could have been changed from
        // another request, while we were waiting for the mutex lock
        if ($forceRefresh)
            Yii::app()->loadGlobalState();

        $this->_pd = Yii::app()->getGlobalState($this->getStateKey(),array());
    }

    /**
     * Replace all sripts registered at $coreScriptPosition with compressed file
     */
    private function renderCompressedPackage($name)
    {
        if(($package = $this->getCompressedInfo($name))===null)
            return;

        if(isset($package['js']))
        {
            $p = $this->coreScriptPosition;

            // Keys in scriptFiles must be equal to value to make unifyScripts work:
            $packageFiles = array_combine($package['js']['urls'],$package['js']['urls']);

            $this->scriptFiles[$p]=isset($this->scriptFiles[$p]) ?
                array_merge($packageFiles,$this->scriptFiles[$p]) : $packageFiles;

            YII_DEBUG && Yii::trace(
                sprintf(
                    "Render compressed js package '%s'\nContains:\n%s\nURLs:\n%s\nCoreScripts: %s",
                    $name,
                    implode(",\n",$package['js']['files']),
                    implode(",\n",$package['js']['urls']),
                    implode(", ",$package['js']['coreScripts'])
                ),
                'application.components.packagecompressor'
            );
        }

        if(isset($package['css']))
        {
            $cssFiles = $this->cssFiles;

            $urls = $this->cssFiles = array();

            foreach($package['css']['urls'] as $url)
                $this->cssFiles[$url] = $package['css']['media'];

            foreach($cssFiles as $url => $media)
                $this->cssFiles[$url] = $media;

            YII_DEBUG && Yii::trace(
                sprintf(
                    "Render compressed css package '%s'\nContains:\n%s\nURLs:\n%s",
                    $name,
                    implode(",\n",$package['css']['files']),
                    implode(",\n",$package['css']['urls'])
                ),
                'application.components.packagecompressor'
            );
        }
    }

    /**
     * Remove any registered core scripts and packages if we have it in the package to prevent publishing
     *
     * @param string $name of package
     */
    private function unregisterPackagedCoreScripts($package)
    {
        if (($info = $this->getCompressedInfo($package))===null || !isset($info['js']))
            return;

        // Remove the package itself from the coreScripts or it would
        // still render the uncompressed script files
        unset($this->coreScripts[$package]);

        // Also remove the coreScripts contained in the package
        foreach($info['js']['coreScripts'] as $name) {
            unset($this->coreScripts[$name]);
            unset($this->_registeredPackages[$name]);
        }
    }

    /**
     * Save meta information about compressed packages to global state
     */
    private function savePackageData()
    {
        Yii::app()->setGlobalState($this->getStateKey(),$this->_pd);

        // We want to be sure that global state is written immediately. Default would be onEndRequest.
        Yii::app()->saveGlobalState();
    }

    /**
     * Stores meta information about compressed package to cache and global state
     *
     * @param mixed Array of format array('file'=>...,'urls'=>...) or null to reset
     */
    private function setCompressedInfo($name,$value)
    {
        if($this->_pd===null)
            $this->loadPackageData();

        if($value!==null)
            $this->_pd[$name]=$value;
        elseif(isset($this->_pd[$name]))
            unset($this->_pd[$name]);

        $this->savePackageData();
    }

    /**
     * Attempt to add a fingerprint to any image url found in the input file
     *
     * Example CSS that we want to match:
     *   background: url('/images/stars/star.png') no-repeat 0px 0px;
     *
     * Resulting image file that we want to get a fingerprint for: /images/stars/star.png;
     *
     * Notes:
     *  A) Cope with ' or " or no string encloser.
     *  B) Only modify local assets, i.e. not apsolute urls.
     *  C) Only modify jpg|jpeg|gif|png assets.
     *  D) Don't modify assets that already have a fingerprint
     *
     * @param String $fileName Full file name of a CSS file
     * @return string Modified CSS text
     */
    private function addCssImageFingerPrints($fileName)
    {
        $webRoot = realpath(Yii::getPathOfAlias('webroot'));

        return preg_replace_callback(
            '/url\([\'\"]?(.*?\.(jpg|jpeg|gif|png))[\'\"]?\)/',
            function($matches) use ($fileName,$webRoot)
            {
                $imageURL = $matches[1];

                if (preg_match('/^(https?:)?\/\//', $imageURL))
                    return $matches[0]; // We don't fingerprint absolute urls

                // image urls that start with a / are relative to the webroot, otherwise they are relative to the url of the CSS file.
                $imageFile = ( $imageURL[0]==='/' ? $webRoot : dirname($fileName).'/' ) . $imageURL;

                if (file_exists($imageFile))
                    return 'url(\''.$imageURL.'?'.substr(md5_file($imageFile),0,8).'\')';

                // We won't always find the image, e.g. there might be a mod_rewrite rule in play.
                YII_DEBUG && Yii::trace(
                    sprintf("Unable to find css image '%s' on disk. Css File: '%s'. CSS: %s.",
                        $imageFile,
                        $fileName,
                        $matches[0]),
                    'application.components.packagecompressor'
                );
                return $matches[0];
            },
            file_get_contents($fileName)
        );
    }
}