Icybee / Patron

lib/HTMLParser.php

<?php

/*
 * This file is part of the Patron package.
 *
 * (c) Olivier Laviale <olivier.laviale@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Patron;

class HTMLParser
{
	const T_ERROR_HANDLER = 'error-handler';

	private $encoding;
	private $matches;
	private $escaped;
	private $opened = [];

	protected $error_handler;
	protected $namespace;

	public function __construct(array $tags=[])
	{
		$tags += [

			self::T_ERROR_HANDLER => function($str, $args) {

				trigger_error(\ICanBoogie\format($str, $args));

			}

		];

		$this->error_handler = $tags[self::T_ERROR_HANDLER];
	}

	public function parse($html, $namespace=null, $encoding='utf-8')
	{
		$this->encoding = $encoding;
		$this->namespace = $namespace;

		#
		# we take care of escaping comments and processing options. they will not be parsed
		# and will end as text nodes
		#

		$html = $this->escapeSpecials($html);

		#
		# in order to create a tree, we first need to split the HTML using the markups,
		# creating a nice flat array of texts and opening and closing markups.
		#
		# the array can be read as follows :
		#
		# i+0 => some text
		# i+1 => '/' for closing markups, nothing otherwise
		# i+2 => the markup it self, without the '<' '>'
		#
		# note that i+2 might end with a '/' indicating an auto-closing markup
		#

		$this->matches = preg_split
		(
			'#<(/?)' . $namespace . '([^>]*)>#', $html, -1, PREG_SPLIT_DELIM_CAPTURE
		);

		#
		# the flat representation is now ready, we can create our tree
		#

		$tree = $this->buildTree();

		#
		# if comments or processing options where escaped, we can
		# safely unescape them now
		#

		if ($this->escaped)
		{
			$tree = $this->unescapeSpecials($tree);
		}

		return $tree;
	}

	protected function escapeSpecials($html)
	{
		#
		# here we escape comments
		#

		$html = preg_replace_callback('#<\!--.+-->#sU', [ $this, 'escapeSpecials_callback' ], $html);

		#
		# and processing options
		#

		$html = preg_replace_callback('#<\?.+\?>#sU', [ $this, 'escapeSpecials_callback' ], $html);

		return $html;
	}

	protected function escapeSpecials_callback($m)
	{
		$this->escaped = true;

		$text = $m[0];

		$text = str_replace
		(
			[ '<', '>' ],
			[ "\x01", "\x02" ],
			$text
		);

		return $text;
	}

	protected function unescapeSpecials($tree)
	{
		return is_array($tree) ? array_map([ $this, 'unescapeSpecials' ], $tree) : str_replace
		(
			[ "\x01", "\x02" ],
			[ '<', '>' ],
			$tree
		);
	}

	protected function buildTree()
	{
		$nodes = [];

		$i = 0;
		$text = null;

$text is not used, you could remove the assignment.

		while (($value = array_shift($this->matches)) !== null)
		{
			switch ($i++ % 3)
			{
				case 0:

CASE statements must be defined using a colon

				{
					#
					# if the trimed value is not empty we preserve the value,
					# otherwise we discard it.
					#

					if (trim($value))
					{
						$nodes[] = $value;
					}
				}
				break;

				case 1:

CASE statements must be defined using a colon

				{
					$closing = ($value == '/');
				}
				break;

				case 2:

CASE statements must be defined using a colon

				{
					if (substr($value, -1, 1) == '/')
					{
						#
						# auto closing
						#

						$nodes[] = $this->parseMarkup(substr($value, 0, -1));
					}
					else if ($closing)

The variable $closing does not seem to be defined for all execution paths leading up to this point.

					{
						#
						# closing markup
						#

						$open = array_pop($this->opened);

						if ($value != $open)
						{
							$this->error($value, $open);
						}

						return $nodes;
					}
					else
					{
						#
						# this is an open markup with possible children
						#

						$node = $this->parseMarkup($value);

						#
						# push the markup name into the opened markups
						#

						$this->opened[] = $node['name'];

						#
						# create the node and parse its children
						#

						$node['children'] = $this->buildTree($this->matches);

The call to HTMLParser::buildTree() has too many arguments starting with $this->matches.

						$nodes[] = $node;
					}
				}
			}
		}

		return $nodes;
	}

	protected function parseMarkup($markup)
	{
		#
		# get markup's name
		#

		preg_match('#^[^\s]+#', $markup, $matches);

		$name = $matches[0];

		#
		# get markup's arguments
		#

		preg_match_all('#\s+([^=]+)\s*=\s*"([^"]+)"#', $markup, $matches, PREG_SET_ORDER);

		#
		# transform the matches into a nice key/value array
		#

		$args = [];

		foreach ($matches as $m)

The expression $matches of type null|array<integer,array<integer,string>> is not guaranteed to be traversable. How about adding an additional type check?

		{
			#
			# we unescape the html entities of the argument's value
			#

			$args[$m[1]] = html_entity_decode($m[2], ENT_QUOTES, $this->encoding);
		}

		return [ 'name' => $name, 'args' => $args ];
	}

	protected function error($markup, $expected)
	{
		$this->malformed = true;

The property malformed does not exist. Did you maybe forget to declare it?

		call_user_func
		(
			$this->error_handler, $expected
			? 'unexpected closing markup %markup, should be %expected'
			: 'unexpected closing markup %markup, when none was opened', [

				'%markup' => $this->namespace . $markup, '%expected' => $expected

			]
		);
	}

	static public function collectMarkup($nodes, $markup)
	{
		$collected = [];

		foreach ($nodes as $node)
		{
			if (!is_array($node))
			{
				continue;
			}

			if ($node['name'] == $markup)
			{
				$collected[] = $node;
			}

			if (isset($node['children']))
			{
				$collected = array_merge($collected, self::collectMarkup($node['children'], $markup));
			}
		}

		return $collected;
	}
}