mirror of
https://github.com/UnickSoft/graphonline.git
synced 2025-07-01 15:26:12 +00:00
700 lines
30 KiB
PHP
Executable File
700 lines
30 KiB
PHP
Executable File
<?php
|
||
|
||
require_once dirname(__FILE__) . "/Lib/CssPacker.php";
|
||
require_once dirname(__FILE__) . "/Lib/HtmlPacker.php";
|
||
require_once dirname(__FILE__) . "/Lib/JSMin.php";
|
||
require_once dirname(__FILE__) . "/Lib/lessc.inc.php";
|
||
|
||
|
||
/**
|
||
* ExtraPacker - для склеивания и сжатия css и js файлов, а так же сжатия html-контента
|
||
*
|
||
* Выбирает все подключаемые js-ки (тоже с css-ками) собирает в 1 файл и пакует записывая файл info с информацией по запакованным файлам.
|
||
* Поддерживает механизм транзакций.
|
||
*
|
||
* @author Zmi
|
||
*/
|
||
class ExtraPacker
|
||
{
|
||
/**
|
||
* Коэфициент сжатия для js/css при GZIP сжатии
|
||
*/
|
||
const COEF_GZIP_COMPRESS = 9;
|
||
|
||
/**
|
||
* Тег после которого должны встать ссылки на запакованные js и css файлы должен рассполагаться в head разделе документа
|
||
*/
|
||
const TAG_EXTRAPACKER = '<!-- extraPacker -->';
|
||
|
||
const MEMORY_FOR_PACKING = 67108864; // 64Mb
|
||
|
||
const FORCE_DISABLE_GZIP = false;
|
||
|
||
private $addrJsCacheFileInfo;
|
||
private $addrJsCacheFile;
|
||
private $addrCssCacheFileInfo;
|
||
private $addrCssCacheFile;
|
||
private $addrNumJsTrans;
|
||
private $addrNumCssTrans;
|
||
private $flgHtmlPack;
|
||
private $flgCssPack;
|
||
private $flgJsPack;
|
||
private $flgUseTransSystem;
|
||
private $gzipPostfix = '.gz';
|
||
private $pCallBackFunctionJS = NULL;
|
||
private $pCallBackFunctionCSS = NULL;
|
||
private $pFuncGetAddrJsPackFile = NULL;
|
||
private $pFuncGetAddrCssPackFile = NULL;
|
||
private $pGetPathJsFileFromUrl = NULL;
|
||
private $pGetPathCssFileFromUrl = NULL;
|
||
private $arrExeptions_js;
|
||
private $arrExeptionsNotAdd_js;
|
||
private $arrExeptions_css;
|
||
private $arrExeptionsNotAdd_css;
|
||
private $pFuncPreWriteCache;
|
||
private $pFuncPostWriteCache;
|
||
private $flgUseGZIP;
|
||
private $flgBuffering;
|
||
private $pPrepareEachFile = NULL;
|
||
|
||
// Только склеивать файлы
|
||
const ONLY_MERGE_CSS = false;
|
||
const ONLY_MERGE_JS = false;
|
||
|
||
// Перепаковывать каждый раз (удобно если = DEBUG_MODE)
|
||
const ALWAYS_INDEPENDENT_PACK = false;
|
||
const ALWAYS_REPACK = false;
|
||
|
||
private static function MakeDir($path)
|
||
{
|
||
if (is_dir($path))
|
||
{
|
||
return;
|
||
}
|
||
|
||
$path = explode("/", $path);
|
||
if (count($path) == 1)
|
||
{
|
||
$path = explode("\\", $path[0]);
|
||
}
|
||
|
||
$d = "";
|
||
foreach ($path as $dir)
|
||
{
|
||
$d .= $dir . "/";
|
||
if ($d != "/" && $d != "/home/" && !is_dir($d))
|
||
{
|
||
@mkdir($d, 0777);
|
||
@chmod($d, 0777);
|
||
}
|
||
}
|
||
}
|
||
|
||
private static function WriteFile($file, $b)
|
||
{
|
||
self::MakeDir(dirname($file));
|
||
fclose(fopen($file, "a+"));
|
||
$f = fopen($file,"r+");
|
||
fwrite($f, $b);
|
||
fclose($f);
|
||
@chmod($file, 0777);
|
||
}
|
||
|
||
private function HtmlPack($html)
|
||
{
|
||
return Minify_HTML::minify($html);
|
||
}
|
||
|
||
private function PrepareJsContent($jsContent)
|
||
{
|
||
if ($this->pCallBackFunctionJS)
|
||
{
|
||
$jsContent = call_user_func($this->pCallBackFunctionJS, $jsContent);
|
||
}
|
||
|
||
return $jsContent;
|
||
}
|
||
|
||
private function PrepareCssContent($cssContent)
|
||
{
|
||
if ($this->pCallBackFunctionCSS)
|
||
{
|
||
$cssContent = call_user_func($this->pCallBackFunctionCSS, $cssContent);
|
||
}
|
||
|
||
return $cssContent;
|
||
}
|
||
|
||
private static function ReadFile($file, $flag = false)
|
||
{
|
||
$file = trim($file);
|
||
if (!strlen(trim($file)))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if ($flag && $file[0] == "/")
|
||
{
|
||
$file = $_SERVER["DOCUMENT_ROOT"] . $file;
|
||
}
|
||
|
||
$b = false;
|
||
if (strstr($file, "http://") == $file)
|
||
{
|
||
$f = fopen($file, "r");
|
||
while (!feof($f))
|
||
{
|
||
$b .= fread($f, 1024);
|
||
}
|
||
}
|
||
elseif (file_exists($file) && is_readable($file))
|
||
{
|
||
$f = fopen($file, "r");
|
||
$b = fread($f, filesize($file));
|
||
}
|
||
|
||
if (isset($f) && $f)
|
||
{
|
||
fclose($f);
|
||
}
|
||
|
||
return $b;
|
||
}
|
||
|
||
private function GetTrans($type)
|
||
{
|
||
if (file_exists($type == 'js' ? $this->addrNumJsTrans : $this->addrNumCssTrans))
|
||
{
|
||
$number = self::ReadFile($type == 'js' ? $this->addrNumJsTrans : $this->addrNumCssTrans);
|
||
return (int)$number;
|
||
}
|
||
else
|
||
{
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
private function IncTrans($type)
|
||
{
|
||
self::WriteFile($type == 'js' ? $this->addrNumJsTrans : $this->addrNumCssTrans, time());
|
||
}
|
||
|
||
private function UnickList($arrFiles)
|
||
{
|
||
$arrRes = array();
|
||
foreach ($arrFiles as $file)
|
||
{
|
||
$arrRes[$file['addr']] = $file;
|
||
}
|
||
|
||
return array_values($arrRes);
|
||
}
|
||
|
||
public static function MemInBytes($mem)
|
||
{
|
||
$lastSymbol = strtoupper(substr($mem, -1));
|
||
$mem = in_array($lastSymbol, array('K', 'M', 'G')) ? substr($mem, 0, -1) : $mem;
|
||
switch ($lastSymbol)
|
||
{
|
||
case 'K':
|
||
$mem *= 1024;
|
||
break;
|
||
case 'M':
|
||
$mem *= (1024 * 1024);
|
||
break;
|
||
case 'G':
|
||
$mem *= (1024 * 1024 * 1024);
|
||
break;
|
||
};
|
||
return $mem;
|
||
}
|
||
|
||
private function WriteDataInCache($type, $arrFiles, $arrExeptions = array())
|
||
{
|
||
// Устанавливаем памяти на выполнение побольше т.к. будет идти создание pack-версии js/css
|
||
global $g_config;
|
||
$memInBytes = self::MemInBytes($g_config['phpIni']['memory_limit']);
|
||
if (self::MEMORY_FOR_PACKING > $memInBytes)
|
||
{
|
||
ini_set('memory_limit', self::MEMORY_FOR_PACKING);
|
||
}
|
||
// Устанавлиаем время выполнения скрипта больше той что установлено сейчас на 30 секунд
|
||
ini_set('max_execution_time', intval(intval($g_config['phpIni']['max_execution_time']) + 30));
|
||
|
||
|
||
if ($this->pFuncPreWriteCache)
|
||
{
|
||
call_user_func($this->pFuncPreWriteCache);
|
||
}
|
||
|
||
if ($this->flgUseTransSystem)
|
||
{
|
||
$this->IncTrans($type);
|
||
}
|
||
|
||
if ($this->flgUseTransSystem)
|
||
{
|
||
$ext = '.' . $type;
|
||
$t = str_replace($ext, self::GetTrans($type) . $ext, $type == 'js' ? $this->addrJsCacheFile : $this->addrCssCacheFile);
|
||
$type == 'js' ? $this->addrJsCacheFile = $t : $this->addrCssCacheFile = $t;
|
||
}
|
||
|
||
// Удаляем файлы из списка для запаковки которых уже нет на сервере
|
||
foreach ($arrFiles as $k => $v)
|
||
{
|
||
if (!file_exists($v['addr']))
|
||
{
|
||
unset($arrFiles[$k]);
|
||
}
|
||
}
|
||
|
||
$packInfoAboutFiles = serialize($arrFiles);
|
||
self::WriteFile($type == 'js' ? $this->addrJsCacheFileInfo : $this->addrCssCacheFileInfo, $packInfoAboutFiles);
|
||
|
||
|
||
foreach ($arrExeptions as $k => $v)
|
||
{
|
||
$arrExeptions[$k] = call_user_func($type == 'js' ? $this->pGetPathJsFileFromUrl : $this->pGetPathCssFileFromUrl , $v);
|
||
}
|
||
|
||
$endl = $type == 'js' ? ";" : '';
|
||
$fullExeptionContent = "";
|
||
$fullContent = "";
|
||
foreach ($arrFiles as $file)
|
||
{
|
||
$file = $file['addr'];
|
||
$curContent = file_get_contents($file);
|
||
// Если стоит обработка каждого файла перед добавлением в сжатый архив
|
||
if ($this->pPrepareEachFile)
|
||
{
|
||
$curContent = call_user_func($this->pPrepareEachFile, $curContent, $file, $type);
|
||
}
|
||
if (in_array($file, $arrExeptions))
|
||
{
|
||
$fullExeptionContent .= $curContent . $endl;
|
||
}
|
||
else
|
||
{
|
||
$fullContent .= $curContent . $endl;
|
||
}
|
||
}
|
||
|
||
if ($type == 'js')
|
||
{
|
||
if (!self::ONLY_MERGE_JS)
|
||
{
|
||
$packed = JSMin::minify($fullContent);
|
||
}
|
||
else
|
||
{
|
||
$packed = $fullContent;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
$less = new lessc();
|
||
$less->importDir = BASEPATH . 'i/css/';
|
||
$fullContent = $less->parse($fullContent);
|
||
|
||
if (!self::ONLY_MERGE_CSS)
|
||
{
|
||
$cssPacker = new CssPacker($fullContent);
|
||
$packed = $cssPacker->Pack();
|
||
}
|
||
else
|
||
{
|
||
$packed = $fullContent;
|
||
}
|
||
}
|
||
|
||
$packed = $type == 'js' ? ($packed . $fullExeptionContent) : ($fullExeptionContent . $packed);
|
||
$packed = $type == 'js' ? $this->PrepareJsContent($packed) : $this->PrepareCssContent($packed); // Дополнительно обработать контент пользовательской функцией (если есть)
|
||
|
||
self::WriteFile($type == 'js' ? $this->addrJsCacheFile : $this->addrCssCacheFile, $packed);
|
||
self::WriteFile(($type == 'js' ? $this->addrJsCacheFile : $this->addrCssCacheFile) . $this->gzipPostfix, gzencode($packed, self::COEF_GZIP_COMPRESS));
|
||
|
||
if ($this->pFuncPostWriteCache)
|
||
{
|
||
call_user_func($this->pFuncPostWriteCache);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Если массив now содержиться в storage то перепаковывать не надо т.к. все запакованные данные есть
|
||
*/
|
||
private function NeedRePack($storage, $now)
|
||
{
|
||
if (self::ALWAYS_REPACK) return true;
|
||
|
||
$ret = false;
|
||
|
||
foreach ($now as $v)
|
||
{
|
||
if (!in_array($v, $storage))
|
||
{
|
||
$ret = true;
|
||
break;
|
||
}
|
||
}
|
||
return $ret;
|
||
}
|
||
|
||
private function JsPack($html)
|
||
{
|
||
$arrExeptions = $this->arrExeptions_js;
|
||
$arrExeptionsNotAdd = $this->arrExeptionsNotAdd_js;
|
||
|
||
$s = preg_replace('/<!--.*-->/Uis', '', $html);
|
||
$m = array();
|
||
preg_match("~<head.*?>(.*?)</head>~is", $s, $m);
|
||
if (empty($m))
|
||
{
|
||
return $html;
|
||
}
|
||
|
||
$s = $m[1];
|
||
$m = array();
|
||
preg_match_all("~<script.*?src=['\"](.*?).js['\"].*?></script>~", $s, $m);
|
||
if (empty($m))
|
||
{
|
||
return $html;
|
||
}
|
||
|
||
$arrJsFiles = array();
|
||
foreach ($m[1] as $k => $jsAddr)
|
||
{
|
||
$jsAddr = $jsAddr . ".js";
|
||
if (in_array($jsAddr, $arrExeptionsNotAdd))
|
||
{
|
||
unset($m[1][$k]);
|
||
continue;
|
||
}
|
||
$html = str_ireplace($m[0][$k], "", $html);
|
||
$jsAddr = call_user_func($this->pGetPathJsFileFromUrl, $jsAddr);
|
||
$whenModify = filemtime($jsAddr);
|
||
$arrJsFiles[] = array('time' => $whenModify, 'addr' => $jsAddr);
|
||
}
|
||
|
||
$arrJsFiles = $this->UnickList($arrJsFiles);
|
||
|
||
if (file_exists($this->addrJsCacheFileInfo))
|
||
{
|
||
$strInfoJsFiles = file_get_contents($this->addrJsCacheFileInfo);
|
||
$arrInfoJsFiles = unserialize($strInfoJsFiles);
|
||
if ($this->NeedRePack($arrInfoJsFiles, $arrJsFiles))
|
||
{
|
||
if (self::ALWAYS_INDEPENDENT_PACK)
|
||
{
|
||
$arrInfoJsFiles = array();
|
||
}
|
||
$arrAllJsFiles = self::AUnique(self::AMerge($arrInfoJsFiles, $arrJsFiles));
|
||
self::WriteDataInCache('js', $arrAllJsFiles, $arrExeptions);
|
||
}
|
||
else
|
||
{
|
||
if ($this->flgUseTransSystem)
|
||
{
|
||
$this->addrJsCacheFile = str_replace(".js", self::GetTrans('js') . ".js", $this->addrJsCacheFile);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
self::WriteDataInCache('js', $arrJsFiles , $arrExeptions);
|
||
}
|
||
|
||
$includeFileAddr = ($this->flgBuffering && $this->flgUseGZIP) ? $this->addrJsCacheFile.$this->gzipPostfix : $this->addrJsCacheFile;
|
||
|
||
$inc = call_user_func($this->pFuncGetAddrJsPackFile, $includeFileAddr);
|
||
$html = str_ireplace(self::TAG_EXTRAPACKER, self::TAG_EXTRAPACKER . '<script type="text/javascript" charset="UTF-8" src="' . $inc . '"></script>', $html);
|
||
|
||
return $html;
|
||
}
|
||
|
||
private static function AUnique($arr)
|
||
{
|
||
$a = array();
|
||
foreach ($arr as $v)
|
||
{
|
||
$a[$v['addr']] = $v;
|
||
}
|
||
return array_values($a);
|
||
}
|
||
|
||
// По сути тот же самый array_merge
|
||
private static function AMerge()
|
||
{
|
||
$arrs = func_get_args(); // Массивы которые нужно слить в один
|
||
$eaxA = array(); // Результирующий массив
|
||
$eaxAddrsOnly = array(); // Массив только адресов к файлам (нужен просто для более локаничного вычисления)
|
||
|
||
foreach ($arrs as $arr)
|
||
{
|
||
foreach ($arr as $canBeElem)
|
||
{
|
||
// Если текущий файл уже был добавлен
|
||
if (in_array($canBeElem['addr'], $eaxAddrsOnly))
|
||
{
|
||
// То находим его и проверяем, если время его изменения в новом массиве больше старого то заменяем, иначе ничего не делаем
|
||
foreach ($eaxA as $k => $v)
|
||
{
|
||
if ($v['addr'] == $canBeElem['addr'])
|
||
{
|
||
if ($v['time'] < $canBeElem['time'])
|
||
{
|
||
$eaxA[$k] = $canBeElem;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Если же этого файла нет в массиве то добавляем его следущим
|
||
else
|
||
{
|
||
$eaxA[] = $canBeElem;
|
||
$eaxAddrsOnly[] = $canBeElem['addr'];
|
||
}
|
||
}
|
||
}
|
||
return $eaxA;
|
||
}
|
||
|
||
private function CssPack($html)
|
||
{
|
||
$arrExeptions = $this->arrExeptions_css;
|
||
$arrExeptionsNotAdd = $this->arrExeptionsNotAdd_css;
|
||
|
||
$s = preg_replace('/<!--.*-->/Uis', '', $html);
|
||
$m = array();
|
||
preg_match("~<head.*?>(.*?)</head>~is", $s, $m);
|
||
if (empty($m))
|
||
{
|
||
return $html;
|
||
}
|
||
|
||
$s = $m[1];
|
||
$m = array();
|
||
preg_match_all("~<link.*?href=['\"](.*?)\.(css|less)['\"].*?>~", $s, $m);
|
||
if (empty($m))
|
||
{
|
||
return $html;
|
||
}
|
||
|
||
$arrCssFiles = array();
|
||
foreach ($m[1] as $k => $cssAddr)
|
||
{
|
||
$ext = $m[2][$k];
|
||
$cssAddr .= ".{$ext}";
|
||
if (in_array($cssAddr, $arrExeptionsNotAdd))
|
||
{
|
||
unset($m[1][$k]);
|
||
continue;
|
||
}
|
||
$html = str_ireplace($m[0][$k], "", $html);
|
||
$cssAddr = call_user_func($this->pGetPathCssFileFromUrl, $cssAddr);
|
||
$whenModify = filemtime($cssAddr);
|
||
$arrCssFiles[] = array('time' => $whenModify, 'addr' => $cssAddr);
|
||
}
|
||
|
||
$arrCssFiles = $this->UnickList($arrCssFiles);
|
||
|
||
if (file_exists($this->addrCssCacheFileInfo))
|
||
{
|
||
$strInfoCssFiles = file_get_contents($this->addrCssCacheFileInfo);
|
||
$arrInfoCssFiles = unserialize($strInfoCssFiles);
|
||
if ($this->NeedRePack($arrInfoCssFiles, $arrCssFiles))
|
||
{
|
||
if (self::ALWAYS_INDEPENDENT_PACK)
|
||
{
|
||
$arrInfoCssFiles = array();
|
||
}
|
||
$arrAllCssFiles = self::AUnique(self::AMerge($arrInfoCssFiles, $arrCssFiles));
|
||
self::WriteDataInCache('css', $arrAllCssFiles, $arrExeptions);
|
||
}
|
||
else
|
||
{
|
||
if ($this->flgUseTransSystem)
|
||
{
|
||
$this->addrCssCacheFile = str_replace(".css", self::GetTrans('css') . ".css", $this->addrCssCacheFile);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
self::WriteDataInCache('css', $arrCssFiles , $arrExeptions);
|
||
}
|
||
|
||
$includeFileAddr = ($this->flgBuffering && $this->flgUseGZIP) ? $this->addrCssCacheFile.$this->gzipPostfix : $this->addrCssCacheFile;
|
||
|
||
$inc = call_user_func($this->pFuncGetAddrCssPackFile, $includeFileAddr);
|
||
$html = str_ireplace(self::TAG_EXTRAPACKER, self::TAG_EXTRAPACKER . '<link rel="stylesheet" charset="UTF-8" type="text/css" href="' . $inc . '" />', $html);
|
||
|
||
return $html;
|
||
}
|
||
|
||
private function CanUseGZIP()
|
||
{
|
||
if (self::FORCE_DISABLE_GZIP)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
$httpAcceptEncoding = isset($_SERVER['HTTP_ACCEPT_ENCODING']) ? $_SERVER['HTTP_ACCEPT_ENCODING'] : '';
|
||
$hasGzip = strstr($httpAcceptEncoding, 'gzip') !== false && extension_loaded('zlib');
|
||
$canEncoding = true;
|
||
|
||
if (!isset($_SERVER['HTTP_USER_AGENT']))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
$matches = array();
|
||
if (stripos($_SERVER['HTTP_USER_AGENT'], 'safari') === false)
|
||
{
|
||
if (!strstr($_SERVER['HTTP_USER_AGENT'], 'Opera')
|
||
&&
|
||
preg_match('/^Mozilla\/4\.0 \(compatible; MSIE ([0-9]\.[0-9])/i', $_SERVER['HTTP_USER_AGENT'], $matches))
|
||
{
|
||
if (isset($matches[1]))
|
||
{
|
||
$version = floatval($matches[1]);
|
||
|
||
if ($version < 6)
|
||
{
|
||
$canEncoding = false;
|
||
}
|
||
|
||
if ($version == 6 && !strstr($_SERVER['HTTP_USER_AGENT'], 'EV1'))
|
||
{
|
||
$canEncoding = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
$canEncoding = false;
|
||
}
|
||
|
||
return $canEncoding && $hasGzip;
|
||
}
|
||
|
||
/**
|
||
* Функция запаковки контента в зависимости от параметров пакера
|
||
*
|
||
* @param string html-контент документа в котором содержится head с подключенными js-ками и css-ами
|
||
*/
|
||
public function Pack($html)
|
||
{
|
||
// Если нету тега для замены ExtraPacker-ом то просто вернуть контент
|
||
if (strpos($html, self::TAG_EXTRAPACKER) === false)
|
||
{
|
||
return $html;
|
||
}
|
||
|
||
if ($this->flgJsPack)
|
||
{
|
||
$html = $this->JsPack($html);
|
||
}
|
||
if ($this->flgCssPack)
|
||
{
|
||
$html = $this->CssPack($html);
|
||
}
|
||
if ($this->flgHtmlPack)
|
||
{
|
||
$html = $this->HtmlPack($html);
|
||
}
|
||
|
||
return $html;
|
||
}
|
||
|
||
/**
|
||
* Конструктор объекта
|
||
*
|
||
* @param pointer $pGetPathJsFileFromUrl - ссылка на функцию которая получит из url в src js-ки физический путь на диске к этому файлу
|
||
* @param pointer $pGetPathCssFileFromUrl - ссылка на функцию которая получит из url в href css-ки физический путь на диске к этому файлу
|
||
* @param pointer $pFuncGetAddrJsPackFile - ссылка на фунцию которая получит из path на диске спакованного js-файла url который подставится в новый src спакованной js-ки
|
||
* @param pointer $pFuncGetAddrCssPackFile - ссылка на фунцию которая получит из path на диске спакованного css-файла url который подставится в новый href спакованной css-ки
|
||
* @param pointer $pFuncPreWriteCache - указатель на функцию выполняемую до начала работы по созданию нового кеш-файла (обычно блокировка сайта)
|
||
* @param pointer $pFuncPostWriteCache - указатель на функцию выполняемую по завершению работы и записи кеш-файла (обычно разблокировка сайта)
|
||
* @param string $addrJsCacheFileInfo - путь к временному файлу с информацией о спакованных js файлах в текущей транзакции
|
||
* @param string $addrJsCacheFile - путь к временному кеш файлу спакованных js-ок (GZIP будут с таким же именем только префикс из настроек добавится)
|
||
* @param string $addrCssCacheFileInfo - путь к временному файлу с информацией о спакованных css файлах в текущей транзакции
|
||
* @param string $addrCssCacheFile - путь к временному кеш файлу спакованных css-ок (GZIP будут с таким же именем только префикс из настроек добавится)
|
||
* @param bool $flgHtmlPack - флаг включения html-запаковки (могут быть проблемы если используете js-подстветки кода сайте т.к. в начале удалятся пробелы и табуляция)
|
||
* @param bool $flgCssPack - флаг включения css-запаковки
|
||
* @param bool $flgJsPack - флаг включения js-запаковки
|
||
* @param array $arrExeptions_js - массив исключений 1-го порядка (url-ы как и src), данные файлы прибавятся склеенному в конец, но не будут поковаться
|
||
* @param array $arrExeptionsNotAdd_js - массив исключений 2-го порядка - вообще не добавятся в запокованный файл
|
||
* @param array $arrExeptions_css - массив исключений 1-го порядка (url-ы как и href), данные файлы прибавятся склеенному в конец, но не будут поковаться
|
||
* @param array $arrExeptionsNotAdd_css - массив исключений 2-го порядка - вообще не добавятся в запокованный файл
|
||
* @param bool $flgUseTransSystem - использоватьс систему транзакций (в url запакованного файла ставится № говорящий о текущей транзакции)
|
||
* @param string $addrNumJsTrans - путь к файлу содержащий № js транзакций
|
||
* @param string $addrNumCssTrans - путь к файлу содержащий № css транзакций
|
||
* @param bool $flgBuffering - включить авто-определение GZIP буферизации для браузеров
|
||
*/
|
||
public function __construct(
|
||
$pGetPathJsFileFromUrl,
|
||
$pGetPathCssFileFromUrl,
|
||
$pFuncGetAddrJsPackFile,
|
||
$pFuncGetAddrCssPackFile,
|
||
$pFuncPreWriteCache = NULL,
|
||
$pFuncPostWriteCache = NULL,
|
||
$addrJsCacheFileInfo = '',
|
||
$addrJsCacheFile = '',
|
||
$addrCssCacheFileInfo = '',
|
||
$addrCssCacheFile = '',
|
||
$flgHtmlPack = true,
|
||
$flgCssPack = true,
|
||
$flgJsPack = true,
|
||
$arrExeptions_js = array(),
|
||
$arrExeptionsNotAdd_js = array(),
|
||
$arrExeptions_css = array(),
|
||
$arrExeptionsNotAdd_css = array(),
|
||
$flgUseTransSystem = true,
|
||
$addrNumJsTrans = '',
|
||
$addrNumCssTrans = '',
|
||
$flgBuffering = true,
|
||
$pPrepareEachFile = NULL,
|
||
$pCallBackFunctionCSS = NULL,
|
||
$pCallBackFunctionJS = NULL
|
||
)
|
||
{
|
||
$this->pGetPathJsFileFromUrl = $pGetPathJsFileFromUrl;
|
||
$this->pGetPathCssFileFromUrl = $pGetPathCssFileFromUrl;
|
||
|
||
$this->pFuncGetAddrJsPackFile = $pFuncGetAddrJsPackFile;
|
||
$this->pFuncGetAddrCssPackFile = $pFuncGetAddrCssPackFile;
|
||
|
||
$this->pFuncPreWriteCache = $pFuncPreWriteCache;
|
||
$this->pFuncPostWriteCache = $pFuncPostWriteCache;
|
||
|
||
$defaultDir = str_replace("\\", "/", dirname(__FILE__)) . '/tmp/';
|
||
$this->addrJsCacheFileInfo = $addrJsCacheFileInfo ? $addrJsCacheFileInfo : ($defaultDir . "js/cache/info.txt");
|
||
$this->addrJsCacheFile = $addrJsCacheFile ? $addrJsCacheFile : ($defaultDir . "js/cache/js.js");
|
||
$this->addrCssCacheFileInfo = $addrCssCacheFileInfo ? $addrCssCacheFileInfo : ($defaultDir . "css/cache/info.txt");
|
||
$this->addrCssCacheFile = $addrCssCacheFile ? $addrCssCacheFile : ($defaultDir . "css/cache/css.css");
|
||
|
||
$this->flgHtmlPack = $flgHtmlPack;
|
||
$this->flgCssPack = $flgCssPack;
|
||
$this->flgJsPack = $flgJsPack;
|
||
|
||
$this->arrExeptions_js = $arrExeptions_js;
|
||
$this->arrExeptionsNotAdd_js = $arrExeptionsNotAdd_js;
|
||
|
||
$this->arrExeptions_css = $arrExeptions_css;
|
||
$this->arrExeptionsNotAdd_css = $arrExeptionsNotAdd_css;
|
||
|
||
$this->flgUseTransSystem = $flgUseTransSystem;
|
||
$this->addrNumJsTrans = $addrNumJsTrans ? $addrNumJsTrans : ($defaultDir . 'js/cache/trans.txt');
|
||
$this->addrNumCssTrans = $addrNumCssTrans ? $addrNumCssTrans : ($defaultDir . 'css/cache/trans.txt');
|
||
|
||
$this->flgBuffering = $flgBuffering;
|
||
$this->flgUseGZIP = self::CanUseGZIP();
|
||
|
||
$this->pPrepareEachFile = $pPrepareEachFile;
|
||
$this->pCallBackFunctionCSS = $pCallBackFunctionCSS;
|
||
$this->pCallBackFunctionJS = $pCallBackFunctionJS;
|
||
}
|
||
};
|
||
?>
|