58 | * echo $b->uri('/site.js');
59 | * // outputs "/site.js?1678242"
60 | *
61 | * echo $b->uri('/scriptaculous.js?load=effects');
62 | * // outputs "/scriptaculous.js?load=effects&1678242"
63 | *
64 | *
65 | * @param string $uri
66 | * @param boolean $forceAmpersand (default = false) Force the use of ampersand to
67 | * append the timestamp to the URI.
68 | * @return string
69 | */
70 | public function uri($uri, $forceAmpersand = false) {
71 | $sep = ($forceAmpersand || strpos($uri, '?') !== false)
72 | ? self::$ampersand
73 | : '?';
74 | return "{$uri}{$sep}{$this->lastModified}";
75 | }
76 |
77 | /**
78 | * Create a build object
79 | *
80 | * @param array $sources array of Minify_Source objects and/or file paths
81 | *
82 | * @return null
83 | */
84 | public function __construct($sources)
85 | {
86 | $max = 0;
87 | foreach ((array)$sources as $source) {
88 | if ($source instanceof Minify_Source) {
89 | $max = max($max, $source->lastModified);
90 | } elseif (is_string($source)) {
91 | if (0 === strpos($source, '//')) {
92 | $source = $_SERVER['DOCUMENT_ROOT'] . substr($source, 1);
93 | }
94 | if (is_file($source)) {
95 | $max = max($max, filemtime($source));
96 | }
97 | }
98 | }
99 | $this->lastModified = $max;
100 | }
101 | }
102 |
--------------------------------------------------------------------------------
/system/expressionengine/third_party/minimee/libraries/Minify/Cache/APC.php:
--------------------------------------------------------------------------------
1 |
11 | * Minify::setCache(new Minify_Cache_APC());
12 | *
13 | *
14 | * @package Minify
15 | * @author Chris Edwards
16 | **/
17 | class Minify_Cache_APC {
18 |
19 | /**
20 | * Create a Minify_Cache_APC object, to be passed to
21 | * Minify::setCache().
22 | *
23 | *
24 | * @param int $expire seconds until expiration (default = 0
25 | * meaning the item will not get an expiration date)
26 | *
27 | * @return null
28 | */
29 | public function __construct($expire = 0)
30 | {
31 | $this->_exp = $expire;
32 | }
33 |
34 | /**
35 | * Write data to cache.
36 | *
37 | * @param string $id cache id
38 | *
39 | * @param string $data
40 | *
41 | * @return bool success
42 | */
43 | public function store($id, $data)
44 | {
45 | return apc_store($id, "{$_SERVER['REQUEST_TIME']}|{$data}", $this->_exp);
46 | }
47 |
48 | /**
49 | * Get the size of a cache entry
50 | *
51 | * @param string $id cache id
52 | *
53 | * @return int size in bytes
54 | */
55 | public function getSize($id)
56 | {
57 | if (! $this->_fetch($id)) {
58 | return false;
59 | }
60 | return (function_exists('mb_strlen') && ((int)ini_get('mbstring.func_overload') & 2))
61 | ? mb_strlen($this->_data, '8bit')
62 | : strlen($this->_data);
63 | }
64 |
65 | /**
66 | * Does a valid cache entry exist?
67 | *
68 | * @param string $id cache id
69 | *
70 | * @param int $srcMtime mtime of the original source file(s)
71 | *
72 | * @return bool exists
73 | */
74 | public function isValid($id, $srcMtime)
75 | {
76 | return ($this->_fetch($id) && ($this->_lm >= $srcMtime));
77 | }
78 |
79 | /**
80 | * Send the cached content to output
81 | *
82 | * @param string $id cache id
83 | */
84 | public function display($id)
85 | {
86 | echo $this->_fetch($id)
87 | ? $this->_data
88 | : '';
89 | }
90 |
91 | /**
92 | * Fetch the cached content
93 | *
94 | * @param string $id cache id
95 | *
96 | * @return string
97 | */
98 | public function fetch($id)
99 | {
100 | return $this->_fetch($id)
101 | ? $this->_data
102 | : '';
103 | }
104 |
105 | private $_exp = null;
106 |
107 | // cache of most recently fetched id
108 | private $_lm = null;
109 | private $_data = null;
110 | private $_id = null;
111 |
112 | /**
113 | * Fetch data and timestamp from apc, store in instance
114 | *
115 | * @param string $id
116 | *
117 | * @return bool success
118 | */
119 | private function _fetch($id)
120 | {
121 | if ($this->_id === $id) {
122 | return true;
123 | }
124 | $ret = apc_fetch($id);
125 | if (false === $ret) {
126 | $this->_id = null;
127 | return false;
128 | }
129 | list($this->_lm, $this->_data) = explode('|', $ret, 2);
130 | $this->_id = $id;
131 | return true;
132 | }
133 | }
134 |
--------------------------------------------------------------------------------
/system/expressionengine/third_party/minimee/libraries/Minify/Cache/XCache.php:
--------------------------------------------------------------------------------
1 |
14 | * Minify::setCache(new Minify_Cache_XCache());
15 | *
16 | *
17 | * @package Minify
18 | * @author Elan Ruusamäe
47 | * array('//symlink' => '/real/target/path') // unix
48 | * array('//static' => 'D:\\staticStorage') // Windows
49 | *
50 | *
51 | * 'docRoot': (default = $_SERVER['DOCUMENT_ROOT'])
52 | * see Minify_CSS_UriRewriter::rewrite
53 | *
54 | * @return string
55 | */
56 | public static function minify($css, $options = array())
57 | {
58 | $options = array_merge(array(
59 | 'compress' => true,
60 | 'removeCharsets' => true,
61 | 'preserveComments' => true,
62 | 'currentDir' => null,
63 | 'docRoot' => $_SERVER['DOCUMENT_ROOT'],
64 | 'prependRelativePath' => null,
65 | 'symlinks' => array(),
66 | ), $options);
67 |
68 | if ($options['removeCharsets']) {
69 | $css = preg_replace('/@charset[^;]+;\\s*/', '', $css);
70 | }
71 | if ($options['compress']) {
72 | if (! $options['preserveComments']) {
73 | $css = Minify_CSS_Compressor::process($css, $options);
74 | } else {
75 | $css = Minify_CommentPreserver::process(
76 | $css
77 | ,array('Minify_CSS_Compressor', 'process')
78 | ,array($options)
79 | );
80 | }
81 | }
82 | if (! $options['currentDir'] && ! $options['prependRelativePath']) {
83 | return $css;
84 | }
85 | if ($options['currentDir']) {
86 | return Minify_CSS_UriRewriter::rewrite(
87 | $css
88 | ,$options['currentDir']
89 | ,$options['docRoot']
90 | ,$options['symlinks']
91 | );
92 | } else {
93 | return Minify_CSS_UriRewriter::prepend(
94 | $css
95 | ,$options['prependRelativePath']
96 | );
97 | }
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/system/expressionengine/third_party/minimee/libraries/Minify/ClosureCompiler.php:
--------------------------------------------------------------------------------
1 |
16 | * Minify_ClosureCompiler::$jarFile = '/path/to/closure-compiler-20120123.jar';
17 | * Minify_ClosureCompiler::$tempDir = '/tmp';
18 | * $code = Minify_ClosureCompiler::minify(
19 | * $code,
20 | * array('compilation_level' => 'SIMPLE_OPTIMIZATIONS')
21 | * );
22 | *
23 | * --compilation_level WHITESPACE_ONLY, SIMPLE_OPTIMIZATIONS, ADVANCED_OPTIMIZATIONS
24 | *
25 | *
26 | *
27 | * @todo unit tests, $options docs
28 | * @todo more options support (or should just passthru them all?)
29 | *
30 | * @package Minify
31 | * @author Stephen Clay ' . $label . ' ' . $setting . '
'; 22 | 23 | 24 | /** 25 | * begin our DOM wrapper 26 | */ 27 | echo '' . form_submit('submit', lang('save'), 'class="submit"') . '
'; 197 | $this->table->clear(); 198 | echo form_close(); 199 | ?> 200 | 201 | 252 | 253 | 19 | * @author http://code.google.com/u/1stvamp/ (Issue 64 patch) 20 | */ 21 | class Minify_CSS_Compressor { 22 | 23 | /** 24 | * Minify a CSS string 25 | * 26 | * @param string $css 27 | * 28 | * @param array $options (currently ignored) 29 | * 30 | * @return string 31 | */ 32 | public static function process($css, $options = array()) 33 | { 34 | $obj = new Minify_CSS_Compressor($options); 35 | return $obj->_process($css); 36 | } 37 | 38 | /** 39 | * @var array 40 | */ 41 | protected $_options = null; 42 | 43 | /** 44 | * Are we "in" a hack? I.e. are some browsers targetted until the next comment? 45 | * 46 | * @var bool 47 | */ 48 | protected $_inHack = false; 49 | 50 | 51 | /** 52 | * Constructor 53 | * 54 | * @param array $options (currently ignored) 55 | */ 56 | private function __construct($options) { 57 | $this->_options = $options; 58 | } 59 | 60 | /** 61 | * Minify a CSS string 62 | * 63 | * @param string $css 64 | * 65 | * @return string 66 | */ 67 | protected function _process($css) 68 | { 69 | $css = str_replace("\r\n", "\n", $css); 70 | 71 | // preserve empty comment after '>' 72 | // http://www.webdevout.net/css-hacks#in_css-selectors 73 | $css = preg_replace('@>/\\*\\s*\\*/@', '>/*keep*/', $css); 74 | 75 | // preserve empty comment between property and value 76 | // http://css-discuss.incutio.com/?page=BoxModelHack 77 | $css = preg_replace('@/\\*\\s*\\*/\\s*:@', '/*keep*/:', $css); 78 | $css = preg_replace('@:\\s*/\\*\\s*\\*/@', ':/*keep*/', $css); 79 | 80 | // apply callback to all valid comments (and strip out surrounding ws 81 | $css = preg_replace_callback('@\\s*/\\*([\\s\\S]*?)\\*/\\s*@' 82 | ,array($this, '_commentCB'), $css); 83 | 84 | // remove ws around { } and last semicolon in declaration block 85 | $css = preg_replace('/\\s*{\\s*/', '{', $css); 86 | $css = preg_replace('/;?\\s*}\\s*/', '}', $css); 87 | 88 | // remove ws surrounding semicolons 89 | $css = preg_replace('/\\s*;\\s*/', ';', $css); 90 | 91 | // remove ws around urls 92 | $css = preg_replace('/ 93 | url\\( # url( 94 | \\s* 95 | ([^\\)]+?) # 1 = the URL (really just a bunch of non right parenthesis) 96 | \\s* 97 | \\) # ) 98 | /x', 'url($1)', $css); 99 | 100 | // remove ws between rules and colons 101 | $css = preg_replace('/ 102 | \\s* 103 | ([{;]) # 1 = beginning of block or rule separator 104 | \\s* 105 | ([\\*_]?[\\w\\-]+) # 2 = property (and maybe IE filter) 106 | \\s* 107 | : 108 | \\s* 109 | (\\b|[#\'"-]) # 3 = first character of a value 110 | /x', '$1$2:$3', $css); 111 | 112 | // remove ws in selectors 113 | $css = preg_replace_callback('/ 114 | (?: # non-capture 115 | \\s* 116 | [^~>+,\\s]+ # selector part 117 | \\s* 118 | [,>+~] # combinators 119 | )+ 120 | \\s* 121 | [^~>+,\\s]+ # selector part 122 | { # open declaration block 123 | /x' 124 | ,array($this, '_selectorsCB'), $css); 125 | 126 | // minimize hex colors 127 | $css = preg_replace('/([^=])#([a-f\\d])\\2([a-f\\d])\\3([a-f\\d])\\4([\\s;\\}])/i' 128 | , '$1#$2$3$4$5', $css); 129 | 130 | // remove spaces between font families 131 | $css = preg_replace_callback('/font-family:([^;}]+)([;}])/' 132 | ,array($this, '_fontFamilyCB'), $css); 133 | 134 | $css = preg_replace('/@import\\s+url/', '@import url', $css); 135 | 136 | // replace any ws involving newlines with a single newline 137 | $css = preg_replace('/[ \\t]*\\n+\\s*/', "\n", $css); 138 | 139 | // separate common descendent selectors w/ newlines (to limit line lengths) 140 | $css = preg_replace('/([\\w#\\.\\*]+)\\s+([\\w#\\.\\*]+){/', "$1\n$2{", $css); 141 | 142 | // Use newline after 1st numeric value (to limit line lengths). 143 | $css = preg_replace('/ 144 | ((?:padding|margin|border|outline):\\d+(?:px|em)?) # 1 = prop : 1st numeric value 145 | \\s+ 146 | /x' 147 | ,"$1\n", $css); 148 | 149 | // prevent triggering IE6 bug: http://www.crankygeek.com/ie6pebug/ 150 | $css = preg_replace('/:first-l(etter|ine)\\{/', ':first-l$1 {', $css); 151 | 152 | return trim($css); 153 | } 154 | 155 | /** 156 | * Replace what looks like a set of selectors 157 | * 158 | * @param array $m regex matches 159 | * 160 | * @return string 161 | */ 162 | protected function _selectorsCB($m) 163 | { 164 | // remove ws around the combinators 165 | return preg_replace('/\\s*([,>+~])\\s*/', '$1', $m[0]); 166 | } 167 | 168 | /** 169 | * Process a comment and return a replacement 170 | * 171 | * @param array $m regex matches 172 | * 173 | * @return string 174 | */ 175 | protected function _commentCB($m) 176 | { 177 | $hasSurroundingWs = (trim($m[0]) !== $m[1]); 178 | $m = $m[1]; 179 | // $m is the comment content w/o the surrounding tokens, 180 | // but the return value will replace the entire comment. 181 | if ($m === 'keep') { 182 | return '/**/'; 183 | } 184 | if ($m === '" "') { 185 | // component of http://tantek.com/CSS/Examples/midpass.html 186 | return '/*" "*/'; 187 | } 188 | if (preg_match('@";\\}\\s*\\}/\\*\\s+@', $m)) { 189 | // component of http://tantek.com/CSS/Examples/midpass.html 190 | return '/*";}}/* */'; 191 | } 192 | if ($this->_inHack) { 193 | // inversion: feeding only to one browser 194 | if (preg_match('@ 195 | ^/ # comment started like /*/ 196 | \\s* 197 | (\\S[\\s\\S]+?) # has at least some non-ws content 198 | \\s* 199 | /\\* # ends like /*/ or /**/ 200 | @x', $m, $n)) { 201 | // end hack mode after this comment, but preserve the hack and comment content 202 | $this->_inHack = false; 203 | return "/*/{$n[1]}/**/"; 204 | } 205 | } 206 | if (substr($m, -1) === '\\') { // comment ends like \*/ 207 | // begin hack mode and preserve hack 208 | $this->_inHack = true; 209 | return '/*\\*/'; 210 | } 211 | if ($m !== '' && $m[0] === '/') { // comment looks like /*/ foo */ 212 | // begin hack mode and preserve hack 213 | $this->_inHack = true; 214 | return '/*/*/'; 215 | } 216 | if ($this->_inHack) { 217 | // a regular comment ends hack mode but should be preserved 218 | $this->_inHack = false; 219 | return '/**/'; 220 | } 221 | // Issue 107: if there's any surrounding whitespace, it may be important, so 222 | // replace the comment with a single space 223 | return $hasSurroundingWs // remove all other comments 224 | ? ' ' 225 | : ''; 226 | } 227 | 228 | /** 229 | * Process a font-family listing and return a replacement 230 | * 231 | * @param array $m regex matches 232 | * 233 | * @return string 234 | */ 235 | protected function _fontFamilyCB($m) 236 | { 237 | // Issue 210: must not eliminate WS between words in unquoted families 238 | $pieces = preg_split('/(\'[^\']+\'|"[^"]+")/', $m[1], null, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY); 239 | $out = 'font-family:'; 240 | while (null !== ($piece = array_shift($pieces))) { 241 | if ($piece[0] !== '"' && $piece[0] !== "'") { 242 | $piece = preg_replace('/\\s+/', ' ', $piece); 243 | $piece = preg_replace('/\\s?,\\s?/', ',', $piece); 244 | } 245 | $out .= $piece; 246 | } 247 | return $out . $m[2]; 248 | } 249 | } 250 | -------------------------------------------------------------------------------- /system/expressionengine/third_party/minimee/libraries/Minify/HTML.php: -------------------------------------------------------------------------------- 1 | 18 | */ 19 | class Minify_HTML { 20 | /** 21 | * @var boolean 22 | */ 23 | protected $_jsCleanComments = true; 24 | 25 | /** 26 | * "Minify" an HTML page 27 | * 28 | * @param string $html 29 | * 30 | * @param array $options 31 | * 32 | * 'cssMinifier' : (optional) callback function to process content of STYLE 33 | * elements. 34 | * 35 | * 'jsMinifier' : (optional) callback function to process content of SCRIPT 36 | * elements. Note: the type attribute is ignored. 37 | * 38 | * 'xhtml' : (optional boolean) should content be treated as XHTML1.0? If 39 | * unset, minify will sniff for an XHTML doctype. 40 | * 41 | * @return string 42 | */ 43 | public static function minify($html, $options = array()) { 44 | $min = new self($html, $options); 45 | return $min->process(); 46 | } 47 | 48 | 49 | /** 50 | * Create a minifier object 51 | * 52 | * @param string $html 53 | * 54 | * @param array $options 55 | * 56 | * 'cssMinifier' : (optional) callback function to process content of STYLE 57 | * elements. 58 | * 59 | * 'jsMinifier' : (optional) callback function to process content of SCRIPT 60 | * elements. Note: the type attribute is ignored. 61 | * 62 | * 'jsCleanComments' : (optional) whether to remove HTML comments beginning and end of script block 63 | * 64 | * 'xhtml' : (optional boolean) should content be treated as XHTML1.0? If 65 | * unset, minify will sniff for an XHTML doctype. 66 | * 67 | * @return null 68 | */ 69 | public function __construct($html, $options = array()) 70 | { 71 | $this->_html = str_replace("\r\n", "\n", trim($html)); 72 | if (isset($options['xhtml'])) { 73 | $this->_isXhtml = (bool)$options['xhtml']; 74 | } 75 | if (isset($options['cssMinifier'])) { 76 | $this->_cssMinifier = $options['cssMinifier']; 77 | } 78 | if (isset($options['jsMinifier'])) { 79 | $this->_jsMinifier = $options['jsMinifier']; 80 | } 81 | if (isset($options['jsCleanComments'])) { 82 | $this->_jsCleanComments = (bool)$options['jsCleanComments']; 83 | } 84 | } 85 | 86 | 87 | /** 88 | * Minify the markeup given in the constructor 89 | * 90 | * @return string 91 | */ 92 | public function process() 93 | { 94 | if ($this->_isXhtml === null) { 95 | $this->_isXhtml = (false !== strpos($this->_html, '_replacementHash = 'MINIFYHTML' . md5($_SERVER['REQUEST_TIME']); 99 | $this->_placeholders = array(); 100 | 101 | // replace SCRIPTs (and minify) with placeholders 102 | $this->_html = preg_replace_callback( 103 | '/(\\s*)
38 | * array('//symlink' => '/real/target/path') // unix
39 | * array('//static' => 'D:\\staticStorage') // Windows
40 | *
41 | *
42 | * @return string
43 | */
44 | public static function rewrite($css, $currentDir, $docRoot = null, $symlinks = array())
45 | {
46 | self::$_docRoot = self::_realpath(
47 | $docRoot ? $docRoot : $_SERVER['DOCUMENT_ROOT']
48 | );
49 | self::$_currentDir = self::_realpath($currentDir);
50 | self::$_symlinks = array();
51 |
52 | // normalize symlinks
53 | foreach ($symlinks as $link => $target) {
54 | $link = ($link === '//')
55 | ? self::$_docRoot
56 | : str_replace('//', self::$_docRoot . '/', $link);
57 | $link = strtr($link, '/', DIRECTORY_SEPARATOR);
58 | self::$_symlinks[$link] = self::_realpath($target);
59 | }
60 |
61 | self::$debugText .= "docRoot : " . self::$_docRoot . "\n"
62 | . "currentDir : " . self::$_currentDir . "\n";
63 | if (self::$_symlinks) {
64 | self::$debugText .= "symlinks : " . var_export(self::$_symlinks, 1) . "\n";
65 | }
66 | self::$debugText .= "\n";
67 |
68 | $css = self::_trimUrls($css);
69 |
70 | // rewrite
71 | $css = preg_replace_callback('/@import\\s+([\'"])(.*?)[\'"]/'
72 | ,array(self::$className, '_processUriCB'), $css);
73 | $css = preg_replace_callback('/url\\(\\s*([^\\)\\s]+)\\s*\\)/'
74 | ,array(self::$className, '_processUriCB'), $css);
75 |
76 | return $css;
77 | }
78 |
79 | /**
80 | * In CSS content, prepend a path to relative URIs
81 | *
82 | * @param string $css
83 | *
84 | * @param string $path The path to prepend.
85 | *
86 | * @return string
87 | */
88 | public static function prepend($css, $path)
89 | {
90 | self::$_prependPath = $path;
91 |
92 | $css = self::_trimUrls($css);
93 |
94 | // append
95 | $css = preg_replace_callback('/@import\\s+([\'"])(.*?)[\'"]/'
96 | ,array(self::$className, '_processUriCB'), $css);
97 | $css = preg_replace_callback('/url\\(\\s*([^\\)\\s]+)\\s*\\)/'
98 | ,array(self::$className, '_processUriCB'), $css);
99 |
100 | self::$_prependPath = null;
101 | return $css;
102 | }
103 |
104 | /**
105 | * Get a root relative URI from a file relative URI
106 | *
107 | *
108 | * Minify_CSS_UriRewriter::rewriteRelative(
109 | * '../img/hello.gif'
110 | * , '/home/user/www/css' // path of CSS file
111 | * , '/home/user/www' // doc root
112 | * );
113 | * // returns '/img/hello.gif'
114 | *
115 | * // example where static files are stored in a symlinked directory
116 | * Minify_CSS_UriRewriter::rewriteRelative(
117 | * 'hello.gif'
118 | * , '/var/staticFiles/theme'
119 | * , '/home/user/www'
120 | * , array('/home/user/www/static' => '/var/staticFiles')
121 | * );
122 | * // returns '/static/theme/hello.gif'
123 | *
124 | *
125 | * @param string $uri file relative URI
126 | *
127 | * @param string $realCurrentDir realpath of the current file's directory.
128 | *
129 | * @param string $realDocRoot realpath of the site document root.
130 | *
131 | * @param array $symlinks (default = array()) If the file is stored in
132 | * a symlink-ed directory, provide an array of link paths to
133 | * real target paths, where the link paths "appear" to be within the document
134 | * root. E.g.:
135 | *
136 | * array('/home/foo/www/not/real/path' => '/real/target/path') // unix
137 | * array('C:\\htdocs\\not\\real' => 'D:\\real\\target\\path') // Windows
138 | *
139 | *
140 | * @return string
141 | */
142 | public static function rewriteRelative($uri, $realCurrentDir, $realDocRoot, $symlinks = array())
143 | {
144 | // prepend path with current dir separator (OS-independent)
145 | $path = strtr($realCurrentDir, '/', DIRECTORY_SEPARATOR)
146 | . DIRECTORY_SEPARATOR . strtr($uri, '/', DIRECTORY_SEPARATOR);
147 |
148 | self::$debugText .= "file-relative URI : {$uri}\n"
149 | . "path prepended : {$path}\n";
150 |
151 | // "unresolve" a symlink back to doc root
152 | foreach ($symlinks as $link => $target) {
153 | if (0 === strpos($path, $target)) {
154 | // replace $target with $link
155 | $path = $link . substr($path, strlen($target));
156 |
157 | self::$debugText .= "symlink unresolved : {$path}\n";
158 |
159 | break;
160 | }
161 | }
162 | // strip doc root
163 | $path = substr($path, strlen($realDocRoot));
164 |
165 | self::$debugText .= "docroot stripped : {$path}\n";
166 |
167 | // fix to root-relative URI
168 | $uri = strtr($path, '/\\', '//');
169 | $uri = self::removeDots($uri);
170 |
171 | self::$debugText .= "traversals removed : {$uri}\n\n";
172 |
173 | return $uri;
174 | }
175 |
176 | /**
177 | * Remove instances of "./" and "../" where possible from a root-relative URI
178 | *
179 | * @param string $uri
180 | *
181 | * @return string
182 | */
183 | public static function removeDots($uri)
184 | {
185 | $uri = str_replace('/./', '/', $uri);
186 | // inspired by patch from Oleg Cherniy
187 | do {
188 | $uri = preg_replace('@/[^/]+/\\.\\./@', '/', $uri, 1, $changed);
189 | } while ($changed);
190 | return $uri;
191 | }
192 |
193 | /**
194 | * Defines which class to call as part of callbacks, change this
195 | * if you extend Minify_CSS_UriRewriter
196 | *
197 | * @var string
198 | */
199 | protected static $className = 'Minify_CSS_UriRewriter';
200 |
201 | /**
202 | * Get realpath with any trailing slash removed. If realpath() fails,
203 | * just remove the trailing slash.
204 | *
205 | * @param string $path
206 | *
207 | * @return mixed path with no trailing slash
208 | */
209 | protected static function _realpath($path)
210 | {
211 | $realPath = realpath($path);
212 | if ($realPath !== false) {
213 | $path = $realPath;
214 | }
215 | return rtrim($path, '/\\');
216 | }
217 |
218 | /**
219 | * Directory of this stylesheet
220 | *
221 | * @var string
222 | */
223 | private static $_currentDir = '';
224 |
225 | /**
226 | * DOC_ROOT
227 | *
228 | * @var string
229 | */
230 | private static $_docRoot = '';
231 |
232 | /**
233 | * directory replacements to map symlink targets back to their
234 | * source (within the document root) E.g. '/var/www/symlink' => '/var/realpath'
235 | *
236 | * @var array
237 | */
238 | private static $_symlinks = array();
239 |
240 | /**
241 | * Path to prepend
242 | *
243 | * @var string
244 | */
245 | private static $_prependPath = null;
246 |
247 | /**
248 | * @param string $css
249 | *
250 | * @return string
251 | */
252 | private static function _trimUrls($css)
253 | {
254 | return preg_replace('/
255 | url\\( # url(
256 | \\s*
257 | ([^\\)]+?) # 1 = URI (assuming does not contain ")")
258 | \\s*
259 | \\) # )
260 | /x', 'url($1)', $css);
261 | }
262 |
263 | /**
264 | * @param array $m
265 | *
266 | * @return string
267 | */
268 | private static function _processUriCB($m)
269 | {
270 | // $m matched either '/@import\\s+([\'"])(.*?)[\'"]/' or '/url\\(\\s*([^\\)\\s]+)\\s*\\)/'
271 | $isImport = ($m[0][0] === '@');
272 | // determine URI and the quote character (if any)
273 | if ($isImport) {
274 | $quoteChar = $m[1];
275 | $uri = $m[2];
276 | } else {
277 | // $m[1] is either quoted or not
278 | $quoteChar = ($m[1][0] === "'" || $m[1][0] === '"')
279 | ? $m[1][0]
280 | : '';
281 | $uri = ($quoteChar === '')
282 | ? $m[1]
283 | : substr($m[1], 1, strlen($m[1]) - 2);
284 | }
285 | // analyze URI
286 | if ('/' !== $uri[0] // root-relative
287 | && false === strpos($uri, '//') // protocol (non-data)
288 | && 0 !== strpos($uri, 'data:') // data protocol
289 | ) {
290 | // URI is file-relative: rewrite depending on options
291 | if (self::$_prependPath === null) {
292 | $uri = self::rewriteRelative($uri, self::$_currentDir, self::$_docRoot, self::$_symlinks);
293 | } else {
294 | $uri = self::$_prependPath . $uri;
295 | if ($uri[0] === '/') {
296 | $root = '';
297 | $rootRelative = $uri;
298 | $uri = $root . self::removeDots($rootRelative);
299 | } elseif (preg_match('@^((https?\:)?//([^/]+))/@', $uri, $m) && (false !== strpos($m[3], '.'))) {
300 | $root = $m[1];
301 | $rootRelative = substr($uri, strlen($root));
302 | $uri = $root . self::removeDots($rootRelative);
303 | }
304 | }
305 | }
306 | return $isImport
307 | ? "@import {$quoteChar}{$uri}{$quoteChar}"
308 | : "url({$quoteChar}{$uri}{$quoteChar})";
309 | }
310 | }
311 |
--------------------------------------------------------------------------------
/system/expressionengine/third_party/minimee/libraries/HTTP/Encoder.php:
--------------------------------------------------------------------------------
1 |
15 | * // Send a CSS file, compressed if possible
16 | * $he = new HTTP_Encoder(array(
17 | * 'content' => file_get_contents($cssFile)
18 | * ,'type' => 'text/css'
19 | * ));
20 | * $he->encode();
21 | * $he->sendAll();
22 | *
23 | *
24 | *
25 | * // Shortcut to encoding output
26 | * header('Content-Type: text/css'); // needed if not HTML
27 | * HTTP_Encoder::output($css);
28 | *
29 | *
30 | *
31 | * // Just sniff for the accepted encoding
32 | * $encoding = HTTP_Encoder::getAcceptedEncoding();
33 | *
34 | *
35 | * For more control over headers, use getHeaders() and getData() and send your
36 | * own output.
37 | *
38 | * Note: If you don't need header mgmt, use PHP's native gzencode, gzdeflate,
39 | * and gzcompress functions for gzip, deflate, and compress-encoding
40 | * respectively.
41 | *
42 | * @package Minify
43 | * @subpackage HTTP
44 | * @author Stephen Clay
127 | * array(
128 | * 'Content-Length' => '615'
129 | * ,'Content-Encoding' => 'x-gzip'
130 | * ,'Vary' => 'Accept-Encoding'
131 | * )
132 | *
133 | *
134 | * @return array
135 | */
136 | public function getHeaders()
137 | {
138 | return $this->_headers;
139 | }
140 |
141 | /**
142 | * Send output headers
143 | *
144 | * You must call this before headers are sent and it probably cannot be
145 | * used in conjunction with zlib output buffering / mod_gzip. Errors are
146 | * not handled purposefully.
147 | *
148 | * @see getHeaders()
149 | */
150 | public function sendHeaders()
151 | {
152 | foreach ($this->_headers as $name => $val) {
153 | header($name . ': ' . $val);
154 | }
155 | }
156 |
157 | /**
158 | * Send output headers and content
159 | *
160 | * A shortcut for sendHeaders() and echo getContent()
161 | *
162 | * You must call this before headers are sent and it probably cannot be
163 | * used in conjunction with zlib output buffering / mod_gzip. Errors are
164 | * not handled purposefully.
165 | */
166 | public function sendAll()
167 | {
168 | $this->sendHeaders();
169 | echo $this->_content;
170 | }
171 |
172 | /**
173 | * Determine the client's best encoding method from the HTTP Accept-Encoding
174 | * header.
175 | *
176 | * If no Accept-Encoding header is set, or the browser is IE before v6 SP2,
177 | * this will return ('', ''), the "identity" encoding.
178 | *
179 | * A syntax-aware scan is done of the Accept-Encoding, so the method must
180 | * be non 0. The methods are favored in order of gzip, deflate, then
181 | * compress. Deflate is always smallest and generally faster, but is
182 | * rarely sent by servers, so client support could be buggier.
183 | *
184 | * @param bool $allowCompress allow the older compress encoding
185 | *
186 | * @param bool $allowDeflate allow the more recent deflate encoding
187 | *
188 | * @return array two values, 1st is the actual encoding method, 2nd is the
189 | * alias of that method to use in the Content-Encoding header (some browsers
190 | * call gzip "x-gzip" etc.)
191 | */
192 | public static function getAcceptedEncoding($allowCompress = true, $allowDeflate = true)
193 | {
194 | // @link http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
195 |
196 | if (! isset($_SERVER['HTTP_ACCEPT_ENCODING'])
197 | || self::isBuggyIe())
198 | {
199 | return array('', '');
200 | }
201 | $ae = $_SERVER['HTTP_ACCEPT_ENCODING'];
202 | // gzip checks (quick)
203 | if (0 === strpos($ae, 'gzip,') // most browsers
204 | || 0 === strpos($ae, 'deflate, gzip,') // opera
205 | ) {
206 | return array('gzip', 'gzip');
207 | }
208 | // gzip checks (slow)
209 | if (preg_match(
210 | '@(?:^|,)\\s*((?:x-)?gzip)\\s*(?:$|,|;\\s*q=(?:0\\.|1))@'
211 | ,$ae
212 | ,$m)) {
213 | return array('gzip', $m[1]);
214 | }
215 | if ($allowDeflate) {
216 | // deflate checks
217 | $aeRev = strrev($ae);
218 | if (0 === strpos($aeRev, 'etalfed ,') // ie, webkit
219 | || 0 === strpos($aeRev, 'etalfed,') // gecko
220 | || 0 === strpos($ae, 'deflate,') // opera
221 | // slow parsing
222 | || preg_match(
223 | '@(?:^|,)\\s*deflate\\s*(?:$|,|;\\s*q=(?:0\\.|1))@', $ae)) {
224 | return array('deflate', 'deflate');
225 | }
226 | }
227 | if ($allowCompress && preg_match(
228 | '@(?:^|,)\\s*((?:x-)?compress)\\s*(?:$|,|;\\s*q=(?:0\\.|1))@'
229 | ,$ae
230 | ,$m)) {
231 | return array('compress', $m[1]);
232 | }
233 | return array('', '');
234 | }
235 |
236 | /**
237 | * Encode (compress) the content
238 | *
239 | * If the encode method is '' (none) or compression level is 0, or the 'zlib'
240 | * extension isn't loaded, we return false.
241 | *
242 | * Then the appropriate gz_* function is called to compress the content. If
243 | * this fails, false is returned.
244 | *
245 | * The header "Vary: Accept-Encoding" is added. If encoding is successful,
246 | * the Content-Length header is updated, and Content-Encoding is also added.
247 | *
248 | * @param int $compressionLevel given to zlib functions. If not given, the
249 | * class default will be used.
250 | *
251 | * @return bool success true if the content was actually compressed
252 | */
253 | public function encode($compressionLevel = null)
254 | {
255 | if (! self::isBuggyIe()) {
256 | $this->_headers['Vary'] = 'Accept-Encoding';
257 | }
258 | if (null === $compressionLevel) {
259 | $compressionLevel = self::$compressionLevel;
260 | }
261 | if ('' === $this->_encodeMethod[0]
262 | || ($compressionLevel == 0)
263 | || !extension_loaded('zlib'))
264 | {
265 | return false;
266 | }
267 | if ($this->_encodeMethod[0] === 'deflate') {
268 | $encoded = gzdeflate($this->_content, $compressionLevel);
269 | } elseif ($this->_encodeMethod[0] === 'gzip') {
270 | $encoded = gzencode($this->_content, $compressionLevel);
271 | } else {
272 | $encoded = gzcompress($this->_content, $compressionLevel);
273 | }
274 | if (false === $encoded) {
275 | return false;
276 | }
277 | $this->_headers['Content-Length'] = $this->_useMbStrlen
278 | ? (string)mb_strlen($encoded, '8bit')
279 | : (string)strlen($encoded);
280 | $this->_headers['Content-Encoding'] = $this->_encodeMethod[1];
281 | $this->_content = $encoded;
282 | return true;
283 | }
284 |
285 | /**
286 | * Encode and send appropriate headers and content
287 | *
288 | * This is a convenience method for common use of the class
289 | *
290 | * @param string $content
291 | *
292 | * @param int $compressionLevel given to zlib functions. If not given, the
293 | * class default will be used.
294 | *
295 | * @return bool success true if the content was actually compressed
296 | */
297 | public static function output($content, $compressionLevel = null)
298 | {
299 | if (null === $compressionLevel) {
300 | $compressionLevel = self::$compressionLevel;
301 | }
302 | $he = new HTTP_Encoder(array('content' => $content));
303 | $ret = $he->encode($compressionLevel);
304 | $he->sendAll();
305 | return $ret;
306 | }
307 |
308 | /**
309 | * Is the browser an IE version earlier than 6 SP2?
310 | *
311 | * @return bool
312 | */
313 | public static function isBuggyIe()
314 | {
315 | if (empty($_SERVER['HTTP_USER_AGENT'])) {
316 | return false;
317 | }
318 | $ua = $_SERVER['HTTP_USER_AGENT'];
319 | // quick escape for non-IEs
320 | if (0 !== strpos($ua, 'Mozilla/4.0 (compatible; MSIE ')
321 | || false !== strpos($ua, 'Opera')) {
322 | return false;
323 | }
324 | // no regex = faaast
325 | $version = (float)substr($ua, 30);
326 | return self::$encodeToIe6
327 | ? ($version < 6 || ($version == 6 && false === strpos($ua, 'SV1')))
328 | : ($version < 7);
329 | }
330 |
331 | protected $_content = '';
332 | protected $_headers = array();
333 | protected $_encodeMethod = array('', '');
334 | protected $_useMbStrlen = false;
335 | }
336 |
--------------------------------------------------------------------------------
/system/expressionengine/third_party/minimee/libraries/HTTP/ConditionalGet.php:
--------------------------------------------------------------------------------
1 |
13 | * list($updateTime, $content) = getDbUpdateAndContent();
14 | * $cg = new HTTP_ConditionalGet(array(
15 | * 'lastModifiedTime' => $updateTime
16 | * ,'isPublic' => true
17 | * ));
18 | * $cg->sendHeaders();
19 | * if ($cg->cacheIsValid) {
20 | * exit();
21 | * }
22 | * echo $content;
23 | *
24 | *
25 | * E.g. Shortcut for the above
26 | *
27 | * HTTP_ConditionalGet::check($updateTime, true); // exits if client has cache
28 | * echo $content;
29 | *
30 | *
31 | * E.g. Content from DB with no update time:
32 | *
33 | * $content = getContentFromDB();
34 | * $cg = new HTTP_ConditionalGet(array(
35 | * 'contentHash' => md5($content)
36 | * ));
37 | * $cg->sendHeaders();
38 | * if ($cg->cacheIsValid) {
39 | * exit();
40 | * }
41 | * echo $content;
42 | *
43 | *
44 | * E.g. Static content with some static includes:
45 | *
46 | * // before content
47 | * $cg = new HTTP_ConditionalGet(array(
48 | * 'lastUpdateTime' => max(
49 | * filemtime(__FILE__)
50 | * ,filemtime('/path/to/header.inc')
51 | * ,filemtime('/path/to/footer.inc')
52 | * )
53 | * ));
54 | * $cg->sendHeaders();
55 | * if ($cg->cacheIsValid) {
56 | * exit();
57 | * }
58 | *
59 | * @package Minify
60 | * @subpackage HTTP
61 | * @author Stephen Clay
168 | * array(
169 | * 'Cache-Control' => 'max-age=0, public'
170 | * ,'ETag' => '"foobar"'
171 | * )
172 | *
173 | *
174 | * @return array
175 | */
176 | public function getHeaders()
177 | {
178 | return $this->_headers;
179 | }
180 |
181 | /**
182 | * Set the Content-Length header in bytes
183 | *
184 | * With most PHP configs, as long as you don't flush() output, this method
185 | * is not needed and PHP will buffer all output and set Content-Length for
186 | * you. Otherwise you'll want to call this to let the client know up front.
187 | *
188 | * @param int $bytes
189 | *
190 | * @return int copy of input $bytes
191 | */
192 | public function setContentLength($bytes)
193 | {
194 | return $this->_headers['Content-Length'] = $bytes;
195 | }
196 |
197 | /**
198 | * Send headers
199 | *
200 | * @see getHeaders()
201 | *
202 | * Note this doesn't "clear" the headers. Calling sendHeaders() will
203 | * call header() again (but probably have not effect) and getHeaders() will
204 | * still return the headers.
205 | *
206 | * @return null
207 | */
208 | public function sendHeaders()
209 | {
210 | $headers = $this->_headers;
211 | if (array_key_exists('_responseCode', $headers)) {
212 | // FastCGI environments require 3rd arg to header() to be set
213 | list(, $code) = explode(' ', $headers['_responseCode'], 3);
214 | header($headers['_responseCode'], true, $code);
215 | unset($headers['_responseCode']);
216 | }
217 | foreach ($headers as $name => $val) {
218 | header($name . ': ' . $val);
219 | }
220 | }
221 |
222 | /**
223 | * Exit if the client's cache is valid for this resource
224 | *
225 | * This is a convenience method for common use of the class
226 | *
227 | * @param int $lastModifiedTime if given, both ETag AND Last-Modified headers
228 | * will be sent with content. This is recommended.
229 | *
230 | * @param bool $isPublic (default false) if true, the Cache-Control header
231 | * will contain "public", allowing proxies to cache the content. Otherwise
232 | * "private" will be sent, allowing only browser caching.
233 | *
234 | * @param array $options (default empty) additional options for constructor
235 | */
236 | public static function check($lastModifiedTime = null, $isPublic = false, $options = array())
237 | {
238 | if (null !== $lastModifiedTime) {
239 | $options['lastModifiedTime'] = (int)$lastModifiedTime;
240 | }
241 | $options['isPublic'] = (bool)$isPublic;
242 | $cg = new HTTP_ConditionalGet($options);
243 | $cg->sendHeaders();
244 | if ($cg->cacheIsValid) {
245 | exit();
246 | }
247 | }
248 |
249 |
250 | /**
251 | * Get a GMT formatted date for use in HTTP headers
252 | *
253 | *
254 | * header('Expires: ' . HTTP_ConditionalGet::gmtdate($time));
255 | *
256 | *
257 | * @param int $time unix timestamp
258 | *
259 | * @return string
260 | */
261 | public static function gmtDate($time)
262 | {
263 | return gmdate('D, d M Y H:i:s \G\M\T', $time);
264 | }
265 |
266 | protected $_headers = array();
267 | protected $_lmTime = null;
268 | protected $_etag = null;
269 | protected $_stripEtag = false;
270 |
271 | /**
272 | * @param string $hash
273 | *
274 | * @param string $scope
275 | */
276 | protected function _setEtag($hash, $scope)
277 | {
278 | $this->_etag = '"' . substr($scope, 0, 3) . $hash . '"';
279 | $this->_headers['ETag'] = $this->_etag;
280 | }
281 |
282 | /**
283 | * @param int $time
284 | */
285 | protected function _setLastModified($time)
286 | {
287 | $this->_lmTime = (int)$time;
288 | $this->_headers['Last-Modified'] = self::gmtDate($time);
289 | }
290 |
291 | /**
292 | * Determine validity of client cache and queue 304 header if valid
293 | *
294 | * @return bool
295 | */
296 | protected function _isCacheValid()
297 | {
298 | if (null === $this->_etag) {
299 | // lmTime is copied to ETag, so this condition implies that the
300 | // server sent neither ETag nor Last-Modified, so the client can't
301 | // possibly has a valid cache.
302 | return false;
303 | }
304 | $isValid = ($this->resourceMatchedEtag() || $this->resourceNotModified());
305 | if ($isValid) {
306 | $this->_headers['_responseCode'] = 'HTTP/1.0 304 Not Modified';
307 | }
308 | return $isValid;
309 | }
310 |
311 | /**
312 | * @return bool
313 | */
314 | protected function resourceMatchedEtag()
315 | {
316 | if (!isset($_SERVER['HTTP_IF_NONE_MATCH'])) {
317 | return false;
318 | }
319 | $clientEtagList = get_magic_quotes_gpc()
320 | ? stripslashes($_SERVER['HTTP_IF_NONE_MATCH'])
321 | : $_SERVER['HTTP_IF_NONE_MATCH'];
322 | $clientEtags = explode(',', $clientEtagList);
323 |
324 | $compareTo = $this->normalizeEtag($this->_etag);
325 | foreach ($clientEtags as $clientEtag) {
326 | if ($this->normalizeEtag($clientEtag) === $compareTo) {
327 | // respond with the client's matched ETag, even if it's not what
328 | // we would've sent by default
329 | $this->_headers['ETag'] = trim($clientEtag);
330 | return true;
331 | }
332 | }
333 | return false;
334 | }
335 |
336 | /**
337 | * @param string $etag
338 | *
339 | * @return string
340 | */
341 | protected function normalizeEtag($etag) {
342 | $etag = trim($etag);
343 | return $this->_stripEtag
344 | ? preg_replace('/;\\w\\w"$/', '"', $etag)
345 | : $etag;
346 | }
347 |
348 | /**
349 | * @return bool
350 | */
351 | protected function resourceNotModified()
352 | {
353 | if (!isset($_SERVER['HTTP_IF_MODIFIED_SINCE'])) {
354 | return false;
355 | }
356 | // strip off IE's extra data (semicolon)
357 | list($ifModifiedSince) = explode(';', $_SERVER['HTTP_IF_MODIFIED_SINCE'], 2);
358 | if (strtotime($ifModifiedSince) >= $this->_lmTime) {
359 | // Apache 2.2's behavior. If there was no ETag match, send the
360 | // non-encoded version of the ETag value.
361 | $this->_headers['ETag'] = $this->normalizeEtag($this->_etag);
362 | return true;
363 | }
364 | return false;
365 | }
366 | }
367 |
--------------------------------------------------------------------------------
/system/expressionengine/third_party/minimee/ext.minimee.php:
--------------------------------------------------------------------------------
1 |
23 | * @license http://www.opensource.org/licenses/bsd-license.php BSD license
24 | * @link http://johndwells.com/software/minimee
25 | */
26 | class Minimee_ext {
27 |
28 | /**
29 | * EE, obviously
30 | */
31 | private $EE;
32 |
33 |
34 | /**
35 | * Standard Extension stuff
36 | */
37 | public $name = MINIMEE_NAME;
38 | public $version = MINIMEE_VER;
39 | public $description = MINIMEE_DESC;
40 | public $docs_url = MINIMEE_DOCS;
41 | public $settings = array();
42 | public $settings_exist = 'y';
43 |
44 |
45 | /**
46 | * Our magical config class
47 | */
48 | public $config;
49 |
50 |
51 | /**
52 | * Reference to our cache
53 | */
54 | public $cache;
55 |
56 |
57 | // ------------------------------------------------------
58 |
59 |
60 | /**
61 | * Constructor
62 | *
63 | * NOTE: We never use the $settings variable passed to us,
64 | * because we want our Minimee_config object to always be in charge.
65 | *
66 | * @param mixed Settings array - only passed when activating a hook
67 | * @return void
68 | */
69 | public function __construct($settings = array())
70 | {
71 | // Got EE?
72 | $this->EE =& get_instance();
73 |
74 | // grab a reference to our cache
75 | $this->cache =& Minimee_helper::cache();
76 |
77 | // grab instance of our config object
78 | $this->config = Minimee_helper::config();
79 | }
80 | // ------------------------------------------------------
81 |
82 |
83 | /**
84 | * Activate Extension
85 | *
86 | * @return void
87 | */
88 | public function activate_extension()
89 | {
90 | // reset our runtime to 'factory' defaults, and return as array
91 | $settings = $this->config->factory()->to_array();
92 |
93 | // template_post_parse hook
94 | $this->EE->db->insert('extensions', array(
95 | 'class' => __CLASS__,
96 | 'hook' => 'template_post_parse',
97 | 'method' => 'template_post_parse',
98 | 'settings' => serialize($settings),
99 | 'priority' => 10,
100 | 'version' => $this->version,
101 | 'enabled' => 'y'
102 | ));
103 |
104 | // EE Debug Toolbar hook
105 | $this->EE->db->insert('extensions', array(
106 | 'class' => __CLASS__,
107 | 'hook' => 'ee_debug_toolbar_add_panel',
108 | 'method' => 'ee_debug_toolbar_add_panel',
109 | 'settings' => serialize($settings),
110 | 'priority' => 10,
111 | 'version' => $this->version,
112 | 'enabled' => 'y'
113 | ));
114 |
115 | Minimee_helper::log('Extension has been activated.', 3);
116 | }
117 | // ------------------------------------------------------
118 |
119 |
120 | /**
121 | * Disable Extension
122 | *
123 | * @return void
124 | */
125 | public function disable_extension()
126 | {
127 | $this->EE->db->where('class', __CLASS__);
128 | $this->EE->db->delete('extensions');
129 |
130 | Minimee_helper::log('Extension has been disabled.', 3);
131 | }
132 | // ------------------------------------------------------
133 |
134 |
135 | /**
136 | * Method for template_post_parse hook
137 | *
138 | * @param array Array of debug panels
139 | * @param arrat A collection of toolbar settings and values
140 | * @return array The amended array of debug panels
141 | */
142 | public function ee_debug_toolbar_add_panel($panels, $view)
143 | {
144 | // do nothing if not a page
145 | if(REQ != 'PAGE') return $panels;
146 |
147 | // play nice with others
148 | $panels = ($this->EE->extensions->last_call != '' ? $this->EE->extensions->last_call : $panels);
149 |
150 | $panels['minimee'] = new Eedt_panel_model();
151 | $panels['minimee']->set_name('minimee');
152 | $panels['minimee']->set_button_label("Minimee");
153 | $panels['minimee']->set_button_icon("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuNS1jMDIxIDc5LjE1NTc3MiwgMjAxNC8wMS8xMy0xOTo0NDowMCAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIDIwMTQgKE1hY2ludG9zaCkiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6NjQxMzVDNTBGRDdCMTFFMzhDQzk5MzI3QzQ4QkE1NDUiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6NjQxMzVDNTFGRDdCMTFFMzhDQzk5MzI3QzQ4QkE1NDUiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDpFQkM3RkNGNUZENzUxMUUzOENDOTkzMjdDNDhCQTU0NSIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDpFQkM3RkNGNkZENzUxMUUzOENDOTkzMjdDNDhCQTU0NSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PpUOrpsAAAAQSURBVHjaYvj//z8DQIABAAj8Av7bok0WAAAAAElFTkSuQmCC");
154 | $panels['minimee']->set_panel_contents($this->EE->load->view('eedebug_panel', array('logs' => Minimee_helper::get_log()), TRUE));
155 |
156 | if(Minimee_helper::log_has_error())
157 | {
158 | $panels['minimee']->set_panel_css_class('flash');
159 | }
160 |
161 | return $panels;
162 | }
163 | // ------------------------------------------------------
164 |
165 |
166 | /**
167 | * Alias for backwards-compatibility with M1
168 | */
169 | public function minify_html($template, $sub, $site_id)
170 | {
171 | return $this->template_post_parse($template, $sub, $site_id);
172 | }
173 | // ------------------------------------------------------
174 |
175 |
176 |
177 | /**
178 | * Method for template_post_parse hook
179 | *
180 | * @param string Parsed template string
181 | * @param bool Whether is a sub-template or not
182 | * @param string Site ID
183 | * @return string Template string, possibly minified
184 | */
185 | public function template_post_parse($template, $sub, $site_id)
186 | {
187 | // play nice with others
188 | if (isset($this->EE->extensions->last_call) && $this->EE->extensions->last_call)
189 | {
190 | $template = $this->EE->extensions->last_call;
191 | }
192 |
193 | // do nothing if not final template
194 | if ($sub !== FALSE)
195 | {
196 | return $template;
197 | }
198 |
199 | // see if we need to post-render any plugin methods
200 | if (isset($this->cache['template_post_parse']))
201 | {
202 | if ( ! class_exists('Minimee'))
203 | {
204 | include_once PATH_THIRD . 'minimee/pi.minimee.php';
205 | }
206 |
207 | // create a new instance of Minimee each time to guarantee defaults
208 | $m = new Minimee();
209 |
210 | // save our TMPL values to put back into place once finished
211 | $tagparams = $this->EE->TMPL->tagparams;
212 |
213 | // loop through & call each method
214 | foreach($this->cache['template_post_parse'] as $needle => $tag)
215 | {
216 | Minimee_helper::log('Calling Minimee::display("' . $tag['method'] . '") during template_post_parse: ' . serialize($tag['tagparams']), 3);
217 |
218 | $this->EE->TMPL->tagparams = $tag['tagparams'];
219 |
220 | // our second parameter tells Minimee we are calling from template_post_parse
221 | $out = $m->display($tag['method'], TRUE);
222 |
223 | // replace our needle with output
224 | $template = str_replace(LD.$needle.RD, $out, $template);
225 |
226 | // reset Minimee for next loop
227 | $m->reset();
228 | }
229 |
230 | // put things back into place
231 | $this->EE->TMPL->tagparams = $tagparams;
232 | }
233 |
234 | // do nothing if not (likely) html!
235 | if ( ! preg_match('/webpage|static/i', $this->EE->TMPL->template_type))
236 | {
237 | return $template;
238 | }
239 |
240 | // Are we configured to run through HTML minifier?
241 | if ($this->config->is_no('minify_html'))
242 | {
243 | Minimee_helper::log('HTML minification is disabled.', 3);
244 | return $template;
245 | }
246 |
247 | // is Minimee nonetheless disabled?
248 | if ($this->config->is_yes('disable'))
249 | {
250 | Minimee_helper::log('HTML minification aborted because Minimee has been disabled completely.', 3);
251 | return $template;
252 | }
253 |
254 | // we've made it this far, so...
255 | Minimee_helper::log('Running HTML minification.', 3);
256 |
257 | Minimee_helper::library('html');
258 |
259 | // run css & js minification?
260 | $opts = array();
261 | if($this->config->is_yes('minify_css'))
262 | {
263 | $opts['cssMinifier'] = array('Minify_CSS', 'minify');
264 | }
265 | if($this->config->is_yes('minify_js'))
266 | {
267 | $opts['jsMinifier'] = array('JSMin', 'minify');
268 | }
269 |
270 | return Minify_HTML::minify($template, $opts);
271 | }
272 | // ------------------------------------------------------
273 |
274 |
275 | /**
276 | * Save settings
277 | *
278 | * @return void
279 | */
280 | public function save_settings()
281 | {
282 | if (empty($_POST))
283 | {
284 | Minimee_helper::log($this->EE->lang->line('unauthorized_access'), 1);
285 | }
286 |
287 | else
288 | {
289 | // grab our posted form
290 | $settings = $_POST;
291 |
292 | // checkboxes are funny: if they don't exist in post, they must be explicitly added and set to "no"
293 | $checkboxes = array(
294 | 'combine_css',
295 | 'combine_js',
296 | 'minify_css',
297 | 'minify_html',
298 | 'minify_js'
299 | );
300 |
301 | foreach($checkboxes as $key)
302 | {
303 | if ( ! isset($settings[$key]))
304 | {
305 | $settings[$key] = 'no';
306 | }
307 | }
308 |
309 | // run our $settings through sanitise_settings()
310 | $settings = $this->config->sanitise_settings(array_merge($this->config->get_allowed(), $settings));
311 |
312 | // update db
313 | $this->EE->db->where('class', __CLASS__)
314 | ->update('extensions', array('settings' => serialize($settings)));
315 |
316 | Minimee_helper::log('Extension settings have been saved.', 3);
317 |
318 | // save the environment
319 | unset($settings);
320 |
321 | // let frontend know we succeeeded
322 | $this->EE->session->set_flashdata(
323 | 'message_success',
324 | $this->EE->lang->line('preferences_updated')
325 | );
326 |
327 | $this->EE->functions->redirect(BASE.AMP.'C=addons_extensions'.AMP.'M=extension_settings'.AMP.'file=minimee');
328 | }
329 | }
330 | // ------------------------------------------------------
331 |
332 |
333 | /**
334 | * Settings Form
335 | *
336 | * @param Array Current settings from DB
337 | * @return void
338 | */
339 | public function settings_form($current)
340 | {
341 | $this->EE->load->helper('form');
342 | $this->EE->load->library('table');
343 |
344 | // Merge the contents of our db with the allowed
345 | $current = array_merge($this->config->get_allowed(), $current);
346 |
347 | // Used to determine if any advanced settings have been changed
348 | $clean = $this->config->sanitise_settings($this->config->get_allowed());
349 | $basic = array('disable', 'cache_path', 'cache_url', 'combine_css', 'combine_js', 'minify_css', 'minify_js', 'minify_html');
350 |
351 | // remove basic settings
352 | $diff = array_diff(array_keys($clean), $basic);
353 | $hide_advanced_on_startup = 'TRUE';
354 |
355 | foreach($diff as $key)
356 | {
357 | if($clean[$key] != $current[$key])
358 | {
359 | $hide_advanced_on_startup = FALSE;
360 | break;
361 | }
362 | }
363 |
364 | // view vars
365 | $vars = array(
366 | 'config_warning' => ($this->config->location != 'db') ? lang('config_location_warning') : '',
367 | 'form_open' => form_open('C=addons_extensions'.AMP.'M=save_extension_settings'.AMP.'file=minimee'),
368 | 'settings' => $current,
369 | 'hide_advanced_on_startup' => $hide_advanced_on_startup,
370 | 'flashdata_success' => $this->EE->session->flashdata('message_success')
371 | );
372 |
373 | // return our view
374 | return $this->EE->load->view('settings_form', $vars, TRUE);
375 | }
376 | // ------------------------------------------------------
377 |
378 |
379 | /**
380 | * Update Extension
381 | *
382 | * @param string String value of current version
383 | * @return mixed void on update / false if none
384 | */
385 | public function update_extension($current = '')
386 | {
387 | /**
388 | * Up-to-date
389 | */
390 | if ($current == '' OR $current == $this->version)
391 | {
392 | return FALSE;
393 | }
394 |
395 | /**
396 | * 2.0.0
397 | *
398 | * - refactor to use new Minimee_config object
399 | */
400 | if (version_compare($current, '2.0.0', '<'))
401 | {
402 | $query = $this->EE->db
403 | ->select('settings')
404 | ->from('extensions')
405 | ->where('class', __CLASS__)
406 | ->limit(1)
407 | ->get();
408 |
409 | if ($query->num_rows() > 0)
410 | {
411 | $settings = unserialize($query->row()->settings);
412 |
413 | // migrate combine
414 | if(array_key_exists('combine', $settings))
415 | {
416 | $settings['combine_css'] = $settings['combine'];
417 | $settings['combine_js'] = $settings['combine'];
418 | unset($settings['combine']);
419 | }
420 |
421 | // migrate minify
422 | if(array_key_exists('minify', $settings))
423 | {
424 | $settings['minify_css'] = $settings['minify'];
425 | $settings['minify_js'] = $settings['minify'];
426 | $settings['minify_html'] = $settings['minify'];
427 | unset($settings['minify']);
428 | }
429 |
430 | // Sanitise & merge to get a complete up-to-date array of settings
431 | $settings = $this->config->sanitise_settings(array_merge($this->config->get_allowed(), $settings));
432 |
433 | // update db
434 | $this->EE->db
435 | ->where('class', __CLASS__)
436 | ->update('extensions', array(
437 | 'hook' => 'template_post_parse',
438 | 'method' => 'template_post_parse',
439 | 'settings' => serialize($settings)
440 | ));
441 | }
442 |
443 | $query->free_result();
444 |
445 | Minimee_helper::log('Upgraded to 2.0.0', 3);
446 | }
447 |
448 |
449 | /**
450 | * 2.1.8
451 | *
452 | * - Include debug panel via EE Debug Toolbar
453 | */
454 | if (version_compare($current, '2.1.8', '<'))
455 | {
456 | // grab a copy of our settings
457 | $query = $this->EE->db
458 | ->select('settings')
459 | ->from('extensions')
460 | ->where('class', __CLASS__)
461 | ->limit(1)
462 | ->get();
463 |
464 | if ($query->num_rows() > 0)
465 | {
466 | $settings = $query->row()->settings;
467 | }
468 | else
469 | {
470 | $settings = serialize($this->config->factory()->to_array());
471 | }
472 |
473 | // add extension hook
474 | $this->EE->db->insert('extensions', array(
475 | 'class' => __CLASS__,
476 | 'hook' => 'ee_debug_toolbar_add_panel',
477 | 'method' => 'ee_debug_toolbar_add_panel',
478 | 'settings' => $settings,
479 | 'priority' => 10,
480 | 'version' => $this->version,
481 | 'enabled' => 'y'
482 | ));
483 |
484 | $query->free_result();
485 |
486 | Minimee_helper::log('Upgraded to 2.1.8', 3);
487 | }
488 |
489 | // update table row with version
490 | $this->EE->db->where('class', __CLASS__);
491 | $this->EE->db->update(
492 | 'extensions',
493 | array('version' => $this->version)
494 | );
495 |
496 | Minimee_helper::log('Upgrade complete. Now running ' . $this->version, 3);
497 | }
498 | // ------------------------------------------------------
499 |
500 | }
501 | // END CLASS
502 |
503 |
504 | /* End of file ext.minimee.php */
505 | /* Location: ./system/expressionengine/third_party/minimee/ext.minimee.php */
--------------------------------------------------------------------------------