Tocifier::_getParent() - Code Metrics - Inspection of "Merge branch 'dev'" - ntd/silverstripe-autotoc - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 382be2...94943b )

by Nicola

created 2016-05-26 19:42 UTC

Tocifier::_getParent() A

↳ Parent: Tocifier

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	0
loc	10
rs	9.4285
cc	3
eloc	5
nc	3
nop	1

<?php

/*
 * Tocifier is intentionally decoupled from SilverStripe to be able to
 * test it without needing to put all the test infrastructure up.
 */
class Tocifier
namespace YourVendor;

class YourClass { }
{
    // Prefix to prepend to every URL fragment
    public static $prefix = 'TOC-';

    // The original HTML
    private $_raw_html = '';

    // $_raw_html augmented with anchor ids for proper navigation
    private $_html = '';

    // The most recently generated TOC tree.
    private $_tree;

    // Array of references to the potential parents
    private $_dangling = array();


    /**
     * Get the TOC node closest to a given nesting level.
     *
     * @param  int $level  The requested nesting level.
     * @return array
     */
    private function &_getParent($level)
    {
        while (--$level >= 0) {
            if (isset($this->_dangling[$level])) {
                return $this->_dangling[$level];
            }
        }
        // This should never be reached
        assert(false);
    }

    /**
     * Get the plain text content from a DOM element.
     *
     * @param  DOMElement $tag  The DOM element to inspect.
     * @return string
     */
    private function _getPlainText(DOMElement $tag)
    {
        // Work on a copy
        $clone = $tag->cloneNode(true);

        // Strip unneded tags (<small>)
        while (($tag = $clone->getElementsByTagName('small')) && $tag->length) {
            $tag->item(0)->parentNode->removeChild($tag->item(0));
        }

        return $clone->textContent;
    }

    /**
     * Create a new TOC node.
     *
     * @param  string $id     Node id, used for anchoring
     * @param  string $text   Title text
     * @param  int    $level  The nesting level of the node
     * @return array
     */
    private function &_newNode($id, $text, $level)
    {
        $node = array(
            'id'    => $id,
            'title' => $text
        );

        // Clear the trailing dangling parents after level, if any
        end($this->_dangling);
        $last = key($this->_dangling);
        for ($n = $level+1; $n <= $last; ++$n) {
            unset($this->_dangling[$n]);
        }

        // Consider this node a potential dangling parent
        $this->_dangling[$level] =& $node;

        return $node;
    }

    /**
     * Process the specific document.
     *
     * @param  DOMDocument $doc  The document to process.
     */
    private function _processDocument($doc)
    {
        $this->_tree =& $this->_newNode(self::$prefix, '', 0);
        $n = 1;

        $xpath = new DOMXPath($doc);
        $query = '//*[translate(name(), "123456", "......") = "h."][not(@data-hide-from-toc)]';

        foreach ($xpath->query($query) as $h) {
            $text = $this->_getPlainText($h);
            $level = (int) substr($h->tagName, 1);
            $id = self::$prefix . $n;
            ++$n;

            // Build the tree
            $parent =& $this->_getParent($level);
            $node =& $this->_newNode($id, $text, $level);
            if (! isset($parent['children'])) {
                $parent['children'] = array();
            }
            $parent['children'][] =& $node;

            // Prepend the anchor
            $anchor = $doc->createElement('a');
            $anchor->setAttribute('id', $id);
            $anchor->setAttribute('class', 'anchor');
            $h->parentNode->insertBefore($anchor, $h);
        }

        $body = $doc->getElementsByTagName('body')->item(0);
        $this->_html = str_replace(array("<body>\n", '</body>'), '',
                                   $doc->saveHTML($body));
    }

    /**
     * Debug function for dumping a TOC node and its children.
     *
     * @param  array  $node    The TOC node to dump
     * @param  string $indent  Indentation string.
     */
    private function _dumpBranch($node, $indent = '')
    {
        echo $indent . $node['title'] . "\n";
        if (isset($node['children'])) {
            foreach ($node['children'] as &$child) {
                $this->_dumpBranch($child, "$indent\t");
            }
        }
    }


    /**
     * Create a new TOCifier instance.
     *
     * A string containing the HTML to parse for TOC must be passed
     * in. The real processing will be triggered by the process()
     * method.
     *
     * Parsing a file can be easily performed by using
     * file_get_contents():
     *
     * <code>
     * $tocifier = new Tocifier(@file_get_content($file));
     * </code>
     *
     * @param string $html A chunk of valid HTML (UTF-8 encoded).
     */
    public function __construct($html)
    {
        $this->_raw_html = $html;
    }

    /**
     * Parse and process the HTML chunk.
     *
     * The parsing phase involves picking up all the HTML header
     * elements (from <h1> to <h6>), so if the HTML is not well formed
     * or any other error is encountered this function will fail.
     *
     * @return boolean true on success, false on errors.
     */
    public function process()
    {
        // Check if $this->_raw_html is valid
        if (! is_string($this->_raw_html) || empty($this->_raw_html)) {
            return false;
        }

        // DOMDocument sucks ass (welcome to PHP, you poor shit). I
        // really don't understand why it is so difficult for loadHTML()
        // to read a chunk of text in UTF-8...
        $html = mb_convert_encoding($this->_raw_html, 'HTML-ENTITIES', 'UTF-8');

        // Parse the HTML into a DOMDocument tree
        $doc = new DOMDocument();
        if (! @$doc->loadHTML($html)) {
            return false;
        }

        // Process the doc
        $this->_processDocument($doc);
        return true;
    }

    /**
     * Get the TOC (Table Of Contents) from the provided HTML.
     *
     * The HTML must be provided throught the constructor.
     *
     * The TOC is represented in the form of:
     *
     * <code>
     * array(
     *     array('id'       => 'TOC-1',
     *           'title'    => 'Item 1',
     *           'children' => array(
     *               array('id'       => 'TOC-2',
     *                     'title'    => 'Subitem 1.1'
     *               ),
     *               array('id'       => 'TOC-3',
     *                     'title'    => 'Subitem 1.2',
     *                     'children' => array(
     *                         array('id'      => 'TOC-4',
     *                               'title    => 'Subsubitem 1.2.1'
     *     ))))),
     *     array('id'       => 'TOC-5,
     *           'title'    => 'Item 2',
     *           'children' => array(
     *               array('id'       => 'TOC-6',
     *                     'title'    => 'Subitem 2.1'
     *               ),
     *               array('id'       => 'TOC-7',
     *                     'title'    => 'Subitem 2.2'
     * ))));
     * </code>
     *
     * The TOC is cached, so subsequent calls will return the same tree.
     *
     * @return Array An array representing the TOC. A valid array is

     *               always returned.
     */
    public function getTOC()
    {
        return isset($this->_tree['children']) ? $this->_tree['children'] : array();
    }

    /**
     * Get the HTML augmented with anchors for proper navigation.
     *
     * The HTML must be provided throught the feedHtml() method.
     * The returned string is cached, so subsequent calls will return
     * the same string without further processing.
     *
     * @return String The augmented HTML.
     */
    public function getHtml()
    {
        return $this->_html;
    }

    /**
     * Dump the TOC to stdout for debugging purpose.
     */
    public function dumpTOC()
    {
        $this->_dumpBranch($this->_tree);
    }
}


1			<?php
2
3			/*
4			* Tocifier is intentionally decoupled from SilverStripe to be able to
5			* test it without needing to put all the test infrastructure up.
6			*/
7			class Tocifier
			0 ignored issues – show Coding Style Compatibility introduced 2016-02-08 21:00 UTC by Report Bug Copy Issue Report PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions. You can fix this by adding a namespace to your class: namespace YourVendor; class YourClass { } When choosing a vendor namespace, try to pick something that is not too generic to avoid conflicts with other libraries. Loading history...
8			{
9			// Prefix to prepend to every URL fragment
10			public static $prefix = 'TOC-';
11
12			// The original HTML
13			private $_raw_html = '';
14
15			// $_raw_html augmented with anchor ids for proper navigation
16			private $_html = '';
17
18			// The most recently generated TOC tree.
19			private $_tree;
20
21			// Array of references to the potential parents
22			private $_dangling = array();
23
24
25			/**
26			* Get the TOC node closest to a given nesting level.
27			*
28			* @param int $level The requested nesting level.
29			* @return array
30			*/
31			private function &_getParent($level)
32			{
33			while (--$level >= 0) {
34			if (isset($this->_dangling[$level])) {
35			return $this->_dangling[$level];
36			}
37			}
38			// This should never be reached
39			assert(false);
40			}
41
42			/**
43			* Get the plain text content from a DOM element.
44			*
45			* @param DOMElement $tag The DOM element to inspect.
46			* @return string
47			*/
48			private function _getPlainText(DOMElement $tag)
49			{
50			// Work on a copy
51			$clone = $tag->cloneNode(true);
52
53			// Strip unneded tags (<small>)
54			while (($tag = $clone->getElementsByTagName('small')) && $tag->length) {
55			$tag->item(0)->parentNode->removeChild($tag->item(0));
56			}
57
58			return $clone->textContent;
59			}
60
61			/**
62			* Create a new TOC node.
63			*
64			* @param string $id Node id, used for anchoring
65			* @param string $text Title text
66			* @param int $level The nesting level of the node
67			* @return array
68			*/
69			private function &_newNode($id, $text, $level)
70			{
71			$node = array(
72			'id' => $id,
73			'title' => $text
74			);
75
76			// Clear the trailing dangling parents after level, if any
77			end($this->_dangling);
78			$last = key($this->_dangling);
79			for ($n = $level+1; $n <= $last; ++$n) {
80			unset($this->_dangling[$n]);
81			}
82
83			// Consider this node a potential dangling parent
84			$this->_dangling[$level] =& $node;
85
86			return $node;
87			}
88
89			/**
90			* Process the specific document.
91			*
92			* @param DOMDocument $doc The document to process.
93			*/
94			private function _processDocument($doc)
95			{
96			$this->_tree =& $this->_newNode(self::$prefix, '', 0);
97			$n = 1;
98
99			$xpath = new DOMXPath($doc);
100			$query = '//*[translate(name(), "123456", "......") = "h."][not(@data-hide-from-toc)]';
101
102			foreach ($xpath->query($query) as $h) {
103			$text = $this->_getPlainText($h);
104			$level = (int) substr($h->tagName, 1);
105			$id = self::$prefix . $n;
106			++$n;
107
108			// Build the tree
109			$parent =& $this->_getParent($level);
110			$node =& $this->_newNode($id, $text, $level);
111			if (! isset($parent['children'])) {
112			$parent['children'] = array();
113			}
114			$parent['children'][] =& $node;
115
116			// Prepend the anchor
117			$anchor = $doc->createElement('a');
118			$anchor->setAttribute('id', $id);
119			$anchor->setAttribute('class', 'anchor');
120			$h->parentNode->insertBefore($anchor, $h);
121			}
122
123			$body = $doc->getElementsByTagName('body')->item(0);
124			$this->_html = str_replace(array("<body>\n", '</body>'), '',
125			$doc->saveHTML($body));
126			}
127
128			/**
129			* Debug function for dumping a TOC node and its children.
130			*
131			* @param array $node The TOC node to dump
132			* @param string $indent Indentation string.
133			*/
134			private function _dumpBranch($node, $indent = '')
135			{
136			echo $indent . $node['title'] . "\n";
137			if (isset($node['children'])) {
138			foreach ($node['children'] as &$child) {
139			$this->_dumpBranch($child, "$indent\t");
140			}
141			}
142			}
143
144
145			/**
146			* Create a new TOCifier instance.
147			*
148			* A string containing the HTML to parse for TOC must be passed
149			* in. The real processing will be triggered by the process()
150			* method.
151			*
152			* Parsing a file can be easily performed by using
153			* file_get_contents():
154			*
155			* <code>
156			* $tocifier = new Tocifier(@file_get_content($file));
157			* </code>
158			*
159			* @param string $html A chunk of valid HTML (UTF-8 encoded).
160			*/
161			public function __construct($html)
162			{
163			$this->_raw_html = $html;
164			}
165
166			/**
167			* Parse and process the HTML chunk.
168			*
169			* The parsing phase involves picking up all the HTML header
170			* elements (from <h1> to <h6>), so if the HTML is not well formed
171			* or any other error is encountered this function will fail.
172			*
173			* @return boolean true on success, false on errors.
174			*/
175			public function process()
176			{
177			// Check if $this->_raw_html is valid
178			if (! is_string($this->_raw_html) \|\| empty($this->_raw_html)) {
179			return false;
180			}
181
182			// DOMDocument sucks ass (welcome to PHP, you poor shit). I
183			// really don't understand why it is so difficult for loadHTML()
184			// to read a chunk of text in UTF-8...
185			$html = mb_convert_encoding($this->_raw_html, 'HTML-ENTITIES', 'UTF-8');
186
187			// Parse the HTML into a DOMDocument tree
188			$doc = new DOMDocument();
189			if (! @$doc->loadHTML($html)) {
190			return false;
191			}
192
193			// Process the doc
194			$this->_processDocument($doc);
195			return true;
196			}
197
198			/**
199			* Get the TOC (Table Of Contents) from the provided HTML.
200			*
201			* The HTML must be provided throught the constructor.
202			*
203			* The TOC is represented in the form of:
204			*
205			* <code>
206			* array(
207			* array('id' => 'TOC-1',
208			* 'title' => 'Item 1',
209			* 'children' => array(
210			* array('id' => 'TOC-2',
211			* 'title' => 'Subitem 1.1'
212			* ),
213			* array('id' => 'TOC-3',
214			* 'title' => 'Subitem 1.2',
215			* 'children' => array(
216			* array('id' => 'TOC-4',
217			* 'title => 'Subsubitem 1.2.1'
218			* ))))),
219			* array('id' => 'TOC-5,
220			* 'title' => 'Item 2',
221			* 'children' => array(
222			* array('id' => 'TOC-6',
223			* 'title' => 'Subitem 2.1'
224			* ),
225			* array('id' => 'TOC-7',
226			* 'title' => 'Subitem 2.2'
227			* ))));
228			* </code>
229			*
230			* The TOC is cached, so subsequent calls will return the same tree.
231			*
232			* @return Array An array representing the TOC. A valid array is
			0 ignored issues – show Documentation introduced 2016-05-26 19:47 UTC by Report Bug Copy Issue Report Should the return type not be `string\|array`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
233			* always returned.
234			*/
235			public function getTOC()
236			{
237			return isset($this->_tree['children']) ? $this->_tree['children'] : array();
238			}
239
240			/**
241			* Get the HTML augmented with anchors for proper navigation.
242			*
243			* The HTML must be provided throught the feedHtml() method.
244			* The returned string is cached, so subsequent calls will return
245			* the same string without further processing.
246			*
247			* @return String The augmented HTML.
248			*/
249			public function getHtml()
250			{
251			return $this->_html;
252			}
253
254			/**
255			* Dump the TOC to stdout for debugging purpose.
256			*/
257			public function dumpTOC()
258			{
259			$this->_dumpBranch($this->_tree);
260			}
261			}
262

ntd / silverstripe-autotoc

Push — master ( 382be2...94943b )

Tocifier::_getParent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like