HTMLPurifier_ChildDef_Table::__construct() - Code Metrics - Inspection of "Merge pull request #593 from luciorota/patch-8" - geekwright/XoopsCore25 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b5dddf...91d417 )

by Richard

created 2018-09-18 19:36 UTC

HTMLPurifier_ChildDef_Table::__construct() A

↳ Parent: HTMLPurifier_ChildDef_Table

Complexity

Conditions	1
Paths	1

Size

Total Lines	2
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	0
dl	0
loc	2
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

/**
 * Definition for tables.  The general idea is to extract out all of the
 * essential bits, and then reconstruct it later.
 *
 * This is a bit confusing, because the DTDs and the W3C
 * validators seem to disagree on the appropriate definition. The
 * DTD claims:
 *
 *      (CAPTION?, (COL*|COLGROUP*), THEAD?, TFOOT?, TBODY+)
 *
 * But actually, the HTML4 spec then has this to say:
 *
 *      The TBODY start tag is always required except when the table
 *      contains only one table body and no table head or foot sections.
 *      The TBODY end tag may always be safely omitted.
 *
 * So the DTD is kind of wrong.  The validator is, unfortunately, kind
 * of on crack.
 *
 * The definition changed again in XHTML1.1; and in my opinion, this
 * formulation makes the most sense.
 *
 *      caption?, ( col* | colgroup* ), (( thead?, tfoot?, tbody+ ) | ( tr+ ))
 *
 * Essentially, we have two modes: thead/tfoot/tbody mode, and tr mode.
 * If we encounter a thead, tfoot or tbody, we are placed in the former
 * mode, and we *must* wrap any stray tr segments with a tbody. But if
 * we don't run into any of them, just have tr tags is OK.
 */
class HTMLPurifier_ChildDef_Table extends HTMLPurifier_ChildDef
{
    /**
     * @type bool
     */
    public $allow_empty = false;

    /**
     * @type string
     */
    public $type = 'table';

    /**
     * @type array
     */
    public $elements = array(
        'tr' => true,
        'tbody' => true,
        'thead' => true,
        'tfoot' => true,
        'caption' => true,
        'colgroup' => true,
        'col' => true
    );

    public function __construct()
    {
    }

    /**
     * @param array $children
     * @param HTMLPurifier_Config $config
     * @param HTMLPurifier_Context $context
     * @return array
     */
    public function validateChildren($children, $config, $context)
    {
        if (empty($children)) {
            return false;

        }

        // only one of these elements is allowed in a table
        $caption = false;
        $thead = false;
        $tfoot = false;

        // whitespace
        $initial_ws = array();
        $after_caption_ws = array();
        $after_thead_ws = array();
        $after_tfoot_ws = array();

        // as many of these as you want
        $cols = array();
        $content = array();

        $tbody_mode = false; // if true, then we need to wrap any stray
                             // <tr>s with a <tbody>.

        $ws_accum =& $initial_ws;

        foreach ($children as $node) {
            if ($node instanceof HTMLPurifier_Node_Comment) {
                $ws_accum[] = $node;
                continue;
            }
            switch ($node->name) {
            case 'tbody':
                $tbody_mode = true;
                // fall through
            case 'tr':
                $content[] = $node;
                $ws_accum =& $content;
                break;
            case 'caption':
                // there can only be one caption!
                if ($caption !== false)  break;
                $caption = $node;
                $ws_accum =& $after_caption_ws;
                break;
            case 'thead':
                $tbody_mode = true;
                // XXX This breaks rendering properties with
                // Firefox, which never floats a <thead> to
                // the top. Ever. (Our scheme will float the
                // first <thead> to the top.)  So maybe
                // <thead>s that are not first should be
                // turned into <tbody>? Very tricky, indeed.
                if ($thead === false) {
                    $thead = $node;
                    $ws_accum =& $after_thead_ws;
                } else {
                    // Oops, there's a second one! What
                    // should we do?  Current behavior is to
                    // transmutate the first and last entries into
                    // tbody tags, and then put into content.
                    // Maybe a better idea is to *attach
                    // it* to the existing thead or tfoot?
                    // We don't do this, because Firefox
                    // doesn't float an extra tfoot to the
                    // bottom like it does for the first one.
                    $node->name = 'tbody';
                    $content[] = $node;
                    $ws_accum =& $content;
                }
                break;
            case 'tfoot':
                // see above for some aveats
                $tbody_mode = true;
                if ($tfoot === false) {
                    $tfoot = $node;
                    $ws_accum =& $after_tfoot_ws;
                } else {
                    $node->name = 'tbody';
                    $content[] = $node;
                    $ws_accum =& $content;
                }
                break;
            case 'colgroup':
            case 'col':
                $cols[] = $node;
                $ws_accum =& $cols;
                break;
            case '#PCDATA':
                // How is whitespace handled? We treat is as sticky to
                // the *end* of the previous element. So all of the
                // nonsense we have worked on is to keep things
                // together.
                if (!empty($node->is_whitespace)) {
                    $ws_accum[] = $node;
                }
                break;
            }
        }

        if (empty($content)) {
            return false;

        }

        $ret = $initial_ws;
        if ($caption !== false) {
            $ret[] = $caption;
            $ret = array_merge($ret, $after_caption_ws);
        }
        if ($cols !== false) {

            $ret = array_merge($ret, $cols);
        }
        if ($thead !== false) {
            $ret[] = $thead;
            $ret = array_merge($ret, $after_thead_ws);
        }
        if ($tfoot !== false) {
            $ret[] = $tfoot;
            $ret = array_merge($ret, $after_tfoot_ws);
        }

        if ($tbody_mode) {
            // we have to shuffle tr into tbody
            $current_tr_tbody = null;

            foreach($content as $node) {
                switch ($node->name) {
                case 'tbody':
                    $current_tr_tbody = null;
                    $ret[] = $node;
                    break;
                case 'tr':
                    if ($current_tr_tbody === null) {
                        $current_tr_tbody = new HTMLPurifier_Node_Element('tbody');
                        $ret[] = $current_tr_tbody;
                    }
                    $current_tr_tbody->children[] = $node;
                    break;
                case '#PCDATA':
                    //assert($node->is_whitespace);
                    if ($current_tr_tbody === null) {
                        $ret[] = $node;
                    } else {
                        $current_tr_tbody->children[] = $node;
                    }
                    break;
                }
            }
        } else {
            $ret = array_merge($ret, $content);
        }

        return $ret;

    }
}

// vim: et sw=4 sts=4


1			<?php
2
3			/**
4			* Definition for tables. The general idea is to extract out all of the
5			* essential bits, and then reconstruct it later.
6			*
7			* This is a bit confusing, because the DTDs and the W3C
8			* validators seem to disagree on the appropriate definition. The
9			* DTD claims:
10			*
11			* (CAPTION?, (COL\|COLGROUP), THEAD?, TFOOT?, TBODY+)
12			*
13			* But actually, the HTML4 spec then has this to say:
14			*
15			* The TBODY start tag is always required except when the table
16			* contains only one table body and no table head or foot sections.
17			* The TBODY end tag may always be safely omitted.
18			*
19			* So the DTD is kind of wrong. The validator is, unfortunately, kind
20			* of on crack.
21			*
22			* The definition changed again in XHTML1.1; and in my opinion, this
23			* formulation makes the most sense.
24			*
25			* caption?, ( col* \| colgroup* ), (( thead?, tfoot?, tbody+ ) \| ( tr+ ))
26			*
27			* Essentially, we have two modes: thead/tfoot/tbody mode, and tr mode.
28			* If we encounter a thead, tfoot or tbody, we are placed in the former
29			* mode, and we must wrap any stray tr segments with a tbody. But if
30			* we don't run into any of them, just have tr tags is OK.
31			*/
32			class HTMLPurifier_ChildDef_Table extends HTMLPurifier_ChildDef
33			{
34			/**
35			* @type bool
36			*/
37			public $allow_empty = false;
38
39			/**
40			* @type string
41			*/
42			public $type = 'table';
43
44			/**
45			* @type array
46			*/
47			public $elements = array(
48			'tr' => true,
49			'tbody' => true,
50			'thead' => true,
51			'tfoot' => true,
52			'caption' => true,
53			'colgroup' => true,
54			'col' => true
55			);
56
57			public function __construct()
58			{
59			}
60
61			/**
62			* @param array $children
63			* @param HTMLPurifier_Config $config
64			* @param HTMLPurifier_Context $context
65			* @return array
66			*/
67			public function validateChildren($children, $config, $context)
68			{
69			if (empty($children)) {
70			return false;
			0 ignored issues – show Bug Best Practice introduced 2018-09-18 15:24 UTC by Report Bug Copy Issue Report The expression `return false` returns the type `false` which is incompatible with the documented return type `array`. Loading history...
71			}
72
73			// only one of these elements is allowed in a table
74			$caption = false;
75			$thead = false;
76			$tfoot = false;
77
78			// whitespace
79			$initial_ws = array();
80			$after_caption_ws = array();
81			$after_thead_ws = array();
82			$after_tfoot_ws = array();
83
84			// as many of these as you want
85			$cols = array();
86			$content = array();
87
88			$tbody_mode = false; // if true, then we need to wrap any stray
89			// <tr>s with a <tbody>.
90
91			$ws_accum =& $initial_ws;
92
93			foreach ($children as $node) {
94			if ($node instanceof HTMLPurifier_Node_Comment) {
95			$ws_accum[] = $node;
96			continue;
97			}
98			switch ($node->name) {
99			case 'tbody':
100			$tbody_mode = true;
101			// fall through
102			case 'tr':
103			$content[] = $node;
104			$ws_accum =& $content;
105			break;
106			case 'caption':
107			// there can only be one caption!
108			if ($caption !== false) break;
109			$caption = $node;
110			$ws_accum =& $after_caption_ws;
111			break;
112			case 'thead':
113			$tbody_mode = true;
114			// XXX This breaks rendering properties with
115			// Firefox, which never floats a <thead> to
116			// the top. Ever. (Our scheme will float the
117			// first <thead> to the top.) So maybe
118			// <thead>s that are not first should be
119			// turned into <tbody>? Very tricky, indeed.
120			if ($thead === false) {
121			$thead = $node;
122			$ws_accum =& $after_thead_ws;
123			} else {
124			// Oops, there's a second one! What
125			// should we do? Current behavior is to
126			// transmutate the first and last entries into
127			// tbody tags, and then put into content.
128			// Maybe a better idea is to *attach
129			// it* to the existing thead or tfoot?
130			// We don't do this, because Firefox
131			// doesn't float an extra tfoot to the
132			// bottom like it does for the first one.
133			$node->name = 'tbody';
134			$content[] = $node;
135			$ws_accum =& $content;
136			}
137			break;
138			case 'tfoot':
139			// see above for some aveats
140			$tbody_mode = true;
141			if ($tfoot === false) {
142			$tfoot = $node;
143			$ws_accum =& $after_tfoot_ws;
144			} else {
145			$node->name = 'tbody';
146			$content[] = $node;
147			$ws_accum =& $content;
148			}
149			break;
150			case 'colgroup':
151			case 'col':
152			$cols[] = $node;
153			$ws_accum =& $cols;
154			break;
155			case '#PCDATA':
156			// How is whitespace handled? We treat is as sticky to
157			// the end of the previous element. So all of the
158			// nonsense we have worked on is to keep things
159			// together.
160			if (!empty($node->is_whitespace)) {
161			$ws_accum[] = $node;
162			}
163			break;
164			}
165			}
166
167			if (empty($content)) {
168			return false;
			0 ignored issues – show Bug Best Practice introduced 2018-09-18 15:24 UTC by Report Bug Copy Issue Report The expression `return false` returns the type `false` which is incompatible with the documented return type `array`. Loading history...
169			}
170
171			$ret = $initial_ws;
172			if ($caption !== false) {
173			$ret[] = $caption;
174			$ret = array_merge($ret, $after_caption_ws);
175			}
176			if ($cols !== false) {
			0 ignored issues – show introduced 2018-09-18 15:24 UTC by Report Bug Copy Issue Report The condition `$cols !== false` is always `true`. Loading history...
177			$ret = array_merge($ret, $cols);
178			}
179			if ($thead !== false) {
180			$ret[] = $thead;
181			$ret = array_merge($ret, $after_thead_ws);
182			}
183			if ($tfoot !== false) {
184			$ret[] = $tfoot;
185			$ret = array_merge($ret, $after_tfoot_ws);
186			}
187
188			if ($tbody_mode) {
189			// we have to shuffle tr into tbody
190			$current_tr_tbody = null;
191
192			foreach($content as $node) {
193			switch ($node->name) {
194			case 'tbody':
195			$current_tr_tbody = null;
196			$ret[] = $node;
197			break;
198			case 'tr':
199			if ($current_tr_tbody === null) {
200			$current_tr_tbody = new HTMLPurifier_Node_Element('tbody');
201			$ret[] = $current_tr_tbody;
202			}
203			$current_tr_tbody->children[] = $node;
204			break;
205			case '#PCDATA':
206			//assert($node->is_whitespace);
207			if ($current_tr_tbody === null) {
208			$ret[] = $node;
209			} else {
210			$current_tr_tbody->children[] = $node;
211			}
212			break;
213			}
214			}
215			} else {
216			$ret = array_merge($ret, $content);
217			}
218
219			return $ret;
220
221			}
222			}
223
224			// vim: et sw=4 sts=4
225

geekwright / XoopsCore25

Push — master ( b5dddf...91d417 )

HTMLPurifier_ChildDef_Table::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like