ComplexTagMatcher::assertTagDoesNotContainChildren() - Code Metrics - Inspection of "Apply a series of minor performance optimizations" - wmde/hamcrest-html-matchers - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#12)

by Marius

created 2018-04-19 10:04 UTC

ComplexTagMatcher::assertTagDoesNotContainChildren() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	3
nc	2
nop	1
dl	0
loc	5
ccs	4
cts	4
cp	1
crap	2
rs	9.4285
c	0
b	0
f	0

<?php

namespace WMDE\HamcrestHtml;

use Hamcrest\Core\AllOf;
use Hamcrest\Core\IsEqual;
use InvalidArgumentException;
use Hamcrest\Description;
use Hamcrest\Matcher;

class ComplexTagMatcher extends TagMatcher {

	/**
	 * @link http://www.xmlsoft.org/html/libxml-xmlerror.html#xmlParserErrors
	 * @link https://github.com/Chronic-Dev/libxml2/blob/683f296a905710ff285c28b8644ef3a3d8be9486/include/libxml/xmlerror.h#L257
	 */
	const XML_UNKNOWN_TAG_ERROR_CODE = 801;

	/**
	 * @var string
	 */
	private $tagHtmlOutline;

	/**
	 * @var Matcher
	 */
	private $matcher;

	/**
	 * @param string $htmlOutline
	 *
	 * @return self
	 */
	public static function tagMatchingOutline( $htmlOutline ) {
		return new self( $htmlOutline );
	}

	/**
	 * @param string $tagHtmlRepresentation
	 */
	public function __construct( $tagHtmlRepresentation ) {
		parent::__construct();

		$this->tagHtmlOutline = $tagHtmlRepresentation;
		$this->matcher = $this->createMatcherFromHtml( $tagHtmlRepresentation );
	}

	public function describeTo( Description $description ) {
		$description->appendText( 'tag matching outline `' )
			->appendText( $this->tagHtmlOutline )
			->appendText( '` ' );
	}

	/**
	 * @param \DOMElement $item
	 * @param Description $mismatchDescription
	 *
	 * @return bool
	 */
	protected function matchesSafelyWithDiagnosticDescription( $item, Description $mismatchDescription ) {
		if ( $this->matcher->matches( $item ) ) {
			return true;
		}

		$mismatchDescription->appendText( 'was `' )
			->appendText( $this->elementToString( $item ) )
			->appendText( '`' );
		return false;
	}

	/**
	 * @param string $htmlOutline
	 *
	 * @return Matcher
	 */
	private function createMatcherFromHtml( $htmlOutline ) {
		$document = $this->parseHtml( $htmlOutline );
		$targetTag = $this->getSingleTagFromThe( $document );

		$this->assertTagDoesNotContainChildren( $targetTag );

		$attributeMatchers = $this->createAttributeMatchers( $htmlOutline, $targetTag );
		$classMatchers = $this->createClassMatchers( $targetTag );

		return AllOf::allOf(
			new TagNameMatcher( IsEqual::equalTo( $targetTag->tagName ) ),
			call_user_func_array( [ AllOf::class, 'allOf' ], $attributeMatchers ),
			call_user_func_array( [ AllOf::class, 'allOf' ], $classMatchers )
		);
	}

	/**
	 * @param \LibXMLError $error
	 *
	 * @return bool
	 */
	private function isUnknownTagError( \LibXMLError $error ) {
		return $error->code === self::XML_UNKNOWN_TAG_ERROR_CODE;
	}

	/**
	 * @param string $inputHtml
	 * @param string $attributeName
	 *
	 * @return bool
	 */
	private function isBooleanAttribute( $inputHtml, $attributeName ) {
		$quotedName = preg_quote( $attributeName, '/' );

		$attributeHasValueAssigned = preg_match( "/\b{$quotedName}\s*=/ui", $inputHtml );
		return !$attributeHasValueAssigned;
	}

	/**
	 * @param string $html
	 *
	 * @return \DOMDocument
	 * @throws \InvalidArgumentException
	 */
	private function parseHtml( $html ) {
		$internalErrors = libxml_use_internal_errors( true );
		$document = new \DOMDocument();

		// phpcs:ignore Generic.PHP.NoSilencedErrors
		if ( !@$document->loadHTML( $html ) ) {
			throw new \InvalidArgumentException( "There was some parsing error of `$html`" );
		}

		$errors = libxml_get_errors();
		libxml_clear_errors();
		libxml_use_internal_errors( $internalErrors );

		/** @var \LibXMLError $error */
		foreach ( $errors as $error ) {
			if ( $this->isUnknownTagError( $error ) ) {
				continue;
			}

			throw new \InvalidArgumentException(
				'There was parsing error: ' . trim( $error->message ) . ' on line ' . $error->line
			);
		}

		return $document;
	}

	/**
	 * @param \DOMDocument $document
	 *
	 * @return \DOMElement
	 * @throws \InvalidArgumentException
	 */
	private function getSingleTagFromThe( \DOMDocument $document ) {
		$directChildren = $document->documentElement->childNodes->item( 0 )->childNodes;

		if ( $directChildren->length !== 1 ) {
			throw new InvalidArgumentException(
				'Expected exactly 1 tag description, got ' . $directChildren->length
		}


		return $directChildren->item( 0 );
	}

	private function assertTagDoesNotContainChildren( \DOMElement $targetTag ) {
		if ( $targetTag->childNodes->length > 0 ) {
			throw new InvalidArgumentException( 'Nested elements are not allowed' );
		}
	}

	/**
	 * @param string $inputHtml
	 * @param \DOMElement $targetTag
	 *
	 * @return AttributeMatcher[]
	 */
	private function createAttributeMatchers( $inputHtml, \DOMElement $targetTag ) {
		$attributeMatchers = [];
		/** @var \DOMAttr $attribute */
		foreach ( $targetTag->attributes as $attribute ) {
			if ( $attribute->name === 'class' ) {
				continue;
			}

			$attributeMatcher = new AttributeMatcher( IsEqual::equalTo( $attribute->name ) );
			if ( !$this->isBooleanAttribute( $inputHtml, $attribute->name ) ) {
				$attributeMatcher = $attributeMatcher->havingValue( IsEqual::equalTo( $attribute->value ) );
			}

			$attributeMatchers[] = $attributeMatcher;
		}
		return $attributeMatchers;
	}

	/**
	 * @param \DOMElement $targetTag
	 *
	 * @return ClassMatcher[]
	 */
	private function createClassMatchers( \DOMElement $targetTag ) {
		$classMatchers = [];
		$classValue = $targetTag->getAttribute( 'class' );
		foreach ( explode( ' ', $classValue ) as $expectedClass ) {
			if ( $expectedClass === '' ) {
				continue;
			}
			$classMatchers[] = new ClassMatcher( IsEqual::equalTo( $expectedClass ) );
		}
		return $classMatchers;
	}

	/**
	 * @param \DOMElement $element
	 *
	 * @return string
	 */
	private function elementToString( \DOMElement $element ) {
		$newDocument = new \DOMDocument();
		$cloned = $element->cloneNode( true );
		$newDocument->appendChild( $newDocument->importNode( $cloned, true ) );
		return trim( $newDocument->saveHTML() );
	}

}


1		<?php
2
3		namespace WMDE\HamcrestHtml;
4
5		use Hamcrest\Core\AllOf;
6		use Hamcrest\Core\IsEqual;
7		use InvalidArgumentException;
8		use Hamcrest\Description;
9		use Hamcrest\Matcher;
10
11		class ComplexTagMatcher extends TagMatcher {
12
13		/**
14		* @link http://www.xmlsoft.org/html/libxml-xmlerror.html#xmlParserErrors
15		* @link https://github.com/Chronic-Dev/libxml2/blob/683f296a905710ff285c28b8644ef3a3d8be9486/include/libxml/xmlerror.h#L257
16		*/
17		const XML_UNKNOWN_TAG_ERROR_CODE = 801;
18
19		/**
20		* @var string
21		*/
22		private $tagHtmlOutline;
23
24		/**
25		* @var Matcher
26		*/
27		private $matcher;
28
29		/**
30		* @param string $htmlOutline
31		*
32		* @return self
33		*/
34	13	public static function tagMatchingOutline( $htmlOutline ) {
35	13	return new self( $htmlOutline );
36		}
37
38		/**
39		* @param string $tagHtmlRepresentation
40		*/
41	13	public function __construct( $tagHtmlRepresentation ) {
42	13	parent::__construct();
43
44	13	$this->tagHtmlOutline = $tagHtmlRepresentation;
45	13	$this->matcher = $this->createMatcherFromHtml( $tagHtmlRepresentation );
46	10	}
47
48	6	public function describeTo( Description $description ) {
49	6	$description->appendText( 'tag matching outline `' )
50	6	->appendText( $this->tagHtmlOutline )
51	6	->appendText( '` ' );
52	6	}
53
54		/**
55		* @param \DOMElement $item
56		* @param Description $mismatchDescription
57		*
58		* @return bool
59		*/
60	12	protected function matchesSafelyWithDiagnosticDescription( $item, Description $mismatchDescription ) {
61	12	if ( $this->matcher->matches( $item ) ) {
62	12	return true;
63	7	}
64	7
65	7	$mismatchDescription->appendText( 'was `' )
66	7	->appendText( $this->elementToString( $item ) )
67	12	->appendText( '`' );
68		return false;
69		}
70
71		/**
72		* @param string $htmlOutline
73		*
74		* @return Matcher
75	13	*/
76	13	private function createMatcherFromHtml( $htmlOutline ) {
77	12	$document = $this->parseHtml( $htmlOutline );
78		$targetTag = $this->getSingleTagFromThe( $document );
79	11
80		$this->assertTagDoesNotContainChildren( $targetTag );
81	10
82	10	$attributeMatchers = $this->createAttributeMatchers( $htmlOutline, $targetTag );
83		$classMatchers = $this->createClassMatchers( $targetTag );
84	10
85	10	return AllOf::allOf(
86	10	new TagNameMatcher( IsEqual::equalTo( $targetTag->tagName ) ),
87	10	call_user_func_array( [ AllOf::class, 'allOf' ], $attributeMatchers ),
88	10	call_user_func_array( [ AllOf::class, 'allOf' ], $classMatchers )
89		);
90		}
91
92		/**
93		* @param \LibXMLError $error
94		*
95		* @return bool
96		*/
97		private function isUnknownTagError( \LibXMLError $error ) {
98		return $error->code === self::XML_UNKNOWN_TAG_ERROR_CODE;
99		}
100
101		/**
102		* @param string $inputHtml
103		* @param string $attributeName
104		*
105		* @return bool
106	5	*/
107	5	private function isBooleanAttribute( $inputHtml, $attributeName ) {
108		$quotedName = preg_quote( $attributeName, '/' );
109	5
110	5	$attributeHasValueAssigned = preg_match( "/\b{$quotedName}\s*=/ui", $inputHtml );
111		return !$attributeHasValueAssigned;
112		}
113
114		/**
115		* @param string $html
116		*
117		* @return \DOMDocument
118		* @throws \InvalidArgumentException
119	13	*/
120	13	private function parseHtml( $html ) {
121	13	$internalErrors = libxml_use_internal_errors( true );
122		$document = new \DOMDocument();
123
124	13	// phpcs:ignore Generic.PHP.NoSilencedErrors
125	1	if ( !@$document->loadHTML( $html ) ) {
126		throw new \InvalidArgumentException( "There was some parsing error of `$html`" );
127		}
128	12
129	12	$errors = libxml_get_errors();
130	12	libxml_clear_errors();
131		libxml_use_internal_errors( $internalErrors );
132
133	12	/** @var \LibXMLError $error */
134		foreach ( $errors as $error ) {
135		if ( $this->isUnknownTagError( $error ) ) {
136		continue;
137		}
138
139		throw new \InvalidArgumentException(
140		'There was parsing error: ' . trim( $error->message ) . ' on line ' . $error->line
141	12	);
142		}
143	12
144		return $document;
145		}
146
147		/**
148		* @param \DOMDocument $document
149		*
150		* @return \DOMElement
151		* @throws \InvalidArgumentException
152	12	*/
153	12	private function getSingleTagFromThe( \DOMDocument $document ) {
154		$directChildren = $document->documentElement->childNodes->item( 0 )->childNodes;
155	12
156	12	if ( $directChildren->length !== 1 ) {
157		throw new InvalidArgumentException(
158	12	'Expected exactly 1 tag description, got ' . $directChildren->length
159	1	}
		0 ignored issues – show Bug introduced 2018-04-19 10:07 UTC by Report Bug Copy Issue Report This code did not parse for me. Apparently, there is an error somewhere around this line: Syntax error, unexpected '}', expecting ',' or ')' Loading history...
160	1
161	1	return $directChildren->item( 0 );
162		}
163
164	11	private function assertTagDoesNotContainChildren( \DOMElement $targetTag ) {
165		if ( $targetTag->childNodes->length > 0 ) {
166		throw new InvalidArgumentException( 'Nested elements are not allowed' );
167	11	}
168	11	}
169	1
170		/**
171	10	* @param string $inputHtml
172		* @param \DOMElement $targetTag
173		*
174		* @return AttributeMatcher[]
175		*/
176		private function createAttributeMatchers( $inputHtml, \DOMElement $targetTag ) {
177		$attributeMatchers = [];
178		/** @var \DOMAttr $attribute */
179	10	foreach ( $targetTag->attributes as $attribute ) {
180	10	if ( $attribute->name === 'class' ) {
181		continue;
182	10	}
183	8
184	3	$attributeMatcher = new AttributeMatcher( IsEqual::equalTo( $attribute->name ) );
185		if ( !$this->isBooleanAttribute( $inputHtml, $attribute->name ) ) {
186		$attributeMatcher = $attributeMatcher->havingValue( IsEqual::equalTo( $attribute->value ) );
187	5	}
188	5
189	4	$attributeMatchers[] = $attributeMatcher;
190	4	}
191		return $attributeMatchers;
192	5	}
193	10
194	10	/**
195		* @param \DOMElement $targetTag
196		*
197		* @return ClassMatcher[]
198		*/
199		private function createClassMatchers( \DOMElement $targetTag ) {
200		$classMatchers = [];
201		$classValue = $targetTag->getAttribute( 'class' );
202	10	foreach ( explode( ' ', $classValue ) as $expectedClass ) {
203	10	if ( $expectedClass === '' ) {
204	10	continue;
205	10	}
206	10	$classMatchers[] = new ClassMatcher( IsEqual::equalTo( $expectedClass ) );
207	8	}
208		return $classMatchers;
209	3	}
210	10
211	10	/**
212		* @param \DOMElement $element
213		*
214		* @return string
215		*/
216		private function elementToString( \DOMElement $element ) {
217		$newDocument = new \DOMDocument();
218		$cloned = $element->cloneNode( true );
219	7	$newDocument->appendChild( $newDocument->importNode( $cloned, true ) );
220	7	return trim( $newDocument->saveHTML() );
221	7	}
222	7
223		}
224

wmde / hamcrest-html-matchers

GitHub Access Token became invalid

Pull Request — master (#12)

ComplexTagMatcher::assertTagDoesNotContainChildren() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like