mirror of
https://github.com/silverstripe/silverstripe-framework
synced 2024-10-22 14:05:37 +02:00
4c0b452c0f
This allows someone to extends Requirements_Backend and plug in their own minification of files, including CSS minification. It also allows them to override whether or not the header comment is written for each file.
1150 lines
35 KiB
PHP
1150 lines
35 KiB
PHP
<?php
|
|
|
|
/**
|
|
* Requirements tracker, for javascript and css.
|
|
* @todo Document the requirements tracker, and discuss it with the others.
|
|
*
|
|
* @package framework
|
|
* @subpackage view
|
|
*/
|
|
class Requirements {
|
|
|
|
/**
|
|
* Enable combining of css/javascript files.
|
|
* @param boolean $enable
|
|
*/
|
|
public static function set_combined_files_enabled($enable) {
|
|
self::backend()->set_combined_files_enabled($enable);
|
|
}
|
|
|
|
/**
|
|
* Checks whether combining of css/javascript files is enabled.
|
|
* @return boolean
|
|
*/
|
|
public static function get_combined_files_enabled() {
|
|
return self::backend()->get_combined_files_enabled();
|
|
}
|
|
|
|
/**
|
|
* Set the relative folder e.g. "assets" for where to store combined files
|
|
* @param string $folder Path to folder
|
|
*/
|
|
public static function set_combined_files_folder($folder) {
|
|
self::backend()->setCombinedFilesFolder($folder);
|
|
}
|
|
|
|
/**
|
|
* Set whether we want to suffix requirements with the time /
|
|
* location on to the requirements
|
|
*
|
|
* @param bool
|
|
*/
|
|
public static function set_suffix_requirements($var) {
|
|
self::backend()->set_suffix_requirements($var);
|
|
}
|
|
|
|
/**
|
|
* Return whether we want to suffix requirements
|
|
*
|
|
* @return bool
|
|
*/
|
|
public static function get_suffix_requirements() {
|
|
return self::backend()->get_suffix_requirements();
|
|
}
|
|
|
|
/**
|
|
* Instance of requirements for storage
|
|
*
|
|
* @var Requirements
|
|
*/
|
|
private static $backend = null;
|
|
|
|
public static function backend() {
|
|
if(!self::$backend) {
|
|
self::$backend = new Requirements_Backend();
|
|
}
|
|
return self::$backend;
|
|
}
|
|
|
|
/**
|
|
* Setter method for changing the Requirements backend
|
|
*
|
|
* @param Requirements $backend
|
|
*/
|
|
public static function set_backend(Requirements_Backend $backend) {
|
|
self::$backend = $backend;
|
|
}
|
|
|
|
/**
|
|
* Register the given javascript file as required.
|
|
*
|
|
* See {@link Requirements_Backend::javascript()} for more info
|
|
*
|
|
*/
|
|
public static function javascript($file) {
|
|
self::backend()->javascript($file);
|
|
}
|
|
|
|
/**
|
|
* Add the javascript code to the header of the page
|
|
*
|
|
* See {@link Requirements_Backend::customScript()} for more info
|
|
* @param script The script content
|
|
* @param uniquenessID Use this to ensure that pieces of code only get added once.
|
|
*/
|
|
public static function customScript($script, $uniquenessID = null) {
|
|
self::backend()->customScript($script, $uniquenessID);
|
|
}
|
|
|
|
/**
|
|
* Include custom CSS styling to the header of the page.
|
|
*
|
|
* See {@link Requirements_Backend::customCSS()}
|
|
*
|
|
* @param string $script CSS selectors as a string (without <style> tag enclosing selectors).
|
|
* @param int $uniquenessID Group CSS by a unique ID as to avoid duplicate custom CSS in header
|
|
*/
|
|
public static function customCSS($script, $uniquenessID = null) {
|
|
self::backend()->customCSS($script, $uniquenessID);
|
|
}
|
|
|
|
/**
|
|
* Add the following custom code to the <head> section of the page.
|
|
* See {@link Requirements_Backend::insertHeadTags()}
|
|
*
|
|
* @param string $html
|
|
* @param string $uniquenessID
|
|
*/
|
|
public static function insertHeadTags($html, $uniquenessID = null) {
|
|
self::backend()->insertHeadTags($html, $uniquenessID);
|
|
}
|
|
|
|
/**
|
|
* Load the given javascript template with the page.
|
|
* See {@link Requirements_Backend::javascriptTemplate()}
|
|
*
|
|
* @param file The template file to load.
|
|
* @param vars The array of variables to load. These variables are loaded via string search & replace.
|
|
*/
|
|
public static function javascriptTemplate($file, $vars, $uniquenessID = null) {
|
|
self::backend()->javascriptTemplate($file, $vars, $uniquenessID);
|
|
}
|
|
|
|
/**
|
|
* Register the given stylesheet file as required.
|
|
* See {@link Requirements_Backend::css()}
|
|
*
|
|
* @param $file String Filenames should be relative to the base, eg, 'framework/javascript/tree/tree.css'
|
|
* @param $media String Comma-separated list of media-types (e.g. "screen,projector")
|
|
* @see http://www.w3.org/TR/REC-CSS2/media.html
|
|
*/
|
|
public static function css($file, $media = null) {
|
|
self::backend()->css($file, $media);
|
|
}
|
|
|
|
/**
|
|
* Registers the given themeable stylesheet as required.
|
|
*
|
|
* A CSS file in the current theme path name "themename/css/$name.css" is
|
|
* first searched for, and it that doesn't exist and the module parameter is
|
|
* set then a CSS file with that name in the module is used.
|
|
*
|
|
* NOTE: This API is experimental and may change in the future.
|
|
*
|
|
* @param string $name The name of the file - e.g. "/css/File.css" would have
|
|
* the name "File".
|
|
* @param string $module The module to fall back to if the css file does not
|
|
* exist in the current theme.
|
|
* @param string $media The CSS media attribute.
|
|
*/
|
|
public static function themedCSS($name, $module = null, $media = null) {
|
|
return self::backend()->themedCSS($name, $module, $media);
|
|
}
|
|
|
|
/**
|
|
* Clear either a single or all requirements.
|
|
* Caution: Clearing single rules works only with customCSS and customScript if you specified a {@uniquenessID}.
|
|
*
|
|
* See {@link Requirements_Backend::clear()}
|
|
*
|
|
* @param $file String
|
|
*/
|
|
public static function clear($fileOrID = null) {
|
|
self::backend()->clear($fileOrID);
|
|
}
|
|
|
|
/**
|
|
* Blocks inclusion of a specific file
|
|
* See {@link Requirements_Backend::block()}
|
|
*
|
|
* @param unknown_type $fileOrID
|
|
*/
|
|
public static function block($fileOrID) {
|
|
self::backend()->block($fileOrID);
|
|
}
|
|
|
|
/**
|
|
* Removes an item from the blocking-list.
|
|
* See {@link Requirements_Backend::unblock()}
|
|
*
|
|
* @param string $fileOrID
|
|
*/
|
|
public static function unblock($fileOrID) {
|
|
self::backend()->unblock($fileOrID);
|
|
}
|
|
|
|
/**
|
|
* Removes all items from the blocking-list.
|
|
* See {@link Requirements_Backend::unblock_all()}
|
|
*/
|
|
public static function unblock_all() {
|
|
self::backend()->unblock_all();
|
|
}
|
|
|
|
/**
|
|
* Restore requirements cleared by call to Requirements::clear
|
|
* See {@link Requirements_Backend::restore()}
|
|
*/
|
|
public static function restore() {
|
|
self::backend()->restore();
|
|
}
|
|
|
|
/**
|
|
* Update the given HTML content with the appropriate include tags for the registered
|
|
* requirements.
|
|
* See {@link Requirements_Backend::includeInHTML()} for more information.
|
|
*
|
|
* @param string $templateFilePath Absolute path for the *.ss template file
|
|
* @param string $content HTML content that has already been parsed from the $templateFilePath
|
|
* through {@link SSViewer}.
|
|
* @return string HTML content thats augumented with the requirements before the closing <head> tag.
|
|
*/
|
|
public static function includeInHTML($templateFile, $content) {
|
|
return self::backend()->includeInHTML($templateFile, $content);
|
|
}
|
|
|
|
public static function include_in_response(SS_HTTPResponse $response) {
|
|
return self::backend()->include_in_response($response);
|
|
}
|
|
|
|
/**
|
|
* Add i18n files from the given javascript directory.
|
|
*
|
|
* @param String
|
|
* @param Boolean
|
|
* @param Boolean
|
|
*
|
|
* See {@link Requirements_Backend::add_i18n_javascript()} for more information.
|
|
*/
|
|
public static function add_i18n_javascript($langDir, $return = false, $langOnly = false) {
|
|
return self::backend()->add_i18n_javascript($langDir, $return, $langOnly);
|
|
}
|
|
|
|
/**
|
|
* Concatenate several css or javascript files into a single dynamically generated file.
|
|
* See {@link Requirements_Backend::combine_files()} for more info.
|
|
*
|
|
* @param string $combinedFileName
|
|
* @param array $files
|
|
* @param string $media
|
|
*/
|
|
public static function combine_files($combinedFileName, $files, $media = null) {
|
|
self::backend()->combine_files($combinedFileName, $files, $media);
|
|
}
|
|
|
|
/**
|
|
* Returns all combined files.
|
|
* See {@link Requirements_Backend::get_combine_files()}
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function get_combine_files() {
|
|
return self::backend()->get_combine_files();
|
|
}
|
|
|
|
/**
|
|
* Deletes all dynamically generated combined files from the filesystem.
|
|
* See {@link Requirements_Backend::delete_combine_files()}
|
|
*
|
|
* @param string $combinedFileName If left blank, all combined files are deleted.
|
|
*/
|
|
public static function delete_combined_files($combinedFileName = null) {
|
|
return self::backend()->delete_combined_files($combinedFileName);
|
|
}
|
|
|
|
|
|
/**
|
|
* Re-sets the combined files definition. See {@link Requirements_Backend::clear_combined_files()}
|
|
*/
|
|
public static function clear_combined_files() {
|
|
self::backend()->clear_combined_files();
|
|
}
|
|
|
|
/**
|
|
* See {@link combine_files()}.
|
|
*/
|
|
public static function process_combined_files() {
|
|
return self::backend()->process_combined_files();
|
|
}
|
|
|
|
/**
|
|
* Returns all custom scripts
|
|
* See {@link Requirements_Backend::get_custom_scripts()}
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function get_custom_scripts() {
|
|
return self::backend()->get_custom_scripts();
|
|
}
|
|
|
|
/**
|
|
* Set whether you want to write the JS to the body of the page or
|
|
* in the head section
|
|
*
|
|
* @see Requirements_Backend::set_write_js_to_body()
|
|
* @param boolean
|
|
*/
|
|
public static function set_write_js_to_body($var) {
|
|
self::backend()->set_write_js_to_body($var);
|
|
}
|
|
|
|
public static function debug() {
|
|
return self::backend()->debug();
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* @package framework
|
|
* @subpackage view
|
|
*/
|
|
class Requirements_Backend {
|
|
|
|
/**
|
|
* Do we want requirements to suffix onto the requirement link
|
|
* tags for caching or is it disabled. Getter / Setter available
|
|
* through {@link Requirements::set_suffix_requirements()}
|
|
*
|
|
* @var bool
|
|
*/
|
|
protected $suffix_requirements = true;
|
|
|
|
/**
|
|
* Enable combining of css/javascript files.
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $combined_files_enabled = true;
|
|
|
|
/**
|
|
* Paths to all required .js files relative to the webroot.
|
|
*
|
|
* @var array $javascript
|
|
*/
|
|
protected $javascript = array();
|
|
|
|
/**
|
|
* Paths to all required .css files relative to the webroot.
|
|
*
|
|
* @var array $css
|
|
*/
|
|
protected $css = array();
|
|
|
|
/**
|
|
* All custom javascript code that is inserted
|
|
* directly at the bottom of the HTML <head> tag.
|
|
*
|
|
* @var array $customScript
|
|
*/
|
|
protected $customScript = array();
|
|
|
|
/**
|
|
* All custom CSS rules which are inserted
|
|
* directly at the bottom of the HTML <head> tag.
|
|
*
|
|
* @var array $customCSS
|
|
*/
|
|
protected $customCSS = array();
|
|
|
|
/**
|
|
* All custom HTML markup which is added before
|
|
* the closing <head> tag, e.g. additional metatags.
|
|
* This is preferred to entering tags directly into
|
|
*/
|
|
protected $customHeadTags = array();
|
|
|
|
/**
|
|
* Remembers the filepaths of all cleared Requirements
|
|
* through {@link clear()}.
|
|
*
|
|
* @var array $disabled
|
|
*/
|
|
protected $disabled = array();
|
|
|
|
/**
|
|
* The filepaths (relative to webroot) or
|
|
* uniquenessIDs of any included requirements
|
|
* which should be blocked when executing {@link inlcudeInHTML()}.
|
|
* This is useful to e.g. prevent core classes to modifying
|
|
* Requirements without subclassing the entire functionality.
|
|
* Use {@link unblock()} or {@link unblock_all()} to revert changes.
|
|
*
|
|
* @var array $blocked
|
|
*/
|
|
protected $blocked = array();
|
|
|
|
/**
|
|
* See {@link combine_files()}.
|
|
*
|
|
* @var array $combine_files
|
|
*/
|
|
public $combine_files = array();
|
|
|
|
/**
|
|
* Using the JSMin library to minify any
|
|
* javascript file passed to {@link combine_files()}.
|
|
*
|
|
* @var boolean
|
|
*/
|
|
public $combine_js_with_jsmin = true;
|
|
|
|
/**
|
|
* Setting for whether or not a file header should be written when
|
|
* combining files.
|
|
*
|
|
* @var boolean
|
|
*/
|
|
public $write_header_comment = true;
|
|
|
|
/**
|
|
* @var string By default, combined files are stored in assets/_combinedfiles.
|
|
* Set this by calling Requirements::set_combined_files_folder()
|
|
*/
|
|
protected $combinedFilesFolder = null;
|
|
|
|
/**
|
|
* Put all javascript includes at the bottom of the template
|
|
* before the closing <body> tag instead of the <head> tag.
|
|
* This means script downloads won't block other HTTP-requests,
|
|
* which can be a performance improvement.
|
|
* Caution: Doesn't work when modifying the DOM from those external
|
|
* scripts without listening to window.onload/document.ready
|
|
* (e.g. toplevel document.write() calls).
|
|
*
|
|
* @see http://developer.yahoo.com/performance/rules.html#js_bottom
|
|
*
|
|
* @var boolean
|
|
*/
|
|
public $write_js_to_body = true;
|
|
|
|
public function set_combined_files_enabled($enable) {
|
|
$this->combined_files_enabled = (bool) $enable;
|
|
}
|
|
|
|
public function get_combined_files_enabled() {
|
|
return $this->combined_files_enabled;
|
|
}
|
|
|
|
/**
|
|
* @param String $folder
|
|
*/
|
|
public function setCombinedFilesFolder($folder) {
|
|
$this->combinedFilesFolder = $folder;
|
|
}
|
|
|
|
/**
|
|
* @return String Folder relative to the webroot
|
|
*/
|
|
public function getCombinedFilesFolder() {
|
|
return ($this->combinedFilesFolder) ? $this->combinedFilesFolder : ASSETS_DIR . '/_combinedfiles';
|
|
}
|
|
|
|
/**
|
|
* Set whether we want to suffix requirements with the time /
|
|
* location on to the requirements
|
|
*
|
|
* @param bool
|
|
*/
|
|
public function set_suffix_requirements($var) {
|
|
$this->suffix_requirements = $var;
|
|
}
|
|
|
|
/**
|
|
* Return whether we want to suffix requirements
|
|
*
|
|
* @return bool
|
|
*/
|
|
public function get_suffix_requirements() {
|
|
return $this->suffix_requirements;
|
|
}
|
|
|
|
/**
|
|
* Set whether you want the files written to the head or the body. It
|
|
* writes to the body by default which can break some scripts
|
|
*
|
|
* @param boolean
|
|
*/
|
|
public function set_write_js_to_body($var) {
|
|
$this->write_js_to_body = $var;
|
|
}
|
|
/**
|
|
* Register the given javascript file as required.
|
|
* Filenames should be relative to the base, eg, 'framework/javascript/loader.js'
|
|
*/
|
|
|
|
public function javascript($file) {
|
|
$this->javascript[$file] = true;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of all included javascript
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_javascript() {
|
|
return array_keys(array_diff_key($this->javascript,$this->blocked));
|
|
}
|
|
|
|
/**
|
|
* Add the javascript code to the header of the page
|
|
* @todo Make Requirements automatically put this into a separate file :-)
|
|
* @param script The script content
|
|
* @param uniquenessID Use this to ensure that pieces of code only get added once.
|
|
*/
|
|
public function customScript($script, $uniquenessID = null) {
|
|
if($uniquenessID) $this->customScript[$uniquenessID] = $script;
|
|
else $this->customScript[] = $script;
|
|
|
|
$script .= "\n";
|
|
}
|
|
|
|
/**
|
|
* Include custom CSS styling to the header of the page.
|
|
*
|
|
* @param string $script CSS selectors as a string (without <style> tag enclosing selectors).
|
|
* @param int $uniquenessID Group CSS by a unique ID as to avoid duplicate custom CSS in header
|
|
*/
|
|
public function customCSS($script, $uniquenessID = null) {
|
|
if($uniquenessID) $this->customCSS[$uniquenessID] = $script;
|
|
else $this->customCSS[] = $script;
|
|
}
|
|
|
|
/**
|
|
* Add the following custom code to the <head> section of the page.
|
|
*
|
|
* @param string $html
|
|
* @param string $uniquenessID
|
|
*/
|
|
public function insertHeadTags($html, $uniquenessID = null) {
|
|
if($uniquenessID) $this->customHeadTags[$uniquenessID] = $html;
|
|
else $this->customHeadTags[] = $html;
|
|
}
|
|
|
|
/**
|
|
* Load the given javascript template with the page.
|
|
* @param file The template file to load.
|
|
* @param vars The array of variables to load. These variables are loaded via string search & replace.
|
|
*/
|
|
public function javascriptTemplate($file, $vars, $uniquenessID = null) {
|
|
$script = file_get_contents(Director::getAbsFile($file));
|
|
$search = array();
|
|
$replace = array();
|
|
|
|
if($vars) foreach($vars as $k => $v) {
|
|
$search[] = '$' . $k;
|
|
$replace[] = str_replace("\\'","'", Convert::raw2js($v));
|
|
}
|
|
|
|
$script = str_replace($search, $replace, $script);
|
|
$this->customScript($script, $uniquenessID);
|
|
}
|
|
|
|
/**
|
|
* Register the given stylesheet file as required.
|
|
*
|
|
* @param $file String Filenames should be relative to the base, eg, 'framework/javascript/tree/tree.css'
|
|
* @param $media String Comma-separated list of media-types (e.g. "screen,projector")
|
|
* @see http://www.w3.org/TR/REC-CSS2/media.html
|
|
*/
|
|
public function css($file, $media = null) {
|
|
$this->css[$file] = array(
|
|
"media" => $media
|
|
);
|
|
}
|
|
|
|
public function get_css() {
|
|
return array_diff_key($this->css, $this->blocked);
|
|
}
|
|
|
|
/**
|
|
* Needed to actively prevent the inclusion of a file,
|
|
* e.g. when using your own jQuery version.
|
|
* Blocking should only be used as an exception, because
|
|
* it is hard to trace back. You can just block items with an
|
|
* ID, so make sure you add an unique identifier to customCSS() and customScript().
|
|
*
|
|
* @param string $fileOrID
|
|
*/
|
|
public function block($fileOrID) {
|
|
$this->blocked[$fileOrID] = $fileOrID;
|
|
}
|
|
|
|
/**
|
|
* Clear either a single or all requirements.
|
|
* Caution: Clearing single rules works only with customCSS and customScript if you specified a {@uniquenessID}.
|
|
*
|
|
* @param $file String
|
|
*/
|
|
public function clear($fileOrID = null) {
|
|
if($fileOrID) {
|
|
foreach(array('javascript','css', 'customScript', 'customCSS', 'customHeadTags') as $type) {
|
|
if(isset($this->{$type}[$fileOrID])) {
|
|
$this->disabled[$type][$fileOrID] = $this->{$type}[$fileOrID];
|
|
unset($this->{$type}[$fileOrID]);
|
|
}
|
|
}
|
|
} else {
|
|
$this->disabled['javascript'] = $this->javascript;
|
|
$this->disabled['css'] = $this->css;
|
|
$this->disabled['customScript'] = $this->customScript;
|
|
$this->disabled['customCSS'] = $this->customCSS;
|
|
$this->disabled['customHeadTags'] = $this->customHeadTags;
|
|
|
|
$this->javascript = array();
|
|
$this->css = array();
|
|
$this->customScript = array();
|
|
$this->customCSS = array();
|
|
$this->customHeadTags = array();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes an item from the blocking-list.
|
|
* CAUTION: Does not "re-add" any previously blocked elements.
|
|
* @param string $fileOrID
|
|
*/
|
|
public function unblock($fileOrID) {
|
|
if(isset($this->blocked[$fileOrID])) unset($this->blocked[$fileOrID]);
|
|
}
|
|
/**
|
|
* Removes all items from the blocking-list.
|
|
*/
|
|
public function unblock_all() {
|
|
$this->blocked = array();
|
|
}
|
|
|
|
/**
|
|
* Restore requirements cleared by call to Requirements::clear
|
|
*/
|
|
public function restore() {
|
|
$this->javascript = $this->disabled['javascript'];
|
|
$this->css = $this->disabled['css'];
|
|
$this->customScript = $this->disabled['customScript'];
|
|
$this->customCSS = $this->disabled['customCSS'];
|
|
$this->customHeadTags = $this->disabled['customHeadTags'];
|
|
}
|
|
|
|
/**
|
|
* Update the given HTML content with the appropriate include tags for the registered
|
|
* requirements. Needs to receive a valid HTML/XHTML template in the $content parameter,
|
|
* including a <head> tag. The requirements will insert before the closing <head> tag automatically.
|
|
*
|
|
* @todo Calculate $prefix properly
|
|
*
|
|
* @param string $templateFilePath Absolute path for the *.ss template file
|
|
* @param string $content HTML content that has already been parsed from the $templateFilePath
|
|
* through {@link SSViewer}.
|
|
* @return string HTML content thats augumented with the requirements before the closing <head> tag.
|
|
*/
|
|
public function includeInHTML($templateFile, $content) {
|
|
if(
|
|
(strpos($content, '</head>') !== false || strpos($content, '</head ') !== false)
|
|
&& ($this->css || $this->javascript || $this->customCSS || $this->customScript || $this->customHeadTags)
|
|
) {
|
|
$requirements = '';
|
|
$jsRequirements = '';
|
|
|
|
// Combine files - updates $this->javascript and $this->css
|
|
$this->process_combined_files();
|
|
|
|
foreach(array_diff_key($this->javascript,$this->blocked) as $file => $dummy) {
|
|
$path = Convert::raw2xml($this->path_for_file($file));
|
|
if($path) {
|
|
$jsRequirements .= "<script type=\"text/javascript\" src=\"$path\"></script>\n";
|
|
}
|
|
}
|
|
|
|
// add all inline javascript *after* including external files which
|
|
// they might rely on
|
|
if($this->customScript) {
|
|
foreach(array_diff_key($this->customScript,$this->blocked) as $script) {
|
|
$jsRequirements .= "<script type=\"text/javascript\">\n//<![CDATA[\n";
|
|
$jsRequirements .= "$script\n";
|
|
$jsRequirements .= "\n//]]>\n</script>\n";
|
|
}
|
|
}
|
|
|
|
foreach(array_diff_key($this->css,$this->blocked) as $file => $params) {
|
|
$path = Convert::raw2xml($this->path_for_file($file));
|
|
if($path) {
|
|
$media = (isset($params['media']) && !empty($params['media']))
|
|
? " media=\"{$params['media']}\"" : "";
|
|
$requirements .= "<link rel=\"stylesheet\" type=\"text/css\"{$media} href=\"$path\" />\n";
|
|
}
|
|
}
|
|
|
|
foreach(array_diff_key($this->customCSS, $this->blocked) as $css) {
|
|
$requirements .= "<style type=\"text/css\">\n$css\n</style>\n";
|
|
}
|
|
|
|
foreach(array_diff_key($this->customHeadTags,$this->blocked) as $customHeadTag) {
|
|
$requirements .= "$customHeadTag\n";
|
|
}
|
|
|
|
if($this->write_js_to_body) {
|
|
// Remove all newlines from code to preserve layout
|
|
$jsRequirements = preg_replace('/>\n*/', '>', $jsRequirements);
|
|
|
|
// We put script tags into the body, for performance.
|
|
// If your template already has script tags in the body, then we put our script
|
|
// tags just before those. Otherwise, we put it at the bottom.
|
|
$p2 = stripos($content, '<body');
|
|
$p1 = stripos($content, '<script', $p2);
|
|
|
|
if($p1 !== false) {
|
|
$content = substr($content,0,$p1) . $jsRequirements . substr($content,$p1);
|
|
} else {
|
|
$content = preg_replace("/(<\/body[^>]*>)/i", $jsRequirements . "\\1", $content);
|
|
}
|
|
|
|
// Put CSS at the bottom of the head
|
|
$content = preg_replace("/(<\/head>)/i", $requirements . "\\1", $content);
|
|
} else {
|
|
$content = preg_replace("/(<\/head>)/i", $requirements . "\\1", $content);
|
|
$content = preg_replace("/(<\/head>)/i", $jsRequirements . "\\1", $content);
|
|
}
|
|
}
|
|
|
|
return $content;
|
|
}
|
|
|
|
/**
|
|
* Attach requirements inclusion to X-Include-JS and X-Include-CSS headers on the HTTP response
|
|
*/
|
|
public function include_in_response(SS_HTTPResponse $response) {
|
|
$this->process_combined_files();
|
|
$jsRequirements = array();
|
|
$cssRequirements = array();
|
|
|
|
foreach(array_diff_key($this->javascript, $this->blocked) as $file => $dummy) {
|
|
$path = $this->path_for_file($file);
|
|
if($path) {
|
|
$jsRequirements[] = str_replace(',', '%2C', $path);
|
|
}
|
|
}
|
|
|
|
$response->addHeader('X-Include-JS', implode(',', $jsRequirements));
|
|
|
|
foreach(array_diff_key($this->css,$this->blocked) as $file => $params) {
|
|
$path = $this->path_for_file($file);
|
|
if($path) {
|
|
$path = str_replace(',', '%2C', $path);
|
|
$cssRequirements[] = isset($params['media']) ? "$path:##:$params[media]" : $path;
|
|
}
|
|
}
|
|
|
|
$response->addHeader('X-Include-CSS', implode(',', $cssRequirements));
|
|
}
|
|
|
|
/**
|
|
* Add i18n files from the given javascript directory. SilverStripe expects that the given directory
|
|
* will contain a number of java script files named by language: en_US.js, de_DE.js, etc.
|
|
*
|
|
* @param String The javascript lang directory, relative to the site root, e.g., 'framework/javascript/lang'
|
|
* @param Boolean Return all relative file paths rather than including them in requirements
|
|
* @param Boolean Only include language files, not the base libraries
|
|
*/
|
|
public function add_i18n_javascript($langDir, $return = false, $langOnly = false) {
|
|
$files = array();
|
|
if(i18n::config()->js_i18n) {
|
|
// Include i18n.js even if no languages are found. The fact that
|
|
// add_i18n_javascript() was called indicates that the methods in
|
|
// here are needed.
|
|
if(!$langOnly) $files[] = FRAMEWORK_DIR . '/javascript/i18n.js';
|
|
|
|
if(substr($langDir,-1) != '/') $langDir .= '/';
|
|
|
|
$files[] = $langDir . i18n::default_locale() . '.js';
|
|
$files[] = $langDir . i18n::get_locale() . '.js';
|
|
|
|
// If both files don't exist, hard fallback to en_US
|
|
if(!Director::fileExists($files[0]) && !Director::fileExists($files[1])) {
|
|
$files[] = $langDir . 'en_US.js';
|
|
}
|
|
|
|
// Stub i18n implementation for when i18n is disabled.
|
|
} else {
|
|
if(!$langOnly) $files[] = FRAMEWORK_DIR . '/javascript/i18nx.js';
|
|
}
|
|
|
|
if($return) {
|
|
return $files;
|
|
} else {
|
|
foreach($files as $file) $this->javascript($file);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Finds the path for specified file.
|
|
*
|
|
* @param string $fileOrUrl
|
|
* @return string|boolean
|
|
*/
|
|
protected function path_for_file($fileOrUrl) {
|
|
if(preg_match('{^//|http[s]?}', $fileOrUrl)) {
|
|
return $fileOrUrl;
|
|
} elseif(Director::fileExists($fileOrUrl)) {
|
|
$filePath = preg_replace('/\?.*/', '', Director::baseFolder() . '/' . $fileOrUrl);
|
|
$prefix = Director::baseURL();
|
|
$mtimesuffix = "";
|
|
$suffix = '';
|
|
if($this->suffix_requirements) {
|
|
$mtimesuffix = "?m=" . filemtime($filePath);
|
|
$suffix = '&';
|
|
}
|
|
if(strpos($fileOrUrl, '?') !== false) {
|
|
if (strlen($suffix) == 0) {
|
|
$suffix = '?';
|
|
}
|
|
$suffix .= substr($fileOrUrl, strpos($fileOrUrl, '?')+1);
|
|
$fileOrUrl = substr($fileOrUrl, 0, strpos($fileOrUrl, '?'));
|
|
} else {
|
|
$suffix = '';
|
|
}
|
|
return "{$prefix}{$fileOrUrl}{$mtimesuffix}{$suffix}";
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Concatenate several css or javascript files into a single dynamically generated
|
|
* file (stored in {@link Director::baseFolder()}). This increases performance
|
|
* by fewer HTTP requests.
|
|
*
|
|
* The combined file is regenerated
|
|
* based on every file modification time. Optionally a rebuild can be triggered
|
|
* by appending ?flush=1 to the URL.
|
|
* If all files to be combined are javascript, we use the external JSMin library
|
|
* to minify the javascript. This can be controlled by {@link $combine_js_with_jsmin}.
|
|
*
|
|
* All combined files will have a comment on the start of each concatenated file
|
|
* denoting their original position. For easier debugging, we recommend to only
|
|
* minify javascript if not in development mode ({@link Director::isDev()}).
|
|
*
|
|
* CAUTION: You're responsible for ensuring that the load order for combined files
|
|
* is retained - otherwise combining javascript files can lead to functional errors
|
|
* in the javascript logic, and combining css can lead to wrong styling inheritance.
|
|
* Depending on the javascript logic, you also have to ensure that files are not included
|
|
* in more than one combine_files() call.
|
|
* Best practice is to include every javascript file in exactly *one* combine_files()
|
|
* directive to avoid the issues mentioned above - this is enforced by this function.
|
|
*
|
|
* CAUTION: Combining CSS Files discards any "media" information.
|
|
*
|
|
* Example for combined JavaScript:
|
|
* <code>
|
|
* Requirements::combine_files(
|
|
* 'foobar.js',
|
|
* array(
|
|
* 'mysite/javascript/foo.js',
|
|
* 'mysite/javascript/bar.js',
|
|
* )
|
|
* );
|
|
* </code>
|
|
*
|
|
* Example for combined CSS:
|
|
* <code>
|
|
* Requirements::combine_files(
|
|
* 'foobar.css',
|
|
* array(
|
|
* 'mysite/javascript/foo.css',
|
|
* 'mysite/javascript/bar.css',
|
|
* )
|
|
* );
|
|
* </code>
|
|
*
|
|
* @see http://code.google.com/p/jsmin-php/
|
|
*
|
|
* @todo Should we enforce unique inclusion of files, or leave it to the developer? Can auto-detection cause
|
|
* breaks?
|
|
*
|
|
* @param string $combinedFileName Filename of the combined file (will be stored in {@link Director::baseFolder()}
|
|
* by default)
|
|
* @param array $files Array of filenames relative to the webroot
|
|
* @param string $media Comma-separated list of media-types (e.g. "screen,projector").
|
|
*/
|
|
public function combine_files($combinedFileName, $files, $media = null) {
|
|
// duplicate check
|
|
foreach($this->combine_files as $_combinedFileName => $_files) {
|
|
$duplicates = array_intersect($_files, $files);
|
|
if($duplicates && $combinedFileName != $_combinedFileName) {
|
|
user_error("Requirements_Backend::combine_files(): Already included files " . implode(',', $duplicates)
|
|
. " in combined file '{$_combinedFileName}'", E_USER_NOTICE);
|
|
return false;
|
|
}
|
|
}
|
|
foreach($files as $index=>$file) {
|
|
if(is_array($file)) {
|
|
// Either associative array path=>path type=>type or numeric 0=>path 1=>type
|
|
// Otherwise, assume path is the first item
|
|
if (isset($file['type']) && in_array($file['type'], array('css', 'javascript', 'js'))) {
|
|
switch ($file['type']) {
|
|
case 'css':
|
|
$this->css($file['path'], $media);
|
|
break;
|
|
default:
|
|
$this->javascript($file['path']);
|
|
break;
|
|
}
|
|
$files[$index] = $file['path'];
|
|
} elseif (isset($file[1]) && in_array($file[1], array('css', 'javascript', 'js'))) {
|
|
switch ($file[1]) {
|
|
case 'css':
|
|
$this->css($file[0], $media);
|
|
break;
|
|
default:
|
|
$this->javascript($file[0]);
|
|
break;
|
|
}
|
|
$files[$index] = $file[0];
|
|
} else {
|
|
$file = array_shift($file);
|
|
}
|
|
}
|
|
if (!is_array($file)) {
|
|
if(substr($file, -2) == 'js') {
|
|
$this->javascript($file);
|
|
} elseif(substr($file, -3) == 'css') {
|
|
$this->css($file, $media);
|
|
} else {
|
|
user_error("Requirements_Backend::combine_files(): Couldn't guess file type for file '$file', "
|
|
. "please specify by passing using an array instead.", E_USER_NOTICE);
|
|
}
|
|
}
|
|
}
|
|
$this->combine_files[$combinedFileName] = $files;
|
|
}
|
|
|
|
/**
|
|
* Returns all combined files.
|
|
* @return array
|
|
*/
|
|
public function get_combine_files() {
|
|
return $this->combine_files;
|
|
}
|
|
|
|
/**
|
|
* Deletes all dynamically generated combined files from the filesystem.
|
|
*
|
|
* @param string $combinedFileName If left blank, all combined files are deleted.
|
|
*/
|
|
public function delete_combined_files($combinedFileName = null) {
|
|
$combinedFiles = ($combinedFileName) ? array($combinedFileName => null) : $this->combine_files;
|
|
$combinedFolder = ($this->getCombinedFilesFolder()) ?
|
|
(Director::baseFolder() . '/' . $this->combinedFilesFolder) : Director::baseFolder();
|
|
foreach($combinedFiles as $combinedFile => $sourceItems) {
|
|
$filePath = $combinedFolder . '/' . $combinedFile;
|
|
if(file_exists($filePath)) {
|
|
unlink($filePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function clear_combined_files() {
|
|
$this->combine_files = array();
|
|
}
|
|
|
|
/**
|
|
* See {@link combine_files()}
|
|
*
|
|
*/
|
|
public function process_combined_files() {
|
|
// The class_exists call prevents us from loading SapphireTest.php (slow) just to know that
|
|
// SapphireTest isn't running :-)
|
|
if(class_exists('SapphireTest', false)) $runningTest = SapphireTest::is_running_test();
|
|
else $runningTest = false;
|
|
|
|
if((Director::isDev() && !$runningTest && !isset($_REQUEST['combine'])) || !$this->combined_files_enabled) {
|
|
return;
|
|
}
|
|
|
|
// Make a map of files that could be potentially combined
|
|
$combinerCheck = array();
|
|
foreach($this->combine_files as $combinedFile => $sourceItems) {
|
|
foreach($sourceItems as $sourceItem) {
|
|
if(isset($combinerCheck[$sourceItem]) && $combinerCheck[$sourceItem] != $combinedFile){
|
|
user_error("Requirements_Backend::process_combined_files - file '$sourceItem' appears in two " .
|
|
"combined files:" . " '{$combinerCheck[$sourceItem]}' and '$combinedFile'", E_USER_WARNING);
|
|
}
|
|
$combinerCheck[$sourceItem] = $combinedFile;
|
|
|
|
}
|
|
}
|
|
|
|
// Work out the relative URL for the combined files from the base folder
|
|
$combinedFilesFolder = ($this->getCombinedFilesFolder()) ? ($this->getCombinedFilesFolder() . '/') : '';
|
|
|
|
// Figure out which ones apply to this pageview
|
|
$combinedFiles = array();
|
|
$newJSRequirements = array();
|
|
$newCSSRequirements = array();
|
|
foreach($this->javascript as $file => $dummy) {
|
|
if(isset($combinerCheck[$file])) {
|
|
$newJSRequirements[$combinedFilesFolder . $combinerCheck[$file]] = true;
|
|
$combinedFiles[$combinerCheck[$file]] = true;
|
|
} else {
|
|
$newJSRequirements[$file] = true;
|
|
}
|
|
}
|
|
|
|
foreach($this->css as $file => $params) {
|
|
if(isset($combinerCheck[$file])) {
|
|
// Inherit the parameters from the last file in the combine set.
|
|
$newCSSRequirements[$combinedFilesFolder . $combinerCheck[$file]] = $params;
|
|
$combinedFiles[$combinerCheck[$file]] = true;
|
|
} else {
|
|
$newCSSRequirements[$file] = $params;
|
|
}
|
|
}
|
|
|
|
// Process the combined files
|
|
$base = Director::baseFolder() . '/';
|
|
foreach(array_diff_key($combinedFiles, $this->blocked) as $combinedFile => $dummy) {
|
|
$fileList = $this->combine_files[$combinedFile];
|
|
$combinedFilePath = $base . $combinedFilesFolder . '/' . $combinedFile;
|
|
|
|
|
|
// Make the folder if necessary
|
|
if(!file_exists(dirname($combinedFilePath))) {
|
|
Filesystem::makeFolder(dirname($combinedFilePath));
|
|
}
|
|
|
|
// If the file isn't writeable, don't even bother trying to make the combined file and return (falls back
|
|
// to uncombined). Complex test because is_writable fails if the file doesn't exist yet.
|
|
if((file_exists($combinedFilePath) && !is_writable($combinedFilePath))
|
|
|| (!file_exists($combinedFilePath) && !is_writable(dirname($combinedFilePath)))
|
|
) {
|
|
user_error("Requirements_Backend::process_combined_files(): Couldn't create '$combinedFilePath'",
|
|
E_USER_WARNING);
|
|
return false;
|
|
}
|
|
|
|
// Determine if we need to build the combined include
|
|
if(file_exists($combinedFilePath) && !isset($_GET['flush'])) {
|
|
// file exists, check modification date of every contained file
|
|
$srcLastMod = 0;
|
|
foreach($fileList as $file) {
|
|
if(file_exists($base . $file)) {
|
|
$srcLastMod = max(filemtime($base . $file), $srcLastMod);
|
|
}
|
|
}
|
|
$refresh = $srcLastMod > filemtime($combinedFilePath);
|
|
} else {
|
|
// file doesn't exist, or refresh was explicitly required
|
|
$refresh = true;
|
|
}
|
|
|
|
if(!$refresh) continue;
|
|
|
|
$combinedData = "";
|
|
foreach(array_diff($fileList, $this->blocked) as $file) {
|
|
$fileContent = file_get_contents($base . $file);
|
|
$fileContent = $this->minifyFile($file, $fileContent);
|
|
|
|
if ($this->write_header_comment) {
|
|
// write a header comment for each file for easier identification and debugging
|
|
// also the semicolon between each file is required for jQuery to be combinable properly
|
|
$combinedData .= "/****** FILE: $file *****/\n";
|
|
}
|
|
|
|
$combinedData .= $fileContent . "\n";
|
|
}
|
|
|
|
$successfulWrite = false;
|
|
$fh = fopen($combinedFilePath, 'wb');
|
|
if($fh) {
|
|
if(fwrite($fh, $combinedData) == strlen($combinedData)) $successfulWrite = true;
|
|
fclose($fh);
|
|
unset($fh);
|
|
}
|
|
|
|
// Unsuccessful write - just include the regular JS files, rather than the combined one
|
|
if(!$successfulWrite) {
|
|
user_error("Requirements_Backend::process_combined_files(): Couldn't create '$combinedFilePath'",
|
|
E_USER_WARNING);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// @todo Alters the original information, which means you can't call this
|
|
// method repeatedly - it will behave different on the second call!
|
|
$this->javascript = $newJSRequirements;
|
|
$this->css = $newCSSRequirements;
|
|
}
|
|
|
|
protected function minifyFile($filename, $content) {
|
|
// if we have a javascript file and jsmin is enabled, minify the content
|
|
$isJS = stripos($filename, '.js');
|
|
if($isJS && $this->combine_js_with_jsmin) {
|
|
require_once('thirdparty/jsmin/jsmin.php');
|
|
|
|
increase_time_limit_to();
|
|
$content = JSMin::minify($content);
|
|
}
|
|
$content .= ($isJS ? ';' : '') . "\n";
|
|
return $content;
|
|
}
|
|
|
|
public function get_custom_scripts() {
|
|
$requirements = "";
|
|
|
|
if($this->customScript) {
|
|
foreach($this->customScript as $script) {
|
|
$requirements .= "$script\n";
|
|
}
|
|
}
|
|
|
|
return $requirements;
|
|
}
|
|
|
|
/**
|
|
* @see Requirements::themedCSS()
|
|
*/
|
|
public function themedCSS($name, $module = null, $media = null) {
|
|
$path = SSViewer::get_theme_folder();
|
|
$abspath = BASE_PATH . DIRECTORY_SEPARATOR . $path;
|
|
$css = "/css/$name.css";
|
|
|
|
if ($module && file_exists($abspath.'_'.$module.$css)) {
|
|
$this->css($path.'_'.$module.$css, $media);
|
|
}
|
|
else if (file_exists($abspath.$css)) {
|
|
$this->css($path.$css, $media);
|
|
}
|
|
else if ($module) {
|
|
$this->css($module.$css, $media);
|
|
}
|
|
}
|
|
|
|
public function debug() {
|
|
Debug::show($this->javascript);
|
|
Debug::show($this->css);
|
|
Debug::show($this->customCSS);
|
|
Debug::show($this->customScript);
|
|
Debug::show($this->customHeadTags);
|
|
Debug::show($this->combine_files);
|
|
}
|
|
|
|
}
|