Minify_HTML

Compress HTML.

Defined (1)

The class is defined in the following location(s).

/lib/Minify/Minify/HTML.php  
  1. class Minify_HTML { 
  2.     /** 
  3.      * @var boolean 
  4.      */ 
  5.     protected $_jsCleanComments = true; 
  6.  
  7.     /** 
  8.      * "Minify" an HTML page 
  9.      * 
  10.      * @param string $html 
  11.      * 
  12.      * @param array $options 
  13.      * 
  14.      * 'cssMinifier' : (optional) callback function to process content of STYLE 
  15.      * elements. 
  16.      * 
  17.      * 'jsMinifier' : (optional) callback function to process content of SCRIPT 
  18.      * elements. Note: the type attribute is ignored. 
  19.      * 
  20.      * 'xhtml' : (optional boolean) should content be treated as XHTML1.0? If 
  21.      * unset, minify will sniff for an XHTML doctype. 
  22.      * 
  23.      * @return string 
  24.      */ 
  25.     public static function minify($html, $options = array()) { 
  26.         $min = new self($html, $options); 
  27.         return $min->process(); 
  28.     } 
  29.  
  30.  
  31.     /** 
  32.      * Create a minifier object 
  33.      * 
  34.      * @param string $html 
  35.      * 
  36.      * @param array $options 
  37.      * 
  38.      * 'cssMinifier' : (optional) callback function to process content of STYLE 
  39.      * elements. 
  40.      * 
  41.      * 'jsMinifier' : (optional) callback function to process content of SCRIPT 
  42.      * elements. Note: the type attribute is ignored. 
  43.      * 
  44.      * 'jsCleanComments' : (optional) whether to remove HTML comments beginning and end of script block 
  45.      * 
  46.      * 'xhtml' : (optional boolean) should content be treated as XHTML1.0? If 
  47.      * unset, minify will sniff for an XHTML doctype. 
  48.      * 
  49.      * @return null 
  50.      */ 
  51.     public function __construct($html, $options = array()) 
  52.     { 
  53.         $this->_html = str_replace("\r\n", "\n", trim($html)); 
  54.         if (isset($options['xhtml'])) { 
  55.             $this->_isXhtml = (bool)$options['xhtml']; 
  56.         } 
  57.         if (isset($options['cssMinifier'])) { 
  58.             $this->_cssMinifier = $options['cssMinifier']; 
  59.         } 
  60.         if (isset($options['jsMinifier'])) { 
  61.             $this->_jsMinifier = $options['jsMinifier']; 
  62.         } 
  63.  
  64.         $this->_stripCrlf = (isset($options['stripCrlf']) ? (boolean) $options['stripCrlf'] : false) ; 
  65.         $this->_ignoredComments = (isset($options['ignoredComments']) ? (array) $options['ignoredComments'] : array()); 
  66.     } 
  67.  
  68.  
  69.     /** 
  70.      * Minify the markeup given in the constructor 
  71.      * 
  72.      * @return string 
  73.      */ 
  74.     public function process() 
  75.     { 
  76.         if ($this->_isXhtml === null) { 
  77.             $this->_isXhtml = (false !== strpos($this->_html, '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML')); 
  78.         } 
  79.  
  80.         $this->_replacementHash = 'MINIFYHTML' . md5($_SERVER['REQUEST_TIME']); 
  81.         $this->_placeholders = array(); 
  82.  
  83.         // replace dynamic tags 
  84.         $this->_html = preg_replace_callback( 
  85.             '~(<!--\s*m(func|clude)(.*)-->\s*<!--\s*/m(func|clude)\s*-->)~is' 
  86.  , array($this, '_removeComment') 
  87.  , $this->_html); 
  88.  
  89.         // replace SCRIPTs (and minify) with placeholders 
  90.         $this->_html = preg_replace_callback( 
  91.             '/(\\s*)<script(\\b[^>]*?>)([\\s\\S]*?)<\\/script>(\\s*)/i' 
  92.  , array($this, '_removeScriptCB') 
  93.  , $this->_html); 
  94.  
  95.         // replace STYLEs (and minify) with placeholders 
  96.         $this->_html = preg_replace_callback( 
  97.             '/\\s*<style(\\b[^>]*>)([\\s\\S]*?)<\\/style>\\s*/i' 
  98.  , array($this, '_removeStyleCB') 
  99.  , $this->_html); 
  100.  
  101.         // remove HTML comments (not containing IE conditional comments). 
  102.         $this->_html = preg_replace_callback( 
  103.             '/<!--([\\s\\S]*?)-->/' 
  104.  , array($this, '_commentCB') 
  105.  , $this->_html); 
  106.  
  107.         // replace PREs with placeholders 
  108.         $this->_html = preg_replace_callback('/\\s*<pre(\\b[^>]*?>[\\s\\S]*?<\\/pre>)\\s*/i' 
  109.  , array($this, '_removePreCB') 
  110.  , $this->_html); 
  111.  
  112.         // replace TEXTAREAs with placeholders 
  113.         $this->_html = preg_replace_callback( 
  114.             '/\\s*<textarea(\\b[^>]*?>[\\s\\S]*?<\\/textarea>)\\s*/i' 
  115.  , array($this, '_removeTextareaCB') 
  116.  , $this->_html); 
  117.  
  118.         // trim each line. 
  119.         // @todo take into account attribute values that span multiple lines. 
  120.         $this->_html = preg_replace('/^\\s+|\\s+$/m', '', $this->_html); 
  121.  
  122.         // remove ws around block/undisplayed elements 
  123.         $this->_html = preg_replace('/\\s+(<\\/?(?:area|base(?:font)?|blockquote|body' 
  124.             .'|caption|center|col(?:group)?|dd|dir|div|dl|dt|fieldset|form' 
  125.             .'|frame(?:set)?|h[1-6]|head|hr|html|legend|li|link|map|menu|meta' 
  126.             .'|ol|opt(?:group|ion)|p|param|t(?:able|body|head|d|h||r|foot|itle)' 
  127.             .'|ul)\\b[^>]*>)/i', '$1', $this->_html); 
  128.  
  129.         // remove ws outside of all elements 
  130.         $this->_html = preg_replace( 
  131.             '/>(\\s(?:\\s*))?([^<]+)(\\s(?:\s*))?</' 
  132.  , '>$1$2$3<' 
  133.  , $this->_html); 
  134.  
  135.         // use newlines before 1st attribute in open tags (to limit line lengths) 
  136.         $this->_html = preg_replace('/(<[a-z\\-]+)\\s+([^>]+>)/i', "$1\n$2", $this->_html); 
  137.  
  138.         if ($this->_stripCrlf) { 
  139.             $this->_html = preg_replace("~[\r\n]+~", ' ', $this->_html); 
  140.         } else { 
  141.             $this->_html = preg_replace("~[\r\n]+~", "\n", $this->_html); 
  142.         } 
  143.  
  144.         // fill placeholders 
  145.         $this->_html = str_replace( 
  146.             array_keys($this->_placeholders) 
  147.  , array_values($this->_placeholders) 
  148.  , $this->_html 
  149.  ); 
  150.         // issue 229: multi-pass to catch scripts that didn't get replaced in textareas 
  151.         $this->_html = str_replace( 
  152.             array_keys($this->_placeholders) 
  153.  , array_values($this->_placeholders) 
  154.  , $this->_html 
  155.  ); 
  156.         return $this->_html; 
  157.     } 
  158.  
  159.     protected function _commentCB($m) 
  160.     { 
  161.         return (0 === strpos($m[1], '[') || false !== strpos($m[1], '<![') || $this->_ignoredComment($m[1])) 
  162.             ? $m[0] 
  163.             : ''; 
  164.     } 
  165.  
  166.     protected function _ignoredComment($comment) 
  167.     { 
  168.         foreach ($this->_ignoredComments as $ignoredComment) { 
  169.             if (stristr($comment, $ignoredComment) !== false) { 
  170.                 return true; 
  171.             } 
  172.         } 
  173.  
  174.         return false; 
  175.     } 
  176.  
  177.     protected function _reservePlace($content) 
  178.     { 
  179.         $placeholder = '%' . $this->_replacementHash . count($this->_placeholders) . '%'; 
  180.         $this->_placeholders[$placeholder] = $content; 
  181.         return $placeholder; 
  182.     } 
  183.  
  184.     protected $_isXhtml = null; 
  185.     protected $_replacementHash = null; 
  186.     protected $_placeholders = array(); 
  187.     protected $_cssMinifier = null; 
  188.     protected $_jsMinifier = null; 
  189.     protected $_stripCrlf = null; 
  190.     protected $_ignoredComments = null; 
  191.  
  192.     protected function _removePreCB($m) 
  193.     { 
  194.         return $this->_reservePlace("<pre{$m[1]}"); 
  195.     } 
  196.  
  197.     protected function _removeTextareaCB($m) 
  198.     { 
  199.         return $this->_reservePlace("<textarea{$m[1]}"); 
  200.     } 
  201.  
  202.     protected function _removeStyleCB($m) 
  203.     { 
  204.         $openStyle = "<style{$m[1]}"; 
  205.         $css = $m[2]; 
  206.         // remove HTML comments 
  207.         $css = preg_replace('/(?:^\\s*<!--|-->\\s*$)/', '', $css); 
  208.  
  209.         // remove CDATA section markers 
  210.         $css = $this->_removeCdata($css); 
  211.  
  212.         // minify 
  213.         $minifier = $this->_cssMinifier 
  214.             ? $this->_cssMinifier 
  215.             : 'trim'; 
  216.         $css = call_user_func($minifier, $css); 
  217.  
  218.         return $this->_reservePlace($this->_needsCdata($css) 
  219.             ? "{$openStyle}/*<![CDATA[*/{$css}/*]]>*/</style>" 
  220.             : "{$openStyle}{$css}</style>" 
  221.  ); 
  222.     } 
  223.  
  224.     protected function _removeScriptCB($m) 
  225.     { 
  226.         $openScript = "<script{$m[2]}"; 
  227.         $js = $m[3]; 
  228.  
  229.         // whitespace surrounding? preserve at least one space 
  230.         $ws1 = ($m[1] === '') ? '' : ' '; 
  231.         $ws2 = ($m[4] === '') ? '' : ' '; 
  232.  
  233.         // remove HTML comments (and ending "//" if present) 
  234.         if ($this->_jsCleanComments) { 
  235.             $js = preg_replace('/(?:^\\s*<!--\\s*|\\s*(?:\\/\\/)?\\s*-->\\s*$)/', '', $js); 
  236.         } 
  237.  
  238.         // remove CDATA section markers 
  239.         $js_old = $js; 
  240.         $js = $this->_removeCdata($js); 
  241.         $needsCdata = ( $js_old != $js ); 
  242.  
  243.         // minify 
  244.         $minifier = $this->_jsMinifier 
  245.             ? $this->_jsMinifier 
  246.             : 'trim'; 
  247.         $js = call_user_func($minifier, $js); 
  248.  
  249.         return $this->_reservePlace($needsCdata && $this->_needsCdata($js) 
  250.             ? "{$ws1}{$openScript}/*<![CDATA[*/{$js}/*]]>*/</script>{$ws2}" 
  251.             : "{$ws1}{$openScript}{$js}</script>{$ws2}" 
  252.  ); 
  253.     } 
  254.  
  255.     protected function _removeCdata($str) 
  256.     { 
  257.         if (false !== strpos($str, '<![CDATA[')) { 
  258.             $str = str_replace('//<![CDATA[', '', $str); 
  259.             $str = str_replace('/*<![CDATA[*/', '', $str); 
  260.             $str = str_replace('<![CDATA[', '', $str); 
  261.  
  262.             $str = str_replace('//]]>', '', $str); 
  263.             $str = str_replace('/*]]>*/', '', $str); 
  264.             $str = str_replace(']]>', '', $str); 
  265.         } 
  266.  
  267.         return $str; 
  268.     } 
  269.  
  270.     protected function _removeComment($m) 
  271.     { 
  272.         return $this->_reservePlace($m[1]); 
  273.     } 
  274.  
  275.     protected function _needsCdata($str) 
  276.     { 
  277.         return ($this->_isXhtml && preg_match('/(?:[<&]|\\-\\-|\\]\\]>)/', $str)); 
  278.     } 
  279. }