bixbite 0.1.0

data/template/src/html/min/lib/Minify/Controller/MinApp.php

@@ -0,0 +1,132 @@
+<?php
+/**
+ * Class Minify_Controller_MinApp  
+ * @package Minify
+ */
+
+require_once 'Minify/Controller/Base.php';
+
+/**
+ * Controller class for requests to /min/index.php
+ * 
+ * @package Minify
+ * @author Stephen Clay <steve@mrclay.org>
+ */
+class Minify_Controller_MinApp extends Minify_Controller_Base {
+    
+    /**
+     * Set up groups of files as sources
+     * 
+     * @param array $options controller and Minify options
+     * @return array Minify options
+     * 
+     */
+    public function setupSources($options) {
+        // filter controller options
+        $cOptions = array_merge(
+            array(
+                'allowDirs' => '//'
+                ,'groupsOnly' => false
+                ,'groups' => array()
+                ,'maxFiles' => 10                
+            )
+            ,(isset($options['minApp']) ? $options['minApp'] : array())
+        );
+        unset($options['minApp']);
+        $sources = array();
+        if (isset($_GET['g'])) {
+            // try groups
+            if (! isset($cOptions['groups'][$_GET['g']])) {
+                $this->log("A group configuration for \"{$_GET['g']}\" was not set");
+                return $options;
+            }
+            
+            $files = $cOptions['groups'][$_GET['g']];
+            // if $files is a single object, casting will break it
+            if (is_object($files)) {
+                $files = array($files);
+            } elseif (! is_array($files)) {
+                $files = (array)$files;
+            }
+            foreach ($files as $file) {
+                if ($file instanceof Minify_Source) {
+                    $sources[] = $file;
+                    continue;
+                }
+                if (0 === strpos($file, '//')) {
+                    $file = $_SERVER['DOCUMENT_ROOT'] . substr($file, 1);
+                }
+                $file = realpath($file);
+                if (is_file($file)) {
+                    $sources[] = new Minify_Source(array(
+                        'filepath' => $file
+                    ));    
+                } else {
+                    $this->log("The path \"{$file}\" could not be found (or was not a file)");
+                    return $options;
+                }
+            }
+        } elseif (! $cOptions['groupsOnly'] && isset($_GET['f'])) {
+            // try user files
+            // The following restrictions are to limit the URLs that minify will
+            // respond to. Ideally there should be only one way to reference a file.
+            if (// verify at least one file, files are single comma separated, 
+                // and are all same extension
+                ! preg_match('/^[^,]+\\.(css|js)(?:,[^,]+\\.\\1)*$/', $_GET['f'])
+                // no "//"
+                || strpos($_GET['f'], '//') !== false
+                // no "\"
+                || strpos($_GET['f'], '\\') !== false
+                // no "./"
+                || preg_match('/(?:^|[^\\.])\\.\\//', $_GET['f'])
+            ) {
+                $this->log("GET param 'f' invalid (see MinApp.php line 63)");
+                return $options;
+            }
+            $files = explode(',', $_GET['f']);
+            if (count($files) > $cOptions['maxFiles'] || $files != array_unique($files)) {
+                $this->log("Too many or duplicate files specified");
+                return $options;
+            }
+            if (isset($_GET['b'])) {
+                // check for validity
+                if (preg_match('@^[^/]+(?:/[^/]+)*$@', $_GET['b'])
+                    && false === strpos($_GET['b'], '..')
+                    && $_GET['b'] !== '.') {
+                    // valid base
+                    $base = "/{$_GET['b']}/";       
+                } else {
+                    $this->log("GET param 'b' invalid (see MinApp.php line 84)");
+                    return $options;
+                }
+            } else {
+                $base = '/';
+            }
+            $allowDirs = array();
+            foreach ((array)$cOptions['allowDirs'] as $allowDir) {
+                $allowDirs[] = realpath(str_replace('//', $_SERVER['DOCUMENT_ROOT'] . '/', $allowDir));
+            }
+            foreach ($files as $file) {
+                $path = $_SERVER['DOCUMENT_ROOT'] . $base . $file;
+                $file = realpath($path);
+                if (false === $file) {
+                    $this->log("Path \"{$path}\" failed realpath()");
+                    return $options;
+                } elseif (! parent::_fileIsSafe($file, $allowDirs)) {
+                    $this->log("Path \"{$path}\" failed Minify_Controller_Base::_fileIsSafe()");
+                    return $options;
+                } else {
+                    $sources[] = new Minify_Source(array(
+                        'filepath' => $file
+                    ));
+                }
+            }
+        }
+        if ($sources) {
+            $this->sources = $sources;
+        } else {
+            $this->log("No sources to serve");
+        }
+        return $options;
+    }
+}

data/template/src/html/min/lib/Minify/Controller/Page.php

@@ -0,0 +1,82 @@
+<?php
+/**
+ * Class Minify_Controller_Page  
+ * @package Minify
+ */
+
+require_once 'Minify/Controller/Base.php';
+
+/**
+ * Controller class for serving a single HTML page
+ * 
+ * @link http://code.google.com/p/minify/source/browse/trunk/web/examples/1/index.php#59
+ * @package Minify
+ * @author Stephen Clay <steve@mrclay.org>
+ */
+class Minify_Controller_Page extends Minify_Controller_Base {
+    
+    /**
+     * Set up source of HTML content
+     * 
+     * @param array $options controller and Minify options
+     * @return array Minify options
+     * 
+     * Controller options:
+     * 
+     * 'content': (required) HTML markup
+     * 
+     * 'id': (required) id of page (string for use in server-side caching)
+     * 
+     * 'lastModifiedTime': timestamp of when this content changed. This
+     * is recommended to allow both server and client-side caching.
+     * 
+     * 'minifyAll': should all CSS and Javascript blocks be individually 
+     * minified? (default false) 
+     *
+     * @todo Add 'file' option to read HTML file.
+     */
+    public function setupSources($options) {
+        if (isset($options['file'])) {
+            $sourceSpec = array(
+                'filepath' => $options['file']
+            );
+        } else {
+            // strip controller options
+            $sourceSpec = array(
+                'content' => $options['content']
+                ,'id' => $options['id']
+            );
+            unset($options['content'], $options['id']);
+        }
+        if (isset($options['minifyAll'])) {
+            // this will be the 2nd argument passed to Minify_HTML::minify()
+            $sourceSpec['minifyOptions'] = array(
+                'cssMinifier' => array('Minify_CSS', 'minify')
+                ,'jsMinifier' => array('JSMin', 'minify')
+            );
+            $this->_loadCssJsMinifiers = true;
+            unset($options['minifyAll']);
+        }
+        $this->sources[] = new Minify_Source($sourceSpec);
+        
+        $options['contentType'] = Minify::TYPE_HTML;
+        return $options;
+    }
+    
+    protected $_loadCssJsMinifiers = false;
+    
+    /**
+     * @see Minify_Controller_Base::loadMinifier()
+     */
+    public function loadMinifier($minifierCallback)
+    {
+        if ($this->_loadCssJsMinifiers) {
+            // Minify will not call for these so we must manually load
+            // them when Minify/HTML.php is called for.
+            require_once 'Minify/CSS.php';
+            require_once 'JSMin.php';
+        }
+        parent::loadMinifier($minifierCallback); // load Minify/HTML.php
+    }
+}
+

data/template/src/html/min/lib/Minify/Controller/Version1.php

@@ -0,0 +1,118 @@
+<?php
+/**
+ * Class Minify_Controller_Version1  
+ * @package Minify
+ */
+
+require_once 'Minify/Controller/Base.php';
+
+/**
+ * Controller class for emulating version 1 of minify.php
+ * 
+ * <code>
+ * Minify::serve('Version1');
+ * </code>
+ * 
+ * @package Minify
+ * @author Stephen Clay <steve@mrclay.org>
+ */
+class Minify_Controller_Version1 extends Minify_Controller_Base {
+    
+    /**
+     * Set up groups of files as sources
+     * 
+     * @param array $options controller and Minify options
+     * @return array Minify options
+     * 
+     */
+    public function setupSources($options) {
+        self::_setupDefines();
+        if (MINIFY_USE_CACHE) {
+            $cacheDir = defined('MINIFY_CACHE_DIR')
+                ? MINIFY_CACHE_DIR
+                : '';
+            Minify::setCache($cacheDir);
+        }
+        $options['badRequestHeader'] = 'HTTP/1.0 404 Not Found';
+        $options['contentTypeCharset'] = MINIFY_ENCODING;
+
+        // The following restrictions are to limit the URLs that minify will
+        // respond to. Ideally there should be only one way to reference a file.
+        if (! isset($_GET['files'])
+            // verify at least one file, files are single comma separated, 
+            // and are all same extension
+            || ! preg_match('/^[^,]+\\.(css|js)(,[^,]+\\.\\1)*$/', $_GET['files'], $m)
+            // no "//" (makes URL rewriting easier)
+            || strpos($_GET['files'], '//') !== false
+            // no "\"
+            || strpos($_GET['files'], '\\') !== false
+            // no "./"
+            || preg_match('/(?:^|[^\\.])\\.\\//', $_GET['files'])
+        ) {
+            return $options;
+        }
+        $extension = $m[1];
+        
+        $files = explode(',', $_GET['files']);
+        if (count($files) > MINIFY_MAX_FILES) {
+            return $options;
+        }
+        
+        // strings for prepending to relative/absolute paths
+        $prependRelPaths = dirname($_SERVER['SCRIPT_FILENAME'])
+            . DIRECTORY_SEPARATOR;
+        $prependAbsPaths = $_SERVER['DOCUMENT_ROOT'];
+        
+        $sources = array();
+        $goodFiles = array();
+        $hasBadSource = false;
+        
+        $allowDirs = isset($options['allowDirs'])
+            ? $options['allowDirs']
+            : MINIFY_BASE_DIR;
+        
+        foreach ($files as $file) {
+            // prepend appropriate string for abs/rel paths
+            $file = ($file[0] === '/' ? $prependAbsPaths : $prependRelPaths) . $file;
+            // make sure a real file!
+            $file = realpath($file);
+            // don't allow unsafe or duplicate files
+            if (parent::_fileIsSafe($file, $allowDirs) 
+                && !in_array($file, $goodFiles)) 
+            {
+                $goodFiles[] = $file;
+                $srcOptions = array(
+                    'filepath' => $file
+                );
+                $this->sources[] = new Minify_Source($srcOptions);
+            } else {
+                $hasBadSource = true;
+                break;
+            }
+        }
+        if ($hasBadSource) {
+            $this->sources = array();
+        }
+        if (! MINIFY_REWRITE_CSS_URLS) {
+            $options['rewriteCssUris'] = false;
+        }
+        return $options;
+    }
+    
+    private static function _setupDefines()
+    {
+        $defaults = array(
+            'MINIFY_BASE_DIR' => realpath($_SERVER['DOCUMENT_ROOT'])
+            ,'MINIFY_ENCODING' => 'utf-8'
+            ,'MINIFY_MAX_FILES' => 16
+            ,'MINIFY_REWRITE_CSS_URLS' => true
+            ,'MINIFY_USE_CACHE' => true
+        );
+        foreach ($defaults as $const => $val) {
+            if (! defined($const)) {
+                define($const, $val);
+            }
+        }
+    }
+}
+

data/template/src/html/min/lib/Minify/HTML.php

@@ -0,0 +1,245 @@
+<?php
+/**
+ * Class Minify_HTML  
+ * @package Minify
+ */
+
+/**
+ * Compress HTML
+ *
+ * This is a heavy regex-based removal of whitespace, unnecessary comments and 
+ * tokens. IE conditional comments are preserved. There are also options to have
+ * STYLE and SCRIPT blocks compressed by callback functions. 
+ * 
+ * A test suite is available.
+ * 
+ * @package Minify
+ * @author Stephen Clay <steve@mrclay.org>
+ */
+class Minify_HTML {
+
+    /**
+     * "Minify" an HTML page
+     *
+     * @param string $html
+     *
+     * @param array $options
+     *
+     * 'cssMinifier' : (optional) callback function to process content of STYLE
+     * elements.
+     * 
+     * 'jsMinifier' : (optional) callback function to process content of SCRIPT
+     * elements. Note: the type attribute is ignored.
+     * 
+     * 'xhtml' : (optional boolean) should content be treated as XHTML1.0? If
+     * unset, minify will sniff for an XHTML doctype.
+     * 
+     * @return string
+     */
+    public static function minify($html, $options = array()) {
+        $min = new Minify_HTML($html, $options);
+        return $min->process();
+    }
+    
+    
+    /**
+     * Create a minifier object
+     *
+     * @param string $html
+     *
+     * @param array $options
+     *
+     * 'cssMinifier' : (optional) callback function to process content of STYLE
+     * elements.
+     * 
+     * 'jsMinifier' : (optional) callback function to process content of SCRIPT
+     * elements. Note: the type attribute is ignored.
+     * 
+     * 'xhtml' : (optional boolean) should content be treated as XHTML1.0? If
+     * unset, minify will sniff for an XHTML doctype.
+     * 
+     * @return null
+     */
+    public function __construct($html, $options = array())
+    {
+        $this->_html = str_replace("\r\n", "\n", trim($html));
+        if (isset($options['xhtml'])) {
+            $this->_isXhtml = (bool)$options['xhtml'];
+        }
+        if (isset($options['cssMinifier'])) {
+            $this->_cssMinifier = $options['cssMinifier'];
+        }
+        if (isset($options['jsMinifier'])) {
+            $this->_jsMinifier = $options['jsMinifier'];
+        }
+    }
+    
+    
+    /**
+     * Minify the markeup given in the constructor
+     * 
+     * @return string
+     */
+    public function process()
+    {
+        if ($this->_isXhtml === null) {
+            $this->_isXhtml = (false !== strpos($this->_html, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML'));
+        }
+        
+        $this->_replacementHash = 'MINIFYHTML' . md5($_SERVER['REQUEST_TIME']);
+        $this->_placeholders = array();
+        
+        // replace SCRIPTs (and minify) with placeholders
+        $this->_html = preg_replace_callback(
+            '/(\\s*)(<script\\b[^>]*?>)([\\s\\S]*?)<\\/script>(\\s*)/i'
+            ,array($this, '_removeScriptCB')
+            ,$this->_html);
+        
+        // replace STYLEs (and minify) with placeholders
+        $this->_html = preg_replace_callback(
+            '/\\s*(<style\\b[^>]*?>)([\\s\\S]*?)<\\/style>\\s*/i'
+            ,array($this, '_removeStyleCB')
+            ,$this->_html);
+        
+        // remove HTML comments (not containing IE conditional comments).
+        $this->_html = preg_replace_callback(
+            '/<!--([\\s\\S]*?)-->/'
+            ,array($this, '_commentCB')
+            ,$this->_html);
+        
+        // replace PREs with placeholders
+        $this->_html = preg_replace_callback('/\\s*(<pre\\b[^>]*?>[\\s\\S]*?<\\/pre>)\\s*/i'
+            ,array($this, '_removePreCB')
+            ,$this->_html);
+        
+        // replace TEXTAREAs with placeholders
+        $this->_html = preg_replace_callback(
+            '/\\s*(<textarea\\b[^>]*?>[\\s\\S]*?<\\/textarea>)\\s*/i'
+            ,array($this, '_removeTextareaCB')
+            ,$this->_html);
+        
+        // trim each line.
+        // @todo take into account attribute values that span multiple lines.
+        $this->_html = preg_replace('/^\\s+|\\s+$/m', '', $this->_html);
+        
+        // remove ws around block/undisplayed elements
+        $this->_html = preg_replace('/\\s+(<\\/?(?:area|base(?:font)?|blockquote|body'
+            .'|caption|center|cite|col(?:group)?|dd|dir|div|dl|dt|fieldset|form'
+            .'|frame(?:set)?|h[1-6]|head|hr|html|legend|li|link|map|menu|meta'
+            .'|ol|opt(?:group|ion)|p|param|t(?:able|body|head|d|h||r|foot|itle)'
+            .'|ul)\\b[^>]*>)/i', '$1', $this->_html);
+        
+        // remove ws outside of all elements
+        $this->_html = preg_replace_callback(
+            '/>([^<]+)</'
+            ,array($this, '_outsideTagCB')
+            ,$this->_html);
+        
+        // use newlines before 1st attribute in open tags (to limit line lengths)
+        $this->_html = preg_replace('/(<[a-z\\-]+)\\s+([^>]+>)/i', "$1\n$2", $this->_html);
+        
+        // fill placeholders
+        $this->_html = str_replace(
+            array_keys($this->_placeholders)
+            ,array_values($this->_placeholders)
+            ,$this->_html
+        );
+        return $this->_html;
+    }
+    
+    protected function _commentCB($m)
+    {
+        return (0 === strpos($m[1], '[') || false !== strpos($m[1], '<!['))
+            ? $m[0]
+            : '';
+    }
+    
+    protected function _reservePlace($content)
+    {
+        $placeholder = '%' . $this->_replacementHash . count($this->_placeholders) . '%';
+        $this->_placeholders[$placeholder] = $content;
+        return $placeholder;
+    }
+
+    protected $_isXhtml = null;
+    protected $_replacementHash = null;
+    protected $_placeholders = array();
+    protected $_cssMinifier = null;
+    protected $_jsMinifier = null;
+
+    protected function _outsideTagCB($m)
+    {
+        return '>' . preg_replace('/^\\s+|\\s+$/', ' ', $m[1]) . '<';
+    }
+    
+    protected function _removePreCB($m)
+    {
+        return $this->_reservePlace($m[1]);
+    }
+    
+    protected function _removeTextareaCB($m)
+    {
+        return $this->_reservePlace($m[1]);
+    }
+
+    protected function _removeStyleCB($m)
+    {
+        $openStyle = $m[1];
+        $css = $m[2];
+        // remove HTML comments
+        $css = preg_replace('/(?:^\\s*<!--|-->\\s*$)/', '', $css);
+        
+        // remove CDATA section markers
+        $css = $this->_removeCdata($css);
+        
+        // minify
+        $minifier = $this->_cssMinifier
+            ? $this->_cssMinifier
+            : 'trim';
+        $css = call_user_func($minifier, $css);
+        
+        return $this->_reservePlace($this->_needsCdata($css)
+            ? "{$openStyle}/*<![CDATA[*/{$css}/*]]>*/</style>"
+            : "{$openStyle}{$css}</style>"
+        );
+    }
+
+    protected function _removeScriptCB($m)
+    {
+        $openScript = $m[2];
+        $js = $m[3];
+        
+        // whitespace surrounding? preserve at least one space
+        $ws1 = ($m[1] === '') ? '' : ' ';
+        $ws2 = ($m[4] === '') ? '' : ' ';
+ 
+        // remove HTML comments (and ending "//" if present)
+        $js = preg_replace('/(?:^\\s*<!--\\s*|\\s*(?:\\/\\/)?\\s*-->\\s*$)/', '', $js);
+            
+        // remove CDATA section markers
+        $js = $this->_removeCdata($js);
+        
+        // minify
+        $minifier = $this->_jsMinifier
+            ? $this->_jsMinifier
+            : 'trim'; 
+        $js = call_user_func($minifier, $js);
+        
+        return $this->_reservePlace($this->_needsCdata($js)
+            ? "{$ws1}{$openScript}/*<![CDATA[*/{$js}/*]]>*/</script>{$ws2}"
+            : "{$ws1}{$openScript}{$js}</script>{$ws2}"
+        );
+    }
+
+    protected function _removeCdata($str)
+    {
+        return (false !== strpos($str, '<![CDATA['))
+            ? str_replace(array('<![CDATA[', ']]>'), '', $str)
+            : $str;
+    }
+    
+    protected function _needsCdata($str)
+    {
+        return ($this->_isXhtml && preg_match('/(?:[<&]|\\-\\-|\\]\\]>)/', $str));
+    }
+}