Page MenuHomestyx hydra
Files F716650

No OneTemporary
Actions

View Options

diff --git a/src/applications/phame/skins/PhameBasicTemplateBlogSkin.php b/src/applications/phame/skins/PhameBasicTemplateBlogSkin.php
index 25d0b66449..8bee67fe8f 100644
--- a/src/applications/phame/skins/PhameBasicTemplateBlogSkin.php
+++ b/src/applications/phame/skins/PhameBasicTemplateBlogSkin.php
@@ -1,139 +1,139 @@
<?php
/**
* @group phame
*/
final class PhameBasicTemplateBlogSkin extends PhameBasicBlogSkin {
private $cssResources;
public function processRequest() {
$root = dirname(phutil_get_library_root('phabricator'));
require_once $root.'/support/phame/libskin.php';
$this->cssResources = array();
$css = $this->getPath('css/');
if (Filesystem::pathExists($css)) {
foreach (Filesystem::listDirectory($css) as $path) {
if (!preg_match('/.css$/', $path)) {
continue;
}
$this->cssResources[] = phutil_tag(
'link',
array(
'rel' => 'stylesheet',
'type' => 'text/css',
'href' => $this->getResourceURI('css/'.$path),
));
}
}
$map = CelerityResourceMap::getInstance();
$resource_symbol = 'syntax-highlighting-css';
- $resource_uri = $map->getFullyQualifiedURIForSymbol($resource_symbol);
+ $resource_uri = $map->getURIForSymbol($resource_symbol);
$this->cssResources[] = phutil_tag(
'link',
array(
'rel' => 'stylesheet',
'type' => 'text/css',
- 'href' => $resource_uri,
+ 'href' => PhabricatorEnv::getCDNURI($resource_uri),
));
$this->cssResources = phutil_implode_html("\n", $this->cssResources);
$request = $this->getRequest();
$content = $this->renderContent($request);
if (!$content) {
$content = $this->render404Page();
}
$content = array(
$this->renderHeader(),
$content,
$this->renderFooter(),
);
$response = new AphrontWebpageResponse();
$response->setContent(phutil_implode_html("\n", $content));
return $response;
}
public function getCSSResources() {
return $this->cssResources;
}
public function getName() {
return $this->getSpecification()->getName();
}
public function getPath($to_file = null) {
$path = $this->getSpecification()->getRootDirectory();
if ($to_file) {
$path = $path.DIRECTORY_SEPARATOR.$to_file;
}
return $path;
}
private function renderTemplate($__template__, array $__scope__) {
chdir($this->getPath());
ob_start();
if (Filesystem::pathExists($this->getPath($__template__))) {
// Fool lint.
$__evil__ = 'extract';
$__evil__($__scope__ + $this->getDefaultScope());
require $this->getPath($__template__);
}
return phutil_safe_html(ob_get_clean());
}
private function getDefaultScope() {
return array(
'skin' => $this,
'blog' => $this->getBlog(),
'uri' => $this->getURI($this->getURIPath()),
'home_uri' => $this->getURI(''),
'title' => $this->getTitle(),
'description' => $this->getDescription(),
'og_type' => $this->getOGType(),
);
}
protected function renderHeader() {
return $this->renderTemplate(
'header.php',
array());
}
protected function renderFooter() {
return $this->renderTemplate('footer.php', array());
}
protected function render404Page() {
return $this->renderTemplate('404.php', array());
}
protected function renderPostDetail(PhamePostView $post) {
return $this->renderTemplate(
'post-detail.php',
array(
'post' => $post,
));
}
protected function renderPostList(array $posts) {
return $this->renderTemplate(
'post-list.php',
array(
'posts' => $posts,
'older' => $this->renderOlderPageLink(),
'newer' => $this->renderNewerPageLink(),
));
}
}
diff --git a/src/infrastructure/celerity/CelerityResourceMap.php b/src/infrastructure/celerity/CelerityResourceMap.php
index 3e52e58de6..623fca2bdd 100644
--- a/src/infrastructure/celerity/CelerityResourceMap.php
+++ b/src/infrastructure/celerity/CelerityResourceMap.php
@@ -1,210 +1,255 @@
<?php
/**
* Interface to the static resource map, which is a graph of available
* resources, resource dependencies, and packaging information. You generally do
* not need to invoke it directly; instead, you call higher-level Celerity APIs
* and it uses the resource map to satisfy your requests.
*
* @group celerity
*/
final class CelerityResourceMap {
private static $instance;
private $resourceMap;
private $packageMap;
private $reverseMap;
public static function getInstance() {
if (empty(self::$instance)) {
self::$instance = new CelerityResourceMap();
$root = phutil_get_library_root('phabricator');
$path = '__celerity_resource_map__.php';
$ok = include_once $root.'/'.$path;
if (!$ok) {
throw new Exception(
"Failed to load Celerity resource map!");
}
}
return self::$instance;
}
public function setResourceMap($resource_map) {
$this->resourceMap = $resource_map;
return $this;
}
- public function resolveResources(array $symbols) {
+ public function getPackagedNamesForSymbols(array $symbols) {
+ $resolved = $this->resolveResources($symbols);
+ return $this->packageResources($resolved);
+ }
+
+ private function resolveResources(array $symbols) {
$map = array();
foreach ($symbols as $symbol) {
if (!empty($map[$symbol])) {
continue;
}
$this->resolveResource($map, $symbol);
}
return $map;
}
private function resolveResource(array &$map, $symbol) {
if (empty($this->resourceMap[$symbol])) {
throw new Exception(
"Attempting to resolve unknown Celerity resource, '{$symbol}'.");
}
$info = $this->resourceMap[$symbol];
foreach ($info['requires'] as $requires) {
if (!empty($map[$requires])) {
continue;
}
$this->resolveResource($map, $requires);
}
$map[$symbol] = $info;
}
public function setPackageMap($package_map) {
$this->packageMap = $package_map;
return $this;
}
- public function packageResources(array $resolved_map) {
+ private function packageResources(array $resolved_map) {
$packaged = array();
$handled = array();
foreach ($resolved_map as $symbol => $info) {
if (isset($handled[$symbol])) {
continue;
}
if (empty($this->packageMap['reverse'][$symbol])) {
$packaged[$symbol] = $info;
} else {
$package = $this->packageMap['reverse'][$symbol];
$package_info = $this->packageMap['packages'][$package];
$packaged[$package_info['name']] = $package_info;
foreach ($package_info['symbols'] as $packaged_symbol) {
$handled[$packaged_symbol] = true;
}
}
}
- return $packaged;
+
+ $names = array();
+ foreach ($packaged as $key => $resource) {
+ if (isset($resource['disk'])) {
+ $names[] = $resource['disk'];
+ } else {
+ $names[] = $key;
+ }
+ }
+
+ return $names;
}
public function getResourceDataForName($resource_name) {
$root = phutil_get_library_root('phabricator');
$root = dirname($root).'/webroot/';
return Filesystem::readFile($root.$resource_name);
}
public function getResourceNamesForPackageHash($package_hash) {
$package = idx($this->packageMap['packages'], $package_hash);
if (!$package) {
return null;
}
$paths = array();
foreach ($package['symbols'] as $symbol) {
$paths[] = $this->resourceMap[$symbol]['disk'];
}
return $paths;
}
private function lookupSymbolInformation($symbol) {
return idx($this->resourceMap, $symbol);
}
private function lookupFileInformation($path) {
if (empty($this->reverseMap)) {
$this->reverseMap = array();
foreach ($this->resourceMap as $symbol => $data) {
$data['provides'] = $symbol;
$this->reverseMap[$data['disk']] = $data;
}
}
return idx($this->reverseMap, $path);
}
/**
* Get the epoch timestamp of the last modification time of a symbol.
*
* @param string Resource symbol to lookup.
* @return int Epoch timestamp of last resource modification.
*/
- public function getModifiedTimeForSymbol($symbol) {
- $info = $this->lookupSymbolInformation($symbol);
- if ($info) {
- $root = dirname(phutil_get_library_root('phabricator')).'/webroot';
- return (int)filemtime($root.$info['disk']);
+ public function getModifiedTimeForName($name) {
+ $package_hash = null;
+ foreach ($this->packageMap['packages'] as $hash => $package) {
+ if ($package['name'] == $name) {
+ $package_hash = $hash;
+ break;
+ }
+ }
+
+ $root = dirname(phutil_get_library_root('phabricator')).'/webroot';
+
+ $mtime = 0;
+
+ if ($package_hash) {
+ $names = $this->getResourceNamesForPackageHash($package_hash);
+ foreach ($names as $component_name) {
+ $info = $this->lookupFileInformation($component_name);
+ if ($info) {
+ $mtime = max($mtime, (int)filemtime($root.$info['disk']));
+ }
+ }
+ } else {
+ $info = $this->lookupFileInformation($name);
+ if ($info) {
+ $root = dirname(phutil_get_library_root('phabricator')).'/webroot';
+ $mtime = (int)filemtime($root.$info['disk']);
+ }
}
- return 0;
+
+ return $mtime;
}
/**
- * Return the fully-qualified, absolute URI for the resource associated with
- * a symbol. This method is fairly low-level and ignores packaging.
+ * Return the absolute URI for the resource associated with a symbol. This
+ * method is fairly low-level and ignores packaging.
*
* @param string Resource symbol to lookup.
* @return string|null Fully-qualified resource URI, or null if the symbol
* is unknown.
*/
- public function getFullyQualifiedURIForSymbol($symbol) {
+ public function getURIForSymbol($symbol) {
$info = $this->lookupSymbolInformation($symbol);
if ($info) {
return idx($info, 'uri');
}
return null;
}
/**
- * Return the fully-qualified, absolute URI for the resource associated with
- * a resource name. This method is fairly low-level and ignores packaging.
+ * Return the absolute URI for the resource associated with a resource name.
+ * This method is fairly low-level and ignores packaging.
*
* @param string Resource name to lookup.
* @return string|null Fully-qualified resource URI, or null if the name
* is unknown.
*/
- public function getFullyQualifiedURIForName($name) {
+ public function getURIForName($name) {
$info = $this->lookupFileInformation($name);
if ($info) {
return idx($info, 'uri');
}
+
+ foreach ($this->packageMap['packages'] as $hash => $package) {
+ if ($package['name'] == $name) {
+ return $package['uri'];
+ }
+ }
+
return null;
}
/**
* Return the resource symbols required by a named resource.
*
* @param string Resource name to lookup.
* @return list<string>|null List of required symbols, or null if the name
* is unknown.
*/
public function getRequiredSymbolsForName($name) {
$info = $this->lookupFileInformation($name);
if ($info) {
return idx($info, 'requires', array());
}
return null;
}
/**
* Return the resource name for a given symbol.
*
* @param string Resource symbol to lookup.
* @return string|null Resource name, or null if the symbol is unknown.
*/
public function getResourceNameForSymbol($symbol) {
$info = $this->lookupSymbolInformation($symbol);
if ($info) {
return idx($info, 'disk');
}
return null;
}
}
diff --git a/src/infrastructure/celerity/CelerityResourceTransformer.php b/src/infrastructure/celerity/CelerityResourceTransformer.php
index d6b74926c7..846d8b5e89 100644
--- a/src/infrastructure/celerity/CelerityResourceTransformer.php
+++ b/src/infrastructure/celerity/CelerityResourceTransformer.php
@@ -1,226 +1,226 @@
<?php
/**
* @group celerity
*/
final class CelerityResourceTransformer {
private $minify;
private $rawResourceMap;
private $rawURIMap;
private $celerityMap;
private $translateURICallback;
private $currentPath;
public function setTranslateURICallback($translate_uricallback) {
$this->translateURICallback = $translate_uricallback;
return $this;
}
public function setMinify($minify) {
$this->minify = $minify;
return $this;
}
public function setRawResourceMap(array $raw_resource_map) {
$this->rawResourceMap = $raw_resource_map;
return $this;
}
public function setCelerityMap(CelerityResourceMap $celerity_map) {
$this->celerityMap = $celerity_map;
return $this;
}
public function setRawURIMap(array $raw_urimap) {
$this->rawURIMap = $raw_urimap;
return $this;
}
public function getRawURIMap() {
return $this->rawURIMap;
}
/**
* @phutil-external-symbol function jsShrink
*/
public function transformResource($path, $data) {
$type = self::getResourceType($path);
switch ($type) {
case 'css':
$data = $this->replaceCSSPrintRules($path, $data);
$data = $this->replaceCSSVariables($path, $data);
$data = preg_replace_callback(
'@url\s*\((\s*[\'"]?.*?)\)@s',
nonempty(
$this->translateURICallback,
array($this, 'translateResourceURI')),
$data);
break;
}
if (!$this->minify) {
return $data;
}
// Some resources won't survive minification (like Raphael.js), and are
// marked so as not to be minified.
if (strpos($data, '@'.'do-not-minify') !== false) {
return $data;
}
switch ($type) {
case 'css':
// Remove comments.
$data = preg_replace('@/\*.*?\*/@s', '', $data);
// Remove whitespace around symbols.
$data = preg_replace('@\s*([{}:;,])\s*@', '\1', $data);
// Remove unnecessary semicolons.
$data = preg_replace('@;}@', '}', $data);
// Replace #rrggbb with #rgb when possible.
$data = preg_replace(
'@#([a-f0-9])\1([a-f0-9])\2([a-f0-9])\3@i',
'#\1\2\3',
$data);
$data = trim($data);
break;
case 'js':
// If `jsxmin` is available, use it. jsxmin is the Javelin minifier and
// produces the smallest output, but is complicated to build.
if (Filesystem::binaryExists('jsxmin')) {
$future = new ExecFuture('jsxmin __DEV__:0');
$future->write($data);
list($err, $result) = $future->resolve();
if (!$err) {
$data = $result;
break;
}
}
// If `jsxmin` is not available, use `JsShrink`, which doesn't compress
// quite as well but is always available.
$root = dirname(phutil_get_library_root('phabricator'));
require_once $root.'/externals/JsShrink/jsShrink.php';
$data = jsShrink($data);
break;
}
return $data;
}
public static function getResourceType($path) {
return last(explode('.', $path));
}
public function translateResourceURI(array $matches) {
$uri = trim($matches[1], "'\" \r\t\n");
if ($this->rawURIMap !== null) {
if (isset($this->rawURIMap[$uri])) {
$uri = $this->rawURIMap[$uri];
}
} else if ($this->rawResourceMap) {
if (isset($this->rawResourceMap[$uri]['uri'])) {
$uri = $this->rawResourceMap[$uri]['uri'];
}
} else if ($this->celerityMap) {
- $resource_uri = $this->celerityMap->getFullyQualifiedURIForName($uri);
+ $resource_uri = $this->celerityMap->getURIForName($uri);
if ($resource_uri) {
$uri = $resource_uri;
}
}
return 'url('.$uri.')';
}
private function replaceCSSVariables($path, $data) {
$this->currentPath = $path;
return preg_replace_callback(
'/{\$([^}]+)}/',
array($this, 'replaceCSSVariable'),
$data);
}
private function replaceCSSPrintRules($path, $data) {
$this->currentPath = $path;
return preg_replace_callback(
'/!print\s+(.+?{.+?})/s',
array($this, 'replaceCSSPrintRule'),
$data);
}
public static function getCSSVariableMap() {
return array(
// Base Colors
'red' => '#c0392b',
'lightred' => '#f4dddb',
'orange' => '#e67e22',
'lightorange' => '#f7e2d4',
'yellow' => '#f1c40f',
'lightyellow' => '#fdf5d4',
'green' => '#139543',
'lightgreen' => '#d7eddf',
'blue' => '#2980b9',
'lightblue' => '#daeaf3',
'sky' => '#3498db',
'lightsky' => '#ddeef9',
'indigo' => '#c6539d',
'lightindigo' => '#f5e2ef',
'violet' => '#8e44ad',
'lightviolet' => '#ecdff1',
'charcoal' => '#4b4d51',
'backdrop' => '#c4cde0',
// Base Greys
'lightgreyborder' => '#C7CCD9',
'greyborder' => '#A1A6B0',
'darkgreyborder' => '#676A70',
'lightgreytext' => '#92969D',
'greytext' => '#74777D',
'darkgreytext' => '#4B4D51',
'lightgreybackground' => '#F7F7F7',
'greybackground' => '#EBECEE',
// Base Blues
'thinblueborder' => '#DDE8EF',
'lightblueborder' => '#BFCFDA',
'blueborder' => '#8C98B8',
'darkblueborder' => '#626E82',
'lightbluebackground' => '#F8F9FC',
'bluebackground' => '#DAE7FF',
'lightbluetext' => '#8C98B8',
'bluetext' => '#6B748C',
'darkbluetext' => '#464C5C',
);
}
public function replaceCSSVariable($matches) {
static $map;
if (!$map) {
$map = self::getCSSVariableMap();
}
$var_name = $matches[1];
if (empty($map[$var_name])) {
$path = $this->currentPath;
throw new Exception(
"CSS file '{$path}' has unknown variable '{$var_name}'.");
}
return $map[$var_name];
}
public function replaceCSSPrintRule($matches) {
$rule = $matches[1];
$rules = array();
$rules[] = '.printable '.$rule;
$rules[] = "@media print {\n ".str_replace("\n", "\n ", $rule)."\n}\n";
return implode("\n\n", $rules);
}
}
diff --git a/src/infrastructure/celerity/CelerityStaticResourceResponse.php b/src/infrastructure/celerity/CelerityStaticResourceResponse.php
index aee24e4790..ee55074ac4 100644
--- a/src/infrastructure/celerity/CelerityStaticResourceResponse.php
+++ b/src/infrastructure/celerity/CelerityStaticResourceResponse.php
@@ -1,262 +1,256 @@
<?php
/**
* Tracks and resolves dependencies the page declares with
* @{function:require_celerity_resource}, and then builds appropriate HTML or
* Ajax responses.
*
* @group celerity
*/
final class CelerityStaticResourceResponse {
private $symbols = array();
private $needsResolve = true;
private $resolved;
private $packaged;
private $metadata = array();
private $metadataBlock = 0;
private $behaviors = array();
private $hasRendered = array();
public function __construct() {
if (isset($_REQUEST['__metablock__'])) {
$this->metadataBlock = (int)$_REQUEST['__metablock__'];
}
}
public function addMetadata($metadata) {
$id = count($this->metadata);
$this->metadata[$id] = $metadata;
return $this->metadataBlock.'_'.$id;
}
public function getMetadataBlock() {
return $this->metadataBlock;
}
/**
* Register a behavior for initialization. NOTE: if $config is empty,
* a behavior will execute only once even if it is initialized multiple times.
* If $config is nonempty, the behavior will be invoked once for each config.
*/
public function initBehavior($behavior, array $config = array()) {
$this->requireResource('javelin-behavior-'.$behavior);
if (empty($this->behaviors[$behavior])) {
$this->behaviors[$behavior] = array();
}
if ($config) {
$this->behaviors[$behavior][] = $config;
}
return $this;
}
public function requireResource($symbol) {
$this->symbols[$symbol] = true;
$this->needsResolve = true;
return $this;
}
private function resolveResources() {
if ($this->needsResolve) {
$map = CelerityResourceMap::getInstance();
- $this->resolved = $map->resolveResources(array_keys($this->symbols));
- $this->packaged = $map->packageResources($this->resolved);
+
+ $symbols = array_keys($this->symbols);
+ $this->packaged = $map->getPackagedNamesForSymbols($symbols);
+
$this->needsResolve = false;
}
return $this;
}
public function renderSingleResource($symbol) {
$map = CelerityResourceMap::getInstance();
- $resolved = $map->resolveResources(array($symbol));
- $packaged = $map->packageResources($resolved);
+ $packaged = $map->getPackagedNamesForSymbols(array($symbol));
return $this->renderPackagedResources($packaged);
}
public function renderResourcesOfType($type) {
$this->resolveResources();
$resources = array();
- foreach ($this->packaged as $resource) {
- if ($resource['type'] == $type) {
- $resources[] = $resource;
+ foreach ($this->packaged as $name) {
+ $resource_type = CelerityResourceTransformer::getResourceType($name);
+ if ($resource_type == $type) {
+ $resources[] = $name;
}
}
return $this->renderPackagedResources($resources);
}
private function renderPackagedResources(array $resources) {
$output = array();
- foreach ($resources as $resource) {
- if (isset($this->hasRendered[$resource['uri']])) {
+ foreach ($resources as $name) {
+ if (isset($this->hasRendered[$name])) {
continue;
}
- $this->hasRendered[$resource['uri']] = true;
+ $this->hasRendered[$name] = true;
- $output[] = $this->renderResource($resource);
+ $output[] = $this->renderResource($name);
$output[] = "\n";
}
return phutil_implode_html('', $output);
}
- private function renderResource(array $resource) {
- $uri = $this->getURI($resource);
- switch ($resource['type']) {
+ private function renderResource($name) {
+ $uri = $this->getURI($name);
+ $type = CelerityResourceTransformer::getResourceType($name);
+ switch ($type) {
case 'css':
return phutil_tag(
'link',
array(
'rel' => 'stylesheet',
'type' => 'text/css',
'href' => $uri,
));
case 'js':
return phutil_tag(
'script',
array(
'type' => 'text/javascript',
'src' => $uri,
),
'');
}
throw new Exception("Unable to render resource.");
}
public function renderHTMLFooter() {
$data = array();
if ($this->metadata) {
$json_metadata = AphrontResponse::encodeJSONForHTTPResponse(
$this->metadata);
$this->metadata = array();
} else {
$json_metadata = '{}';
}
// Even if there is no metadata on the page, Javelin uses the mergeData()
// call to start dispatching the event queue.
$data[] = 'JX.Stratcom.mergeData('.$this->metadataBlock.', '.
$json_metadata.');';
$onload = array();
if ($this->behaviors) {
$behaviors = $this->behaviors;
$this->behaviors = array();
$higher_priority_names = array(
'refresh-csrf',
'aphront-basic-tokenizer',
'dark-console',
'history-install',
);
$higher_priority_behaviors = array_select_keys(
$behaviors,
$higher_priority_names);
foreach ($higher_priority_names as $name) {
unset($behaviors[$name]);
}
$behavior_groups = array(
$higher_priority_behaviors,
$behaviors);
foreach ($behavior_groups as $group) {
if (!$group) {
continue;
}
$group_json = AphrontResponse::encodeJSONForHTTPResponse(
$group);
$onload[] = 'JX.initBehaviors('.$group_json.')';
}
}
if ($onload) {
foreach ($onload as $func) {
$data[] = 'JX.onload(function(){'.$func.'});';
}
}
if ($data) {
$data = implode("\n", $data);
return self::renderInlineScript($data);
} else {
return '';
}
}
public static function renderInlineScript($data) {
if (stripos($data, '</script>') !== false) {
throw new Exception(
'Literal </script> is not allowed inside inline script.');
}
if (strpos($data, '<!') !== false) {
throw new Exception('Literal <! is not allowed inside inline script.');
}
// We don't use <![CDATA[ ]]> because it is ignored by HTML parsers. We
// would need to send the document with XHTML content type.
return phutil_tag(
'script',
array('type' => 'text/javascript'),
phutil_safe_html($data));
}
public function buildAjaxResponse($payload, $error = null) {
$response = array(
'error' => $error,
'payload' => $payload,
);
if ($this->metadata) {
$response['javelin_metadata'] = $this->metadata;
$this->metadata = array();
}
if ($this->behaviors) {
$response['javelin_behaviors'] = $this->behaviors;
$this->behaviors = array();
}
$this->resolveResources();
$resources = array();
foreach ($this->packaged as $resource) {
$resources[] = $this->getURI($resource);
}
if ($resources) {
$response['javelin_resources'] = $resources;
}
return $response;
}
- private function getURI($resource) {
- $uri = $resource['uri'];
+ private function getURI($name) {
+ $map = CelerityResourceMap::getInstance();
+ $uri = $map->getURIForName($name);
// In developer mode, we dump file modification times into the URI. When a
// page is reloaded in the browser, any resources brought in by Ajax calls
// do not trigger revalidation, so without this it's very difficult to get
// changes to Ajaxed-in CSS to work (you must clear your cache or rerun
// the map script). In production, we can assume the map script gets run
// after changes, and safely skip this.
if (PhabricatorEnv::getEnvConfig('phabricator.developer-mode')) {
- $root = dirname(phutil_get_library_root('phabricator')).'/webroot';
- if (isset($resource['disk'])) {
- $mtime = (int)filemtime($root.$resource['disk']);
- } else {
- $mtime = 0;
- foreach ($resource['symbols'] as $symbol) {
- $map = CelerityResourceMap::getInstance();
- $mtime = max($mtime, $map->getModifiedTimeForSymbol($symbol));
- }
- }
-
+ $mtime = $map->getModifiedTimeForName($name);
$uri = preg_replace('@^/res/@', '/res/'.$mtime.'T/', $uri);
}
return PhabricatorEnv::getCDNURI($uri);
}
}
diff --git a/src/infrastructure/celerity/api.php b/src/infrastructure/celerity/api.php
index d12f3c3f16..1f5346df90 100644
--- a/src/infrastructure/celerity/api.php
+++ b/src/infrastructure/celerity/api.php
@@ -1,61 +1,61 @@
<?php
/**
* Include a CSS or JS static resource by name. This function records a
* dependency for the current page, so when a response is generated it can be
* included. You can call this method from any context, and it is recommended
* you invoke it as close to the actual dependency as possible so that page
* dependencies are minimized.
*
* For more information, see @{article:Adding New CSS and JS}.
*
* @param string Name of the celerity module to include. This is whatever you
* annotated as "@provides" in the file.
* @return void
*
* @group celerity
*/
function require_celerity_resource($symbol) {
$response = CelerityAPI::getStaticResourceResponse();
$response->requireResource($symbol);
}
/**
* Generate a node ID which is guaranteed to be unique for the current page,
* even across Ajax requests. You should use this method to generate IDs for
* nodes which require a uniqueness guarantee.
*
* @return string A string appropriate for use as an 'id' attribute on a DOM
* node. It is guaranteed to be unique for the current page, even
* if the current request is a subsequent Ajax request.
*
* @group celerity
*/
function celerity_generate_unique_node_id() {
static $uniq = 0;
$response = CelerityAPI::getStaticResourceResponse();
$block = $response->getMetadataBlock();
return 'UQ'.$block.'_'.($uniq++);
}
/**
* Get the versioned URI for a raw resource, like an image.
*
* @param string Path to the raw image.
* @return string Versioned path to the image, if one is available.
*
* @group celerity
*/
function celerity_get_resource_uri($resource) {
$map = CelerityResourceMap::getInstance();
- $uri = $map->getFullyQualifiedURIForName($resource);
+ $uri = $map->getURIForName($resource);
if ($uri) {
return $uri;
}
return $resource;
}

File Metadata

Mime Type
text/x-diff
Expires
Thu, Oct 16, 9:48 AM (1 d, 16 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
272603
Default Alt Text
(29 KB)

Event Timeline

styx copyright 2020 sirocyl / ellie (kymkdd) / ncommander / styx contributors
Use of other names and brands is not intended to reflect a claim of, or right to, use the name or brand.
styx is an operating system using the Linux kernel and components, and "styx Linux" as a phrase does not reflect the inclusion of the Linux brand or trademark in the styx project.
Linux® is the registered trademark of Linus Torvalds in the U.S. and other countries.
Terms and Conditions (TODO: fix this!)