/**
* Replace constant expressions in given AVT
*
* @param DOMAttr $attribute
* @return void
*/
protected function replaceAVT(DOMAttr $attribute)
{
AVTHelper::replace($attribute, function ($token) {
if ($token[0] === 'expression') {
$token[1] = $this->evaluateExpression($token[1]);
}
return $token;
});
}
/**
* Replace an expression with a literal value in given attribute
*
* @param DOMAttr $attribute
* @param string $expr
* @param string $value
* @return void
*/
protected function replaceAttribute(DOMAttr $attribute, $expr, $value)
{
AVTHelper::replace($attribute, function ($token) use($expr, $value) {
// Test whether this expression is the one we're looking for
if ($token[0] === 'expression' && $token[1] === $expr) {
// Replace the expression with the value (as a literal)
$token = ['literal', $value];
}
return $token;
});
}
/**
* Convert an attribute value template into PHP
*
* NOTE: escaping must be performed by the caller
*
* @link http://www.w3.org/TR/xslt#dt-attribute-value-template
*
* @param string $attrValue Attribute value template
* @return string
*/
protected function convertAttributeValueTemplate($attrValue)
{
$phpExpressions = [];
foreach (AVTHelper::parse($attrValue) as $token) {
if ($token[0] === 'literal') {
$phpExpressions[] = var_export($token[1], true);
} else {
$phpExpressions[] = $this->convertXPath($token[1]);
}
}
return implode('.', $phpExpressions);
}
protected function generateAttributes(array $attributes)
{
if (isset($attributes['style']) && \is_array($attributes['style'])) {
$attributes['style'] = $this->generateStyle($attributes['style']);
}
\ksort($attributes);
$xsl = '';
foreach ($attributes as $attrName => $attrValue) {
$innerXML = \strpos($attrValue, '<xsl:') !== \false ? $attrValue : AVTHelper::toXSL($attrValue);
$xsl .= '<xsl:attribute name="' . \htmlspecialchars($attrName, \ENT_QUOTES, 'UTF-8') . '">' . $innerXML . '</xsl:attribute>';
}
return $xsl;
}
/**
* Normalize the value of an attribute
*
* @param DOMAttr $attribute
* @return void
*/
protected function normalizeAttribute(DOMAttr $attribute)
{
// Trim the URL and parse it
$tokens = AVTHelper::parse(trim($attribute->value));
$attrValue = '';
foreach ($tokens as list($type, $content)) {
if ($type === 'literal') {
$attrValue .= BuiltInFilters::sanitizeUrl($content);
} else {
$attrValue .= '{' . $content . '}';
}
}
// Unescape brackets in the host part
$attrValue = $this->unescapeBrackets($attrValue);
// Update the attribute's value
$attribute->value = htmlspecialchars($attrValue);
}
/**
* Remove extraneous space in XPath expressions used in XSL elements
*
* @param DOMElement $template <xsl:template/> node
* @return void
*/
public function normalize(DOMElement $template)
{
$xpath = new DOMXPath($template->ownerDocument);
// Get all the "match", "select" and "test" attributes of XSL elements, whose value contains
// a space
$query = '//xsl:*/@*[contains(., " ")][contains("matchselectest", name())]';
foreach ($xpath->query($query) as $attribute) {
$attribute->parentNode->setAttribute($attribute->nodeName, XPathHelper::minify($attribute->nodeValue));
}
// Get all the attributes of non-XSL elements, whose value contains a space
$query = '//*[namespace-uri() != "' . self::XMLNS_XSL . '"]' . '/@*[contains(., " ")]';
foreach ($xpath->query($query) as $attribute) {
AVTHelper::replace($attribute, function ($token) {
if ($token[0] === 'expression') {
$token[1] = XPathHelper::minify($token[1]);
}
return $token;
});
}
}
/**
* Get all the potential XPath expressions used in given template
*
* @param DOMElement $template <xsl:template/> node
* @return array XPath expression as key, reference node as value
*/
protected function getExpressions(DOMElement $template)
{
$xpath = new DOMXPath($template->ownerDocument);
$exprs = [];
foreach ($xpath->query('//@*') as $attribute) {
if ($attribute->parentNode->namespaceURI === self::XMLNS_XSL) {
// Attribute of an XSL element. May or may not use XPath, but it shouldn't produce
// false-positives
$expr = $attribute->value;
$exprs[$expr] = $attribute;
} else {
// Attribute of an HTML (or otherwise) element -- Look for inline expressions
foreach (AVTHelper::parse($attribute->value) as $token) {
if ($token[0] === 'expression') {
$exprs[$token[1]] = $attribute;
}
}
}
}
return $exprs;
}
/**
* Replace xsl:value nodes that contain a literal with a Text node
*
* @param DOMElement $template <xsl:template/> node
* @return void
*/
public function normalize(DOMElement $template)
{
$xpath = new DOMXPath($template->ownerDocument);
foreach ($xpath->query('//xsl:value-of') as $valueOf) {
$textContent = $this->getTextContent($valueOf->getAttribute('select'));
if ($textContent !== false) {
$this->replaceElement($valueOf, $textContent);
}
}
$query = '//*[namespace-uri() != "' . self::XMLNS_XSL . '"]' . '/@*[contains(., "{")]';
foreach ($xpath->query($query) as $attribute) {
AVTHelper::replace($attribute, function ($token) {
if ($token[0] === 'expression') {
$textContent = $this->getTextContent($token[1]);
if ($textContent !== false) {
// Turn this token into a literal
$token = ['literal', $textContent];
}
}
return $token;
});
}
}
protected function generateAttributes(array $attributes, $addResponsive = \false)
{
if ($addResponsive) {
$attributes = $this->addResponsiveStyle($attributes);
}
unset($attributes['responsive']);
$xsl = '';
foreach ($attributes as $attrName => $innerXML) {
if (\strpos($innerXML, '<') === \false) {
$tokens = AVTHelper::parse($innerXML);
$innerXML = '';
foreach ($tokens as $_bada9f30) {
list($type, $content) = $_bada9f30;
if ($type === 'literal') {
$innerXML .= \htmlspecialchars($content, \ENT_NOQUOTES, 'UTF-8');
} else {
$innerXML .= '<xsl:value-of select="' . \htmlspecialchars($content, \ENT_QUOTES, 'UTF-8') . '"/>';
}
}
}
$xsl .= '<xsl:attribute name="' . \htmlspecialchars($attrName, \ENT_QUOTES, 'UTF-8') . '">' . $innerXML . '</xsl:attribute>';
}
return $xsl;
}
/**
* Append an <output/> element to given node in the IR
*
* @param DOMElement $ir Parent node
* @param string $type Either 'avt', 'literal' or 'xpath'
* @param string $content Content to output
* @return void
*/
protected static function appendOutput(DOMElement $ir, $type, $content)
{
// Reparse AVTs and add them as separate xpath/literal outputs
if ($type === 'avt') {
foreach (AVTHelper::parse($content) as $token) {
$type = $token[0] === 'expression' ? 'xpath' : 'literal';
self::appendOutput($ir, $type, $token[1]);
}
return;
}
if ($type === 'xpath') {
// Remove whitespace surrounding XPath expressions
$content = trim($content);
}
if ($type === 'literal' && $content === '') {
// Don't add empty literals
return;
}
self::appendElement($ir, 'output', htmlspecialchars($content))->setAttribute('type', $type);
}
/**
* Test whether an attribute node is safe
*
* @param DOMAttr $attribute Attribute node
* @param Tag $tag Reference tag
* @return void
*/
protected function checkAttributeNode(DOMAttr $attribute, Tag $tag)
{
// Parse the attribute value for XPath expressions and assess their safety
foreach (AVTHelper::parse($attribute->value) as $token) {
if ($token[0] === 'expression') {
$this->checkExpression($attribute, $token[1], $tag);
}
}
}
/**
* @testdox toXSL() tests
* @dataProvider getToXSLTests
*/
public function testToXSL($attrValue, $expected)
{
$this->assertSame($expected, AVTHelper::toXSL($attrValue));
}
/**
* Get the regexp used to remove meta elements from the intermediate representation
*
* @param array $templates
* @return string
*/
public static function getMetaElementsRegexp(array $templates)
{
$exprs = [];
// Coalesce all templates and load them into DOM
$xsl = '<xsl:template xmlns:xsl="http://www.w3.org/1999/XSL/Transform">' . implode('', $templates) . '</xsl:template>';
$dom = new DOMDocument();
$dom->loadXML($xsl);
$xpath = new DOMXPath($dom);
// Collect the values of all the "match", "select" and "test" attributes of XSL elements
$query = '//xsl:*/@*[contains("matchselectest", name())]';
foreach ($xpath->query($query) as $attribute) {
$exprs[] = $attribute->value;
}
// Collect the XPath expressions used in all the attributes of non-XSL elements
$query = '//*[namespace-uri() != "' . self::XMLNS_XSL . '"]/@*';
foreach ($xpath->query($query) as $attribute) {
foreach (AVTHelper::parse($attribute->value) as $token) {
if ($token[0] === 'expression') {
$exprs[] = $token[1];
}
}
}
// Names of the meta elements
$tagNames = ['e' => true, 'i' => true, 's' => true];
// In the highly unlikely event the meta elements are rendered, we remove them from the list
foreach (array_keys($tagNames) as $tagName) {
if (isset($templates[$tagName]) && $templates[$tagName] !== '') {
unset($tagNames[$tagName]);
}
}
// Create a regexp that matches the tag names used as element names, e.g. "s" in "//s" but
// not in "@s" or "$s"
$regexp = '(\\b(?<![$@])(' . implode('|', array_keys($tagNames)) . ')(?!-)\\b)';
// Now look into all of the expressions that we've collected
preg_match_all($regexp, implode("\n", $exprs), $m);
foreach ($m[0] as $tagName) {
unset($tagNames[$tagName]);
}
if (empty($tagNames)) {
// Always-false regexp
return '((?!))';
}
return '(<' . RegexpBuilder::fromList(array_keys($tagNames)) . '>[^<]*</[^>]+>)';
}