OutputRules::nl() - Code Metrics - Inspection of "update changelog for 2.4.0" - Masterminds/html5-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 30aab1...cadcfa )

by Asmir

created 2018-11-23 06:52 UTC

OutputRules::nl() A

↳ Parent: OutputRules

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	3
cts	3
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1

<?php
/**
 * @file
 * The rules for generating output in the serializer.
 *
 * These output rules are likely to generate output similar to the document that
 * was parsed. It is not intended to output exactly the document that was parsed.
 */
namespace Masterminds\HTML5\Serializer;

use Masterminds\HTML5\Elements;

/**
 * Generate the output html5 based on element rules.
 */
class OutputRules implements \Masterminds\HTML5\Serializer\RulesInterface
{
    /**
     * Defined in http://www.w3.org/TR/html51/infrastructure.html#html-namespace-0
     */
    const NAMESPACE_HTML = 'http://www.w3.org/1999/xhtml';

    const NAMESPACE_MATHML = 'http://www.w3.org/1998/Math/MathML';

    const NAMESPACE_SVG = 'http://www.w3.org/2000/svg';

    const NAMESPACE_XLINK = 'http://www.w3.org/1999/xlink';

    const NAMESPACE_XML = 'http://www.w3.org/XML/1998/namespace';

    const NAMESPACE_XMLNS = 'http://www.w3.org/2000/xmlns/';

    /**
     * Holds the HTML5 element names that causes a namespace switch
     *
     * @var array
     */
    protected $implicitNamespaces = array(
        self::NAMESPACE_HTML,
        self::NAMESPACE_SVG,
        self::NAMESPACE_MATHML,
        self::NAMESPACE_XML,
        self::NAMESPACE_XMLNS,
    );

    const IM_IN_HTML = 1;

    const IM_IN_SVG = 2;

    const IM_IN_MATHML = 3;

    /**
     * Used as cache to detect if is available ENT_HTML5
     * @var boolean
     */
    private $hasHTML5 = false;

    protected $traverser;

    protected $encode = false;

    protected $out;

    protected $outputMode;

    private $xpath;

    protected $nonBooleanAttributes = array(
        /*
        array(
            'nodeNamespace'=>'http://www.w3.org/1999/xhtml',
            'attrNamespace'=>'http://www.w3.org/1999/xhtml',

            'nodeName'=>'img', 'nodeName'=>array('img', 'a'),
            'attrName'=>'alt', 'attrName'=>array('title', 'alt'),
        ),
        */
        array(
            'nodeNamespace' => 'http://www.w3.org/1999/xhtml',
            'attrName' => array('href',
                'hreflang',
                'http-equiv',
                'icon',
                'id',
                'keytype',
                'kind',
                'label',
                'lang',
                'language',
                'list',
                'maxlength',
                'media',
                'method',
                'name',
                'placeholder',
                'rel',
                'rows',
                'rowspan',
                'sandbox',
                'spellcheck',
                'scope',
                'seamless',
                'shape',
                'size',
                'sizes',
                'span',
                'src',
                'srcdoc',
                'srclang',
                'srcset',
                'start',
                'step',
                'style',
                'summary',
                'tabindex',
                'target',
                'title',
                'type',
                'value',
                'width',
                'border',
                'charset',
                'cite',
                'class',
                'code',
                'codebase',
                'color',
                'cols',
                'colspan',
                'content',
                'coords',
                'data',
                'datetime',
                'default',
                'dir',
                'dirname',
                'enctype',
                'for',
                'form',
                'formaction',
                'headers',
                'height',
                'accept',
                'accept-charset',
                'accesskey',
                'action',
                'align',
                'alt',
                'bgcolor',
            ),
        ),
        array(
            'nodeNamespace' => 'http://www.w3.org/1999/xhtml',
            'xpath' => 'starts-with(local-name(), \'data-\')',
        ),
    );

    const DOCTYPE = '<!DOCTYPE html>';

    public function __construct($output, $options = array())
    {
        if (isset($options['encode_entities'])) {
            $this->encode = $options['encode_entities'];
        }

        $this->outputMode = static::IM_IN_HTML;
        $this->out = $output;

        // If HHVM, see https://github.com/facebook/hhvm/issues/2727
        $this->hasHTML5 = defined('ENT_HTML5') && !defined('HHVM_VERSION');
    }
    public function addRule(array $rule)
    {
        $this->nonBooleanAttributes[] = $rule;
    }

    public function setTraverser(\Masterminds\HTML5\Serializer\Traverser $traverser)
    {
        $this->traverser = $traverser;

        return $this;
    }

    public function document($dom)
    {
        $this->doctype();
        if ($dom->documentElement) {
            foreach ($dom->childNodes as $node) {
                $this->traverser->node($node);
            }
            $this->nl();
        }
    }

    protected function doctype()
    {
        $this->wr(static::DOCTYPE);
        $this->nl();
    }

    public function element($ele)
    {
        $name = $ele->tagName;

        // Per spec:
        // If the element has a declared namespace in the HTML, MathML or
        // SVG namespaces, we use the lname instead of the tagName.
        if ($this->traverser->isLocalElement($ele)) {
            $name = $ele->localName;
        }

        // If we are in SVG or MathML there is special handling.
        // Using if/elseif instead of switch because it's faster in PHP.
        if ($name == 'svg') {
            $this->outputMode = static::IM_IN_SVG;
            $name = Elements::normalizeSvgElement($name);
        } elseif ($name == 'math') {
            $this->outputMode = static::IM_IN_MATHML;
        }

        $this->openTag($ele);
        if (Elements::isA($name, Elements::TEXT_RAW)) {
            foreach ($ele->childNodes as $child) {
                if ($child instanceof \DOMCharacterData) {
                    $this->wr($child->data);
                } elseif ($child instanceof \DOMElement) {
                    $this->element($child);
                }
            }
        } else {
            // Handle children.
            if ($ele->hasChildNodes()) {
                $this->traverser->children($ele->childNodes);
            }

            // Close out the SVG or MathML special handling.
            if ($name == 'svg' || $name == 'math') {
                $this->outputMode = static::IM_IN_HTML;
            }
        }

        // If not unary, add a closing tag.
        if (! Elements::isA($name, Elements::VOID_TAG)) {
            $this->closeTag($ele);
        }
    }

    /**
     * Write a text node.
     *
     * @param \DOMText $ele
     *            The text node to write.
     */
    public function text($ele)
    {
        if (isset($ele->parentNode) && isset($ele->parentNode->tagName) && Elements::isA($ele->parentNode->localName, Elements::TEXT_RAW)) {
            $this->wr($ele->data);
            return;
        }

        // FIXME: This probably needs some flags set.
        $this->wr($this->enc($ele->data));
    }

    public function cdata($ele)
    {
        // This encodes CDATA.
        $this->wr($ele->ownerDocument->saveXML($ele));
    }

    public function comment($ele)
    {
        // These produce identical output.
        // $this->wr('<!--')->wr($ele->data)->wr('-->');
        $this->wr($ele->ownerDocument->saveXML($ele));
    }

    public function processorInstruction($ele)
    {
        $this->wr('<?')
            ->wr($ele->target)
            ->wr(' ')
            ->wr($ele->data)
            ->wr('?>');
    }
    /**
     * Write the namespace attributes
     *
     *
     * @param \DOMNode $ele
     *            The element being written.
     */
    protected function namespaceAttrs($ele)
    {
        if (!$this->xpath || $this->xpath->document !== $ele->ownerDocument){
            $this->xpath = new \DOMXPath($ele->ownerDocument);
        }

        foreach( $this->xpath->query('namespace::*[not(.=../../namespace::*)]', $ele ) as $nsNode ) {
            if (!in_array($nsNode->nodeValue, $this->implicitNamespaces)) {
                $this->wr(' ')->wr($nsNode->nodeName)->wr('="')->wr($nsNode->nodeValue)->wr('"');
            }
        }
    }

    /**
     * Write the opening tag.
     *
     * Tags for HTML, MathML, and SVG are in the local name. Otherwise, use the
     * qualified name (8.3).
     *
     * @param \DOMNode $ele
     *            The element being written.
     */
    protected function openTag($ele)
    {
        $this->wr('<')->wr($this->traverser->isLocalElement($ele) ? $ele->localName : $ele->tagName);


        $this->attrs($ele);
        $this->namespaceAttrs($ele);


        if ($this->outputMode == static::IM_IN_HTML) {
            $this->wr('>');
        }         // If we are not in html mode we are in SVG, MathML, or XML embedded content.
        else {
            if ($ele->hasChildNodes()) {
                $this->wr('>');
            }             // If there are no children this is self closing.
            else {
                $this->wr(' />');
            }
        }
    }

    protected function attrs($ele)
    {
        // FIXME: Needs support for xml, xmlns, xlink, and namespaced elements.
        if (! $ele->hasAttributes()) {
            return $this;
        }

        // TODO: Currently, this always writes name="value", and does not do
        // value-less attributes.
        $map = $ele->attributes;
        $len = $map->length;
        for ($i = 0; $i < $len; ++ $i) {
            $node = $map->item($i);
            $val = $this->enc($node->value, true);

            // XXX: The spec says that we need to ensure that anything in
            // the XML, XMLNS, or XLink NS's should use the canonical
            // prefix. It seems that DOM does this for us already, but there
            // may be exceptions.
            $name = $node->nodeName;

            // Special handling for attributes in SVG and MathML.
            // Using if/elseif instead of switch because it's faster in PHP.
            if ($this->outputMode == static::IM_IN_SVG) {
                $name = Elements::normalizeSvgAttribute($name);
            } elseif ($this->outputMode == static::IM_IN_MATHML) {
                $name = Elements::normalizeMathMlAttribute($name);
            }

            $this->wr(' ')->wr($name);

            if ((isset($val) && $val !== '') || $this->nonBooleanAttribute($node)) {
                $this->wr('="')->wr($val)->wr('"');
            }
        }
    }


    protected function nonBooleanAttribute(\DOMAttr $attr)
    {
        $ele = $attr->ownerElement;
        foreach($this->nonBooleanAttributes as $rule){

            if(isset($rule['nodeNamespace']) && $rule['nodeNamespace']!==$ele->namespaceURI){
                continue;
            }
            if(isset($rule['attNamespace']) && $rule['attNamespace']!==$attr->namespaceURI){
                continue;
            }
            if(isset($rule['nodeName']) && !is_array($rule['nodeName']) && $rule['nodeName']!==$ele->localName){
                continue;
            }
            if(isset($rule['nodeName']) && is_array($rule['nodeName']) && !in_array($ele->localName, $rule['nodeName'], true)){
                continue;
            }
            if(isset($rule['attrName']) && !is_array($rule['attrName']) && $rule['attrName']!==$attr->localName){
                continue;
            }
            if(isset($rule['attrName']) && is_array($rule['attrName']) && !in_array($attr->localName, $rule['attrName'], true)){
                continue;
            }
            if(isset($rule['xpath'])){

                $xp = $this->getXPath($attr);
                if(isset($rule['prefixes'])){
                    foreach($rule['prefixes'] as $nsPrefix => $ns){
                        $xp->registerNamespace($nsPrefix, $ns);
                    }
                }
                if(!$xp->evaluate($rule['xpath'], $attr)){
                    continue;
                }
            }

            return true;
        }

        return false;
    }

    private function getXPath(\DOMNode $node){
        if(!$this->xpath){
            $this->xpath = new \DOMXPath($node->ownerDocument);
        }
        return $this->xpath;
    }

    /**
     * Write the closing tag.
     *
     * Tags for HTML, MathML, and SVG are in the local name. Otherwise, use the
     * qualified name (8.3).
     *
     * @param \DOMNode $ele
     *            The element being written.
     */
    protected function closeTag($ele)
    {
        if ($this->outputMode == static::IM_IN_HTML || $ele->hasChildNodes()) {
            $this->wr('</')->wr($this->traverser->isLocalElement($ele) ? $ele->localName : $ele->tagName)->wr('>');
        }
    }

    /**
     * Write to the output.
     *
     * @param string $text
     *            The string to put into the output.
     *
     * @return \Masterminds\HTML5\Serializer\Traverser $this so it can be used in chaining.
     */
    protected function wr($text)
    {
        fwrite($this->out, $text);
        return $this;
    }

    /**
     * Write a new line character.
     *
     * @return \Masterminds\HTML5\Serializer\Traverser $this so it can be used in chaining.
     */
    protected function nl()
    {
        fwrite($this->out, PHP_EOL);
        return $this;
    }

    /**
     * Encode text.
     *
     * When encode is set to false, the default value, the text passed in is
     * escaped per section 8.3 of the html5 spec. For details on how text is
     * escaped see the escape() method.
     *
     * When encoding is set to true the text is converted to named character
     * references where appropriate. Section 8.1.4 Character references of the
     * html5 spec refers to using named character references. This is useful for
     * characters that can't otherwise legally be used in the text.
     *
     * The named character references are listed in section 8.5.
     *
     * @see http://www.w3.org/TR/2013/CR-html5-20130806/syntax.html#named-character-references True encoding will turn all named character references into their entities.
     *      This includes such characters as +.# and many other common ones. By default
     *      encoding here will just escape &'<>".
     *
     *      Note, PHP 5.4+ has better html5 encoding.
     *
     * @todo Use the Entities class in php 5.3 to have html5 entities.
     *
     * @param string $text
     *            text to encode.
     * @param boolean $attribute
     *            True if we are encoding an attrubute, false otherwise
     *
     * @return string The encoded text.
     */
    protected function enc($text, $attribute = false)
    {

        // Escape the text rather than convert to named character references.
        if (! $this->encode) {
            return $this->escape($text, $attribute);
        }

        // If we are in PHP 5.4+ we can use the native html5 entity functionality to
        // convert the named character references.

        if ($this->hasHTML5) {
            return htmlentities($text, ENT_HTML5 | ENT_SUBSTITUTE | ENT_QUOTES, 'UTF-8', false);
        }         // If a version earlier than 5.4 html5 entities are not entirely handled.
        // This manually handles them.
        else {
            return strtr($text, \Masterminds\HTML5\Serializer\HTML5Entities::$map);
        }
    }

    /**
     * Escape test.
     *
     * According to the html5 spec section 8.3 Serializing HTML fragments, text
     * within tags that are not style, script, xmp, iframe, noembed, and noframes
     * need to be properly escaped.
     *
     * The & should be converted to &amp;, no breaking space unicode characters
     * converted to &nbsp;, when in attribute mode the " should be converted to
     * &quot;, and when not in attribute mode the < and > should be converted to
     * &lt; and &gt;.
     *
     * @see http://www.w3.org/TR/2013/CR-html5-20130806/syntax.html#escapingString
     *
     * @param string $text
     *            text to escape.
     * @param boolean $attribute
     *            True if we are escaping an attrubute, false otherwise
     */
    protected function escape($text, $attribute = false)
    {

        // Not using htmlspecialchars because, while it does escaping, it doesn't
        // match the requirements of section 8.5. For example, it doesn't handle
        // non-breaking spaces.
        if ($attribute) {
            $replace = array(
                '"' => '&quot;',
                '&' => '&amp;',
                "\xc2\xa0" => '&nbsp;'
            );
        } else {
            $replace = array(
                '<' => '&lt;',
                '>' => '&gt;',
                '&' => '&amp;',
                "\xc2\xa0" => '&nbsp;'
            );
        }

        return strtr($text, $replace);
    }
}


1		<?php
2		/**
3		* @file
4		* The rules for generating output in the serializer.
5		*
6		* These output rules are likely to generate output similar to the document that
7		* was parsed. It is not intended to output exactly the document that was parsed.
8		*/
9		namespace Masterminds\HTML5\Serializer;
10
11		use Masterminds\HTML5\Elements;
12
13		/**
14		* Generate the output html5 based on element rules.
15		*/
16		class OutputRules implements \Masterminds\HTML5\Serializer\RulesInterface
17		{
18		/**
19		* Defined in http://www.w3.org/TR/html51/infrastructure.html#html-namespace-0
20		*/
21		const NAMESPACE_HTML = 'http://www.w3.org/1999/xhtml';
22
23		const NAMESPACE_MATHML = 'http://www.w3.org/1998/Math/MathML';
24
25		const NAMESPACE_SVG = 'http://www.w3.org/2000/svg';
26
27		const NAMESPACE_XLINK = 'http://www.w3.org/1999/xlink';
28
29		const NAMESPACE_XML = 'http://www.w3.org/XML/1998/namespace';
30
31		const NAMESPACE_XMLNS = 'http://www.w3.org/2000/xmlns/';
32
33		/**
34		* Holds the HTML5 element names that causes a namespace switch
35		*
36		* @var array
37		*/
38		protected $implicitNamespaces = array(
39		self::NAMESPACE_HTML,
40		self::NAMESPACE_SVG,
41		self::NAMESPACE_MATHML,
42		self::NAMESPACE_XML,
43		self::NAMESPACE_XMLNS,
44		);
45
46		const IM_IN_HTML = 1;
47
48		const IM_IN_SVG = 2;
49
50		const IM_IN_MATHML = 3;
51
52		/**
53		* Used as cache to detect if is available ENT_HTML5
54		* @var boolean
55		*/
56		private $hasHTML5 = false;
57
58		protected $traverser;
59
60		protected $encode = false;
61
62		protected $out;
63
64		protected $outputMode;
65
66		private $xpath;
67
68		protected $nonBooleanAttributes = array(
69		/*
70		array(
71		'nodeNamespace'=>'http://www.w3.org/1999/xhtml',
72		'attrNamespace'=>'http://www.w3.org/1999/xhtml',
73
74		'nodeName'=>'img', 'nodeName'=>array('img', 'a'),
75		'attrName'=>'alt', 'attrName'=>array('title', 'alt'),
76		),
77		*/
78		array(
79		'nodeNamespace' => 'http://www.w3.org/1999/xhtml',
80		'attrName' => array('href',
81		'hreflang',
82		'http-equiv',
83		'icon',
84		'id',
85		'keytype',
86		'kind',
87		'label',
88		'lang',
89		'language',
90		'list',
91		'maxlength',
92		'media',
93		'method',
94		'name',
95		'placeholder',
96		'rel',
97		'rows',
98		'rowspan',
99		'sandbox',
100		'spellcheck',
101		'scope',
102		'seamless',
103		'shape',
104		'size',
105		'sizes',
106		'span',
107		'src',
108		'srcdoc',
109		'srclang',
110		'srcset',
111		'start',
112		'step',
113		'style',
114		'summary',
115		'tabindex',
116		'target',
117		'title',
118		'type',
119		'value',
120		'width',
121		'border',
122		'charset',
123		'cite',
124		'class',
125		'code',
126		'codebase',
127		'color',
128		'cols',
129		'colspan',
130		'content',
131		'coords',
132		'data',
133		'datetime',
134		'default',
135		'dir',
136		'dirname',
137		'enctype',
138		'for',
139		'form',
140		'formaction',
141		'headers',
142		'height',
143		'accept',
144		'accept-charset',
145		'accesskey',
146		'action',
147		'align',
148		'alt',
149		'bgcolor',
150		),
151		),
152		array(
153		'nodeNamespace' => 'http://www.w3.org/1999/xhtml',
154		'xpath' => 'starts-with(local-name(), \'data-\')',
155		),
156		);
157
158		const DOCTYPE = '<!DOCTYPE html>';
159
160	64	public function __construct($output, $options = array())
161		{
162	64	if (isset($options['encode_entities'])) {
163	64	$this->encode = $options['encode_entities'];
164	64	}
165
166	64	$this->outputMode = static::IM_IN_HTML;
167	64	$this->out = $output;
168
169		// If HHVM, see https://github.com/facebook/hhvm/issues/2727
170	64	$this->hasHTML5 = defined('ENT_HTML5') && !defined('HHVM_VERSION');
171	64	}
172		public function addRule(array $rule)
173		{
174		$this->nonBooleanAttributes[] = $rule;
175		}
176
177	64	public function setTraverser(\Masterminds\HTML5\Serializer\Traverser $traverser)
178		{
179	64	$this->traverser = $traverser;
180
181	64	return $this;
182		}
183
184	18	public function document($dom)
185		{
186	18	$this->doctype();
187	18	if ($dom->documentElement) {
188	17	foreach ($dom->childNodes as $node) {
189	17	$this->traverser->node($node);
190	17	}
191	17	$this->nl();
192	17	}
193	18	}
194
195	19	protected function doctype()
196		{
197	19	$this->wr(static::DOCTYPE);
198	19	$this->nl();
199	19	}
200
201	27	public function element($ele)
202		{
203	27	$name = $ele->tagName;
204
205		// Per spec:
206		// If the element has a declared namespace in the HTML, MathML or
207		// SVG namespaces, we use the lname instead of the tagName.
208	27	if ($this->traverser->isLocalElement($ele)) {
209	27	$name = $ele->localName;
210	27	}
211
212		// If we are in SVG or MathML there is special handling.
213		// Using if/elseif instead of switch because it's faster in PHP.
214	27	if ($name == 'svg') {
215	3	$this->outputMode = static::IM_IN_SVG;
216	3	$name = Elements::normalizeSvgElement($name);
217	27	} elseif ($name == 'math') {
218	2	$this->outputMode = static::IM_IN_MATHML;
219	2	}
220
221	27	$this->openTag($ele);
222	27	if (Elements::isA($name, Elements::TEXT_RAW)) {
223	4	foreach ($ele->childNodes as $child) {
224	4	if ($child instanceof \DOMCharacterData) {
225	4	$this->wr($child->data);
226	4	} elseif ($child instanceof \DOMElement) {
227	1	$this->element($child);
228	1	}
229	4	}
230	4	} else {
231		// Handle children.
232	25	if ($ele->hasChildNodes()) {
233	25	$this->traverser->children($ele->childNodes);
234	25	}
235
236		// Close out the SVG or MathML special handling.
237	25	if ($name == 'svg' \|\| $name == 'math') {
238	5	$this->outputMode = static::IM_IN_HTML;
239	5	}
240		}
241
242		// If not unary, add a closing tag.
243	27	if (! Elements::isA($name, Elements::VOID_TAG)) {
244	27	$this->closeTag($ele);
245	27	}
246	27	}
247
248		/**
249		* Write a text node.
250		*
251		* @param \DOMText $ele
252		* The text node to write.
253		*/
254	24	public function text($ele)
255		{
256	24	if (isset($ele->parentNode) && isset($ele->parentNode->tagName) && Elements::isA($ele->parentNode->localName, Elements::TEXT_RAW)) {
257	1	$this->wr($ele->data);
258	1	return;
259		}
260
261		// FIXME: This probably needs some flags set.
262	24	$this->wr($this->enc($ele->data));
263	24	}
264
265	2	public function cdata($ele)
266		{
267		// This encodes CDATA.
268	2	$this->wr($ele->ownerDocument->saveXML($ele));
269	2	}
270
271	3	public function comment($ele)
272		{
273		// These produce identical output.
274		// $this->wr('<!--')->wr($ele->data)->wr('-->');
275	3	$this->wr($ele->ownerDocument->saveXML($ele));
276	3	}
277
278	3	public function processorInstruction($ele)
279		{
280	3	$this->wr('<?')
281	3	->wr($ele->target)
282	3	->wr(' ')
283	3	->wr($ele->data)
284	3	->wr('?>');
285	3	}
286		/**
287		* Write the namespace attributes
288		*
289		*
290		* @param \DOMNode $ele
291		* The element being written.
292		*/
293	28	protected function namespaceAttrs($ele)
294		{
295	28	if (!$this->xpath \|\| $this->xpath->document !== $ele->ownerDocument){
296	28	$this->xpath = new \DOMXPath($ele->ownerDocument);
297	28	}
298
299	28	foreach( $this->xpath->query('namespace::[not(.=../../namespace::)]', $ele ) as $nsNode ) {
300	23	if (!in_array($nsNode->nodeValue, $this->implicitNamespaces)) {
301	3	$this->wr(' ')->wr($nsNode->nodeName)->wr('="')->wr($nsNode->nodeValue)->wr('"');
302	3	}
303	28	}
304	28	}
305
306		/**
307		* Write the opening tag.
308		*
309		* Tags for HTML, MathML, and SVG are in the local name. Otherwise, use the
310		* qualified name (8.3).
311		*
312		* @param \DOMNode $ele
313		* The element being written.
314		*/
315	28	protected function openTag($ele)
316		{
317	28	$this->wr('<')->wr($this->traverser->isLocalElement($ele) ? $ele->localName : $ele->tagName);
318
319
320	28	$this->attrs($ele);
321	28	$this->namespaceAttrs($ele);
322
323
324	28	if ($this->outputMode == static::IM_IN_HTML) {
325	26	$this->wr('>');
326	26	} // If we are not in html mode we are in SVG, MathML, or XML embedded content.
327		else {
328	5	if ($ele->hasChildNodes()) {
329	5	$this->wr('>');
330	5	} // If there are no children this is self closing.
331		else {
332	2	$this->wr(' />');
333		}
334		}
335	28	}
336
337	39	protected function attrs($ele)
338		{
339		// FIXME: Needs support for xml, xmlns, xlink, and namespaced elements.
340	39	if (! $ele->hasAttributes()) {
341	23	return $this;
342		}
343
344		// TODO: Currently, this always writes name="value", and does not do
345		// value-less attributes.
346	30	$map = $ele->attributes;
347	30	$len = $map->length;
348	30	for ($i = 0; $i < $len; ++ $i) {
349	30	$node = $map->item($i);
350	30	$val = $this->enc($node->value, true);
351
352		// XXX: The spec says that we need to ensure that anything in
353		// the XML, XMLNS, or XLink NS's should use the canonical
354		// prefix. It seems that DOM does this for us already, but there
355		// may be exceptions.
356	30	$name = $node->nodeName;
357
358		// Special handling for attributes in SVG and MathML.
359		// Using if/elseif instead of switch because it's faster in PHP.
360	30	if ($this->outputMode == static::IM_IN_SVG) {
361	3	$name = Elements::normalizeSvgAttribute($name);
362	30	} elseif ($this->outputMode == static::IM_IN_MATHML) {
363	2	$name = Elements::normalizeMathMlAttribute($name);
364	2	}
365
366	30	$this->wr(' ')->wr($name);
367
368	30	if ((isset($val) && $val !== '') \|\| $this->nonBooleanAttribute($node)) {
369	27	$this->wr('="')->wr($val)->wr('"');
370	27	}
371	30	}
372	30	}
373
374
375	10	protected function nonBooleanAttribute(\DOMAttr $attr)
376		{
377	10	$ele = $attr->ownerElement;
378	10	foreach($this->nonBooleanAttributes as $rule){
379
380	10	if(isset($rule['nodeNamespace']) && $rule['nodeNamespace']!==$ele->namespaceURI){
381		continue;
382		}
383	10	if(isset($rule['attNamespace']) && $rule['attNamespace']!==$attr->namespaceURI){
384		continue;
385		}
386	10	if(isset($rule['nodeName']) && !is_array($rule['nodeName']) && $rule['nodeName']!==$ele->localName){
387		continue;
388		}
389	10	if(isset($rule['nodeName']) && is_array($rule['nodeName']) && !in_array($ele->localName, $rule['nodeName'], true)){
390		continue;
391		}
392	10	if(isset($rule['attrName']) && !is_array($rule['attrName']) && $rule['attrName']!==$attr->localName){
393		continue;
394		}
395	10	if(isset($rule['attrName']) && is_array($rule['attrName']) && !in_array($attr->localName, $rule['attrName'], true)){
396	9	continue;
397		}
398	10	if(isset($rule['xpath'])){
399
400	9	$xp = $this->getXPath($attr);
401	9	if(isset($rule['prefixes'])){
402		foreach($rule['prefixes'] as $nsPrefix => $ns){
403		$xp->registerNamespace($nsPrefix, $ns);
404		}
405		}
406	9	if(!$xp->evaluate($rule['xpath'], $attr)){
407	8	continue;
408		}
409	1	}
410
411	4	return true;
412	8	}
413
414	8	return false;
415		}
416
417	9	private function getXPath(\DOMNode $node){
418	9	if(!$this->xpath){
419	9	$this->xpath = new \DOMXPath($node->ownerDocument);
420	9	}
421	9	return $this->xpath;
422		}
423
424		/**
425		* Write the closing tag.
426		*
427		* Tags for HTML, MathML, and SVG are in the local name. Otherwise, use the
428		* qualified name (8.3).
429		*
430		* @param \DOMNode $ele
431		* The element being written.
432		*/
433	27	protected function closeTag($ele)
434		{
435	27	if ($this->outputMode == static::IM_IN_HTML \|\| $ele->hasChildNodes()) {
436	27	$this->wr('</')->wr($this->traverser->isLocalElement($ele) ? $ele->localName : $ele->tagName)->wr('>');
437	27	}
438	27	}
439
440		/**
441		* Write to the output.
442		*
443		* @param string $text
444		* The string to put into the output.
445		*
446		* @return \Masterminds\HTML5\Serializer\Traverser $this so it can be used in chaining.
447		*/
448	48	protected function wr($text)
449		{
450	48	fwrite($this->out, $text);
451	48	return $this;
452		}
453
454		/**
455		* Write a new line character.
456		*
457		* @return \Masterminds\HTML5\Serializer\Traverser $this so it can be used in chaining.
458		*/
459	20	protected function nl()
460		{
461	20	fwrite($this->out, PHP_EOL);
462	20	return $this;
463		}
464
465		/**
466		* Encode text.
467		*
468		* When encode is set to false, the default value, the text passed in is
469		* escaped per section 8.3 of the html5 spec. For details on how text is
470		* escaped see the escape() method.
471		*
472		* When encoding is set to true the text is converted to named character
473		* references where appropriate. Section 8.1.4 Character references of the
474		* html5 spec refers to using named character references. This is useful for
475		* characters that can't otherwise legally be used in the text.
476		*
477		* The named character references are listed in section 8.5.
478		*
479		* @see http://www.w3.org/TR/2013/CR-html5-20130806/syntax.html#named-character-references True encoding will turn all named character references into their entities.
480		* This includes such characters as +.# and many other common ones. By default
481		* encoding here will just escape &'<>".
482		*
483		* Note, PHP 5.4+ has better html5 encoding.
484		*
485		* @todo Use the Entities class in php 5.3 to have html5 entities.
486		*
487		* @param string $text
488		* text to encode.
489		* @param boolean $attribute
490		* True if we are encoding an attrubute, false otherwise
491		*
492		* @return string The encoded text.
493		*/
494	44	protected function enc($text, $attribute = false)
495		{
496
497		// Escape the text rather than convert to named character references.
498	44	if (! $this->encode) {
499	44	return $this->escape($text, $attribute);
500		}
501
502		// If we are in PHP 5.4+ we can use the native html5 entity functionality to
503		// convert the named character references.
504
505	7	if ($this->hasHTML5) {
506	7	return htmlentities($text, ENT_HTML5 \| ENT_SUBSTITUTE \| ENT_QUOTES, 'UTF-8', false);
507		} // If a version earlier than 5.4 html5 entities are not entirely handled.
508		// This manually handles them.
509		else {
510		return strtr($text, \Masterminds\HTML5\Serializer\HTML5Entities::$map);
511		}
512		}
513
514		/**
515		* Escape test.
516		*
517		* According to the html5 spec section 8.3 Serializing HTML fragments, text
518		* within tags that are not style, script, xmp, iframe, noembed, and noframes
519		* need to be properly escaped.
520		*
521		* The & should be converted to &, no breaking space unicode characters
522		* converted to  , when in attribute mode the " should be converted to
523		* ", and when not in attribute mode the < and > should be converted to
524		* < and >.
525		*
526		* @see http://www.w3.org/TR/2013/CR-html5-20130806/syntax.html#escapingString
527		*
528		* @param string $text
529		* text to escape.
530		* @param boolean $attribute
531		* True if we are escaping an attrubute, false otherwise
532		*/
533	51	protected function escape($text, $attribute = false)
534		{
535
536		// Not using htmlspecialchars because, while it does escaping, it doesn't
537		// match the requirements of section 8.5. For example, it doesn't handle
538		// non-breaking spaces.
539	51	if ($attribute) {
540		$replace = array(
541	38	'"' => '"',
542	38	'&' => '&',
543		"\xc2\xa0" => ' '
544	38	);
545	38	} else {
546		$replace = array(
547	30	'<' => '<',
548	30	'>' => '>',
549	30	'&' => '&',
550		"\xc2\xa0" => ' '
551	30	);
552		}
553
554	51	return strtr($text, $replace);
555		}
556		}
557

Masterminds / html5-php

Push — master ( 30aab1...cadcfa )

OutputRules::nl() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like