wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Helper/SparqlHelper.php

Spacing +134 added lines, -136 removed lines

@@ -107,18 +107,18 @@ 
 		$this->violationMessageDeserializer = $violationMessageDeserializer;
 		$this->dataFactory = $dataFactory;
 
-		$this->entityPrefix = $rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ENTITY );
+		$this->entityPrefix = $rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ENTITY);
 		$this->prefixes = <<<EOT
-PREFIX wd: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ENTITY )}>
-PREFIX wds: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_STATEMENT )}>
-PREFIX wdt: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_DIRECT_CLAIM )}>
-PREFIX wdv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_VALUE )}>
-PREFIX p: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_CLAIM )}>
-PREFIX ps: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_CLAIM_STATEMENT )}>
-PREFIX pq: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_QUALIFIER )}>
-PREFIX pqv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_QUALIFIER_VALUE )}>
-PREFIX pr: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_REFERENCE )}>
-PREFIX prv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_REFERENCE_VALUE )}>
+PREFIX wd: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ENTITY)}>
+PREFIX wds: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_STATEMENT)}>
+PREFIX wdt: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_DIRECT_CLAIM)}>
+PREFIX wdv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_VALUE)}>
+PREFIX p: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_CLAIM)}>
+PREFIX ps: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_CLAIM_STATEMENT)}>
+PREFIX pq: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_QUALIFIER)}>
+PREFIX pqv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_QUALIFIER_VALUE)}>
+PREFIX pr: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_REFERENCE)}>
+PREFIX prv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_REFERENCE_VALUE)}>
 PREFIX wikibase: <http://wikiba.se/ontology#>
 PREFIX wikibase-beta: <http://wikiba.se/ontology-beta#>
 EOT;
@@ -133,21 +133,21 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function hasType( $id, array $classes, $withInstance ) {
-		$instanceOfId = $this->config->get( 'WBQualityConstraintsInstanceOfId' );
-		$subclassOfId = $this->config->get( 'WBQualityConstraintsSubclassOfId' );
+	public function hasType($id, array $classes, $withInstance) {
+		$instanceOfId = $this->config->get('WBQualityConstraintsInstanceOfId');
+		$subclassOfId = $this->config->get('WBQualityConstraintsSubclassOfId');
 
-		$path = ( $withInstance ? "wdt:$instanceOfId/" : "" ) . "wdt:$subclassOfId*";
+		$path = ($withInstance ? "wdt:$instanceOfId/" : "")."wdt:$subclassOfId*";
 
 		$metadatas = [];
 
-		foreach ( array_chunk( $classes, 20 ) as $classesChunk ) {
-			$classesValues = implode( ' ', array_map(
-				function( $class ) {
-					return 'wd:' . $class;
+		foreach (array_chunk($classes, 20) as $classesChunk) {
+			$classesValues = implode(' ', array_map(
+				function($class) {
+					return 'wd:'.$class;
 				},
 				$classesChunk
-			) );
+			));
 
 			$query = <<<EOF
 ASK {
@@ -158,19 +158,19 @@ 
 EOF;
 			// TODO hint:gearing is a workaround for T168973 and can hopefully be removed eventually
 
-			$result = $this->runQuery( $query );
+			$result = $this->runQuery($query);
 			$metadatas[] = $result->getMetadata();
-			if ( $result->getArray()['boolean'] ) {
+			if ($result->getArray()['boolean']) {
 				return new CachedBool(
 					true,
-					Metadata::merge( $metadatas )
+					Metadata::merge($metadatas)
 				);
 			}
 		}
 
 		return new CachedBool(
 			false,
-			Metadata::merge( $metadatas )
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -186,10 +186,10 @@ 
 		$ignoreDeprecatedStatements
 	) {
 		$pid = $statement->getPropertyId()->serialize();
-		$guid = str_replace( '$', '-', $statement->getGuid() );
+		$guid = str_replace('$', '-', $statement->getGuid());
 
 		$deprecatedFilter = '';
-		if ( $ignoreDeprecatedStatements ) {
+		if ($ignoreDeprecatedStatements) {
 			$deprecatedFilter .= 'MINUS { ?otherStatement wikibase:rank wikibase:DeprecatedRank. }';
 			$deprecatedFilter .= 'MINUS { ?otherStatement wikibase-beta:rank wikibase-beta:DeprecatedRank. }';
 		}
@@ -209,9 +209,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -236,16 +236,15 @@ 
 		$dataType = $this->propertyDataTypeLookup->getDataTypeIdForProperty(
 			$snak->getPropertyId()
 		);
-		list( $value, $isFullValue ) = $this->getRdfLiteral( $dataType, $dataValue );
-		if ( $isFullValue ) {
+		list($value, $isFullValue) = $this->getRdfLiteral($dataType, $dataValue);
+		if ($isFullValue) {
 			$prefix .= 'v';
 		}
 		$path = $type === Context::TYPE_QUALIFIER ?
-			"$prefix:$pid" :
-			"prov:wasDerivedFrom/$prefix:$pid";
+			"$prefix:$pid" : "prov:wasDerivedFrom/$prefix:$pid";
 
 		$deprecatedFilter = '';
-		if ( $ignoreDeprecatedStatements ) {
+		if ($ignoreDeprecatedStatements) {
 			$deprecatedFilter = <<< EOF
   MINUS { ?otherStatement wikibase:rank wikibase:DeprecatedRank. }
   MINUS { ?otherStatement wikibase-beta:rank wikibase-beta:DeprecatedRank. }
@@ -266,9 +265,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -278,8 +277,8 @@ 
 	 *
 	 * @return string
 	 */
-	private function stringLiteral( $text ) {
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
+	private function stringLiteral($text) {
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
 	}
 
 	/**
@@ -289,17 +288,17 @@ 
 	 *
 	 * @return CachedEntityIds
 	 */
-	private function getOtherEntities( CachedQueryResults $results ) {
-		return new CachedEntityIds( array_map(
-			function ( $resultBindings ) {
+	private function getOtherEntities(CachedQueryResults $results) {
+		return new CachedEntityIds(array_map(
+			function($resultBindings) {
 				$entityIRI = $resultBindings['otherEntity']['value'];
-				$entityPrefixLength = strlen( $this->entityPrefix );
-				if ( substr( $entityIRI, 0, $entityPrefixLength ) === $this->entityPrefix ) {
+				$entityPrefixLength = strlen($this->entityPrefix);
+				if (substr($entityIRI, 0, $entityPrefixLength) === $this->entityPrefix) {
 					try {
 						return $this->entityIdParser->parse(
-							substr( $entityIRI, $entityPrefixLength )
+							substr($entityIRI, $entityPrefixLength)
 						);
-					} catch ( EntityIdParsingException $e ) {
+					} catch (EntityIdParsingException $e) {
 						// fall through
 					}
 				}
@@ -307,7 +306,7 @@ 
 				return null;
 			},
 			$results->getArray()['results']['bindings']
-		), $results->getMetadata() );
+		), $results->getMetadata());
 	}
 
 	// @codingStandardsIgnoreStart cyclomatic complexity of this function is too high
@@ -320,47 +319,47 @@ 
 	 * @return array the literal or IRI as a string in SPARQL syntax,
 	 * and a boolean indicating whether it refers to a full value node or not
 	 */
-	private function getRdfLiteral( $dataType, DataValue $dataValue ) {
-		switch ( $dataType ) {
+	private function getRdfLiteral($dataType, DataValue $dataValue) {
+		switch ($dataType) {
 			case 'string':
 			case 'external-id':
-				return [ $this->stringLiteral( $dataValue->getValue() ), false ];
+				return [$this->stringLiteral($dataValue->getValue()), false];
 			case 'commonsMedia':
-				$url = $this->rdfVocabulary->getMediaFileURI( $dataValue->getValue() );
-				return [ '<' . $url . '>', false ];
+				$url = $this->rdfVocabulary->getMediaFileURI($dataValue->getValue());
+				return ['<'.$url.'>', false];
 			case 'geo-shape':
-				$url = $this->rdfVocabulary->getGeoShapeURI( $dataValue->getValue() );
-				return [ '<' . $url . '>', false ];
+				$url = $this->rdfVocabulary->getGeoShapeURI($dataValue->getValue());
+				return ['<'.$url.'>', false];
 			case 'tabular-data':
-				$url = $this->rdfVocabulary->getTabularDataURI( $dataValue->getValue() );
-				return [ '<' . $url . '>', false ];
+				$url = $this->rdfVocabulary->getTabularDataURI($dataValue->getValue());
+				return ['<'.$url.'>', false];
 			case 'url':
 				$url = $dataValue->getValue();
-				if ( !preg_match( '/^[^<>"{}\\\\|^`\\x00-\\x20]*$/D', $url ) ) {
+				if (!preg_match('/^[^<>"{}\\\\|^`\\x00-\\x20]*$/D', $url)) {
 					// not a valid URL for SPARQL (see SPARQL spec, production 139 IRIREF)
 					// such an URL should never reach us, so just throw
-					throw new InvalidArgumentException( 'invalid URL: ' . $url );
+					throw new InvalidArgumentException('invalid URL: '.$url);
 				}
-				return [ '<' . $url . '>', false ];
+				return ['<'.$url.'>', false];
 			case 'wikibase-item':
 			case 'wikibase-property':
 				/** @var EntityIdValue $dataValue */
-				return [ 'wd:' . $dataValue->getEntityId()->getSerialization(), false ];
+				return ['wd:'.$dataValue->getEntityId()->getSerialization(), false];
 			case 'monolingualtext':
 				/** @var MonolingualTextValue $dataValue */
 				$lang = $dataValue->getLanguageCode();
-				if ( !preg_match( '/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/D', $lang ) ) {
+				if (!preg_match('/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/D', $lang)) {
 					// not a valid language tag for SPARQL (see SPARQL spec, production 145 LANGTAG)
 					// such a language tag should never reach us, so just throw
-					throw new InvalidArgumentException( 'invalid language tag: ' . $lang );
+					throw new InvalidArgumentException('invalid language tag: '.$lang);
 				}
-				return [ $this->stringLiteral( $dataValue->getText() ) . '@' . $lang, false ];
+				return [$this->stringLiteral($dataValue->getText()).'@'.$lang, false];
 			case 'globe-coordinate':
 			case 'quantity':
 			case 'time':
-				return [ 'wdv:' . $dataValue->getHash(), true ];
+				return ['wdv:'.$dataValue->getHash(), true];
 			default:
-				throw new InvalidArgumentException( 'unknown data type: ' . $dataType );
+				throw new InvalidArgumentException('unknown data type: '.$dataType);
 		}
 	}
 	// @codingStandardsIgnoreEnd
@@ -373,44 +372,44 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpression( $text, $regex ) {
+	public function matchesRegularExpression($text, $regex) {
 		// caching wrapper around matchesRegularExpressionWithSparql
 
-		$textHash = hash( 'sha256', $text );
+		$textHash = hash('sha256', $text);
 		$cacheKey = $this->cache->makeKey(
 			'WikibaseQualityConstraints', // extension
 			'regex', // action
 			'WDQS-Java', // regex flavor
-			hash( 'sha256', $regex )
+			hash('sha256', $regex)
 		);
-		$cacheMapSize = $this->config->get( 'WBQualityConstraintsFormatCacheMapSize' );
+		$cacheMapSize = $this->config->get('WBQualityConstraintsFormatCacheMapSize');
 
 		$cacheMapArray = $this->cache->getWithSetCallback(
 			$cacheKey,
 			WANObjectCache::TTL_DAY,
-			function( $cacheMapArray ) use ( $text, $regex, $textHash, $cacheMapSize ) {
+			function($cacheMapArray) use ($text, $regex, $textHash, $cacheMapSize) {
 				// Initialize the cache map if not set
-				if ( $cacheMapArray === false ) {
+				if ($cacheMapArray === false) {
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.init';
-					$this->dataFactory->increment( $key );
+					$this->dataFactory->increment($key);
 					return [];
 				}
 
 				$key = 'wikibase.quality.constraints.regex.cache.refresh';
-				$this->dataFactory->increment( $key );
-				$cacheMap = MapCacheLRU::newFromArray( $cacheMapArray, $cacheMapSize );
-				if ( $cacheMap->has( $textHash ) ) {
+				$this->dataFactory->increment($key);
+				$cacheMap = MapCacheLRU::newFromArray($cacheMapArray, $cacheMapSize);
+				if ($cacheMap->has($textHash)) {
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.hit';
-					$this->dataFactory->increment( $key );
-					$cacheMap->get( $textHash ); // ping cache
+					$this->dataFactory->increment($key);
+					$cacheMap->get($textHash); // ping cache
 				} else {
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.miss';
-					$this->dataFactory->increment( $key );
+					$this->dataFactory->increment($key);
 					try {
-						$matches = $this->matchesRegularExpressionWithSparql( $text, $regex );
-					} catch ( ConstraintParameterException $e ) {
-						$matches = $this->serializeConstraintParameterException( $e );
-					} catch ( SparqlHelperException $e ) {
+						$matches = $this->matchesRegularExpressionWithSparql($text, $regex);
+					} catch (ConstraintParameterException $e) {
+						$matches = $this->serializeConstraintParameterException($e);
+					} catch (SparqlHelperException $e) {
 						// don’t cache this
 						return $cacheMap->toArray();
 					}
@@ -434,42 +433,42 @@ 
 			]
 		);
 
-		if ( isset( $cacheMapArray[$textHash] ) ) {
+		if (isset($cacheMapArray[$textHash])) {
 			$key = 'wikibase.quality.constraints.regex.cache.hit';
-			$this->dataFactory->increment( $key );
+			$this->dataFactory->increment($key);
 			$matches = $cacheMapArray[$textHash];
-			if ( is_bool( $matches ) ) {
+			if (is_bool($matches)) {
 				return $matches;
-			} elseif ( is_array( $matches ) &&
-				$matches['type'] == ConstraintParameterException::class ) {
-				throw $this->deserializeConstraintParameterException( $matches );
+			} elseif (is_array($matches) &&
+				$matches['type'] == ConstraintParameterException::class) {
+				throw $this->deserializeConstraintParameterException($matches);
 			} else {
 				throw new MWException(
-					'Value of unknown type in object cache (' .
-					'cache key: ' . $cacheKey . ', ' .
-					'cache map key: ' . $textHash . ', ' .
-					'value type: ' . gettype( $matches ) . ')'
+					'Value of unknown type in object cache ('.
+					'cache key: '.$cacheKey.', '.
+					'cache map key: '.$textHash.', '.
+					'value type: '.gettype($matches).')'
 				);
 			}
 		} else {
 			$key = 'wikibase.quality.constraints.regex.cache.miss';
-			$this->dataFactory->increment( $key );
-			return $this->matchesRegularExpressionWithSparql( $text, $regex );
+			$this->dataFactory->increment($key);
+			return $this->matchesRegularExpressionWithSparql($text, $regex);
 		}
 	}
 
-	private function serializeConstraintParameterException( ConstraintParameterException $cpe ) {
+	private function serializeConstraintParameterException(ConstraintParameterException $cpe) {
 		return [
 			'type' => ConstraintParameterException::class,
-			'violationMessage' => $this->violationMessageSerializer->serialize( $cpe->getViolationMessage() ),
+			'violationMessage' => $this->violationMessageSerializer->serialize($cpe->getViolationMessage()),
 		];
 	}
 
-	private function deserializeConstraintParameterException( array $serialization ) {
+	private function deserializeConstraintParameterException(array $serialization) {
 		$message = $this->violationMessageDeserializer->deserialize(
 			$serialization['violationMessage']
 		);
-		return new ConstraintParameterException( $message );
+		return new ConstraintParameterException($message);
 	}
 
 	/**
@@ -483,25 +482,25 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpressionWithSparql( $text, $regex ) {
-		$textStringLiteral = $this->stringLiteral( $text );
-		$regexStringLiteral = $this->stringLiteral( '^(?:' . $regex . ')$' );
+	public function matchesRegularExpressionWithSparql($text, $regex) {
+		$textStringLiteral = $this->stringLiteral($text);
+		$regexStringLiteral = $this->stringLiteral('^(?:'.$regex.')$');
 
 		$query = <<<EOF
 SELECT (REGEX($textStringLiteral, $regexStringLiteral) AS ?matches) {}
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
 		$vars = $result->getArray()['results']['bindings'][0];
-		if ( array_key_exists( 'matches', $vars ) ) {
+		if (array_key_exists('matches', $vars)) {
 			// true or false ⇒ regex okay, text matches or not
 			return $vars['matches']['value'] === 'true';
 		} else {
 			// empty result: regex broken
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-regex' ) )
-					->withInlineCode( $regex, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-regex'))
+					->withInlineCode($regex, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -513,14 +512,14 @@ 
 	 *
 	 * @return boolean
 	 */
-	public function isTimeout( $responseContent ) {
-		$timeoutRegex = implode( '|', array_map(
-			function ( $fqn ) {
-				return preg_quote( $fqn, '/' );
+	public function isTimeout($responseContent) {
+		$timeoutRegex = implode('|', array_map(
+			function($fqn) {
+				return preg_quote($fqn, '/');
 			},
-			$this->config->get( 'WBQualityConstraintsSparqlTimeoutExceptionClasses' )
-		) );
-		return (bool)preg_match( '/' . $timeoutRegex . '/', $responseContent );
+			$this->config->get('WBQualityConstraintsSparqlTimeoutExceptionClasses')
+		));
+		return (bool) preg_match('/'.$timeoutRegex.'/', $responseContent);
 	}
 
 	/**
@@ -532,17 +531,17 @@ 
 	 * @return integer|boolean the max-age (in seconds)
 	 * or a plain boolean if no max-age can be determined
 	 */
-	public function getCacheMaxAge( $responseHeaders ) {
+	public function getCacheMaxAge($responseHeaders) {
 		if (
-			array_key_exists( 'x-cache-status', $responseHeaders ) &&
-			preg_match( '/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0] )
+			array_key_exists('x-cache-status', $responseHeaders) &&
+			preg_match('/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0])
 		) {
 			$maxage = [];
 			if (
-				array_key_exists( 'cache-control', $responseHeaders ) &&
-				preg_match( '/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage )
+				array_key_exists('cache-control', $responseHeaders) &&
+				preg_match('/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage)
 			) {
-				return intval( $maxage[1] );
+				return intval($maxage[1]);
 			} else {
 				return true;
 			}
@@ -560,59 +559,58 @@ 
 	 *
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function runQuery( $query ) {
+	public function runQuery($query) {
 
-		$endpoint = $this->config->get( 'WBQualityConstraintsSparqlEndpoint' );
-		$maxQueryTimeMillis = $this->config->get( 'WBQualityConstraintsSparqlMaxMillis' );
-		$url = $endpoint . '?' . http_build_query(
+		$endpoint = $this->config->get('WBQualityConstraintsSparqlEndpoint');
+		$maxQueryTimeMillis = $this->config->get('WBQualityConstraintsSparqlMaxMillis');
+		$url = $endpoint.'?'.http_build_query(
 			[
-				'query' => "#wbqc\n" . $this->prefixes . $query,
+				'query' => "#wbqc\n".$this->prefixes.$query,
 				'format' => 'json',
 				'maxQueryTimeMillis' => $maxQueryTimeMillis,
 			],
-			null, ini_get( 'arg_separator.output' ),
+			null, ini_get('arg_separator.output'),
 			// encode spaces with %20, not +
 			PHP_QUERY_RFC3986
 		);
 
 		$options = [
 			'method' => 'GET',
-			'timeout' => (int)round( ( $maxQueryTimeMillis + 1000 ) / 1000 ),
+			'timeout' => (int) round(($maxQueryTimeMillis + 1000) / 1000),
 			'connectTimeout' => 'default',
 		];
-		$request = MWHttpRequest::factory( $url, $options );
-		$startTime = microtime( true );
+		$request = MWHttpRequest::factory($url, $options);
+		$startTime = microtime(true);
 		$status = $request->execute();
-		$endTime = microtime( true );
+		$endTime = microtime(true);
 		$this->dataFactory->timing(
 			'wikibase.quality.constraints.sparql.timing',
-			( $endTime - $startTime ) * 1000
+			($endTime - $startTime) * 1000
 		);
 
-		$maxAge = $this->getCacheMaxAge( $request->getResponseHeaders() );
-		if ( $maxAge ) {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.cached' );
+		$maxAge = $this->getCacheMaxAge($request->getResponseHeaders());
+		if ($maxAge) {
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.cached');
 		}
 
-		if ( $status->isOK() ) {
+		if ($status->isOK()) {
 			$json = $request->getContent();
-			$arr = json_decode( $json, true );
+			$arr = json_decode($json, true);
 			return new CachedQueryResults(
 				$arr,
 				Metadata::ofCachingMetadata(
 					$maxAge ?
-						CachingMetadata::ofMaximumAgeInSeconds( $maxAge ) :
-						CachingMetadata::fresh()
+						CachingMetadata::ofMaximumAgeInSeconds($maxAge) : CachingMetadata::fresh()
 				)
 			);
 		} else {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.error' );
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.error');
 
 			$this->dataFactory->increment(
 				"wikibase.quality.constraints.sparql.error.http.{$request->getStatus()}"
 			);
 
-			if ( $this->isTimeout( $request->getContent() ) ) {
+			if ($this->isTimeout($request->getContent())) {
 				$this->dataFactory->increment(
 					'wikibase.quality.constraints.sparql.error.timeout'
 				);

src/Api/ResultsCache.php

Spacing +8 added lines, -8 removed lines

@@ -36,7 +36,7 @@ 
 	 * @param WANObjectCache $cache
 	 * @param string $formatVersion The version of the API response format.
 	 */
-	public function __construct( WANObjectCache $cache, $formatVersion ) {
+	public function __construct(WANObjectCache $cache, $formatVersion) {
 		$this->cache = $cache;
 		$this->formatVersion = $formatVersion;
 	}
@@ -45,7 +45,7 @@ 
 	 * @param EntityId $entityId
 	 * @return string cache key
 	 */
-	public function makeKey( EntityId $entityId ) {
+	public function makeKey(EntityId $entityId) {
 		return $this->cache->makeKey(
 			'WikibaseQualityConstraints', // extension
 			'checkConstraints', // action
@@ -61,8 +61,8 @@ 
 	 * @param float &$asOf UNIX timestamp of cached value; null on failure [returned]
 	 * @return mixed
 	 */
-	public function get( EntityId $key, &$curTTL = null, array $checkKeys = [], &$asOf = null ) {
-		return $this->cache->get( $this->makeKey( $key ), $curTTL, $checkKeys, $asOf );
+	public function get(EntityId $key, &$curTTL = null, array $checkKeys = [], &$asOf = null) {
+		return $this->cache->get($this->makeKey($key), $curTTL, $checkKeys, $asOf);
 	}
 
 	/**
@@ -72,16 +72,16 @@ 
 	 * @param array $opts
 	 * @return bool
 	 */
-	public function set( EntityId $key, $value, $ttl = 0, array $opts = [] ) {
-		return $this->cache->set( $this->makeKey( $key ), $value, $ttl, $opts );
+	public function set(EntityId $key, $value, $ttl = 0, array $opts = []) {
+		return $this->cache->set($this->makeKey($key), $value, $ttl, $opts);
 	}
 
 	/**
 	 * @param EntityId $key
 	 * @return bool
 	 */
-	public function delete( EntityId $key ) {
-		return $this->cache->delete( $this->makeKey( $key ) );
+	public function delete(EntityId $key) {
+		return $this->cache->delete($this->makeKey($key));
 	}
 
 }

src/ConstraintCheck/Message/ViolationMessageRenderer.php

Doc Comments -2 removed lines

@@ -352,7 +352,6 @@ 
 	}
 
 	/**
-	 * @param string[] $text Context::TYPE_* constants
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
@@ -387,7 +386,6 @@ 
 	}
 
 	/**
-	 * @param string[] $text Context::TYPE_* constants
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */

Spacing +82 added lines, -82 removed lines

@@ -78,17 +78,17 @@ 
 	 * (temporarily, pre-rendered strings are allowed and returned without changes)
 	 * @return string
 	 */
-	public function render( ViolationMessage $violationMessage ) {
+	public function render(ViolationMessage $violationMessage) {
 		$messageKey = $violationMessage->getMessageKey();
-		$paramsLists = [ [] ];
-		foreach ( $violationMessage->getArguments() as $argument ) {
-			$params = $this->renderArgument( $argument );
+		$paramsLists = [[]];
+		foreach ($violationMessage->getArguments() as $argument) {
+			$params = $this->renderArgument($argument);
 			$paramsLists[] = $params;
 		}
-		$allParams = call_user_func_array( 'array_merge', $paramsLists );
+		$allParams = call_user_func_array('array_merge', $paramsLists);
 		return $this->messageLocalizer
-			->msg( $messageKey )
-			->params( $allParams )
+			->msg($messageKey)
+			->params($allParams)
 			->escaped();
 	}
 
@@ -97,13 +97,13 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return string HTML
 	 */
-	protected function addRole( $value, $role ) {
-		if ( $role === null ) {
+	protected function addRole($value, $role) {
+		if ($role === null) {
 			return $value;
 		}
 
-		return '<span class="wbqc-role wbqc-role-' . htmlspecialchars( $role ) . '">' .
-			$value .
+		return '<span class="wbqc-role wbqc-role-'.htmlspecialchars($role).'">'.
+			$value.
 			'</span>';
 	}
 
@@ -111,15 +111,15 @@ 
 	 * @param string $key message key
 	 * @return string HTML
 	 */
-	protected function msgEscaped( $key ) {
-		return $this->messageLocalizer->msg( $key )->escaped();
+	protected function msgEscaped($key) {
+		return $this->messageLocalizer->msg($key)->escaped();
 	}
 
 	/**
 	 * @param array $argument
 	 * @return array[] params (for Message::params)
 	 */
-	protected function renderArgument( array $argument ) {
+	protected function renderArgument(array $argument) {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'renderEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'renderEntityIdList',
@@ -139,12 +139,12 @@ 
 		$value = $argument['value'];
 		$role = $argument['role'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$params = $this->$method( $value, $role );
+			$params = $this->$method($value, $role);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
@@ -158,46 +158,46 @@ 
 	 * and return a single-element array with a raw message param (i. e. [ Message::rawParam( … ) ])
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderList( array $list, $role, callable $render ) {
-		if ( $list === [] ) {
+	private function renderList(array $list, $role, callable $render) {
+		if ($list === []) {
 			return [
-				Message::numParam( 0 ),
-				Message::rawParam( '<ul></ul>' ),
+				Message::numParam(0),
+				Message::rawParam('<ul></ul>'),
 			];
 		}
 
-		if ( count( $list ) > $this->maxListLength ) {
-			$list = array_slice( $list, 0, $this->maxListLength );
+		if (count($list) > $this->maxListLength) {
+			$list = array_slice($list, 0, $this->maxListLength);
 			$truncated = true;
 		}
 
 		$renderedParamsLists = array_map(
 			$render,
 			$list,
-			array_fill( 0, count( $list ), $role )
+			array_fill(0, count($list), $role)
 		);
 		$renderedParams = array_map(
-			function ( $params ) {
+			function($params) {
 				return $params[0];
 			},
 			$renderedParamsLists
 		);
 		$renderedElements = array_map(
-			function ( $param ) {
+			function($param) {
 				return $param['raw'];
 			},
 			$renderedParams
 		);
-		if ( isset( $truncated ) ) {
-			$renderedElements[] = $this->msgEscaped( 'ellipsis' );
+		if (isset($truncated)) {
+			$renderedElements[] = $this->msgEscaped('ellipsis');
 		}
 
 		return array_merge(
 			[
-				Message::numParam( count( $list ) ),
+				Message::numParam(count($list)),
 				Message::rawParam(
-					'<ul><li>' .
-					implode( '</li><li>', $renderedElements ) .
+					'<ul><li>'.
+					implode('</li><li>', $renderedElements).
 					'</li></ul>'
 				),
 			],
@@ -210,11 +210,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderEntityId( EntityId $entityId, $role ) {
-		return [ Message::rawParam( $this->addRole(
-			$this->entityIdFormatter->formatEntityId( $entityId ),
+	private function renderEntityId(EntityId $entityId, $role) {
+		return [Message::rawParam($this->addRole(
+			$this->entityIdFormatter->formatEntityId($entityId),
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -222,8 +222,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderEntityIdList( array $entityIdList, $role ) {
-		return $this->renderList( $entityIdList, $role, [ $this, 'renderEntityId' ] );
+	private function renderEntityIdList(array $entityIdList, $role) {
+		return $this->renderList($entityIdList, $role, [$this, 'renderEntityId']);
 	}
 
 	/**
@@ -231,24 +231,24 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderItemIdSnakValue( ItemIdSnakValue $value, $role ) {
-		switch ( true ) {
+	private function renderItemIdSnakValue(ItemIdSnakValue $value, $role) {
+		switch (true) {
 			case $value->isValue():
-				return $this->renderEntityId( $value->getItemId(), $role );
+				return $this->renderEntityId($value->getItemId(), $role);
 			case $value->isSomeValue():
-				return [ Message::rawParam( $this->addRole(
-					'<span class="wikibase-snakview-variation-somevaluesnak">' .
-						$this->msgEscaped( 'wikibase-snakview-snaktypeselector-somevalue' ) .
+				return [Message::rawParam($this->addRole(
+					'<span class="wikibase-snakview-variation-somevaluesnak">'.
+						$this->msgEscaped('wikibase-snakview-snaktypeselector-somevalue').
 						'</span>',
 					$role
-				) ) ];
+				))];
 			case $value->isNoValue():
-				return [ Message::rawParam( $this->addRole(
-					'<span class="wikibase-snakview-variation-novaluesnak">' .
-					$this->msgEscaped( 'wikibase-snakview-snaktypeselector-novalue' ) .
+				return [Message::rawParam($this->addRole(
+					'<span class="wikibase-snakview-variation-novaluesnak">'.
+					$this->msgEscaped('wikibase-snakview-snaktypeselector-novalue').
 						'</span>',
 					$role
-				) ) ];
+				))];
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
@@ -263,8 +263,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderItemIdSnakValueList( array $valueList, $role ) {
-		return $this->renderList( $valueList, $role, [ $this, 'renderItemIdSnakValue' ] );
+	private function renderItemIdSnakValueList(array $valueList, $role) {
+		return $this->renderList($valueList, $role, [$this, 'renderItemIdSnakValue']);
 	}
 
 	/**
@@ -272,11 +272,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderDataValue( DataValue $dataValue, $role ) {
-		return [ Message::rawParam( $this->addRole(
-			$this->dataValueFormatter->format( $dataValue ),
+	private function renderDataValue(DataValue $dataValue, $role) {
+		return [Message::rawParam($this->addRole(
+			$this->dataValueFormatter->format($dataValue),
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -284,7 +284,7 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderDataValueType( $dataValueType, $role ) {
+	private function renderDataValueType($dataValueType, $role) {
 		$messageKeys = [
 			'string' => 'datatypes-type-string',
 			'monolingualtext' => 'datatypes-type-monolingualtext',
@@ -293,15 +293,15 @@ 
 			'wikibase-entityid' => 'wbqc-dataValueType-wikibase-entityid',
 		];
 
-		if ( array_key_exists( $dataValueType, $messageKeys ) ) {
-			return [ Message::rawParam( $this->addRole(
-				$this->msgEscaped( $messageKeys[$dataValueType] ),
+		if (array_key_exists($dataValueType, $messageKeys)) {
+			return [Message::rawParam($this->addRole(
+				$this->msgEscaped($messageKeys[$dataValueType]),
 				$role
-			) ) ];
+			))];
 		} else {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'Unknown data value type ' . $dataValueType
+				'Unknown data value type '.$dataValueType
 			);
 			// @codeCoverageIgnoreEnd
 		}
@@ -312,11 +312,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderInlineCode( $code, $role ) {
-		return [ Message::rawParam( $this->addRole(
-			'<code>' . htmlspecialchars( $code ) . '</code>',
+	private function renderInlineCode($code, $role) {
+		return [Message::rawParam($this->addRole(
+			'<code>'.htmlspecialchars($code).'</code>',
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -324,8 +324,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderConstraintScope( $scope, $role ) {
-		switch ( $scope ) {
+	private function renderConstraintScope($scope, $role) {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
 				$itemId = $this->config->get(
 					'WBQualityConstraintsConstraintCheckedOnMainValueId'
@@ -345,10 +345,10 @@ 
 				// callers should never let this happen, but if it does happen,
 				// showing “unknown value” seems reasonable
 				// @codeCoverageIgnoreStart
-				return $this->renderItemIdSnakValue( ItemIdSnakValue::someValue(), $role );
+				return $this->renderItemIdSnakValue(ItemIdSnakValue::someValue(), $role);
 				// @codeCoverageIgnoreEnd
 		}
-		return $this->renderEntityId( new ItemId( $itemId ), $role );
+		return $this->renderEntityId(new ItemId($itemId), $role);
 	}
 
 	/**
@@ -356,8 +356,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderConstraintScopeList( array $scopeList, $role ) {
-		return $this->renderList( $scopeList, $role, [ $this, 'renderConstraintScope' ] );
+	private function renderConstraintScopeList(array $scopeList, $role) {
+		return $this->renderList($scopeList, $role, [$this, 'renderConstraintScope']);
 	}
 
 	/**
@@ -365,25 +365,25 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderPropertyScope( $scope, $role ) {
-		switch ( $scope ) {
+	private function renderPropertyScope($scope, $role) {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsMainValueId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsMainValueId');
 				break;
 			case Context::TYPE_QUALIFIER:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsQualifiersId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsQualifiersId');
 				break;
 			case Context::TYPE_REFERENCE:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsReferencesId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsReferencesId');
 				break;
 			default:
 				// callers should never let this happen, but if it does happen,
 				// showing “unknown value” seems reasonable
 				// @codeCoverageIgnoreStart
-				return $this->renderItemIdSnakValue( ItemIdSnakValue::someValue(), $role );
+				return $this->renderItemIdSnakValue(ItemIdSnakValue::someValue(), $role);
 				// @codeCoverageIgnoreEnd
 		}
-		return $this->renderEntityId( new ItemId( $itemId ), $role );
+		return $this->renderEntityId(new ItemId($itemId), $role);
 	}
 
 	/**
@@ -391,8 +391,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderPropertyScopeList( array $scopeList, $role ) {
-		return $this->renderList( $scopeList, $role, [ $this, 'renderPropertyScope' ] );
+	private function renderPropertyScopeList(array $scopeList, $role) {
+		return $this->renderList($scopeList, $role, [$this, 'renderPropertyScope']);
 	}
 
 	/**
@@ -400,10 +400,10 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderLanguage( $languageCode, $role ) {
+	private function renderLanguage($languageCode, $role) {
 		return [
-			Message::plaintextParam( Language::fetchLanguageName( $languageCode ) ),
-			Message::plaintextParam( $languageCode ),
+			Message::plaintextParam(Language::fetchLanguageName($languageCode)),
+			Message::plaintextParam($languageCode),
 		];
 	}
 

src/ConstraintCheck/Checker/PropertyScopeChecker.php

Spacing +8 added lines, -8 removed lines

@@ -49,7 +49,7 @@ 
 		];
 	}
 
-	public function checkConstraint( Context $context, Constraint $constraint ) {
+	public function checkConstraint(Context $context, Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
 
@@ -58,7 +58,7 @@ 
 			$constraintTypeItemId
 		);
 
-		if ( in_array( $context->getType(), $allowedContextTypes ) ) {
+		if (in_array($context->getType(), $allowedContextTypes)) {
 			return new CheckResult(
 				$context->getCursor(),
 				$constraint,
@@ -71,15 +71,15 @@ 
 				$constraint,
 				[],
 				CheckResult::STATUS_VIOLATION,
-				( new ViolationMessage( 'wbqc-violation-message-property-scope' ) )
-					->withEntityId( $context->getSnak()->getPropertyId() )
-					->withPropertyScope( $context->getType() )
-					->withPropertyScopeList( $allowedContextTypes )
+				(new ViolationMessage('wbqc-violation-message-property-scope'))
+					->withEntityId($context->getSnak()->getPropertyId())
+					->withPropertyScope($context->getType())
+					->withPropertyScopeList($allowedContextTypes)
 			);
 		}
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ) {
+	public function checkConstraintParameters(Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
 		$exceptions = [];
@@ -88,7 +88,7 @@ 
 				$constraintParameters,
 				$constraintTypeItemId
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/ConstraintCheck/Message/ViolationMessage.php

Spacing +35 added lines, -35 removed lines

@@ -122,17 +122,17 @@ 
 	public function __construct(
 		$messageKey
 	) {
-		if ( strpos( $messageKey, self::MESSAGE_KEY_PREFIX ) !== 0 ) {
+		if (strpos($messageKey, self::MESSAGE_KEY_PREFIX) !== 0) {
 			throw new InvalidArgumentException(
-				'ViolationMessage key ⧼' .
-				$messageKey .
-				'⧽ should start with "' .
-				self::MESSAGE_KEY_PREFIX .
+				'ViolationMessage key ⧼'.
+				$messageKey.
+				'⧽ should start with "'.
+				self::MESSAGE_KEY_PREFIX.
 				'".'
 			);
 		}
 
-		$this->messageKeySuffix = substr( $messageKey, strlen( self::MESSAGE_KEY_PREFIX ) );
+		$this->messageKeySuffix = substr($messageKey, strlen(self::MESSAGE_KEY_PREFIX));
 		$this->arguments = [];
 	}
 
@@ -141,7 +141,7 @@ 
 	 * @return string
 	 */
 	public function getMessageKey() {
-		return self::MESSAGE_KEY_PREFIX . $this->messageKeySuffix;
+		return self::MESSAGE_KEY_PREFIX.$this->messageKeySuffix;
 	}
 
 	/**
@@ -161,9 +161,9 @@ 
 	 * @param mixed $value the value, which should match the $type
 	 * @return ViolationMessage
 	 */
-	public function withArgument( $type, $role, $value ) {
+	public function withArgument($type, $role, $value) {
 		$ret = clone $this;
-		$ret->arguments[] = [ 'type' => $type, 'role' => $role, 'value' => $value ];
+		$ret->arguments[] = ['type' => $type, 'role' => $role, 'value' => $value];
 		return $ret;
 	}
 
@@ -175,8 +175,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withEntityId( EntityId $entityId, $role = null ) {
-		return $this->withArgument( self::TYPE_ENTITY_ID, $role, $entityId );
+	public function withEntityId(EntityId $entityId, $role = null) {
+		return $this->withArgument(self::TYPE_ENTITY_ID, $role, $entityId);
 	}
 
 	/**
@@ -193,8 +193,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withEntityIdList( array $entityIdList, $role = null ) {
-		return $this->withArgument( self::TYPE_ENTITY_ID_LIST, $role, $entityIdList );
+	public function withEntityIdList(array $entityIdList, $role = null) {
+		return $this->withArgument(self::TYPE_ENTITY_ID_LIST, $role, $entityIdList);
 	}
 
 	/**
@@ -205,8 +205,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withItemIdSnakValue( ItemIdSnakValue $value, $role = null ) {
-		return $this->withArgument( self::TYPE_ITEM_ID_SNAK_VALUE, $role, $value );
+	public function withItemIdSnakValue(ItemIdSnakValue $value, $role = null) {
+		return $this->withArgument(self::TYPE_ITEM_ID_SNAK_VALUE, $role, $value);
 	}
 
 	/**
@@ -223,8 +223,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withItemIdSnakValueList( array $valueList, $role = null ) {
-		return $this->withArgument( self::TYPE_ITEM_ID_SNAK_VALUE_LIST, $role, $valueList );
+	public function withItemIdSnakValueList(array $valueList, $role = null) {
+		return $this->withArgument(self::TYPE_ITEM_ID_SNAK_VALUE_LIST, $role, $valueList);
 	}
 
 	/**
@@ -235,8 +235,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withDataValue( DataValue $dataValue, $role = null ) {
-		return $this->withArgument( self::TYPE_DATA_VALUE, $role, $dataValue );
+	public function withDataValue(DataValue $dataValue, $role = null) {
+		return $this->withArgument(self::TYPE_DATA_VALUE, $role, $dataValue);
 	}
 
 	/**
@@ -251,8 +251,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withDataValueType( $dataValueType, $role = null ) {
-		return $this->withArgument( self::TYPE_DATA_VALUE_TYPE, $role, $dataValueType );
+	public function withDataValueType($dataValueType, $role = null) {
+		return $this->withArgument(self::TYPE_DATA_VALUE_TYPE, $role, $dataValueType);
 	}
 
 	/**
@@ -263,8 +263,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withInlineCode( $code, $role = null ) {
-		return $this->withArgument( self::TYPE_INLINE_CODE, $role, $code );
+	public function withInlineCode($code, $role = null) {
+		return $this->withArgument(self::TYPE_INLINE_CODE, $role, $code);
 	}
 
 	/**
@@ -275,8 +275,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withConstraintScope( $scope, $role = null ) {
-		return $this->withArgument( self::TYPE_CONSTRAINT_SCOPE, $role, $scope );
+	public function withConstraintScope($scope, $role = null) {
+		return $this->withArgument(self::TYPE_CONSTRAINT_SCOPE, $role, $scope);
 	}
 
 	/**
@@ -287,8 +287,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withConstraintScopeList( array $scopeList, $role = null ) {
-		return $this->withArgument( self::TYPE_CONSTRAINT_SCOPE_LIST, $role, $scopeList );
+	public function withConstraintScopeList(array $scopeList, $role = null) {
+		return $this->withArgument(self::TYPE_CONSTRAINT_SCOPE_LIST, $role, $scopeList);
 	}
 
 	/**
@@ -299,8 +299,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withPropertyScope( $scope, $role = null ) {
-		return $this->withArgument( self::TYPE_PROPERTY_SCOPE, $role, $scope );
+	public function withPropertyScope($scope, $role = null) {
+		return $this->withArgument(self::TYPE_PROPERTY_SCOPE, $role, $scope);
 	}
 
 	/**
@@ -311,8 +311,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withPropertyScopeList( array $scopeList, $role = null ) {
-		return $this->withArgument( self::TYPE_PROPERTY_SCOPE_LIST, $role, $scopeList );
+	public function withPropertyScopeList(array $scopeList, $role = null) {
+		return $this->withArgument(self::TYPE_PROPERTY_SCOPE_LIST, $role, $scopeList);
 	}
 
 	/**
@@ -327,8 +327,8 @@ 
 	 * @param string $languageCode
 	 * @return ViolationMessage
 	 */
-	public function withLanguage( $languageCode ) {
-		return $this->withArgument( self::TYPE_LANGUAGE, null, $languageCode );
+	public function withLanguage($languageCode) {
+		return $this->withArgument(self::TYPE_LANGUAGE, null, $languageCode);
 	}
 
 	/**
@@ -343,8 +343,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withMultilingualText( MultilingualTextValue $text, $role = null ) {
-		return $this->withArgument( self::TYPE_MULTILINGUAL_TEXT, $role, $text );
+	public function withMultilingualText(MultilingualTextValue $text, $role = null) {
+		return $this->withArgument(self::TYPE_MULTILINGUAL_TEXT, $role, $text);
 	}
 
 }

src/ConstraintCheck/Message/ViolationMessageDeserializer.php

Spacing +31 added lines, -31 removed lines

@@ -39,23 +39,23 @@ 
 		$this->dataValueFactory = $dataValueFactory;
 	}
 
-	public function unabbreviateViolationMessageKey( $messageKeySuffix ) {
-		return ViolationMessage::MESSAGE_KEY_PREFIX . $messageKeySuffix;
+	public function unabbreviateViolationMessageKey($messageKeySuffix) {
+		return ViolationMessage::MESSAGE_KEY_PREFIX.$messageKeySuffix;
 	}
 
 	/**
 	 * @param array $serialization
 	 * @return ViolationMessage
 	 */
-	public function deserialize( $serialization ) {
-		Assert::parameterType( 'array', $serialization, '$serialization' );
+	public function deserialize($serialization) {
+		Assert::parameterType('array', $serialization, '$serialization');
 
 		$message = new ViolationMessage(
-			$this->unabbreviateViolationMessageKey( $serialization['k'] )
+			$this->unabbreviateViolationMessageKey($serialization['k'])
 		);
 
-		foreach ( $serialization['a'] as $serializedArgument ) {
-			$message = $this->deserializeArgument( $message, $serializedArgument );
+		foreach ($serialization['a'] as $serializedArgument) {
+			$message = $this->deserializeArgument($message, $serializedArgument);
 		}
 
 		return $message;
@@ -66,7 +66,7 @@ 
 	 * @param array $serializedArgument [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
 	 * @return ViolationMessage $message with the deserialized argument appended
 	 */
-	private function deserializeArgument( ViolationMessage $message, array $serializedArgument ) {
+	private function deserializeArgument(ViolationMessage $message, array $serializedArgument) {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'deserializeEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'deserializeEntityIdList',
@@ -87,23 +87,23 @@ 
 		$serializedValue = $serializedArgument['v'];
 		$role = $serializedArgument['r'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$value = $this->$method( $serializedValue );
+			$value = $this->$method($serializedValue);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
-		return $message->withArgument( $type, $role, $value );
+		return $message->withArgument($type, $role, $value);
 	}
 
 	/**
 	 * @param string $string any value that shall simply be deserialized into itself
 	 * @return string that same value, unchanged
 	 */
-	private function deserializeStringByIdentity( $string ) {
+	private function deserializeStringByIdentity($string) {
 		return $string;
 	}
 
@@ -111,30 +111,30 @@ 
 	 * @param string $entityIdSerialization entity ID serialization
 	 * @return EntityId
 	 */
-	private function deserializeEntityId( $entityIdSerialization ) {
-		return $this->entityIdParser->parse( $entityIdSerialization );
+	private function deserializeEntityId($entityIdSerialization) {
+		return $this->entityIdParser->parse($entityIdSerialization);
 	}
 
 	/**
 	 * @param string[] $entityIdSerializations entity ID serializations
 	 * @return EntityId[]
 	 */
-	private function deserializeEntityIdList( array $entityIdSerializations ) {
-		return array_map( [ $this, 'deserializeEntityId' ], $entityIdSerializations );
+	private function deserializeEntityIdList(array $entityIdSerializations) {
+		return array_map([$this, 'deserializeEntityId'], $entityIdSerializations);
 	}
 
 	/**
 	 * @param string $valueSerialization entity ID serialization, '::somevalue' or '::novalue'
 	 * @return ItemIdSnakValue
 	 */
-	private function deserializeItemIdSnakValue( $valueSerialization ) {
-		switch ( $valueSerialization ) {
+	private function deserializeItemIdSnakValue($valueSerialization) {
+		switch ($valueSerialization) {
 			case '::somevalue':
 				return ItemIdSnakValue::someValue();
 			case '::novalue':
 				return ItemIdSnakValue::noValue();
 			default:
-				return ItemIdSnakValue::fromItemId( $this->deserializeEntityId( $valueSerialization ) );
+				return ItemIdSnakValue::fromItemId($this->deserializeEntityId($valueSerialization));
 		}
 	}
 
@@ -142,24 +142,24 @@ 
 	 * @param string[] $valueSerializations entity ID serializations, '::somevalue's or '::novalue's
 	 * @return ItemIdSnakValue[]
 	 */
-	private function deserializeItemIdSnakValueList( $valueSerializations ) {
-		return array_map( [ $this, 'deserializeItemIdSnakValue' ], $valueSerializations );
+	private function deserializeItemIdSnakValueList($valueSerializations) {
+		return array_map([$this, 'deserializeItemIdSnakValue'], $valueSerializations);
 	}
 
 	/**
 	 * @param array $dataValueSerialization the data value in array form
 	 * @return DataValue
 	 */
-	private function deserializeDataValue( array $dataValueSerialization ) {
-		return $this->dataValueFactory->newFromArray( $dataValueSerialization );
+	private function deserializeDataValue(array $dataValueSerialization) {
+		return $this->dataValueFactory->newFromArray($dataValueSerialization);
 	}
 
 	/**
 	 * @param string $contextTypeAbbreviation
 	 * @return string one of the Context::TYPE_* constants
 	 */
-	private function deserializeContextType( $contextTypeAbbreviation ) {
-		switch ( $contextTypeAbbreviation ) {
+	private function deserializeContextType($contextTypeAbbreviation) {
+		switch ($contextTypeAbbreviation) {
 			case 's':
 				return Context::TYPE_STATEMENT;
 			case 'q':
@@ -169,7 +169,7 @@ 
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					'Unknown context type abbreviation ' . $contextTypeAbbreviation
+					'Unknown context type abbreviation '.$contextTypeAbbreviation
 				);
 				// @codeCoverageIgnoreEnd
 		}
@@ -179,16 +179,16 @@ 
 	 * @param string[] $contextTypeAbbreviations
 	 * @return string[] Context::TYPE_* constants
 	 */
-	private function deserializeContextTypeList( array $contextTypeAbbreviations ) {
-		return array_map( [ $this, 'deserializeContextType' ], $contextTypeAbbreviations );
+	private function deserializeContextTypeList(array $contextTypeAbbreviations) {
+		return array_map([$this, 'deserializeContextType'], $contextTypeAbbreviations);
 	}
 
 	/**
 	 * @param mixed $textSerialization {@see MultilingualTextValue::getArrayValue}
 	 * @return MultilingualTextValue
 	 */
-	private function deserializeMultilingualText( $textSerialization ) {
-		return MultilingualTextValue::newFromArray( $textSerialization );
+	private function deserializeMultilingualText($textSerialization) {
+		return MultilingualTextValue::newFromArray($textSerialization);
 	}
 
 }

src/Api/CheckResultsRenderer.php

Spacing +14 added lines, -14 removed lines

@@ -59,11 +59,11 @@ 
 	 * @param CachedCheckResults $checkResults
 	 * @return CachedCheckConstraintsResponse
 	 */
-	public function render( CachedCheckResults $checkResults ) {
+	public function render(CachedCheckResults $checkResults) {
 		$response = [];
-		foreach ( $checkResults->getArray() as $checkResult ) {
-			$resultArray = $this->checkResultToArray( $checkResult );
-			$checkResult->getContextCursor()->storeCheckResultInArray( $resultArray, $response );
+		foreach ($checkResults->getArray() as $checkResult) {
+			$resultArray = $this->checkResultToArray($checkResult);
+			$checkResult->getContextCursor()->storeCheckResultInArray($resultArray, $response);
 		}
 		return new CachedCheckConstraintsResponse(
 			$response,
@@ -71,18 +71,18 @@ 
 		);
 	}
 
-	public function checkResultToArray( CheckResult $checkResult ) {
-		if ( $checkResult instanceof NullResult ) {
+	public function checkResultToArray(CheckResult $checkResult) {
+		if ($checkResult instanceof NullResult) {
 			return null;
 		}
 
 		$constraintId = $checkResult->getConstraint()->getConstraintId();
 		$typeItemId = $checkResult->getConstraint()->getConstraintTypeItemId();
-		$constraintPropertyId = new PropertyId( $checkResult->getContextCursor()->getSnakPropertyId() );
+		$constraintPropertyId = new PropertyId($checkResult->getContextCursor()->getSnakPropertyId());
 
-		$title = $this->entityTitleLookup->getTitleForId( $constraintPropertyId );
-		$typeLabel = $this->entityIdLabelFormatter->formatEntityId( new ItemId( $typeItemId ) );
-		$link = $title->getFullURL() . '#' . $constraintId;
+		$title = $this->entityTitleLookup->getTitleForId($constraintPropertyId);
+		$typeLabel = $this->entityIdLabelFormatter->formatEntityId(new ItemId($typeItemId));
+		$link = $title->getFullURL().'#'.$constraintId;
 
 		$constraint = [
 			'id' => $constraintId,
@@ -98,14 +98,14 @@ 
 			'constraint' => $constraint
 		];
 		$message = $checkResult->getMessage();
-		if ( $message ) {
-			$result['message-html'] = $this->violationMessageRenderer->render( $message );
+		if ($message) {
+			$result['message-html'] = $this->violationMessageRenderer->render($message);
 		}
-		if ( $checkResult->getContextCursor()->getType() === Context::TYPE_STATEMENT ) {
+		if ($checkResult->getContextCursor()->getType() === Context::TYPE_STATEMENT) {
 			$result['claim'] = $checkResult->getContextCursor()->getStatementGuid();
 		}
 		$cachingMetadataArray = $checkResult->getMetadata()->getCachingMetadata()->toArray();
-		if ( $cachingMetadataArray !== null ) {
+		if ($cachingMetadataArray !== null) {
 			$result['cached'] = $cachingMetadataArray;
 		}
 

src/ConstraintCheck/Helper/ConstraintParameterParser.php

Spacing +282 added lines, -282 removed lines

@@ -78,15 +78,15 @@ 
 	 * @param array $parameters
 	 * @throws ConstraintParameterException
 	 */
-	public function checkError( array $parameters ) {
-		if ( array_key_exists( '@error', $parameters ) ) {
+	public function checkError(array $parameters) {
+		if (array_key_exists('@error', $parameters)) {
 			$error = $parameters['@error'];
-			if ( array_key_exists( 'toolong', $error ) && $error['toolong'] ) {
+			if (array_key_exists('toolong', $error) && $error['toolong']) {
 				$msg = 'wbqc-violation-message-parameters-error-toolong';
 			} else {
 				$msg = 'wbqc-violation-message-parameters-error-unknown';
 			}
-			throw new ConstraintParameterException( new ViolationMessage( $msg ) );
+			throw new ConstraintParameterException(new ViolationMessage($msg));
 		}
 	}
 
@@ -96,11 +96,11 @@ 
 	 * @param string $parameterId
 	 * @throws ConstraintParameterException
 	 */
-	private function requireSingleParameter( array $parameters, $parameterId ) {
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
+	private function requireSingleParameter(array $parameters, $parameterId) {
+		if (count($parameters[$parameterId]) !== 1) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-single' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-single'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -112,11 +112,11 @@ 
 	 * @return void
 	 * @throws ConstraintParameterException
 	 */
-	private function requireValueParameter( Snak $snak, $parameterId ) {
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
+	private function requireValueParameter(Snak $snak, $parameterId) {
+		if (!($snak instanceof PropertyValueSnak)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -128,17 +128,17 @@ 
 	 * @throws ConstraintParameterException
 	 * @return EntityId
 	 */
-	private function parseEntityIdParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseEntityIdParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			return $value->getEntityId();
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-entity' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-entity'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -149,20 +149,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] class entity ID serializations
 	 */
-	public function parseClassParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
+	public function parseClassParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$classId = $this->config->get('WBQualityConstraintsClassId');
+		if (!array_key_exists($classId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $classId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($classId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$classes = [];
-		foreach ( $constraintParameters[$classId] as $class ) {
-			$classes[] = $this->parseEntityIdParameter( $class, $classId )->getSerialization();
+		foreach ($constraintParameters[$classId] as $class) {
+			$classes[] = $this->parseEntityIdParameter($class, $classId)->getSerialization();
 		}
 		return $classes;
 	}
@@ -173,23 +173,23 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
 	 */
-	public function parseRelationParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
+	public function parseRelationParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$relationId = $this->config->get('WBQualityConstraintsRelationId');
+		if (!array_key_exists($relationId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $relationId );
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
-		$instanceId = $this->config->get( 'WBQualityConstraintsInstanceOfRelationId' );
-		$subclassId = $this->config->get( 'WBQualityConstraintsSubclassOfRelationId' );
-		$instanceOrSubclassId = $this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' );
-		switch ( $relationEntityId ) {
+		$this->requireSingleParameter($constraintParameters, $relationId);
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
+		$instanceId = $this->config->get('WBQualityConstraintsInstanceOfRelationId');
+		$subclassId = $this->config->get('WBQualityConstraintsSubclassOfRelationId');
+		$instanceOrSubclassId = $this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId');
+		switch ($relationEntityId) {
 			case $instanceId:
 				return 'instance';
 			case $subclassId:
@@ -198,13 +198,13 @@ 
 				return 'instanceOrSubclass';
 			default:
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-						->withEntityId( new PropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+						->withEntityId(new PropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 						->withEntityIdList(
 							[
-								new ItemId( $instanceId ),
-								new ItemId( $subclassId ),
-								new ItemId( $instanceOrSubclassId ),
+								new ItemId($instanceId),
+								new ItemId($subclassId),
+								new ItemId($instanceOrSubclassId),
 							],
 							Role::CONSTRAINT_PARAMETER_VALUE
 						)
@@ -219,20 +219,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return PropertyId
 	 */
-	private function parsePropertyIdParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parsePropertyIdParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			$id = $value->getEntityId();
-			if ( $id instanceof PropertyId ) {
+			if ($id instanceof PropertyId) {
 				return $id;
 			}
 		}
 		throw new ConstraintParameterException(
-			( new ViolationMessage( 'wbqc-violation-message-parameter-property' ) )
-				->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-				->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+			(new ViolationMessage('wbqc-violation-message-parameter-property'))
+				->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+				->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 		);
 	}
 
@@ -243,32 +243,32 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId
 	 */
-	public function parsePropertyParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertyParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $propertyId );
-		return $this->parsePropertyIdParameter( $constraintParameters[$propertyId][0], $propertyId );
+		$this->requireSingleParameter($constraintParameters, $propertyId);
+		return $this->parsePropertyIdParameter($constraintParameters[$propertyId][0], $propertyId);
 	}
 
-	private function parseItemIdParameter( PropertyValueSnak $snak, $parameterId ) {
+	private function parseItemIdParameter(PropertyValueSnak $snak, $parameterId) {
 		$dataValue = $snak->getDataValue();
-		if ( $dataValue instanceof EntityIdValue &&
+		if ($dataValue instanceof EntityIdValue &&
 			$dataValue->getEntityId() instanceof ItemId
 		) {
-			return ItemIdSnakValue::fromItemId( $dataValue->getEntityId() );
+			return ItemIdSnakValue::fromItemId($dataValue->getEntityId());
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -287,16 +287,16 @@ 
 		$required,
 		$parameterId = null
 	) {
-		$this->checkError( $constraintParameters );
-		if ( $parameterId === null ) {
-			$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+		$this->checkError($constraintParameters);
+		if ($parameterId === null) {
+			$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 		}
-		if ( !array_key_exists( $parameterId, $constraintParameters ) ) {
-			if ( $required ) {
+		if (!array_key_exists($parameterId, $constraintParameters)) {
+			if ($required) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-						->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			} else {
 				return [];
@@ -304,11 +304,11 @@ 
 		}
 
 		$values = [];
-		foreach ( $constraintParameters[$parameterId] as $parameter ) {
-			$snak = $this->snakDeserializer->deserialize( $parameter );
-			switch ( true ) {
+		foreach ($constraintParameters[$parameterId] as $parameter) {
+			$snak = $this->snakDeserializer->deserialize($parameter);
+			switch (true) {
 				case $snak instanceof PropertyValueSnak:
-					$values[] = $this->parseItemIdParameter( $snak, $parameterId );
+					$values[] = $this->parseItemIdParameter($snak, $parameterId);
 					break;
 				case $snak instanceof PropertySomeValueSnak:
 					$values[] = ItemIdSnakValue::someValue();
@@ -327,27 +327,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId[]
 	 */
-	public function parsePropertiesParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertiesParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$parameters = $constraintParameters[$propertyId];
-		if ( count( $parameters ) === 1 &&
-			$this->snakDeserializer->deserialize( $parameters[0] ) instanceof PropertyNoValueSnak
+		if (count($parameters) === 1 &&
+			$this->snakDeserializer->deserialize($parameters[0]) instanceof PropertyNoValueSnak
 		) {
 			return [];
 		}
 
 		$properties = [];
-		foreach ( $parameters as $parameter ) {
-			$properties[] = $this->parsePropertyIdParameter( $parameter, $propertyId );
+		foreach ($parameters as $parameter) {
+			$properties[] = $this->parsePropertyIdParameter($parameter, $propertyId);
 		}
 		return $properties;
 	}
@@ -358,16 +358,16 @@ 
 	 * @throws ConstraintParameterException
 	 * @return DataValue|null
 	 */
-	private function parseValueOrNoValueParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		if ( $snak instanceof PropertyValueSnak ) {
+	private function parseValueOrNoValueParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		if ($snak instanceof PropertyValueSnak) {
 			return $snak->getDataValue();
-		} elseif ( $snak instanceof PropertyNoValueSnak ) {
+		} elseif ($snak instanceof PropertyNoValueSnak) {
 			return null;
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -377,10 +377,10 @@ 
 	 * @param string $parameterId
 	 * @return DataValue|null
 	 */
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, $parameterId ) {
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, $parameterId) {
 		try {
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
-		} catch ( ConstraintParameterException $e ) {
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
+		} catch (ConstraintParameterException $e) {
 			// unknown value means “now”
 			return new NowValue();
 		}
@@ -393,14 +393,14 @@ 
 	 * @param string $unit
 	 * @return bool
 	 */
-	private function exactlyOneQuantityWithUnit( DataValue $min = null, DataValue $max = null, $unit ) {
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
-			!( $max instanceof UnboundedQuantityValue )
+	private function exactlyOneQuantityWithUnit(DataValue $min = null, DataValue $max = null, $unit) {
+		if (!($min instanceof UnboundedQuantityValue) ||
+			!($max instanceof UnboundedQuantityValue)
 		) {
 			return false;
 		}
 
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
 	}
 
 	/**
@@ -413,42 +413,42 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] if the parameter is invalid or missing
 	 */
-	private function parseRangeParameter( array $constraintParameters, $minimumId, $maximumId, $constraintTypeItemId, $type ) {
-		$this->checkError( $constraintParameters );
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
-			!array_key_exists( $maximumId, $constraintParameters )
+	private function parseRangeParameter(array $constraintParameters, $minimumId, $maximumId, $constraintTypeItemId, $type) {
+		$this->checkError($constraintParameters);
+		if (!array_key_exists($minimumId, $constraintParameters) ||
+			!array_key_exists($maximumId, $constraintParameters)
 		) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-needed' ) )
-					->withDataValueType( $type )
-					->withEntityId( new PropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new PropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-needed'))
+					->withDataValueType($type)
+					->withEntityId(new PropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new PropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $minimumId );
-		$this->requireSingleParameter( $constraintParameters, $maximumId );
+		$this->requireSingleParameter($constraintParameters, $minimumId);
+		$this->requireSingleParameter($constraintParameters, $maximumId);
 		$parseFunction = $type === 'time' ? 'parseValueOrNoValueOrNowParameter' : 'parseValueOrNoValueParameter';
-		$min = $this->$parseFunction( $constraintParameters[$minimumId][0], $minimumId );
-		$max = $this->$parseFunction( $constraintParameters[$maximumId][0], $maximumId );
+		$min = $this->$parseFunction($constraintParameters[$minimumId][0], $minimumId);
+		$max = $this->$parseFunction($constraintParameters[$maximumId][0], $maximumId);
 
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
-		if ( $this->exactlyOneQuantityWithUnit( $min, $max, $yearUnit ) ) {
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
+		if ($this->exactlyOneQuantityWithUnit($min, $max, $yearUnit)) {
 			throw new ConstraintParameterException(
-				new ViolationMessage( 'wbqc-violation-message-range-parameters-one-year' )
+				new ViolationMessage('wbqc-violation-message-range-parameters-one-year')
 			);
 		}
-		if ( $min === null && $max === null ||
-			$min !== null && $max !== null && $min->equals( $max ) ) {
+		if ($min === null && $max === null ||
+			$min !== null && $max !== null && $min->equals($max)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-same' ) )
-					->withEntityId( new PropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new PropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
+					->withEntityId(new PropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new PropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		return [ $min, $max ];
+		return [$min, $max];
 	}
 
 	/**
@@ -458,11 +458,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseQuantityRangeParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parseQuantityRangeParameter(array $constraintParameters, $constraintTypeItemId) {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
 			$constraintTypeItemId,
 			'quantity'
 		);
@@ -475,11 +475,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseTimeRangeParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parseTimeRangeParameter(array $constraintParameters, $constraintTypeItemId) {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
 			$constraintTypeItemId,
 			'time'
 		);
@@ -492,17 +492,17 @@ 
 	 * @throws ConstraintParameterException
 	 * @return string
 	 */
-	private function parseStringParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseStringParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof StringValue ) {
+		if ($value instanceof StringValue) {
 			return $value->getValue();
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-string' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -513,15 +513,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseNamespaceParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
+	public function parseNamespaceParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
 			return '';
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
 	}
 
 	/**
@@ -530,19 +530,19 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseFormatParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
+	public function parseFormatParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
+		if (!array_key_exists($formatId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($formatId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $formatId );
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
+		$this->requireSingleParameter($constraintParameters, $formatId);
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
 	}
 
 	/**
@@ -550,16 +550,16 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return EntityId[]
 	 */
-	public function parseExceptionParameter( array $constraintParameters ) {
-		$this->checkError( $constraintParameters );
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
+	public function parseExceptionParameter(array $constraintParameters) {
+		$this->checkError($constraintParameters);
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
 			return [];
 		}
 
 		return array_map(
-			function( $snakSerialization ) use ( $exceptionId ) {
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
+			function($snakSerialization) use ($exceptionId) {
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
 			},
 			$constraintParameters[$exceptionId]
 		);
@@ -570,26 +570,26 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string|null 'mandatory' or null
 	 */
-	public function parseConstraintStatusParameter( array $constraintParameters ) {
-		$this->checkError( $constraintParameters );
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
+	public function parseConstraintStatusParameter(array $constraintParameters) {
+		$this->checkError($constraintParameters);
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
 			return null;
 		}
 
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
-		$this->requireValueParameter( $snak, $constraintStatusId );
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
+		$this->requireValueParameter($snak, $constraintStatusId);
 		$statusId = $snak->getDataValue()->getEntityId()->getSerialization();
 
-		if ( $statusId === $mandatoryId ) {
+		if ($statusId === $mandatoryId) {
 			return 'mandatory';
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new PropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityIdList( [ new ItemId( $mandatoryId ) ], Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new PropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityIdList([new ItemId($mandatoryId)], Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -601,12 +601,12 @@ 
 	 * @return void
 	 * @throws ConstraintParameterException
 	 */
-	private function requireMonolingualTextParameter( DataValue $dataValue, $parameterId ) {
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
+	private function requireMonolingualTextParameter(DataValue $dataValue, $parameterId) {
+		if (!($dataValue instanceof MonolingualTextValue)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -619,30 +619,30 @@ 
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
 	 * @return MultilingualTextValue
 	 */
-	private function parseMultilingualTextParameter( array $snakSerializations, $parameterId ) {
+	private function parseMultilingualTextParameter(array $snakSerializations, $parameterId) {
 		$result = [];
 
-		foreach ( $snakSerializations as $snakSerialization ) {
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-			$this->requireValueParameter( $snak, $parameterId );
+		foreach ($snakSerializations as $snakSerialization) {
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
+			$this->requireValueParameter($snak, $parameterId);
 
 			$value = $snak->getDataValue();
-			$this->requireMonolingualTextParameter( $value, $parameterId );
+			$this->requireMonolingualTextParameter($value, $parameterId);
 			/** @var MonolingualTextValue $value */
 
 			$code = $value->getLanguageCode();
-			if ( array_key_exists( $code, $result ) ) {
+			if (array_key_exists($code, $result)) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-single-per-language' ) )
-						->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-						->withLanguage( $code )
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
+						->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+						->withLanguage($code)
 				);
 			}
 
 			$result[$code] = $value;
 		}
 
-		return new MultilingualTextValue( $result );
+		return new MultilingualTextValue($result);
 	}
 
 	/**
@@ -650,11 +650,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseSyntaxClarificationParameter( array $constraintParameters ) {
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
+	public function parseSyntaxClarificationParameter(array $constraintParameters) {
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
 
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
-			return new MultilingualTextValue( [] );
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
+			return new MultilingualTextValue([]);
 		}
 
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -673,9 +673,9 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string[]|null Context::TYPE_* constants
 	 */
-	public function parseConstraintScopeParameter( array $constraintParameters, $constraintTypeItemId, array $validScopes = null ) {
+	public function parseConstraintScopeParameter(array $constraintParameters, $constraintTypeItemId, array $validScopes = null) {
 		$contextTypes = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
+		$parameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
 		$items = $this->parseItemsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -683,23 +683,23 @@ 
 			$parameterId
 		);
 
-		if ( $items === [] ) {
+		if ($items === []) {
 			return null;
 		}
 
-		foreach ( $items as $item ) {
-			$contextTypes[] = $this->parseContextTypeItem( $item, 'constraint scope', $parameterId );
+		foreach ($items as $item) {
+			$contextTypes[] = $this->parseContextTypeItem($item, 'constraint scope', $parameterId);
 		}
 
-		if ( $validScopes !== null ) {
-			$invalidScopes = array_diff( $contextTypes, $validScopes );
-			if ( $invalidScopes !== [] ) {
-				$invalidScope = array_pop( $invalidScopes );
+		if ($validScopes !== null) {
+			$invalidScopes = array_diff($contextTypes, $validScopes);
+			if ($invalidScopes !== []) {
+				$invalidScope = array_pop($invalidScopes);
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
-						->withConstraintScope( $invalidScope, Role::CONSTRAINT_PARAMETER_VALUE )
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-						->withConstraintScopeList( $validScopes, Role::CONSTRAINT_PARAMETER_VALUE )
+					(new ViolationMessage('wbqc-violation-message-invalid-scope'))
+						->withConstraintScope($invalidScope, Role::CONSTRAINT_PARAMETER_VALUE)
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withConstraintScopeList($validScopes, Role::CONSTRAINT_PARAMETER_VALUE)
 				);
 			}
 		}
@@ -713,15 +713,15 @@ 
 	 * @param ItemId $unitId
 	 * @return string unit
 	 */
-	private function parseUnitParameter( ItemId $unitId ) {
+	private function parseUnitParameter(ItemId $unitId) {
 		$unitRepositoryName = $unitId->getRepositoryName();
-		if ( !array_key_exists( $unitRepositoryName, $this->conceptBaseUris ) ) {
+		if (!array_key_exists($unitRepositoryName, $this->conceptBaseUris)) {
 			throw new LogicException(
-				'No base URI for concept URI for repository: ' . $unitRepositoryName
+				'No base URI for concept URI for repository: '.$unitRepositoryName
 			);
 		}
 		$baseUri = $this->conceptBaseUris[$unitRepositoryName];
-		return $baseUri . $unitId->getSerialization();
+		return $baseUri.$unitId->getSerialization();
 	}
 
 	/**
@@ -731,23 +731,23 @@ 
 	 * @return UnitsParameter
 	 * @throws ConstraintParameterException
 	 */
-	private function parseUnitItem( ItemIdSnakValue $item ) {
-		switch ( true ) {
+	private function parseUnitItem(ItemIdSnakValue $item) {
+		switch (true) {
 			case $item->isValue():
-				$unit = $this->parseUnitParameter( $item->getItemId() );
+				$unit = $this->parseUnitParameter($item->getItemId());
 				return new UnitsParameter(
-					[ $item->getItemId() ],
-					[ UnboundedQuantityValue::newFromNumber( 1, $unit ) ],
+					[$item->getItemId()],
+					[UnboundedQuantityValue::newFromNumber(1, $unit)],
 					false
 				);
 			case $item->isSomeValue():
-				$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+				$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
-						->withEntityId( new PropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+						->withEntityId(new PropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			case $item->isNoValue():
-				return new UnitsParameter( [], [], true );
+				return new UnitsParameter([], [], true);
 		}
 	}
 
@@ -757,26 +757,26 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return UnitsParameter
 	 */
-	public function parseUnitsParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
+	public function parseUnitsParameter(array $constraintParameters, $constraintTypeItemId) {
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
 		$unitItems = [];
 		$unitQuantities = [];
 		$unitlessAllowed = false;
 
-		foreach ( $items as $item ) {
-			$unit = $this->parseUnitItem( $item );
-			$unitItems = array_merge( $unitItems, $unit->getUnitItemIds() );
-			$unitQuantities = array_merge( $unitQuantities, $unit->getUnitQuantities() );
+		foreach ($items as $item) {
+			$unit = $this->parseUnitItem($item);
+			$unitItems = array_merge($unitItems, $unit->getUnitItemIds());
+			$unitQuantities = array_merge($unitQuantities, $unit->getUnitQuantities());
 			$unitlessAllowed = $unitlessAllowed || $unit->getUnitlessAllowed();
 		}
 
-		if ( $unitQuantities === [] && !$unitlessAllowed ) {
+		if ($unitQuantities === [] && !$unitlessAllowed) {
 			throw new LogicException(
 				'The "units" parameter is required, and yet we seem to be missing any allowed unit'
 			);
 		}
 
-		return new UnitsParameter( $unitItems, $unitQuantities, $unitlessAllowed );
+		return new UnitsParameter($unitItems, $unitQuantities, $unitlessAllowed);
 	}
 
 	/**
@@ -786,49 +786,49 @@ 
 	 * @return EntityTypesParameter
 	 * @throws ConstraintParameterException
 	 */
-	private function parseEntityTypeItem( ItemIdSnakValue $item ) {
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+	private function parseEntityTypeItem(ItemIdSnakValue $item) {
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 
-		if ( !$item->isValue() ) {
+		if (!$item->isValue()) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$itemId = $item->getItemId();
-		switch ( $itemId->getSerialization() ) {
-			case $this->config->get( 'WBQualityConstraintsWikibaseItemId' ):
+		switch ($itemId->getSerialization()) {
+			case $this->config->get('WBQualityConstraintsWikibaseItemId'):
 				$entityType = 'item';
 				break;
-			case $this->config->get( 'WBQualityConstraintsWikibasePropertyId' ):
+			case $this->config->get('WBQualityConstraintsWikibasePropertyId'):
 				$entityType = 'property';
 				break;
-			case $this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ):
+			case $this->config->get('WBQualityConstraintsWikibaseLexemeId'):
 				$entityType = 'lexeme';
 				break;
-			case $this->config->get( 'WBQualityConstraintsWikibaseFormId' ):
+			case $this->config->get('WBQualityConstraintsWikibaseFormId'):
 				$entityType = 'form';
 				break;
-			case $this->config->get( 'WBQualityConstraintsWikibaseSenseId' ):
+			case $this->config->get('WBQualityConstraintsWikibaseSenseId'):
 				$entityType = 'sense';
 				break;
 			default:
 				$allowed = [
-					new ItemId( $this->config->get( 'WBQualityConstraintsWikibaseItemId' ) ),
-					new ItemId( $this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) ),
-					new ItemId( $this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) ),
-					new ItemId( $this->config->get( 'WBQualityConstraintsWikibaseFormId' ) ),
-					new ItemId( $this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) ),
+					new ItemId($this->config->get('WBQualityConstraintsWikibaseItemId')),
+					new ItemId($this->config->get('WBQualityConstraintsWikibasePropertyId')),
+					new ItemId($this->config->get('WBQualityConstraintsWikibaseLexemeId')),
+					new ItemId($this->config->get('WBQualityConstraintsWikibaseFormId')),
+					new ItemId($this->config->get('WBQualityConstraintsWikibaseSenseId')),
 				];
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-						->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-						->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
+					(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+						->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+						->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
 				);
 		}
 
-		return new EntityTypesParameter( [ $entityType ], [ $itemId ] );
+		return new EntityTypesParameter([$entityType], [$itemId]);
 	}
 
 	/**
@@ -837,27 +837,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return EntityTypesParameter
 	 */
-	public function parseEntityTypesParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parseEntityTypesParameter(array $constraintParameters, $constraintTypeItemId) {
 		$entityTypes = [];
 		$entityTypeItemIds = [];
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
 
-		foreach ( $items as $item ) {
-			$entityType = $this->parseEntityTypeItem( $item );
-			$entityTypes = array_merge( $entityTypes, $entityType->getEntityTypes() );
-			$entityTypeItemIds = array_merge( $entityTypeItemIds, $entityType->getEntityTypeItemIds() );
+		foreach ($items as $item) {
+			$entityType = $this->parseEntityTypeItem($item);
+			$entityTypes = array_merge($entityTypes, $entityType->getEntityTypes());
+			$entityTypeItemIds = array_merge($entityTypeItemIds, $entityType->getEntityTypeItemIds());
 		}
 
-		if ( empty( $entityTypes ) ) {
+		if (empty($entityTypes)) {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'The "entity types" parameter is required, ' .
+				'The "entity types" parameter is required, '.
 				'and yet we seem to be missing any allowed entity type'
 			);
 			// @codeCoverageIgnoreEnd
 		}
 
-		return new EntityTypesParameter( $entityTypes, $entityTypeItemIds );
+		return new EntityTypesParameter($entityTypes, $entityTypeItemIds);
 	}
 
 	/**
@@ -865,18 +865,18 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return PropertyId[]
 	 */
-	public function parseSeparatorsParameter( array $constraintParameters ) {
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
+	public function parseSeparatorsParameter(array $constraintParameters) {
+		$separatorId = $this->config->get('WBQualityConstraintsSeparatorId');
 
-		if ( !array_key_exists( $separatorId, $constraintParameters ) ) {
+		if (!array_key_exists($separatorId, $constraintParameters)) {
 			return [];
 		}
 
 		$parameters = $constraintParameters[$separatorId];
 		$separators = [];
 
-		foreach ( $parameters as $parameter ) {
-			$separators[] = $this->parsePropertyIdParameter( $parameter, $separatorId );
+		foreach ($parameters as $parameter) {
+			$separators[] = $this->parsePropertyIdParameter($parameter, $separatorId);
 		}
 
 		return $separators;
@@ -891,26 +891,26 @@ 
 	 * @return string one of the Context::TYPE_* constants
 	 * @throws ConstraintParameterException
 	 */
-	private function parseContextTypeItem( ItemIdSnakValue $item, $use, $parameterId ) {
-		if ( !$item->isValue() ) {
+	private function parseContextTypeItem(ItemIdSnakValue $item, $use, $parameterId) {
+		if (!$item->isValue()) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		if ( $use === 'constraint scope' ) {
-			$mainSnakId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' );
-			$qualifiersId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' );
-			$referencesId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' );
+		if ($use === 'constraint scope') {
+			$mainSnakId = $this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId');
+			$qualifiersId = $this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId');
+			$referencesId = $this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId');
 		} else {
-			$mainSnakId = $this->config->get( 'WBQualityConstraintsAsMainValueId' );
-			$qualifiersId = $this->config->get( 'WBQualityConstraintsAsQualifiersId' );
-			$referencesId = $this->config->get( 'WBQualityConstraintsAsReferencesId' );
+			$mainSnakId = $this->config->get('WBQualityConstraintsAsMainValueId');
+			$qualifiersId = $this->config->get('WBQualityConstraintsAsQualifiersId');
+			$referencesId = $this->config->get('WBQualityConstraintsAsReferencesId');
 		}
 
 		$itemId = $item->getItemId();
-		switch ( $itemId->getSerialization() ) {
+		switch ($itemId->getSerialization()) {
 			case $mainSnakId:
 				return Context::TYPE_STATEMENT;
 			case $qualifiersId:
@@ -918,11 +918,11 @@ 
 			case $referencesId:
 				return Context::TYPE_REFERENCE;
 			default:
-				$allowed = [ $mainSnakId, $qualifiersId, $referencesId ];
+				$allowed = [$mainSnakId, $qualifiersId, $referencesId];
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-						->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-						->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
+					(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+						->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+						->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
 				);
 		}
 	}
@@ -933,9 +933,9 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] list of Context::TYPE_* constants
 	 */
-	public function parsePropertyScopeParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parsePropertyScopeParameter(array $constraintParameters, $constraintTypeItemId) {
 		$contextTypes = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
 		$items = $this->parseItemsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -943,14 +943,14 @@ 
 			$parameterId
 		);
 
-		foreach ( $items as $item ) {
-			$contextTypes[] = $this->parseContextTypeItem( $item, 'property scope', $parameterId );
+		foreach ($items as $item) {
+			$contextTypes[] = $this->parseContextTypeItem($item, 'property scope', $parameterId);
 		}
 
-		if ( empty( $contextTypes ) ) {
+		if (empty($contextTypes)) {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'The "property scope" parameter is required, ' .
+				'The "property scope" parameter is required, '.
 				'and yet we seem to be missing any allowed scope'
 			);
 			// @codeCoverageIgnoreEnd

src/ConstraintRepository.php

Spacing +42 added lines, -42 removed lines

@@ -21,23 +21,23 @@ 
 	 *
 	 * @return Constraint[]
 	 */
-	public function queryConstraintsForProperty( PropertyId $propertyId ) {
-		$db = wfGetDB( DB_REPLICA );
+	public function queryConstraintsForProperty(PropertyId $propertyId) {
+		$db = wfGetDB(DB_REPLICA);
 
 		$results = $db->select(
 			'wbqc_constraints',
 			'*',
-			[ 'pid' => $propertyId->getNumericId() ]
+			['pid' => $propertyId->getNumericId()]
 		);
 
-		return $this->convertToConstraints( $results );
+		return $this->convertToConstraints($results);
 	}
 
-	private function encodeConstraintParameters( array $constraintParameters ) {
-		$json = json_encode( $constraintParameters, JSON_FORCE_OBJECT );
+	private function encodeConstraintParameters(array $constraintParameters) {
+		$json = json_encode($constraintParameters, JSON_FORCE_OBJECT);
 
-		if ( strlen( $json ) > 50000 ) {
-			$json = json_encode( [ '@error' => [ 'toolong' => true ] ] );
+		if (strlen($json) > 50000) {
+			$json = json_encode(['@error' => ['toolong' => true]]);
 		}
 
 		return $json;
@@ -49,21 +49,21 @@ 
 	 * @throws DBUnexpectedError
 	 * @return bool
 	 */
-	public function insertBatch( array $constraints ) {
+	public function insertBatch(array $constraints) {
 		$accumulator = array_map(
-			function ( Constraint $constraint ) {
+			function(Constraint $constraint) {
 				return [
 					'constraint_guid' => $constraint->getConstraintId(),
 					'pid' => $constraint->getPropertyId()->getNumericId(),
 					'constraint_type_qid' => $constraint->getConstraintTypeItemId(),
-					'constraint_parameters' => $this->encodeConstraintParameters( $constraint->getConstraintParameters() )
+					'constraint_parameters' => $this->encodeConstraintParameters($constraint->getConstraintParameters())
 				];
 			},
 			$constraints
 		);
 
-		$db = wfGetDB( DB_MASTER );
-		return $db->insert( 'wbqc_constraints', $accumulator );
+		$db = wfGetDB(DB_MASTER);
+		return $db->insert('wbqc_constraints', $accumulator);
 	}
 
 	/**
@@ -71,13 +71,13 @@ 
 	 *
 	 * @return string[]
 	 */
-	private function uuidPattern( LikeMatch $any ) {
+	private function uuidPattern(LikeMatch $any) {
 		return array_merge(
-			array_fill( 0, 8, $any ), [ '-' ],
-			array_fill( 0, 4, $any ), [ '-' ],
-			array_fill( 0, 4, $any ), [ '-' ],
-			array_fill( 0, 4, $any ), [ '-' ],
-			array_fill( 0, 12, $any )
+			array_fill(0, 8, $any), ['-'],
+			array_fill(0, 4, $any), ['-'],
+			array_fill(0, 4, $any), ['-'],
+			array_fill(0, 4, $any), ['-'],
+			array_fill(0, 12, $any)
 		);
 	}
 
@@ -88,11 +88,11 @@ 
 	 * @throws DBUnexpectedError
 	 */
 	public function deleteWhereConstraintIdIsUuid() {
-		$db = wfGetDB( DB_MASTER );
+		$db = wfGetDB(DB_MASTER);
 		$db->delete(
 			'wbqc_constraints',
 			// WHERE constraint_guid LIKE ________-____-____-____-____________
-			'constraint_guid ' . $db->buildLike( $this->uuidPattern( $db->anyChar() ) )
+			'constraint_guid '.$db->buildLike($this->uuidPattern($db->anyChar()))
 		);
 	}
 
@@ -104,14 +104,14 @@ 
 	 *
 	 * @throws DBUnexpectedError
 	 */
-	public function deleteForPropertyWhereConstraintIdIsStatementId( PropertyId $propertyId ) {
-		$db = wfGetDB( DB_MASTER );
+	public function deleteForPropertyWhereConstraintIdIsStatementId(PropertyId $propertyId) {
+		$db = wfGetDB(DB_MASTER);
 		$db->delete(
 			'wbqc_constraints',
 			[
 				'pid' => $propertyId->getNumericId(),
 				// AND constraint_guid LIKE %$________-____-____-____-____________
-				'constraint_guid ' . $db->buildLike( array_merge( [ $db->anyString(), '$' ], $this->uuidPattern( $db->anyChar() ) ) )
+				'constraint_guid '.$db->buildLike(array_merge([$db->anyString(), '$'], $this->uuidPattern($db->anyChar())))
 			]
 		);
 	}
@@ -122,21 +122,21 @@ 
 	 * @throws InvalidArgumentException
 	 * @throws DBUnexpectedError
 	 */
-	public function deleteAll( $batchSize = 1000 ) {
-		if ( !is_int( $batchSize ) ) {
+	public function deleteAll($batchSize = 1000) {
+		if (!is_int($batchSize)) {
 			throw new InvalidArgumentException();
 		}
 		$lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
-		$db = $lbFactory->getMainLB()->getConnection( DB_MASTER );
-		if ( $db->getType() === 'sqlite' ) {
-			$db->delete( 'wbqc_constraints', '*' );
+		$db = $lbFactory->getMainLB()->getConnection(DB_MASTER);
+		if ($db->getType() === 'sqlite') {
+			$db->delete('wbqc_constraints', '*');
 		} else {
 			do {
-				$db->commit( __METHOD__, 'flush' );
+				$db->commit(__METHOD__, 'flush');
 				$lbFactory->waitForReplication();
-				$table = $db->tableName( 'wbqc_constraints' );
-				$db->query( sprintf( 'DELETE FROM %s LIMIT %d', $table, $batchSize ) );
-			} while ( $db->affectedRows() > 0 );
+				$table = $db->tableName('wbqc_constraints');
+				$db->query(sprintf('DELETE FROM %s LIMIT %d', $table, $batchSize));
+			} while ($db->affectedRows() > 0);
 		}
 	}
 
@@ -145,26 +145,26 @@ 
 	 *
 	 * @return Constraint[]
 	 */
-	private function convertToConstraints( IResultWrapper $results ) {
+	private function convertToConstraints(IResultWrapper $results) {
 		$constraints = [];
-		foreach ( $results as $result ) {
+		foreach ($results as $result) {
 			$constraintTypeItemId = $result->constraint_type_qid;
-			$constraintParameters = json_decode( $result->constraint_parameters, true );
+			$constraintParameters = json_decode($result->constraint_parameters, true);
 
-			if ( $constraintParameters === null ) {
+			if ($constraintParameters === null) {
 				// T171295
-				LoggerFactory::getInstance( 'WikibaseQualityConstraints' )
-					->warning( 'Constraint {constraintId} has invalid constraint parameters.', [
+				LoggerFactory::getInstance('WikibaseQualityConstraints')
+					->warning('Constraint {constraintId} has invalid constraint parameters.', [
 						'method' => __METHOD__,
 						'constraintId' => $result->constraint_guid,
 						'constraintParameters' => $result->constraint_parameters,
-					] );
-				$constraintParameters = [ '@error' => [ /* unknown */ ] ];
+					]);
+				$constraintParameters = ['@error' => [/* unknown */]];
 			}
 
 			$constraints[] = new Constraint(
 				$result->constraint_guid,
-				PropertyId::newFromNumber( $result->pid ),
+				PropertyId::newFromNumber($result->pid),
 				$constraintTypeItemId,
 				$constraintParameters
 			);