Beispiel #1
0
 public function action_minify()
 {
     // load config
     $config = Kohana::config('minify');
     //require  MINIFY_MIN_DIR.'/Minify.php';
     Minify::$uploaderHoursBehind = $config['uploaderHoursBehind'];
     Minify::setCache(isset($config['cachePath']) ? $config['cachePath'] : '', $config['cacheFileLocking']);
     if ($config['documentRoot']) {
         $_SERVER['DOCUMENT_ROOT'] = $config['documentRoot'];
     } elseif (0 === stripos(PHP_OS, 'win')) {
         Minify::setDocRoot();
         // IIS may need help
     }
     $config['serveOptions']['minifierOptions']['text/css']['symlinks'] = $config['symlinks'];
     // auto-add targets to allowDirs
     foreach ($config['symlinks'] as $uri => $target) {
         $config['serveOptions']['minApp']['allowDirs'][] = $target;
     }
     if ($config['allowDebugFlag']) {
         if (!empty($_COOKIE['minDebug'])) {
             foreach (preg_split('/\\s+/', $_COOKIE['minDebug']) as $debugUri) {
                 if (false !== strpos($_SERVER['REQUEST_URI'], $debugUri)) {
                     $config['serveOptions']['debug'] = true;
                     break;
                 }
             }
         }
         // allow GET to override
         if (isset($_GET['debug'])) {
             $config['serveOptions']['debug'] = true;
         }
     }
     if ($config['errorLogger']) {
         //require _once MINIFY_MIN_DIR . '/Minify/Logger.php';
         if (true === $config['errorLogger']) {
             //require _once MINIFY_MIN_DIR . '/FirePHP.php';
             Minify_Logger::setLogger(FirePHP::getInstance(true));
         } else {
             Minify_Logger::setLogger($config['errorLogger']);
         }
     }
     // check for URI versioning
     if (preg_match('/&\\d/', $_SERVER['QUERY_STRING'])) {
         $config['serveOptions']['maxAge'] = 31536000;
     }
     if (isset($_GET['g'])) {
         // well need groups config
         $config['serveOptions']['minApp']['groups'] = $config['groupsConfig'];
     }
     if (isset($_GET['f']) || isset($_GET['g'])) {
         // serve!
         Minify::serve('MinApp', $config['serveOptions']);
         exit;
     }
 }
Beispiel #2
0
 /**
  * Runs minify
  */
 function process()
 {
     require_once W3TC_LIB_MINIFY_DIR . '/Minify.php';
     require_once W3TC_LIB_MINIFY_DIR . '/HTTP/Encoder.php';
     HTTP_Encoder::$encodeToIe6 = $this->_config->get_boolean('minify.comprss.ie6');
     Minify::$uploaderHoursBehind = $this->_config->get_integer('minify.fixtime');
     Minify::setCache($this->_get_cache());
     $serve_options = $this->_config->get_array('minify.options');
     $serve_options['maxAge'] = $this->_config->get_integer('minify.maxage');
     $serve_options['encodeOutput'] = $this->_config->get_boolean('minify.compress');
     $serve_options['postprocessor'] = array(&$this, 'postprocessor');
     if (stripos(PHP_OS, 'win') === 0) {
         Minify::setDocRoot();
     }
     foreach ($this->_config->get_array('minify.symlinks') as $link => $target) {
         $link = str_replace('//', realpath($_SERVER['DOCUMENT_ROOT']), $link);
         $link = strtr($link, '/', DIRECTORY_SEPARATOR);
         $serve_options['minifierOptions']['text/css']['symlinks'][$link] = realpath($target);
     }
     if ($this->_config->get_boolean('minify.debug')) {
         $serve_options['debug'] = true;
     }
     if ($this->_config->get('minify.debug')) {
         require_once W3TC_LIB_MINIFY_DIR . '/Minify/Logger.php';
         Minify_Logger::setLogger($this);
     }
     if (isset($_GET['f']) || isset($_GET['gg']) && isset($_GET['g']) && isset($_GET['t'])) {
         if (isset($_GET['gg']) && isset($_GET['g']) && isset($_GET['t'])) {
             $serve_options['minApp']['groups'] = $this->get_groups($_GET['gg'], $_GET['t']);
             if ($_GET['t'] == 'js' && (in_array($_GET['g'], array('include', 'include-nb')) && $this->_config->get_boolean('minify.js.combine.header') || in_array($_GET['g'], array('include-footer', 'include-footer-nb')) && $this->_config->get_boolean('minify.js.combine.footer'))) {
                 $serve_options['minifiers']['application/x-javascript'] = array($this, 'minify_stub');
             }
             /**
              * Setup user-friendly cache ID for disk cache
              */
             if ($this->_config->get_string('minify.engine') == 'file') {
                 $cacheId = sprintf('%s.%s.%s', $_GET['gg'], $_GET['g'], $_GET['t']);
                 Minify::setCacheId($cacheId);
             }
         }
         @header('Pragma: public');
         try {
             Minify::serve('MinApp', $serve_options);
         } catch (Exception $exception) {
             printf('<strong>W3 Total Cache Error:</strong> Minify error: %s', $exception->getMessage());
         }
     } else {
         die('This file cannot be accessed directly');
     }
 }
Beispiel #3
0
 public function serve()
 {
     // Adapted from index.php and config.php in the Minify distribution
     $min_serveOptions = array();
     $min_uploaderHoursBehind = isset($this->_config['min_uploaderHoursBehind']) ? $this->_config['min_uploaderHoursBehind'] : 0;
     Minify::$uploaderHoursBehind = $min_uploaderHoursBehind;
     $min_cacheFileLocking = isset($this->_config['min_cacheFileLocking']) ? $this->_config['min_cacheFileLocking'] : true;
     $min_cachePath = $this->_config['cache_dir'];
     Minify::setCache($min_cachePath, $min_cacheFileLocking);
     $min_symlinks = isset($this->_config['min_symlinks']) ? $this->_config['min_symlinks'] : array();
     foreach ($min_symlinks as $link => $target) {
         $link = str_replace('//', realpath($_SERVER['DOCUMENT_ROOT']), $link);
         $link = strtr($link, '/', DIRECTORY_SEPARATOR);
         $min_serveOptions['minifierOptions']['text/css']['symlinks'][$link] = realpath($target);
     }
     $min_serveOptions['minifierOptions']['text/css']['symlinks'] = $min_symlinks;
     if (isset($this->_config['debug_minify_logger'])) {
         require_once 'Minify/Logger.php';
         if (true === $this->_config['debug_minify_logger']) {
             require_once 'FirePHP.php';
             Minify_Logger::setLogger(FirePHP::getInstance(true));
         } else {
             Minify_Logger::setLogger($this->_config['debug_minify_logger']);
         }
     }
     // check for URI versioning
     if (!empty($this->_version)) {
         $min_serveOptions['maxAge'] = 31536000;
     } else {
         # don't cache if we are not using a version number
         $min_serveOptions['maxAge'] = 0;
     }
     $min_serveOptions['swift']['files'] = array();
     foreach ($this->_current_modules as $module) {
         if (!empty($this->_config['debug_use_alt_resources']) && !empty($this->_config['modules'][$module]['debug_path'])) {
             $min_serveOptions['swift']['files'][] = $this->_config['modules'][$module]['debug_path'];
         } else {
             $min_serveOptions['swift']['files'][] = $this->_config['modules'][$module]['path'];
         }
     }
     # check what format we're working on by looking at the extension on the first file
     # if we are in debug mode for the current type of files use Minify's debug mode
     if (!empty($this->_config['debug_minify_js_off']) && pathinfo($min_serveOptions['swift']['files'][0], PATHINFO_EXTENSION) == 'js' || !empty($this->_config['debug_minify_css_off']) && pathinfo($min_serveOptions['swift']['files'][0], PATHINFO_EXTENSION) == 'css') {
         $min_serveOptions['debug'] = true;
     }
     Minify::serve('Swift', $min_serveOptions);
 }
Beispiel #4
0
 public function action_index()
 {
     $group = $this->request->param('group');
     if (!empty($group)) {
         $_GET['g'] = $group;
     }
     $config = Kohana::$config->load('minify');
     Minify::$uploaderHoursBehind = $config['uploaderHoursBehind'];
     Minify::setCache(isset($config['cachePath']) ? $config['cachePath'] : '', $config['cacheFileLocking']);
     if ($config['documentRoot']) {
         $_SERVER['DOCUMENT_ROOT'] = $config['documentRoot'];
         Minify::$isDocRootSet = TRUE;
     }
     $serve_options = $config['serveOptions'];
     $serve_options['minifierOptions']['text/css']['symlinks'] = $config['symlinks'];
     foreach ($config['symlinks'] as $uri => $target) {
         $serve_options['minApp']['allowDirs'][] = $target;
     }
     if ($config['allowDebugFlag']) {
         $serve_options['debug'] = Minify_DebugDetector::shouldDebugRequest($_COOKIE, $_GET, $_SERVER['REQUEST_URI']);
     }
     if ($config['errorLogger']) {
         if (TRUE === $config['errorLogger']) {
             Minify_Logger::setLogger(FirePHP::getInstance(true));
         } else {
             Minify_Logger::setLogger($config['errorLogger']);
         }
     }
     // Check for URI versioning
     if (preg_match('/&\\d/', Arr::get($_SERVER, 'QUERY_STRING'))) {
         $serve_options['maxAge'] = 31536000;
     }
     if (isset($_GET['g'])) {
         // well need groups config
         $serve_options['minApp']['groups'] = $config['groupsConfig'];
     }
     if (isset($_GET['f']) or isset($_GET['g'])) {
         $response = Minify::serve(new Minify_Controller_MinApp(), array('quiet' => TRUE) + $serve_options);
         $this->response->headers($response['headers'])->status($response['statusCode'])->body($response['content']);
     }
 }
Beispiel #5
0
 public function action_index()
 {
     extract(Kohana::$config->load('minify')->as_array(), EXTR_SKIP);
     if ($this->request->param('group')) {
         $_GET['g'] = $this->request->param('group');
     }
     Minify::$uploaderHoursBehind = $uploaderHoursBehind;
     Minify::setCache(isset($cachePath) ? $cachePath : '', $cacheFileLocking);
     if ($documentRoot) {
         $_SERVER['DOCUMENT_ROOT'] = $documentRoot;
         Minify::$isDocRootSet = TRUE;
     }
     $serveOptions['minifierOptions']['text/css']['symlinks'] = $symlinks;
     $serveOptions['minApp']['allowDirs'] += array_values($symlinks);
     if ($allowDebugFlag) {
         $serveOptions['debug'] = Minify_DebugDetector::shouldDebugRequest($_COOKIE, $_GET, $_SERVER['REQUEST_URI']);
     }
     if ($errorLogger) {
         if (TRUE === $errorLogger) {
             $errorLogger = FirePHP::getInstance(TRUE);
         }
         Minify_Logger::setLogger($errorLogger);
     }
     // Check for URI versioning
     if (preg_match('/&\\d/', $_SERVER['QUERY_STRING'])) {
         $serveOptions['maxAge'] = 31536000;
     }
     if (isset($_GET['g'])) {
         // Well need groups config
         $serveOptions['minApp']['groups'] = $groupsConfig;
     }
     if (isset($_GET['f']) or isset($_GET['g'])) {
         set_time_limit(0);
         // Serve!
         $response = Minify::serve(new Minify_Controller_MinApp(), array('quiet' => TRUE) + $serveOptions);
         $this->response->headers($response['headers'])->body($response['content'])->status($response['statusCode']);
     }
 }
Beispiel #6
0
                            msg += 'The option "zlib.output_compression" is disabled in your PHP configuration '
                                + 'so this behavior is likely due to a server option.';
                        $(document.body).prepend(msg + '<\/p>');
                    } else if (ocStatus == '1')
                        $(document.body).prepend('<\p class=topNote><\strong>Note:</\strong> The option '
                            + '"zlib.output_compression" is enabled in your PHP configuration, but has been '
                            + 'successfully disabled via ini_set(). If you experience mangled output you '
                            + 'may want to consider disabling this option in your PHP configuration.<\/p>'
                        );
                });
            });
        });
    </script>
    <script type="text/javascript">
        // workaround required to test when /min isn't child of web root
        var src = location.pathname.replace(/\/[^\/]*$/, '/_index.js').substr(1);
        document.write('<\script type="text/javascript" src="../?f=' + src + '"><\/script>');
    </script>

<?php 
$serveOpts = array('content' => ob_get_contents(), 'id' => __FILE__, 'lastModifiedTime' => max(filemtime(__FILE__), filemtime(dirname(__FILE__) . '/../config.php')), 'minifyAll' => true, 'encodeOutput' => $encodeOutput);
ob_end_clean();
set_include_path(dirname(__FILE__) . '/../lib' . PATH_SEPARATOR . get_include_path());
require 'Minify.php';
if (0 === stripos(PHP_OS, 'win')) {
    Minify::setDocRoot();
    // we may be on IIS
}
Minify::setCache(isset($min_cachePath) ? $min_cachePath : null);
Minify::$uploaderHoursBehind = $min_uploaderHoursBehind;
Minify::serve('Page', $serveOpts);
 public function action_template_header()
 {
     //Cache::expire( self::$cache_name . '_js' );
     //Cache::expire( self::$cache_name . '_css' );
     // try to disable output_compression (may not have an effect)
     ini_set('zlib.output_compression', '0');
     $modified_js = Stack::get_sorted_stack('template_header_javascript');
     foreach ($modified_js as $key => $value) {
         Stack::remove('template_header_javascript', $key);
     }
     Stack::add('template_header_javascript', Site::get_url('user') . '/files/minified.js', 'Minified');
     $modified_css = Stack::get_sorted_stack('template_stylesheet');
     $css = array();
     foreach ($modified_css as $key => $value) {
         $css[] = $value[0];
         Stack::remove('template_stylesheet', $key);
     }
     Stack::add('template_stylesheet', array(Site::get_url('user') . "/files/minified.css", 'screen'), 'style');
     /*
      * If we have the files or the cache havent expired don't create new files.
      */
     if (!file_exists(site::get_dir('user') . '/files/minified.css') || !file_exists(site::get_dir('user') . '/files/minified.js') || (!Cache::has(self::$cache_name . '_js') || !Cache::has(self::$cache_name . '_css'))) {
         /* Taken from min/index.php */
         define('MINIFY_MIN_DIR', dirname(__FILE__) . '/min/');
         // load config
         require MINIFY_MIN_DIR . '/config.php';
         // setup include path
         set_include_path($min_libPath . PATH_SEPARATOR . get_include_path());
         require 'Minify.php';
         Minify::$uploaderHoursBehind = $min_uploaderHoursBehind;
         Minify::setCache(isset($min_cachePath) ? $min_cachePath : '', $min_cacheFileLocking);
         if ($min_documentRoot) {
             $_SERVER['DOCUMENT_ROOT'] = $min_documentRoot;
         } elseif (0 === stripos(PHP_OS, 'win')) {
             Minify::setDocRoot();
             // IIS may need help
         }
         $min_serveOptions['minifierOptions']['text/css']['symlinks'] = $min_symlinks;
         // Using jsmin+ 1.3
         $min_serveOptions['minifiers']['application/x-javascript'] = array('JSMinPlus', 'minify');
         /* Javascript */
         if (!Cache::has(self::$cache_name . '_js') || !file_exists(site::get_dir('user') . '/files/minified.js')) {
             $js_stack = array();
             foreach ($modified_js as $js) {
                 $js_stack[] = Site::get_path('base') . str_replace(Site::get_url('habari') . '/', '', $js);
             }
             $options = array('files' => $js_stack, 'encodeOutput' => false, 'quiet' => true);
             $result = Minify::serve('Files', $options);
             file_put_contents(site::get_dir('user') . '/files/minified.js', $result['content']);
             Cache::set(self::$cache_name . '_js', 'true', Options::get('minification__expire'));
         }
         /* CSS */
         if (!Cache::has(self::$cache_name . '_css') || !file_exists(site::get_dir('user') . '/files/minified.css')) {
             $css_stack = array();
             foreach ($css as $file) {
                 $css_stack[] = Site::get_path('base') . str_replace(Site::get_url('habari') . '/', '', $file);
             }
             $options = array('files' => $css_stack, 'encodeOutput' => false, 'quiet' => true);
             // handle request
             $result = Minify::serve('Files', $options);
             file_put_contents(site::get_dir('user') . '/files/minified.css', $result['content']);
             Cache::set(self::$cache_name . '_css', 'true', Options::get('minification__expire'));
         }
     }
 }
 /**
  * Serves friendly minify url with minified contents
  *
  * This actually does a remote get from Minify's dir with appropriate `?f`
  * query variable built from persistently stored detected enqueued files.
  * All minified contents as well as headers should be preserved.
  *
  * Serving friendly minify urls like this cause a lot of overheads, but is
  * safer to use than server rewrite rules.
  *
  * @uses wp_remote_get()
  * @return void
  */
 public function serve($query)
 {
     $group_handle = isset($_GET['min_group']) ? $this->_sanitize_request($_GET['min_group']) : '';
     $type = isset($_GET['min_type']) && in_array($_GET['min_type'], array('js', 'css')) ? $_GET['min_type'] : '';
     $bid = isset($_GET['blog']) ? (int) $_GET['blog'] : 0;
     if (empty($group_handle) || empty($type) || empty($bid)) {
         // if missing any important data, do not proceed
         return;
     }
     global $blog_id;
     if ($bid != $blog_id) {
         // if not on the correct blog, do not proceed
         return;
     }
     $group = $this->_detector->get_group($group_handle);
     if (false == $group) {
         // this should not happen, but just in case it does
         echo sprintf(__('Minify group %s not found.', $this->_domain), $group_handle);
         exit;
     }
     // load Minify class based on default or custom Minify directory
     $min_dir = $this->_main->get_min_dir();
     if (empty($min_dir) || !file_exists($min_dir . 'config.php')) {
         // if Minify directory is not valid or Minify library is not found
         // we can not continue
         _e('Invalid Minify directory, please check Minify settings.', $this->_domain);
         exit;
     }
     // prepare input for Minify to handle
     $_GET['f'] = $group['string'];
     if ($this->_options['enable_debug'] == 'yes') {
         // add debug flag if needed
         $_GET['debug'] = 1;
     } else {
         // minified contents are often served compressed so it's best to turn off
         // error reporting to avoid content encoding error, unless debug is
         // enabled. This is useful when Minify doesn't catch all the notices
         // (for example when the cache directory is not writable).
         error_reporting(0);
     }
     // load Minify classes
     define('MINIFY_MIN_DIR', $min_dir);
     require_once MINIFY_MIN_DIR . '/config.php';
     require_once $min_libPath . '/Minify/Loader.php';
     Minify_Loader::register();
     // set some optional for the Minify application based on current settings
     Minify::$uploaderHoursBehind = $min_uploaderHoursBehind;
     // set cache file name (id) and cache path if needed
     Minify::setCacheId('minify-b' . $blog_id . '-' . $group_handle . '.' . $type);
     Minify::setCache(isset($min_cachePath) ? $min_cachePath : '', $min_cacheFileLocking);
     if ($min_documentRoot) {
         $_SERVER['DOCUMENT_ROOT'] = $min_documentRoot;
         Minify::$isDocRootSet = true;
     }
     // set serve options for each file type if needed
     $min_serveOptions['minifierOptions']['text/css']['symlinks'] = $min_symlinks;
     foreach ($min_symlinks as $uri => $target) {
         $min_serveOptions['minApp']['allowDirs'][] = $target;
     }
     if ($min_allowDebugFlag) {
         // allow debugging Minify application
         $min_serveOptions['debug'] = Minify_DebugDetector::shouldDebugRequest($_COOKIE, $_GET, $_SERVER['REQUEST_URI']);
     }
     if ($min_errorLogger) {
         // log Minify error if allowed
         if (true === $min_errorLogger) {
             $min_errorLogger = FirePHP::getInstance(true);
         }
         Minify_Logger::setLogger($min_errorLogger);
     }
     // serve minified contents, on the fly or from cache
     $min_serveController = new Minify_Controller_MinApp();
     Minify::serve($min_serveController, $min_serveOptions);
     // for a proper response headers
     exit;
 }
Beispiel #9
0
 public function connect(Application $app)
 {
     $app['controller.minifier'] = $this;
     $controllers = $app['controllers_factory'];
     $controllers->get('/', function (Application $app, Request $request) {
         // cache directory path
         $min_cachePath = $app['root.path'] . '/tmp/cache_minify';
         /**
          * Cache file locking. Set to false if filesystem is NFS. On at least one
          * NFS system flock-ing attempts stalled PHP for 30 seconds!
          */
         $min_cacheFileLocking = true;
         /**
          * Combining multiple CSS files can place @import declarations after rules, which
          * is invalid. Minify will attempt to detect when this happens and place a
          * warning comment at the top of the CSS output. To resolve this you can either
          * move the @imports within your CSS files, or enable this option, which will
          * move all @imports to the top of the output. Note that moving @imports could
          * affect CSS values (which is why this option is disabled by default).
          */
         $min_serveOptions['bubbleCssImports'] = false;
         if ($app['debug']) {
             // may cause js errors
             $min_serveOptions['debug'] = false;
             // disallow minification instead
             $min_serveOptions['minApp']['noMinPattern'] = '#\\.(?:js|css)$#i';
             $min_serveOptions['maxAge'] = 0;
         } else {
             $min_serveOptions['debug'] = false;
             $min_serveOptions['maxAge'] = 1800;
         }
         /**
          * Set to true to disable the "f" GET parameter for specifying files.
          * Only the "g" parameter will be considered.
          */
         $min_serveOptions['minApp']['groupsOnly'] = false;
         /**
          * Maximum # of files that can be specified in the "f" GET parameter
          */
         $min_serveOptions['minApp']['maxFiles'] = 10;
         /**
          * If you minify CSS files stored in symlink-ed directories, the URI rewriting
          * algorithm can fail. To prevent this, provide an array of link paths to
          * target paths, where the link paths are within the document root.
          *
          * Because paths need to be normalized for this to work, use "//" to substitute
          * the doc root in the link paths (the array keys). E.g.:
          * <code>
          * array('//symlink' => '/real/target/path') // unix
          * array('//static' => 'D:\\staticStorage')  // Windows
          * </code>
          */
         $min_symlinks = [];
         /**
          * If you upload files from Windows to a non-Windows server, Windows may report
          * incorrect mtimes for the files. This may cause Minify to keep serving stale
          * cache files when source file changes are made too frequently (e.g. more than
          * once an hour).
          *
          * Immediately after modifying and uploading a file, use the touch command to
          * update the mtime on the server. If the mtime jumps ahead by a number of hours,
          * set this variable to that number. If the mtime moves back, this should not be
          * needed.
          *
          * In the Windows SFTP client WinSCP, there's an option that may fix this
          * issue without changing the variable below. Under login > environment,
          * select the option "Adjust remote timestamp with DST".
          * @link http://winscp.net/eng/docs/ui_login_environment#daylight_saving_time
          */
         $min_uploaderHoursBehind = 0;
         // return an array instead of echoing output
         $min_serveOptions['quiet'] = true;
         \Minify::$uploaderHoursBehind = $min_uploaderHoursBehind;
         \Minify::setCache(isset($min_cachePath) ? $min_cachePath : '', $min_cacheFileLocking);
         // required to work well :(
         $_SERVER['DOCUMENT_ROOT'] = __DIR__ . '/../../../../www/';
         \Minify::$isDocRootSet = true;
         $min_serveOptions['minifierOptions']['text/css']['symlinks'] = $min_symlinks;
         // auto-add targets to allowDirs
         foreach ($min_symlinks as $uri => $target) {
             $min_serveOptions['minApp']['allowDirs'][] = $target;
         }
         if (null !== $request->query->get('g')) {
             // well need groups config
             $min_serveOptions['minApp']['groups'] = (require __DIR__ . '/../../../conf.d/minifyGroupsConfig.php');
         }
         if (null === $request->query->get('f') && null === $request->query->get('g')) {
             throw new HttpException(400, 'Please provide an argument');
         }
         $ret = \Minify::serve(new \Minify_Controller_MinApp(), $min_serveOptions);
         if (!$ret['success']) {
             throw new HttpException(500, 'Unable to generate data');
         }
         $response = new Response($ret['content'], $ret['statusCode']);
         $response->setMaxAge($min_serveOptions['maxAge']);
         foreach ($ret['headers'] as $key => $value) {
             $response->headers->set($key, $value);
         }
         return $response;
     })->bind('minifier');
     return $controllers;
 }
Beispiel #10
0
 public function runServe(TBGRequest $request)
 {
     if (!TBGContext::isMinifyEnabled()) {
         $itemarray = array($request['g'] => explode(',', base64_decode($request['files'])));
         if (array_key_exists('js', $itemarray)) {
             header('Content-type: text/javascript');
             foreach ($itemarray['js'] as $file) {
                 $ext = substr($file, -2);
                 if ($ext == 'js' && file_exists($file) && strpos(realpath($file), THEBUGGENIE_PATH) !== false) {
                     echo file_get_contents($file);
                 }
             }
         } else {
             header('Content-type: text/css');
             foreach ($itemarray['css'] as $file) {
                 $ext = substr($file, -3);
                 if ($ext == 'css' && file_exists($file) && strpos(realpath($file), THEBUGGENIE_PATH) !== false) {
                     echo file_get_contents($file);
                 }
             }
         }
         exit;
     }
     $this->getResponse()->setDecoration(TBGResponse::DECORATE_NONE);
     define('MINIFY_MIN_DIR', dirname(__FILE__) . '/../../../core/min');
     // load config
     require MINIFY_MIN_DIR . '/config.php';
     // setup include path
     set_include_path($min_libPath . PATH_SEPARATOR . get_include_path());
     require 'Minify.php';
     Minify::$uploaderHoursBehind = $min_uploaderHoursBehind;
     Minify::setCache(isset($min_cachePath) ? $min_cachePath : '', $min_cacheFileLocking);
     if ($min_documentRoot) {
         $_SERVER['DOCUMENT_ROOT'] = $min_documentRoot;
     } elseif (0 === mb_stripos(PHP_OS, 'win')) {
         Minify::setDocRoot();
         // IIS may need help
     }
     $min_serveOptions['minifierOptions']['text/css']['symlinks'] = $min_symlinks;
     if ($min_allowDebugFlag && isset($_GET['debug'])) {
         $min_serveOptions['debug'] = true;
     }
     if ($min_errorLogger) {
         require_once 'Minify/Logger.php';
         if (true === $min_errorLogger) {
             require_once 'FirePHP.php';
             Minify_Logger::setLogger(FirePHP::getInstance(true));
         } else {
             Minify_Logger::setLogger($min_errorLogger);
         }
     }
     // check for URI versioning
     if (preg_match('/&\\d/', $_SERVER['QUERY_STRING'])) {
         $min_serveOptions['maxAge'] = 31536000;
     }
     $itemarray = array($request['g'] => explode(',', base64_decode($request['files'])));
     $min_serveOptions['minApp']['groups'] = $itemarray;
     ob_end_clean();
     $data = Minify::serve('MinApp', $min_serveOptions);
     header_remove('Pragma');
     foreach ($data['headers'] as $name => $val) {
         header($name . ': ' . $val);
     }
     header('HTTP/1.1 ' . $data['statusCode']);
     if ($data['statusCode'] != 304) {
         echo $data['content'];
     }
     exit;
 }
 public function action_plugin_act_do_minify($handler)
 {
     $_SERVER['DOCUMENT_ROOT'] = HABARI_PATH;
     define('MINIFY_MIN_DIR', dirname(__FILE__) . '/vendor');
     ini_set('zlib.output_compression', '0');
     set_include_path(dirname(__FILE__) . '/vendor' . PATH_SEPARATOR . get_include_path());
     $opts['bubbleCssImports'] = FALSE;
     $opts['maxAge'] = preg_match('/&\\d/', $_SERVER['QUERY_STRING']) ? 31536000 : Options::get('minify__max_age');
     // check for URI versioning
     $opts['minApp']['groupsOnly'] = FALSE;
     $opts['minApp']['maxFiles'] = 20;
     $opts['encodeOutput'] = Options::get('minify__encode_output');
     require 'Minify.php';
     Minify::$uploaderHoursBehind = 0;
     Minify::setCache(HABARI_PATH . '/user/cache/', TRUE);
     Minify::serve('MinApp', $opts);
 }