wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Helper/SparqlHelper.php

Spacing +176 added lines, -179 removed lines

@@ -200,73 +200,73 @@ 
 		$this->defaultUserAgent = $defaultUserAgent;
 		$this->requestFactory = $requestFactory;
 		$this->entityPrefixes = [];
-		foreach ( $rdfVocabulary->entityNamespaceNames as $namespaceName ) {
-			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI( $namespaceName );
+		foreach ($rdfVocabulary->entityNamespaceNames as $namespaceName) {
+			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI($namespaceName);
 		}
 
-		$this->endpoint = $config->get( 'WBQualityConstraintsSparqlEndpoint' );
-		$this->maxQueryTimeMillis = $config->get( 'WBQualityConstraintsSparqlMaxMillis' );
-		$this->instanceOfId = $config->get( 'WBQualityConstraintsInstanceOfId' );
-		$this->subclassOfId = $config->get( 'WBQualityConstraintsSubclassOfId' );
-		$this->cacheMapSize = $config->get( 'WBQualityConstraintsFormatCacheMapSize' );
+		$this->endpoint = $config->get('WBQualityConstraintsSparqlEndpoint');
+		$this->maxQueryTimeMillis = $config->get('WBQualityConstraintsSparqlMaxMillis');
+		$this->instanceOfId = $config->get('WBQualityConstraintsInstanceOfId');
+		$this->subclassOfId = $config->get('WBQualityConstraintsSubclassOfId');
+		$this->cacheMapSize = $config->get('WBQualityConstraintsFormatCacheMapSize');
 		$this->timeoutExceptionClasses = $config->get(
 			'WBQualityConstraintsSparqlTimeoutExceptionClasses'
 		);
 		$this->sparqlHasWikibaseSupport = $config->get(
 			'WBQualityConstraintsSparqlHasWikibaseSupport'
 		);
-		$this->sparqlThrottlingFallbackDuration = (int)$config->get(
+		$this->sparqlThrottlingFallbackDuration = (int) $config->get(
 			'WBQualityConstraintsSparqlThrottlingFallbackDuration'
 		);
 
-		$this->prefixes = $this->getQueryPrefixes( $rdfVocabulary );
+		$this->prefixes = $this->getQueryPrefixes($rdfVocabulary);
 	}
 
-	private function getQueryPrefixes( RdfVocabulary $rdfVocabulary ) {
+	private function getQueryPrefixes(RdfVocabulary $rdfVocabulary) {
 		// TODO: it would probably be smarter that RdfVocubulary exposed these prefixes somehow
 		$prefixes = '';
-		foreach ( $rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName ) {
+		foreach ($rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName) {
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 		$prefixes .= <<<END
-PREFIX wds: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_STATEMENT )}>
-PREFIX wdv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_VALUE )}>\n
+PREFIX wds: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_STATEMENT)}>
+PREFIX wdv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_VALUE)}>\n
 END;
 
-		foreach ( $rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces ) {
+		foreach ($rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces) {
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_DIRECT_CLAIM];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM_STATEMENT];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 		$prefixes .= <<<END
-PREFIX wikibase: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ONTOLOGY )}>\n
+PREFIX wikibase: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ONTOLOGY)}>\n
 END;
 		return $prefixes;
 	}
@@ -278,21 +278,20 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function hasType( $id, array $classes ) {
+	public function hasType($id, array $classes) {
 		// TODO hint:gearing is a workaround for T168973 and can hopefully be removed eventually
 		$gearingHint = $this->sparqlHasWikibaseSupport ?
-			' hint:Prior hint:gearing "forward".' :
-			'';
+			' hint:Prior hint:gearing "forward".' : '';
 
 		$metadatas = [];
 
-		foreach ( array_chunk( $classes, 20 ) as $classesChunk ) {
-			$classesValues = implode( ' ', array_map(
-				static function ( $class ) {
-					return 'wd:' . $class;
+		foreach (array_chunk($classes, 20) as $classesChunk) {
+			$classesValues = implode(' ', array_map(
+				static function($class) {
+					return 'wd:'.$class;
 				},
 				$classesChunk
-			) );
+			));
 
 			$query = <<<EOF
 ASK {
@@ -302,19 +301,19 @@ 
 }
 EOF;
 
-			$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)
 		);
 	}
 
@@ -325,7 +324,7 @@ 
 	 * @param PropertyId $separator
 	 * @return string
 	 */
-	private function nestedSeparatorFilter( PropertyId $separator ) {
+	private function nestedSeparatorFilter(PropertyId $separator) {
 		$filter = <<<EOF
   MINUS {
     ?statement pq:$separator ?qualifier.
@@ -369,10 +368,10 @@ 
 		$pid = $statement->getPropertyId()->getSerialization();
 		$guid = $statement->getGuid();
 		'@phan-var string $guid'; // statement must have a non-null GUID
-		$guidForRdf = str_replace( '$', '-', $guid );
+		$guidForRdf = str_replace('$', '-', $guid);
 
-		$separatorFilters = array_map( [ $this, 'nestedSeparatorFilter' ], $separators );
-		$finalSeparatorFilter = implode( "\n", $separatorFilters );
+		$separatorFilters = array_map([$this, 'nestedSeparatorFilter'], $separators);
+		$finalSeparatorFilter = implode("\n", $separatorFilters);
 
 		$query = <<<EOF
 SELECT DISTINCT ?otherEntity WHERE {
@@ -390,9 +389,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -417,16 +416,15 @@ 
 		$dataType = $this->propertyDataTypeLookup->getDataTypeIdForProperty(
 			$snak->getPropertyId()
 		);
-		[ $value, $isFullValue ] = $this->getRdfLiteral( $dataType, $dataValue );
-		if ( $isFullValue ) {
+		[$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. }
 EOF;
@@ -446,9 +444,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -458,8 +456,8 @@ 
 	 *
 	 * @return string
 	 */
-	private function stringLiteral( $text ) {
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
+	private function stringLiteral($text) {
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
 	}
 
 	/**
@@ -469,18 +467,18 @@ 
 	 *
 	 * @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'];
-				foreach ( $this->entityPrefixes as $entityPrefix ) {
-					$entityPrefixLength = strlen( $entityPrefix );
-					if ( substr( $entityIRI, 0, $entityPrefixLength ) === $entityPrefix ) {
+				foreach ($this->entityPrefixes as $entityPrefix) {
+					$entityPrefixLength = strlen($entityPrefix);
+					if (substr($entityIRI, 0, $entityPrefixLength) === $entityPrefix) {
 						try {
 							return $this->entityIdParser->parse(
-								substr( $entityIRI, $entityPrefixLength )
+								substr($entityIRI, $entityPrefixLength)
 							);
-						} catch ( EntityIdParsingException $e ) {
+						} catch (EntityIdParsingException $e) {
 							// fall through
 						}
 					}
@@ -491,7 +489,7 @@ 
 				return null;
 			},
 			$results->getArray()['results']['bindings']
-		), $results->getMetadata() );
+		), $results->getMetadata());
 	}
 
 	// phpcs:disable Generic.Metrics.CyclomaticComplexity,Squiz.WhiteSpace.FunctionSpacing
@@ -504,50 +502,50 @@ 
 	 * @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 */
 				'@phan-var EntityIdValue $dataValue';
-				return [ 'wd:' . $dataValue->getEntityId()->getSerialization(), false ];
+				return ['wd:'.$dataValue->getEntityId()->getSerialization(), false];
 			case 'monolingualtext':
 				/** @var MonolingualTextValue $dataValue */
 				'@phan-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':
 				// @phan-suppress-next-line PhanUndeclaredMethod
-				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);
 		}
 	}
 	// phpcs:enable
@@ -560,43 +558,43 @@ 
 	 * @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)
 		);
 
 		$cacheMapArray = $this->cache->getWithSetCallback(
 			$cacheKey,
 			WANObjectCache::TTL_DAY,
-			function ( $cacheMapArray ) use ( $text, $regex, $textHash ) {
+			function($cacheMapArray) use ($text, $regex, $textHash) {
 				// 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, $this->cacheMapSize );
-				if ( $cacheMap->has( $textHash ) ) {
+				$this->dataFactory->increment($key);
+				$cacheMap = MapCacheLRU::newFromArray($cacheMapArray, $this->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();
 					}
@@ -620,42 +618,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 UnexpectedValueException(
-					'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);
 	}
 
 	/**
@@ -669,25 +667,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, false );
+		$result = $this->runQuery($query, false);
 
 		$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)
 			);
 		}
 	}
@@ -699,14 +697,14 @@ 
 	 *
 	 * @return boolean
 	 */
-	public function isTimeout( $responseContent ) {
-		$timeoutRegex = implode( '|', array_map(
-			static function ( $fqn ) {
-				return preg_quote( $fqn, '/' );
+	public function isTimeout($responseContent) {
+		$timeoutRegex = implode('|', array_map(
+			static function($fqn) {
+				return preg_quote($fqn, '/');
 			},
 			$this->timeoutExceptionClasses
-		) );
-		return (bool)preg_match( '/' . $timeoutRegex . '/', $responseContent );
+		));
+		return (bool) preg_match('/'.$timeoutRegex.'/', $responseContent);
 	}
 
 	/**
@@ -718,17 +716,17 @@ 
 	 * @return int|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;
 			}
@@ -749,34 +747,34 @@ 
 	 * or SparlHelper::EMPTY_RETRY_AFTER if there is an empty Retry-After
 	 * or SparlHelper::INVALID_RETRY_AFTER if there is something wrong with the format
 	 */
-	public function getThrottling( MWHttpRequest $request ) {
-		$retryAfterValue = $request->getResponseHeader( 'Retry-After' );
-		if ( $retryAfterValue === null ) {
+	public function getThrottling(MWHttpRequest $request) {
+		$retryAfterValue = $request->getResponseHeader('Retry-After');
+		if ($retryAfterValue === null) {
 			return self::NO_RETRY_AFTER;
 		}
 
-		$trimmedRetryAfterValue = trim( $retryAfterValue );
-		if ( $trimmedRetryAfterValue === '' ) {
+		$trimmedRetryAfterValue = trim($retryAfterValue);
+		if ($trimmedRetryAfterValue === '') {
 			return self::EMPTY_RETRY_AFTER;
 		}
 
-		if ( is_numeric( $trimmedRetryAfterValue ) ) {
-			$delaySeconds = (int)$trimmedRetryAfterValue;
-			if ( $delaySeconds >= 0 ) {
-				return $this->getTimestampInFuture( new DateInterval( 'PT' . $delaySeconds . 'S' ) );
+		if (is_numeric($trimmedRetryAfterValue)) {
+			$delaySeconds = (int) $trimmedRetryAfterValue;
+			if ($delaySeconds >= 0) {
+				return $this->getTimestampInFuture(new DateInterval('PT'.$delaySeconds.'S'));
 			}
 		} else {
-			$return = strtotime( $trimmedRetryAfterValue );
-			if ( $return !== false ) {
-				return new ConvertibleTimestamp( $return );
+			$return = strtotime($trimmedRetryAfterValue);
+			if ($return !== false) {
+				return new ConvertibleTimestamp($return);
 			}
 		}
 		return self::INVALID_RETRY_AFTER;
 	}
 
-	private function getTimestampInFuture( DateInterval $delta ) {
+	private function getTimestampInFuture(DateInterval $delta) {
 		$now = new ConvertibleTimestamp();
-		return new ConvertibleTimestamp( $now->timestamp->add( $delta ) );
+		return new ConvertibleTimestamp($now->timestamp->add($delta));
 	}
 
 	/**
@@ -790,65 +788,64 @@ 
 	 *
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function runQuery( $query, $needsPrefixes = true ) {
+	public function runQuery($query, $needsPrefixes = true) {
 
-		if ( $this->throttlingLock->isLocked( self::EXPIRY_LOCK_ID ) ) {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
+		if ($this->throttlingLock->isLocked(self::EXPIRY_LOCK_ID)) {
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.throttling');
 			throw new TooManySparqlRequestsException();
 		}
 
-		if ( $this->sparqlHasWikibaseSupport ) {
+		if ($this->sparqlHasWikibaseSupport) {
 			$needsPrefixes = false;
 		}
 
-		if ( $needsPrefixes ) {
-			$query = $this->prefixes . $query;
+		if ($needsPrefixes) {
+			$query = $this->prefixes.$query;
 		}
-		$query = "#wbqc\n" . $query;
+		$query = "#wbqc\n".$query;
 
-		$url = $this->endpoint . '?' . http_build_query(
+		$url = $this->endpoint.'?'.http_build_query(
 			[
 				'query' => $query,
 				'format' => 'json',
 				'maxQueryTimeMillis' => $this->maxQueryTimeMillis,
 			],
-			'', ini_get( 'arg_separator.output' ),
+			'', ini_get('arg_separator.output'),
 			// encode spaces with %20, not +
 			PHP_QUERY_RFC3986
 		);
 
 		$options = [
 			'method' => 'GET',
-			'timeout' => (int)round( ( $this->maxQueryTimeMillis + 1000 ) / 1000 ),
+			'timeout' => (int) round(($this->maxQueryTimeMillis + 1000) / 1000),
 			'connectTimeout' => 'default',
 			'userAgent' => $this->defaultUserAgent,
 		];
-		$request = $this->requestFactory->create( $url, $options, __METHOD__ );
-		$startTime = microtime( true );
+		$request = $this->requestFactory->create($url, $options, __METHOD__);
+		$startTime = microtime(true);
 		$requestStatus = $request->execute();
-		$endTime = microtime( true );
+		$endTime = microtime(true);
 		$this->dataFactory->timing(
 			'wikibase.quality.constraints.sparql.timing',
-			( $endTime - $startTime ) * 1000
+			($endTime - $startTime) * 1000
 		);
 
-		$this->guardAgainstTooManyRequestsError( $request );
+		$this->guardAgainstTooManyRequestsError($request);
 
-		$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 ( $requestStatus->isOK() ) {
+		if ($requestStatus->isOK()) {
 			$json = $request->getContent();
-			$jsonStatus = FormatJson::parse( $json, FormatJson::FORCE_ASSOC );
-			if ( $jsonStatus->isOK() ) {
+			$jsonStatus = FormatJson::parse($json, FormatJson::FORCE_ASSOC);
+			if ($jsonStatus->isOK()) {
 				return new CachedQueryResults(
 					$jsonStatus->getValue(),
 					Metadata::ofCachingMetadata(
 						$maxAge ?
-							CachingMetadata::ofMaximumAgeInSeconds( $maxAge ) :
-							CachingMetadata::fresh()
+							CachingMetadata::ofMaximumAgeInSeconds($maxAge) : CachingMetadata::fresh()
 					)
 				);
 			} else {
@@ -865,9 +862,9 @@ 
 			// fall through to general error handling
 		}
 
-		$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.error' );
+		$this->dataFactory->increment('wikibase.quality.constraints.sparql.error');
 
-		if ( $this->isTimeout( $request->getContent() ) ) {
+		if ($this->isTimeout($request->getContent())) {
 			$this->dataFactory->increment(
 				'wikibase.quality.constraints.sparql.error.timeout'
 			);
@@ -882,29 +879,29 @@ 
 	 * @param MWHttpRequest $request
 	 * @throws TooManySparqlRequestsException
 	 */
-	private function guardAgainstTooManyRequestsError( MWHttpRequest $request ): void {
-		if ( $request->getStatus() !== self::HTTP_TOO_MANY_REQUESTS ) {
+	private function guardAgainstTooManyRequestsError(MWHttpRequest $request): void {
+		if ($request->getStatus() !== self::HTTP_TOO_MANY_REQUESTS) {
 			return;
 		}
 
 		$fallbackBlockDuration = $this->sparqlThrottlingFallbackDuration;
 
-		if ( $fallbackBlockDuration < 0 ) {
-			throw new InvalidArgumentException( 'Fallback duration must be positive int but is: ' .
-				$fallbackBlockDuration );
+		if ($fallbackBlockDuration < 0) {
+			throw new InvalidArgumentException('Fallback duration must be positive int but is: '.
+				$fallbackBlockDuration);
 		}
 
-		$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
-		$throttlingUntil = $this->getThrottling( $request );
-		if ( !( $throttlingUntil instanceof ConvertibleTimestamp ) ) {
-			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid( $request );
+		$this->dataFactory->increment('wikibase.quality.constraints.sparql.throttling');
+		$throttlingUntil = $this->getThrottling($request);
+		if (!($throttlingUntil instanceof ConvertibleTimestamp)) {
+			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid($request);
 			$this->throttlingLock->lock(
 				self::EXPIRY_LOCK_ID,
-				$this->getTimestampInFuture( new DateInterval( 'PT' . $fallbackBlockDuration . 'S' ) )
+				$this->getTimestampInFuture(new DateInterval('PT'.$fallbackBlockDuration.'S'))
 			);
 		} else {
-			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent( $throttlingUntil, $request );
-			$this->throttlingLock->lock( self::EXPIRY_LOCK_ID, $throttlingUntil );
+			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent($throttlingUntil, $request);
+			$this->throttlingLock->lock(self::EXPIRY_LOCK_ID, $throttlingUntil);
 		}
 		throw new TooManySparqlRequestsException();
 	}

src/ConstraintCheck/Checker/ContemporaryChecker.php

Spacing +42 added lines, -43 removed lines

@@ -80,7 +80,7 @@ 
 	 * @codeCoverageIgnore This method is purely declarative.
 	 */
 	public function getDefaultContextTypes() {
-		return [ Context::TYPE_STATEMENT ];
+		return [Context::TYPE_STATEMENT];
 	}
 
 	/** @codeCoverageIgnore This method is purely declarative. */
@@ -97,31 +97,31 @@ 
 	 * @return CheckResult
 	 * @throws ConfigException
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint ) {
-		if ( $context->getSnakRank() === Statement::RANK_DEPRECATED ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_DEPRECATED );
+	public function checkConstraint(Context $context, Constraint $constraint) {
+		if ($context->getSnakRank() === Statement::RANK_DEPRECATED) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_DEPRECATED);
 		}
 		$snak = $context->getSnak();
-		if ( !$snak instanceof PropertyValueSnak ) {
+		if (!$snak instanceof PropertyValueSnak) {
 			// nothing to check
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_COMPLIANCE );
+			return new CheckResult($context, $constraint, CheckResult::STATUS_COMPLIANCE);
 		}
 
 		$dataValue = $snak->getDataValue();
-		if ( !$dataValue instanceof EntityIdValue ) {
+		if (!$dataValue instanceof EntityIdValue) {
 			// wrong data type
-			$message = ( new ViolationMessage( 'wbqc-violation-message-value-needed-of-type' ) )
-				->withEntityId( new ItemId( $constraint->getConstraintTypeItemId() ), Role::CONSTRAINT_TYPE_ITEM )
-				->withDataValueType( 'wikibase-entityid' );
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_VIOLATION, $message );
+			$message = (new ViolationMessage('wbqc-violation-message-value-needed-of-type'))
+				->withEntityId(new ItemId($constraint->getConstraintTypeItemId()), Role::CONSTRAINT_TYPE_ITEM)
+				->withDataValueType('wikibase-entityid');
+			return new CheckResult($context, $constraint, CheckResult::STATUS_VIOLATION, $message);
 		}
 
 		$objectId = $dataValue->getEntityId();
-		$objectItem = $this->entityLookup->getEntity( $objectId );
-		if ( !( $objectItem instanceof StatementListProvider ) ) {
+		$objectItem = $this->entityLookup->getEntity($objectId);
+		if (!($objectItem instanceof StatementListProvider)) {
 			// object was deleted/doesn't exist
-			$message = new ViolationMessage( 'wbqc-violation-message-value-entity-must-exist' );
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_VIOLATION, $message );
+			$message = new ViolationMessage('wbqc-violation-message-value-entity-must-exist');
+			return new CheckResult($context, $constraint, CheckResult::STATUS_VIOLATION, $message);
 		}
 		/** @var Statement[] $objectStatements */
 		$objectStatements = $objectItem->getStatements()->toArray();
@@ -129,9 +129,9 @@ 
 		$subjectId = $context->getEntity()->getId();
 		$subjectStatements = $context->getEntity()->getStatements()->toArray();
 		/** @var String[] $startPropertyIds */
-		$startPropertyIds = $this->config->get( self::CONFIG_VARIABLE_START_PROPERTY_IDS );
+		$startPropertyIds = $this->config->get(self::CONFIG_VARIABLE_START_PROPERTY_IDS);
 		/** @var String[] $endPropertyIds */
-		$endPropertyIds = $this->config->get( self::CONFIG_VARIABLE_END_PROPERTY_IDS );
+		$endPropertyIds = $this->config->get(self::CONFIG_VARIABLE_END_PROPERTY_IDS);
 		$subjectStartValue = $this->getExtremeValue(
 			$startPropertyIds,
 			$subjectStatements,
@@ -153,15 +153,15 @@ 
 			'end'
 		);
 		if (
-			$this->rangeCheckerHelper->getComparison( $subjectStartValue, $subjectEndValue ) <= 0 &&
-			$this->rangeCheckerHelper->getComparison( $objectStartValue, $objectEndValue ) <= 0 && (
-				$this->rangeCheckerHelper->getComparison( $subjectEndValue, $objectStartValue ) < 0 ||
-				$this->rangeCheckerHelper->getComparison( $objectEndValue, $subjectStartValue ) < 0
+			$this->rangeCheckerHelper->getComparison($subjectStartValue, $subjectEndValue) <= 0 &&
+			$this->rangeCheckerHelper->getComparison($objectStartValue, $objectEndValue) <= 0 && (
+				$this->rangeCheckerHelper->getComparison($subjectEndValue, $objectStartValue) < 0 ||
+				$this->rangeCheckerHelper->getComparison($objectEndValue, $subjectStartValue) < 0
 			)
 		) {
 			if (
 				$subjectEndValue == null ||
-				$this->rangeCheckerHelper->getComparison( $objectEndValue, $subjectEndValue ) < 0
+				$this->rangeCheckerHelper->getComparison($objectEndValue, $subjectEndValue) < 0
 			) {
 				$earlierEntityId = $objectId;
 				$minEndValue = $objectEndValue;
@@ -186,7 +186,7 @@ 
 			$message = null;
 			$status = CheckResult::STATUS_COMPLIANCE;
 		}
-		return new CheckResult( $context, $constraint, $status, $message );
+		return new CheckResult($context, $constraint, $status, $message);
 	}
 
 	/**
@@ -196,19 +196,19 @@ 
 	 *
 	 * @return DataValue|null
 	 */
-	private function getExtremeValue( $extremePropertyIds, $statements, $startOrEnd ) {
-		if ( $startOrEnd !== 'start' && $startOrEnd !== 'end' ) {
-			throw new \InvalidArgumentException( '$startOrEnd must be \'start\' or \'end\'.' );
+	private function getExtremeValue($extremePropertyIds, $statements, $startOrEnd) {
+		if ($startOrEnd !== 'start' && $startOrEnd !== 'end') {
+			throw new \InvalidArgumentException('$startOrEnd must be \'start\' or \'end\'.');
 		}
 		$extremeValue = null;
-		foreach ( $extremePropertyIds as $extremePropertyId ) {
-			$statementList = new StatementList( ...$statements );
-			$extremeStatements = $statementList->getByPropertyId( new NumericPropertyId( $extremePropertyId ) );
+		foreach ($extremePropertyIds as $extremePropertyId) {
+			$statementList = new StatementList(...$statements);
+			$extremeStatements = $statementList->getByPropertyId(new NumericPropertyId($extremePropertyId));
 			/** @var Statement $extremeStatement */
-			foreach ( $extremeStatements as $extremeStatement ) {
-				if ( $extremeStatement->getRank() !== Statement::RANK_DEPRECATED ) {
+			foreach ($extremeStatements as $extremeStatement) {
+				if ($extremeStatement->getRank() !== Statement::RANK_DEPRECATED) {
 					$snak = $extremeStatement->getMainSnak();
-					if ( !$snak instanceof PropertyValueSnak ) {
+					if (!$snak instanceof PropertyValueSnak) {
 						return null;
 					} else {
 						$comparison = $this->rangeCheckerHelper->getComparison(
@@ -217,8 +217,8 @@ 
 						);
 						if (
 							$extremeValue === null ||
-							( $startOrEnd === 'start' && $comparison < 0 ) ||
-							( $startOrEnd === 'end' && $comparison > 0 )
+							($startOrEnd === 'start' && $comparison < 0) ||
+							($startOrEnd === 'end' && $comparison > 0)
 						) {
 							$extremeValue = $snak->getDataValue();
 						}
@@ -248,17 +248,16 @@ 
 		DataValue $maxStartValue
 	) {
 		$messageKey = $earlierEntityId === $subjectId ?
-			'wbqc-violation-message-contemporary-subject-earlier' :
-			'wbqc-violation-message-contemporary-value-earlier';
-		return ( new ViolationMessage( $messageKey ) )
-			->withEntityId( $subjectId, Role::SUBJECT )
-			->withEntityId( $propertyId, Role::PREDICATE )
-			->withEntityId( $objectId, Role::OBJECT )
-			->withDataValue( $minEndValue, Role::OBJECT )
-			->withDataValue( $maxStartValue, Role::OBJECT );
+			'wbqc-violation-message-contemporary-subject-earlier' : 'wbqc-violation-message-contemporary-value-earlier';
+		return (new ViolationMessage($messageKey))
+			->withEntityId($subjectId, Role::SUBJECT)
+			->withEntityId($propertyId, Role::PREDICATE)
+			->withEntityId($objectId, Role::OBJECT)
+			->withDataValue($minEndValue, Role::OBJECT)
+			->withDataValue($maxStartValue, Role::OBJECT);
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ) {
+	public function checkConstraintParameters(Constraint $constraint) {
 		// no parameters
 		return [];
 	}

src/ConstraintCheck/Helper/TypeCheckerHelper.php

Spacing +54 added lines, -54 removed lines

@@ -81,26 +81,26 @@ 
 	 * @return bool
 	 * @throws OverflowException if $entitiesChecked exceeds the configured limit
 	 */
-	private function isSubclassOf( EntityId $comparativeClass, array $classesToCheck, &$entitiesChecked = 0 ) {
-		$maxEntities = $this->config->get( 'WBQualityConstraintsTypeCheckMaxEntities' );
+	private function isSubclassOf(EntityId $comparativeClass, array $classesToCheck, &$entitiesChecked = 0) {
+		$maxEntities = $this->config->get('WBQualityConstraintsTypeCheckMaxEntities');
 		if ( ++$entitiesChecked > $maxEntities ) {
-			throw new OverflowException( 'Too many entities to check' );
+			throw new OverflowException('Too many entities to check');
 		}
 
-		$item = $this->entityLookup->getEntity( $comparativeClass );
-		if ( !( $item instanceof StatementListProvider ) ) {
+		$item = $this->entityLookup->getEntity($comparativeClass);
+		if (!($item instanceof StatementListProvider)) {
 			return false; // lookup failed, probably because item doesn't exist
 		}
 
-		$subclassId = $this->config->get( 'WBQualityConstraintsSubclassOfId' );
+		$subclassId = $this->config->get('WBQualityConstraintsSubclassOfId');
 		$statements = $item->getStatements()
-			->getByPropertyId( new NumericPropertyId( $subclassId ) )
+			->getByPropertyId(new NumericPropertyId($subclassId))
 			->getBestStatements();
 		/** @var Statement $statement */
-		foreach ( $statements as $statement ) {
+		foreach ($statements as $statement) {
 			$mainSnak = $statement->getMainSnak();
 
-			if ( !$this->hasCorrectType( $mainSnak ) ) {
+			if (!$this->hasCorrectType($mainSnak)) {
 				continue;
 			}
 			/** @var PropertyValueSnak $mainSnak */
@@ -110,11 +110,11 @@ 
 			'@phan-var EntityIdValue $dataValue';
 			$comparativeClass = $dataValue->getEntityId();
 
-			if ( in_array( $comparativeClass->getSerialization(), $classesToCheck ) ) {
+			if (in_array($comparativeClass->getSerialization(), $classesToCheck)) {
 				return true;
 			}
 
-			if ( $this->isSubclassOf( $comparativeClass, $classesToCheck, $entitiesChecked ) ) {
+			if ($this->isSubclassOf($comparativeClass, $classesToCheck, $entitiesChecked)) {
 				return true;
 			}
 		}
@@ -135,40 +135,40 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if SPARQL is used and the query times out or some other error occurs
 	 */
-	public function isSubclassOfWithSparqlFallback( EntityId $comparativeClass, array $classesToCheck ) {
-		$timing = $this->statsFactory->getTiming( 'isSubclassOf_duration_seconds' )
-			->setLabel( 'result', 'success' )
-			->setLabel( 'TypeCheckerImplementation', 'php' )
-			->copyToStatsdAt( 'wikibase.quality.constraints.type.php.success.timing' );
+	public function isSubclassOfWithSparqlFallback(EntityId $comparativeClass, array $classesToCheck) {
+		$timing = $this->statsFactory->getTiming('isSubclassOf_duration_seconds')
+			->setLabel('result', 'success')
+			->setLabel('TypeCheckerImplementation', 'php')
+			->copyToStatsdAt('wikibase.quality.constraints.type.php.success.timing');
 		$timing->start();
 
 		try {
 			$entitiesChecked = 0;
-			$isSubclass = $this->isSubclassOf( $comparativeClass, $classesToCheck, $entitiesChecked );
+			$isSubclass = $this->isSubclassOf($comparativeClass, $classesToCheck, $entitiesChecked);
 			$timing->stop();
 
 			// not really a timing, but works like one (we want percentiles etc.)
 			// TODO: probably a good candidate for T348796
-			$this->statsFactory->getTiming( 'isSubclassOf_entities_total' )
-				->setLabel( 'TypeCheckerImplementation', 'php' )
-				->setLabel( 'result', 'success' )
-				->copyToStatsdAt( 'wikibase.quality.constraints.type.php.success.entities' )
-				->observe( $entitiesChecked );
-
-			return new CachedBool( $isSubclass, Metadata::blank() );
-		} catch ( OverflowException $e ) {
-			$timing->setLabel( 'result', 'overflow' )
-				->copyToStatsdAt( 'wikibase.quality.constraints.type.php.overflow.timing' )
+			$this->statsFactory->getTiming('isSubclassOf_entities_total')
+				->setLabel('TypeCheckerImplementation', 'php')
+				->setLabel('result', 'success')
+				->copyToStatsdAt('wikibase.quality.constraints.type.php.success.entities')
+				->observe($entitiesChecked);
+
+			return new CachedBool($isSubclass, Metadata::blank());
+		} catch (OverflowException $e) {
+			$timing->setLabel('result', 'overflow')
+				->copyToStatsdAt('wikibase.quality.constraints.type.php.overflow.timing')
 				->stop();
 
-			if ( !( $this->sparqlHelper instanceof DummySparqlHelper ) ) {
-				$this->statsFactory->getCounter( 'sparql_typeFallback_total' )
-					->copyToStatsdAt( 'wikibase.quality.constraints.sparql.typeFallback' )
+			if (!($this->sparqlHelper instanceof DummySparqlHelper)) {
+				$this->statsFactory->getCounter('sparql_typeFallback_total')
+					->copyToStatsdAt('wikibase.quality.constraints.sparql.typeFallback')
 					->increment();
 
-				$timing->setLabel( 'TypeCheckerImplementation', 'sparql' )
-					->setLabel( 'result', 'success' )
-					->copyToStatsdAt( 'wikibase.quality.constraints.type.sparql.success.timing' )
+				$timing->setLabel('TypeCheckerImplementation', 'sparql')
+					->setLabel('result', 'success')
+					->copyToStatsdAt('wikibase.quality.constraints.type.sparql.success.timing')
 					->start();
 
 				$hasType = $this->sparqlHelper->hasType(
@@ -180,7 +180,7 @@ 
 
 				return $hasType;
 			} else {
-				return new CachedBool( false, Metadata::blank() );
+				return new CachedBool(false, Metadata::blank());
 			}
 		}
 	}
@@ -198,13 +198,13 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if SPARQL is used and the query times out or some other error occurs
 	 */
-	public function hasClassInRelation( StatementList $statements, array $relationIds, array $classesToCheck ) {
+	public function hasClassInRelation(StatementList $statements, array $relationIds, array $classesToCheck) {
 		$metadatas = [];
 
-		foreach ( $this->getBestStatementsByPropertyIds( $statements, $relationIds ) as $statement ) {
+		foreach ($this->getBestStatementsByPropertyIds($statements, $relationIds) as $statement) {
 			$mainSnak = $statement->getMainSnak();
 
-			if ( !$this->hasCorrectType( $mainSnak ) ) {
+			if (!$this->hasCorrectType($mainSnak)) {
 				continue;
 			}
 			/** @var PropertyValueSnak $mainSnak */
@@ -214,24 +214,24 @@ 
 			'@phan-var EntityIdValue $dataValue';
 			$comparativeClass = $dataValue->getEntityId();
 
-			if ( in_array( $comparativeClass->getSerialization(), $classesToCheck ) ) {
+			if (in_array($comparativeClass->getSerialization(), $classesToCheck)) {
 				// discard $metadatas, we know this is fresh
-				return new CachedBool( true, Metadata::blank() );
+				return new CachedBool(true, Metadata::blank());
 			}
 
-			$result = $this->isSubclassOfWithSparqlFallback( $comparativeClass, $classesToCheck );
+			$result = $this->isSubclassOfWithSparqlFallback($comparativeClass, $classesToCheck);
 			$metadatas[] = $result->getMetadata();
-			if ( $result->getBool() ) {
+			if ($result->getBool()) {
 				return new CachedBool(
 					true,
-					Metadata::merge( $metadatas )
+					Metadata::merge($metadatas)
 				);
 			}
 		}
 
 		return new CachedBool(
 			false,
-			Metadata::merge( $metadatas )
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -240,7 +240,7 @@ 
 	 * @return bool
 	 * @phan-assert PropertyValueSnak $mainSnak
 	 */
-	private function hasCorrectType( Snak $mainSnak ) {
+	private function hasCorrectType(Snak $mainSnak) {
 		return $mainSnak instanceof PropertyValueSnak
 			&& $mainSnak->getDataValue()->getType() === 'wikibase-entityid';
 	}
@@ -257,15 +257,15 @@ 
 	) {
 		$statementArrays = [];
 
-		foreach ( $propertyIdSerializations as $propertyIdSerialization ) {
-			$propertyId = new NumericPropertyId( $propertyIdSerialization );
+		foreach ($propertyIdSerializations as $propertyIdSerialization) {
+			$propertyId = new NumericPropertyId($propertyIdSerialization);
 			$statementArrays[] = $statements
-				->getByPropertyId( $propertyId )
+				->getByPropertyId($propertyId)
 				->getBestStatements()
 				->toArray();
 		}
 
-		return call_user_func_array( 'array_merge', $statementArrays );
+		return call_user_func_array('array_merge', $statementArrays);
 	}
 
 	/**
@@ -285,8 +285,8 @@ 
 		$relation
 	) {
 		$classes = array_map(
-			static function ( $itemIdSerialization ) {
-				return new ItemId( $itemIdSerialization );
+			static function($itemIdSerialization) {
+				return new ItemId($itemIdSerialization);
 			},
 			$classes
 		);
@@ -298,10 +298,10 @@ 
 		// wbqc-violation-message-valueType-instance
 		// wbqc-violation-message-valueType-subclass
 		// wbqc-violation-message-valueType-instanceOrSubclass
-		return ( new ViolationMessage( 'wbqc-violation-message-' . $checker . '-' . $relation ) )
-			->withEntityId( $propertyId, Role::CONSTRAINT_PROPERTY )
-			->withEntityId( $entityId, Role::SUBJECT )
-			->withEntityIdList( $classes, Role::OBJECT );
+		return (new ViolationMessage('wbqc-violation-message-'.$checker.'-'.$relation))
+			->withEntityId($propertyId, Role::CONSTRAINT_PROPERTY)
+			->withEntityId($entityId, Role::SUBJECT)
+			->withEntityIdList($classes, Role::OBJECT);
 	}
 
 }

src/ServiceWiring.php

Spacing +144 added lines, -144 removed lines

@@ -31,53 +31,53 @@ 
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResultSerializer;
 
 return [
-	ConstraintsServices::EXPIRY_LOCK => static function ( MediaWikiServices $services ): ExpiryLock {
-		return new ExpiryLock( ObjectCache::getInstance( CACHE_ANYTHING ) );
+	ConstraintsServices::EXPIRY_LOCK => static function(MediaWikiServices $services): ExpiryLock {
+		return new ExpiryLock(ObjectCache::getInstance(CACHE_ANYTHING));
 	},
 
-	ConstraintsServices::LOGGING_HELPER => static function ( MediaWikiServices $services ): LoggingHelper {
+	ConstraintsServices::LOGGING_HELPER => static function(MediaWikiServices $services): LoggingHelper {
 		return new LoggingHelper(
 			$services->getStatsdDataFactory(),
-			LoggerFactory::getInstance( 'WikibaseQualityConstraints' ),
+			LoggerFactory::getInstance('WikibaseQualityConstraints'),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintsServices::CONSTRAINT_STORE => static function ( MediaWikiServices $services ): ConstraintRepositoryStore {
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
-		if ( $propertySource === null ) {
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for properties not stored in a database.' );
+	ConstraintsServices::CONSTRAINT_STORE => static function(MediaWikiServices $services): ConstraintRepositoryStore {
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
+		if ($propertySource === null) {
+			throw new RuntimeException('Can\'t get a ConstraintStore for properties not stored in a database.');
 		}
 
-		$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
-		if ( $propertySource->getSourceName() !== $localEntitySourceName ) {
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for a non local entity source.' );
+		$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
+		if ($propertySource->getSourceName() !== $localEntitySourceName) {
+			throw new RuntimeException('Can\'t get a ConstraintStore for a non local entity source.');
 		}
 
 		$dbName = $propertySource->getDatabaseName();
 		return new ConstraintRepositoryStore(
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
 			$dbName
 		);
 	},
 
-	ConstraintsServices::CONSTRAINT_LOOKUP => static function ( MediaWikiServices $services ): ConstraintLookup {
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
-		if ( $propertySource === null ) {
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for properties not stored in a database.' );
+	ConstraintsServices::CONSTRAINT_LOOKUP => static function(MediaWikiServices $services): ConstraintLookup {
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
+		if ($propertySource === null) {
+			throw new RuntimeException('Can\'t get a ConstraintStore for properties not stored in a database.');
 		}
 
 		$dbName = $propertySource->getDatabaseName();
 		$rawLookup = new ConstraintRepositoryLookup(
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
 			$dbName
 		);
-		return new CachingConstraintLookup( $rawLookup );
+		return new CachingConstraintLookup($rawLookup);
 	},
 
-	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function ( MediaWikiServices $services ): CheckResultSerializer {
+	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function(MediaWikiServices $services): CheckResultSerializer {
 		return new CheckResultSerializer(
 			new ConstraintSerializer(
 				false // constraint parameters are not exposed
@@ -88,9 +88,9 @@ 
 		);
 	},
 
-	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function ( MediaWikiServices $services ): CheckResultDeserializer {
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
+	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function(MediaWikiServices $services): CheckResultDeserializer {
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
 
 		return new CheckResultDeserializer(
 			new ConstraintDeserializer(),
@@ -103,17 +103,17 @@ 
 		);
 	},
 
-	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function (
+	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function(
 		MediaWikiServices $services
 	): ViolationMessageSerializer {
 		return new ViolationMessageSerializer();
 	},
 
-	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function (
+	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function(
 		MediaWikiServices $services
 	): ViolationMessageDeserializer {
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
 
 		return new ViolationMessageDeserializer(
 			$entityIdParser,
@@ -121,39 +121,39 @@ 
 		);
 	},
 
-	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function (
+	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function(
 		MediaWikiServices $services
 	): ConstraintParameterParser {
-		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory( $services );
-		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
+		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory($services);
+		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
 
 		return new ConstraintParameterParser(
 			$services->getMainConfig(),
 			$deserializerFactory,
-			$entitySourceDefinitions->getDatabaseSourceForEntityType( 'item' )->getConceptBaseUri()
+			$entitySourceDefinitions->getDatabaseSourceForEntityType('item')->getConceptBaseUri()
 		);
 	},
 
-	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function ( MediaWikiServices $services ): ConnectionCheckerHelper {
+	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function(MediaWikiServices $services): ConnectionCheckerHelper {
 		return new ConnectionCheckerHelper();
 	},
 
-	ConstraintsServices::RANGE_CHECKER_HELPER => static function ( MediaWikiServices $services ): RangeCheckerHelper {
+	ConstraintsServices::RANGE_CHECKER_HELPER => static function(MediaWikiServices $services): RangeCheckerHelper {
 		return new RangeCheckerHelper(
 			$services->getMainConfig(),
-			WikibaseRepo::getUnitConverter( $services )
+			WikibaseRepo::getUnitConverter($services)
 		);
 	},
 
-	ConstraintsServices::SPARQL_HELPER => static function ( MediaWikiServices $services ): SparqlHelper {
-		$endpoint = $services->getMainConfig()->get( 'WBQualityConstraintsSparqlEndpoint' );
-		if ( $endpoint === '' ) {
+	ConstraintsServices::SPARQL_HELPER => static function(MediaWikiServices $services): SparqlHelper {
+		$endpoint = $services->getMainConfig()->get('WBQualityConstraintsSparqlEndpoint');
+		if ($endpoint === '') {
 			return new DummySparqlHelper();
 		}
 
-		$rdfVocabulary = WikibaseRepo::getRdfVocabulary( $services );
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
-		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup( $services );
+		$rdfVocabulary = WikibaseRepo::getRdfVocabulary($services);
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
+		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup($services);
 
 		return new SparqlHelper(
 			$services->getMainConfig(),
@@ -161,128 +161,128 @@ 
 			$entityIdParser,
 			$propertyDataTypeLookup,
 			$services->getMainWANObjectCache(),
-			ConstraintsServices::getViolationMessageSerializer( $services ),
-			ConstraintsServices::getViolationMessageDeserializer( $services ),
+			ConstraintsServices::getViolationMessageSerializer($services),
+			ConstraintsServices::getViolationMessageDeserializer($services),
 			$services->getStatsdDataFactory(),
-			ConstraintsServices::getExpiryLock( $services ),
-			ConstraintsServices::getLoggingHelper( $services ),
-			WikiMap::getCurrentWikiId() . ' WikibaseQualityConstraints ' . $services->getHttpRequestFactory()->getUserAgent(),
+			ConstraintsServices::getExpiryLock($services),
+			ConstraintsServices::getLoggingHelper($services),
+			WikiMap::getCurrentWikiId().' WikibaseQualityConstraints '.$services->getHttpRequestFactory()->getUserAgent(),
 			$services->getHttpRequestFactory()
 		);
 	},
 
-	ConstraintsServices::TYPE_CHECKER_HELPER => static function ( MediaWikiServices $services ): TypeCheckerHelper {
+	ConstraintsServices::TYPE_CHECKER_HELPER => static function(MediaWikiServices $services): TypeCheckerHelper {
 		return new TypeCheckerHelper(
-			WikibaseServices::getEntityLookup( $services ),
+			WikibaseServices::getEntityLookup($services),
 			$services->getMainConfig(),
-			ConstraintsServices::getSparqlHelper( $services ),
-			$services->getStatsFactory()->withComponent( 'WikibaseQualityConstraints' )
+			ConstraintsServices::getSparqlHelper($services),
+			$services->getStatsFactory()->withComponent('WikibaseQualityConstraints')
 		);
 	},
 
-	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function (
+	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function(
 		MediaWikiServices $services
 	): DelegatingConstraintChecker {
-		$statementGuidParser = WikibaseRepo::getStatementGuidParser( $services );
+		$statementGuidParser = WikibaseRepo::getStatementGuidParser($services);
 
 		$config = $services->getMainConfig();
 		$checkerMap = [
-			$config->get( 'WBQualityConstraintsConflictsWithConstraintId' )
-				=> ConstraintCheckerServices::getConflictsWithChecker( $services ),
-			$config->get( 'WBQualityConstraintsItemRequiresClaimConstraintId' )
-				=> ConstraintCheckerServices::getItemChecker( $services ),
-			$config->get( 'WBQualityConstraintsValueRequiresClaimConstraintId' )
-				=> ConstraintCheckerServices::getTargetRequiredClaimChecker( $services ),
-			$config->get( 'WBQualityConstraintsSymmetricConstraintId' )
-				=> ConstraintCheckerServices::getSymmetricChecker( $services ),
-			$config->get( 'WBQualityConstraintsInverseConstraintId' )
-				=> ConstraintCheckerServices::getInverseChecker( $services ),
-			$config->get( 'WBQualityConstraintsUsedAsQualifierConstraintId' )
-				=> ConstraintCheckerServices::getQualifierChecker( $services ),
-			$config->get( 'WBQualityConstraintsAllowedQualifiersConstraintId' )
-				=> ConstraintCheckerServices::getQualifiersChecker( $services ),
-			$config->get( 'WBQualityConstraintsMandatoryQualifierConstraintId' )
-				=> ConstraintCheckerServices::getMandatoryQualifiersChecker( $services ),
-			$config->get( 'WBQualityConstraintsRangeConstraintId' )
-				=> ConstraintCheckerServices::getRangeChecker( $services ),
-			$config->get( 'WBQualityConstraintsDifferenceWithinRangeConstraintId' )
-				=> ConstraintCheckerServices::getDiffWithinRangeChecker( $services ),
-			$config->get( 'WBQualityConstraintsTypeConstraintId' )
-				=> ConstraintCheckerServices::getTypeChecker( $services ),
-			$config->get( 'WBQualityConstraintsValueTypeConstraintId' )
-				=> ConstraintCheckerServices::getValueTypeChecker( $services ),
-			$config->get( 'WBQualityConstraintsSingleValueConstraintId' )
-				=> ConstraintCheckerServices::getSingleValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsMultiValueConstraintId' )
-				=> ConstraintCheckerServices::getMultiValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' )
-				=> ConstraintCheckerServices::getUniqueValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsFormatConstraintId' )
-				=> ConstraintCheckerServices::getFormatChecker( $services ),
-			$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' )
-				=> ConstraintCheckerServices::getCommonsLinkChecker( $services ),
-			$config->get( 'WBQualityConstraintsOneOfConstraintId' )
-				=> ConstraintCheckerServices::getOneOfChecker( $services ),
-			$config->get( 'WBQualityConstraintsUsedForValuesOnlyConstraintId' )
-				=> ConstraintCheckerServices::getValueOnlyChecker( $services ),
-			$config->get( 'WBQualityConstraintsUsedAsReferenceConstraintId' )
-				=> ConstraintCheckerServices::getReferenceChecker( $services ),
-			$config->get( 'WBQualityConstraintsNoBoundsConstraintId' )
-				=> ConstraintCheckerServices::getNoBoundsChecker( $services ),
-			$config->get( 'WBQualityConstraintsAllowedUnitsConstraintId' )
-				=> ConstraintCheckerServices::getAllowedUnitsChecker( $services ),
-			$config->get( 'WBQualityConstraintsSingleBestValueConstraintId' )
-				=> ConstraintCheckerServices::getSingleBestValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsAllowedEntityTypesConstraintId' )
-				=> ConstraintCheckerServices::getEntityTypeChecker( $services ),
-			$config->get( 'WBQualityConstraintsNoneOfConstraintId' )
-				=> ConstraintCheckerServices::getNoneOfChecker( $services ),
-			$config->get( 'WBQualityConstraintsIntegerConstraintId' )
-				=> ConstraintCheckerServices::getIntegerChecker( $services ),
-			$config->get( 'WBQualityConstraintsCitationNeededConstraintId' )
-				=> ConstraintCheckerServices::getCitationNeededChecker( $services ),
-			$config->get( 'WBQualityConstraintsPropertyScopeConstraintId' )
-				=> ConstraintCheckerServices::getPropertyScopeChecker( $services ),
-			$config->get( 'WBQualityConstraintsContemporaryConstraintId' )
-				=> ConstraintCheckerServices::getContemporaryChecker( $services ),
-			$config->get( 'WBQualityConstraintsLexemeLanguageConstraintId' )
-				=> ConstraintCheckerServices::getLexemeLanguageChecker( $services ),
-			$config->get( 'WBQualityConstraintsLabelInLanguageConstraintId' )
-				=> ConstraintCheckerServices::getLabelInLanguageChecker( $services ),
+			$config->get('WBQualityConstraintsConflictsWithConstraintId')
+				=> ConstraintCheckerServices::getConflictsWithChecker($services),
+			$config->get('WBQualityConstraintsItemRequiresClaimConstraintId')
+				=> ConstraintCheckerServices::getItemChecker($services),
+			$config->get('WBQualityConstraintsValueRequiresClaimConstraintId')
+				=> ConstraintCheckerServices::getTargetRequiredClaimChecker($services),
+			$config->get('WBQualityConstraintsSymmetricConstraintId')
+				=> ConstraintCheckerServices::getSymmetricChecker($services),
+			$config->get('WBQualityConstraintsInverseConstraintId')
+				=> ConstraintCheckerServices::getInverseChecker($services),
+			$config->get('WBQualityConstraintsUsedAsQualifierConstraintId')
+				=> ConstraintCheckerServices::getQualifierChecker($services),
+			$config->get('WBQualityConstraintsAllowedQualifiersConstraintId')
+				=> ConstraintCheckerServices::getQualifiersChecker($services),
+			$config->get('WBQualityConstraintsMandatoryQualifierConstraintId')
+				=> ConstraintCheckerServices::getMandatoryQualifiersChecker($services),
+			$config->get('WBQualityConstraintsRangeConstraintId')
+				=> ConstraintCheckerServices::getRangeChecker($services),
+			$config->get('WBQualityConstraintsDifferenceWithinRangeConstraintId')
+				=> ConstraintCheckerServices::getDiffWithinRangeChecker($services),
+			$config->get('WBQualityConstraintsTypeConstraintId')
+				=> ConstraintCheckerServices::getTypeChecker($services),
+			$config->get('WBQualityConstraintsValueTypeConstraintId')
+				=> ConstraintCheckerServices::getValueTypeChecker($services),
+			$config->get('WBQualityConstraintsSingleValueConstraintId')
+				=> ConstraintCheckerServices::getSingleValueChecker($services),
+			$config->get('WBQualityConstraintsMultiValueConstraintId')
+				=> ConstraintCheckerServices::getMultiValueChecker($services),
+			$config->get('WBQualityConstraintsDistinctValuesConstraintId')
+				=> ConstraintCheckerServices::getUniqueValueChecker($services),
+			$config->get('WBQualityConstraintsFormatConstraintId')
+				=> ConstraintCheckerServices::getFormatChecker($services),
+			$config->get('WBQualityConstraintsCommonsLinkConstraintId')
+				=> ConstraintCheckerServices::getCommonsLinkChecker($services),
+			$config->get('WBQualityConstraintsOneOfConstraintId')
+				=> ConstraintCheckerServices::getOneOfChecker($services),
+			$config->get('WBQualityConstraintsUsedForValuesOnlyConstraintId')
+				=> ConstraintCheckerServices::getValueOnlyChecker($services),
+			$config->get('WBQualityConstraintsUsedAsReferenceConstraintId')
+				=> ConstraintCheckerServices::getReferenceChecker($services),
+			$config->get('WBQualityConstraintsNoBoundsConstraintId')
+				=> ConstraintCheckerServices::getNoBoundsChecker($services),
+			$config->get('WBQualityConstraintsAllowedUnitsConstraintId')
+				=> ConstraintCheckerServices::getAllowedUnitsChecker($services),
+			$config->get('WBQualityConstraintsSingleBestValueConstraintId')
+				=> ConstraintCheckerServices::getSingleBestValueChecker($services),
+			$config->get('WBQualityConstraintsAllowedEntityTypesConstraintId')
+				=> ConstraintCheckerServices::getEntityTypeChecker($services),
+			$config->get('WBQualityConstraintsNoneOfConstraintId')
+				=> ConstraintCheckerServices::getNoneOfChecker($services),
+			$config->get('WBQualityConstraintsIntegerConstraintId')
+				=> ConstraintCheckerServices::getIntegerChecker($services),
+			$config->get('WBQualityConstraintsCitationNeededConstraintId')
+				=> ConstraintCheckerServices::getCitationNeededChecker($services),
+			$config->get('WBQualityConstraintsPropertyScopeConstraintId')
+				=> ConstraintCheckerServices::getPropertyScopeChecker($services),
+			$config->get('WBQualityConstraintsContemporaryConstraintId')
+				=> ConstraintCheckerServices::getContemporaryChecker($services),
+			$config->get('WBQualityConstraintsLexemeLanguageConstraintId')
+				=> ConstraintCheckerServices::getLexemeLanguageChecker($services),
+			$config->get('WBQualityConstraintsLabelInLanguageConstraintId')
+				=> ConstraintCheckerServices::getLabelInLanguageChecker($services),
 		];
 
 		return new DelegatingConstraintChecker(
-			WikibaseServices::getEntityLookup( $services ),
+			WikibaseServices::getEntityLookup($services),
 			$checkerMap,
-			ConstraintsServices::getConstraintLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
+			ConstraintsServices::getConstraintLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
 			$statementGuidParser,
-			ConstraintsServices::getLoggingHelper( $services ),
-			$config->get( 'WBQualityConstraintsCheckQualifiers' ),
-			$config->get( 'WBQualityConstraintsCheckReferences' ),
-			$config->get( 'WBQualityConstraintsPropertiesWithViolatingQualifiers' )
+			ConstraintsServices::getLoggingHelper($services),
+			$config->get('WBQualityConstraintsCheckQualifiers'),
+			$config->get('WBQualityConstraintsCheckReferences'),
+			$config->get('WBQualityConstraintsPropertiesWithViolatingQualifiers')
 		);
 	},
 
-	ConstraintsServices::RESULTS_SOURCE => static function ( MediaWikiServices $services ): ResultsSource {
+	ConstraintsServices::RESULTS_SOURCE => static function(MediaWikiServices $services): ResultsSource {
 		$config = $services->getMainConfig();
 		$resultsSource = new CheckingResultsSource(
-			ConstraintsServices::getDelegatingConstraintChecker( $services )
+			ConstraintsServices::getDelegatingConstraintChecker($services)
 		);
 
 		$cacheCheckConstraintsResults = false;
 
-		if ( $config->get( 'WBQualityConstraintsCacheCheckConstraintsResults' ) ) {
+		if ($config->get('WBQualityConstraintsCacheCheckConstraintsResults')) {
 			$cacheCheckConstraintsResults = true;
 			// check that we can use getLocalRepoWikiPageMetaDataAccessor()
 			// TODO we should always be able to cache constraint check results (T244726)
-			$entitySources = WikibaseRepo::getEntitySourceDefinitions( $services )->getSources();
-			$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
+			$entitySources = WikibaseRepo::getEntitySourceDefinitions($services)->getSources();
+			$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
 
-			foreach ( $entitySources as $entitySource ) {
-				if ( $entitySource->getSourceName() !== $localEntitySourceName ) {
-					LoggerFactory::getInstance( 'WikibaseQualityConstraints' )->warning(
-						'Cannot cache constraint check results for non-local source: ' .
+			foreach ($entitySources as $entitySource) {
+				if ($entitySource->getSourceName() !== $localEntitySourceName) {
+					LoggerFactory::getInstance('WikibaseQualityConstraints')->warning(
+						'Cannot cache constraint check results for non-local source: '.
 						$entitySource->getSourceName()
 					);
 					$cacheCheckConstraintsResults = false;
@@ -291,42 +291,42 @@ 
 			}
 		}
 
-		if ( $cacheCheckConstraintsResults ) {
+		if ($cacheCheckConstraintsResults) {
 			$possiblyStaleConstraintTypes = [
-				$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' ),
-				$config->get( 'WBQualityConstraintsTypeConstraintId' ),
-				$config->get( 'WBQualityConstraintsValueTypeConstraintId' ),
-				$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' ),
+				$config->get('WBQualityConstraintsCommonsLinkConstraintId'),
+				$config->get('WBQualityConstraintsTypeConstraintId'),
+				$config->get('WBQualityConstraintsValueTypeConstraintId'),
+				$config->get('WBQualityConstraintsDistinctValuesConstraintId'),
 			];
-			$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
+			$entityIdParser = WikibaseRepo::getEntityIdParser($services);
 			$wikiPageEntityMetaDataAccessor = WikibaseRepo::getLocalRepoWikiPageMetaDataAccessor(
 				$services );
 
 			$resultsSource = new CachingResultsSource(
 				$resultsSource,
 				ResultsCache::getDefaultInstance(),
-				ConstraintsServices::getCheckResultSerializer( $services ),
-				ConstraintsServices::getCheckResultDeserializer( $services ),
+				ConstraintsServices::getCheckResultSerializer($services),
+				ConstraintsServices::getCheckResultDeserializer($services),
 				$wikiPageEntityMetaDataAccessor,
 				$entityIdParser,
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsTTLSeconds' ),
+				$config->get('WBQualityConstraintsCacheCheckConstraintsTTLSeconds'),
 				$possiblyStaleConstraintTypes,
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds' ),
-				ConstraintsServices::getLoggingHelper( $services )
+				$config->get('WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds'),
+				ConstraintsServices::getLoggingHelper($services)
 			);
 		}
 
 		return $resultsSource;
 	},
 
-	ConstraintsServices::VIOLATION_MESSAGE_RENDERER_FACTORY => static function (
+	ConstraintsServices::VIOLATION_MESSAGE_RENDERER_FACTORY => static function(
 		MediaWikiServices $services
 	): ViolationMessageRendererFactory {
 		return new ViolationMessageRendererFactory(
 			$services->getMainConfig(),
 			$services->getLanguageNameUtils(),
-			WikibaseRepo::getEntityIdHtmlLinkFormatterFactory( $services ),
-			WikibaseRepo::getValueFormatterFactory( $services )
+			WikibaseRepo::getEntityIdHtmlLinkFormatterFactory($services),
+			WikibaseRepo::getValueFormatterFactory($services)
 		);
 	},
 ];

src/ServiceWiring-Wikibase.php

Spacing +7 added lines, -7 removed lines

@@ -10,20 +10,20 @@
 use Wikibase\Repo\WikibaseRepo;
 
 return [
-	WikibaseServices::ENTITY_LOOKUP => static function ( MediaWikiServices $services ): EntityLookup {
+	WikibaseServices::ENTITY_LOOKUP => static function(MediaWikiServices $services): EntityLookup {
 		return new ExceptionIgnoringEntityLookup(
-			WikibaseRepo::getEntityLookup( $services )
+			WikibaseRepo::getEntityLookup($services)
 		);
 	},
 
-	WikibaseServices::ENTITY_LOOKUP_WITHOUT_CACHE => static function ( MediaWikiServices $services ): EntityLookup {
+	WikibaseServices::ENTITY_LOOKUP_WITHOUT_CACHE => static function(MediaWikiServices $services): EntityLookup {
 		return new ExceptionIgnoringEntityLookup(
-			WikibaseRepo::getStore( $services )
-				->getEntityLookup( Store::LOOKUP_CACHING_RETRIEVE_ONLY )
+			WikibaseRepo::getStore($services)
+				->getEntityLookup(Store::LOOKUP_CACHING_RETRIEVE_ONLY)
 		);
 	},
 
-	WikibaseServices::PROPERTY_DATA_TYPE_LOOKUP => static function ( MediaWikiServices $services ): PropertyDataTypeLookup {
-		return WikibaseRepo::getPropertyDataTypeLookup( $services );
+	WikibaseServices::PROPERTY_DATA_TYPE_LOOKUP => static function(MediaWikiServices $services): PropertyDataTypeLookup {
+		return WikibaseRepo::getPropertyDataTypeLookup($services);
 	},
 ];

src/ServiceWiring-ConstraintCheckers.php

Spacing +75 added lines, -75 removed lines

@@ -38,216 +38,216 @@
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\ValueTypeChecker;
 
 return [
-	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function ( MediaWikiServices $services ): ConflictsWithChecker {
+	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function(MediaWikiServices $services): ConflictsWithChecker {
 		return new ConflictsWithChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::ITEM_CHECKER => static function ( MediaWikiServices $services ): ItemChecker {
+	ConstraintCheckerServices::ITEM_CHECKER => static function(MediaWikiServices $services): ItemChecker {
 		return new ItemChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function (
+	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function(
 		MediaWikiServices $services
 	): TargetRequiredClaimChecker {
 		return new TargetRequiredClaimChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function ( MediaWikiServices $services ): SymmetricChecker {
+	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function(MediaWikiServices $services): SymmetricChecker {
 		return new SymmetricChecker(
-			WikibaseServices::getEntityLookupWithoutCache( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			WikibaseServices::getEntityLookupWithoutCache($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::INVERSE_CHECKER => static function ( MediaWikiServices $services ): InverseChecker {
+	ConstraintCheckerServices::INVERSE_CHECKER => static function(MediaWikiServices $services): InverseChecker {
 		return new InverseChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::QUALIFIER_CHECKER => static function ( MediaWikiServices $services ): QualifierChecker {
+	ConstraintCheckerServices::QUALIFIER_CHECKER => static function(MediaWikiServices $services): QualifierChecker {
 		return new QualifierChecker();
 	},
 
-	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function ( MediaWikiServices $services ): QualifiersChecker {
+	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function(MediaWikiServices $services): QualifiersChecker {
 		return new QualifiersChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function (
+	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function(
 		MediaWikiServices $services
 	): MandatoryQualifiersChecker {
 		return new MandatoryQualifiersChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::RANGE_CHECKER => static function ( MediaWikiServices $services ): RangeChecker {
+	ConstraintCheckerServices::RANGE_CHECKER => static function(MediaWikiServices $services): RangeChecker {
 		return new RangeChecker(
-			WikibaseServices::getPropertyDataTypeLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services )
+			WikibaseServices::getPropertyDataTypeLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getRangeCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function (
+	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function(
 		MediaWikiServices $services
 	): DiffWithinRangeChecker {
 		return new DiffWithinRangeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getRangeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::TYPE_CHECKER => static function ( MediaWikiServices $services ): TypeChecker {
+	ConstraintCheckerServices::TYPE_CHECKER => static function(MediaWikiServices $services): TypeChecker {
 		return new TypeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getTypeCheckerHelper( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getTypeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function ( MediaWikiServices $services ): ValueTypeChecker {
+	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function(MediaWikiServices $services): ValueTypeChecker {
 		return new ValueTypeChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getTypeCheckerHelper( $services ),
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getTypeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function ( MediaWikiServices $services ): SingleValueChecker {
+	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function(MediaWikiServices $services): SingleValueChecker {
 		return new SingleValueChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function ( MediaWikiServices $services ): MultiValueChecker {
+	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function(MediaWikiServices $services): MultiValueChecker {
 		return new MultiValueChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function ( MediaWikiServices $services ): UniqueValueChecker {
+	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function(MediaWikiServices $services): UniqueValueChecker {
 		// TODO return a different, dummy implementation if SPARQL is not available
 		return new UniqueValueChecker(
-			ConstraintsServices::getSparqlHelper( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getSparqlHelper($services),
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::FORMAT_CHECKER => static function ( MediaWikiServices $services ): FormatChecker {
+	ConstraintCheckerServices::FORMAT_CHECKER => static function(MediaWikiServices $services): FormatChecker {
 		// TODO return a different, dummy implementation if SPARQL is not available
 		return new FormatChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
 			$services->getMainConfig(),
-			ConstraintsServices::getSparqlHelper( $services ),
+			ConstraintsServices::getSparqlHelper($services),
 			$services->getShellboxClientFactory()
 		);
 	},
 
-	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function ( MediaWikiServices $services ): CommonsLinkChecker {
+	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function(MediaWikiServices $services): CommonsLinkChecker {
 		$pageNameNormalizer = new MediaWikiPageNameNormalizer();
 		return new CommonsLinkChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
 			$pageNameNormalizer,
-			WikibaseRepo::getPropertyDataTypeLookup( $services )
+			WikibaseRepo::getPropertyDataTypeLookup($services)
 		);
 	},
 
-	ConstraintCheckerServices::ONE_OF_CHECKER => static function ( MediaWikiServices $services ): OneOfChecker {
+	ConstraintCheckerServices::ONE_OF_CHECKER => static function(MediaWikiServices $services): OneOfChecker {
 		return new OneOfChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function ( MediaWikiServices $services ): ValueOnlyChecker {
+	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function(MediaWikiServices $services): ValueOnlyChecker {
 		return new ValueOnlyChecker();
 	},
 
-	ConstraintCheckerServices::REFERENCE_CHECKER => static function ( MediaWikiServices $services ): ReferenceChecker {
+	ConstraintCheckerServices::REFERENCE_CHECKER => static function(MediaWikiServices $services): ReferenceChecker {
 		return new ReferenceChecker();
 	},
 
-	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function ( MediaWikiServices $services ): NoBoundsChecker {
+	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function(MediaWikiServices $services): NoBoundsChecker {
 		return new NoBoundsChecker();
 	},
 
-	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function ( MediaWikiServices $services ): AllowedUnitsChecker {
+	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function(MediaWikiServices $services): AllowedUnitsChecker {
 		return new AllowedUnitsChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			WikibaseRepo::getUnitConverter( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			WikibaseRepo::getUnitConverter($services)
 		);
 	},
 
-	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function (
+	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function(
 		MediaWikiServices $services
 	): SingleBestValueChecker {
 		return new SingleBestValueChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function ( MediaWikiServices $services ): EntityTypeChecker {
+	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function(MediaWikiServices $services): EntityTypeChecker {
 		return new EntityTypeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::NONE_OF_CHECKER => static function ( MediaWikiServices $services ): NoneOfChecker {
+	ConstraintCheckerServices::NONE_OF_CHECKER => static function(MediaWikiServices $services): NoneOfChecker {
 		return new NoneOfChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::INTEGER_CHECKER => static function ( MediaWikiServices $services ): IntegerChecker {
+	ConstraintCheckerServices::INTEGER_CHECKER => static function(MediaWikiServices $services): IntegerChecker {
 		return new IntegerChecker();
 	},
 
-	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function ( MediaWikiServices $services ): CitationNeededChecker {
+	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function(MediaWikiServices $services): CitationNeededChecker {
 		return new CitationNeededChecker();
 	},
 
-	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function ( MediaWikiServices $services ): PropertyScopeChecker {
+	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function(MediaWikiServices $services): PropertyScopeChecker {
 		return new PropertyScopeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function ( MediaWikiServices $services ): ContemporaryChecker {
+	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function(MediaWikiServices $services): ContemporaryChecker {
 		return new ContemporaryChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services ),
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getRangeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function ( MediaWikiServices $services ): LanguageChecker {
+	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function(MediaWikiServices $services): LanguageChecker {
 		return new LanguageChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			WikibaseServices::getEntityLookup( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			WikibaseServices::getEntityLookup($services)
 		);
 	},
 
-	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function (
+	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function(
 		MediaWikiServices $services
 	): LabelInLanguageChecker {
 		return new LabelInLanguageChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 ];

src/Api/ExpiryLock.php

Spacing +19 added lines, -19 removed lines

@@ -26,7 +26,7 @@ 
 	/**
 	 * @param BagOStuff $cache
 	 */
-	public function __construct( BagOStuff $cache ) {
+	public function __construct(BagOStuff $cache) {
 		$this->cache = $cache;
 	}
 
@@ -37,17 +37,17 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	private function makeKey( $id ) {
-		if ( trim( $id ) === '' ) {
-			throw new ParameterTypeException( '$id', 'non-empty string' );
+	private function makeKey($id) {
+		if (trim($id) === '') {
+			throw new ParameterTypeException('$id', 'non-empty string');
 		}
 
-		Assert::parameterType( 'string', $id, '$id' );
+		Assert::parameterType('string', $id, '$id');
 
 		return $this->cache->makeKey(
 			'WikibaseQualityConstraints',
 			'ExpiryLock',
-			(string)$id
+			(string) $id
 		);
 	}
 
@@ -59,15 +59,15 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	public function lock( $id, ConvertibleTimestamp $expiryTimestamp ) {
+	public function lock($id, ConvertibleTimestamp $expiryTimestamp) {
 
-		$cacheId = $this->makeKey( $id );
+		$cacheId = $this->makeKey($id);
 
-		if ( !$this->isLockedInternal( $cacheId ) ) {
+		if (!$this->isLockedInternal($cacheId)) {
 			return $this->cache->set(
 				$cacheId,
-				$expiryTimestamp->getTimestamp( TS_UNIX ),
-				(int)$expiryTimestamp->getTimestamp( TS_UNIX )
+				$expiryTimestamp->getTimestamp(TS_UNIX),
+				(int) $expiryTimestamp->getTimestamp(TS_UNIX)
 			);
 		} else {
 			return false;
@@ -81,20 +81,20 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	private function isLockedInternal( $cacheId ) {
-		$expiryTime = $this->cache->get( $cacheId );
-		if ( !$expiryTime ) {
+	private function isLockedInternal($cacheId) {
+		$expiryTime = $this->cache->get($cacheId);
+		if (!$expiryTime) {
 			return false;
 		}
 
 		try {
-			$lockExpiryTimeStamp = new ConvertibleTimestamp( $expiryTime );
-		} catch ( TimestampException $exception ) {
+			$lockExpiryTimeStamp = new ConvertibleTimestamp($expiryTime);
+		} catch (TimestampException $exception) {
 			return false;
 		}
 
 		$now = new ConvertibleTimestamp();
-		if ( $now->timestamp < $lockExpiryTimeStamp->timestamp ) {
+		if ($now->timestamp < $lockExpiryTimeStamp->timestamp) {
 			return true;
 		} else {
 			return false;
@@ -108,8 +108,8 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	public function isLocked( $id ) {
-		return $this->isLockedInternal( $this->makeKey( $id ) );
+	public function isLocked($id) {
+		return $this->isLockedInternal($this->makeKey($id));
 	}
 
 }

src/ConstraintCheck/Helper/ConstraintParameterParser.php

Spacing +291 added lines, -291 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Helper;
 
@@ -68,15 +68,15 @@ 
 	 * Check if any errors are recorded in the constraint parameters.
 	 * @throws ConstraintParameterException
 	 */
-	public function checkError( array $parameters ): void {
-		if ( array_key_exists( '@error', $parameters ) ) {
+	public function checkError(array $parameters): void {
+		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));
 		}
 	}
 
@@ -84,11 +84,11 @@ 
 	 * Require that $parameters contains exactly one $parameterId parameter.
 	 * @throws ConstraintParameterException
 	 */
-	private function requireSingleParameter( array $parameters, string $parameterId ): void {
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
+	private function requireSingleParameter(array $parameters, string $parameterId): void {
+		if (count($parameters[$parameterId]) !== 1) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-single' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-single'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -97,11 +97,11 @@ 
 	 * Require that $snak is a {@link PropertyValueSnak}.
 	 * @throws ConstraintParameterException
 	 */
-	private function requireValueParameter( Snak $snak, string $parameterId ): void {
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
+	private function requireValueParameter(Snak $snak, string $parameterId): void {
+		if (!($snak instanceof PropertyValueSnak)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -110,17 +110,17 @@ 
 	 * Parse a single entity ID parameter.
 	 * @throws ConstraintParameterException
 	 */
-	private function parseEntityIdParameter( array $snakSerialization, string $parameterId ): EntityId {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseEntityIdParameter(array $snakSerialization, string $parameterId): EntityId {
+		$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 NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-entity'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -131,20 +131,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] class entity ID serializations
 	 */
-	public function parseClassParameter( array $constraintParameters, string $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
+	public function parseClassParameter(array $constraintParameters, string $constraintTypeItemId): array {
+		$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 NumericPropertyId( $classId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($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;
 	}
@@ -155,31 +155,31 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
 	 */
-	public function parseRelationParameter( array $constraintParameters, string $constraintTypeItemId ): string {
-		$this->checkError( $constraintParameters );
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
+	public function parseRelationParameter(array $constraintParameters, string $constraintTypeItemId): string {
+		$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 NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $relationId );
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
-		if ( !( $relationEntityId instanceof ItemId ) ) {
+		$this->requireSingleParameter($constraintParameters, $relationId);
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
+		if (!($relationEntityId instanceof ItemId)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( new EntityIdValue( $relationEntityId ), Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue(new EntityIdValue($relationEntityId), Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
-		return $this->mapItemId( $relationEntityId, [
-			$this->config->get( 'WBQualityConstraintsInstanceOfRelationId' ) => 'instance',
-			$this->config->get( 'WBQualityConstraintsSubclassOfRelationId' ) => 'subclass',
-			$this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' ) => 'instanceOrSubclass',
-		], $relationId );
+		return $this->mapItemId($relationEntityId, [
+			$this->config->get('WBQualityConstraintsInstanceOfRelationId') => 'instance',
+			$this->config->get('WBQualityConstraintsSubclassOfRelationId') => 'subclass',
+			$this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId') => 'instanceOrSubclass',
+		], $relationId);
 	}
 
 	/**
@@ -189,20 +189,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return PropertyId
 	 */
-	private function parsePropertyIdParameter( array $snakSerialization, string $parameterId ): PropertyId {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parsePropertyIdParameter(array $snakSerialization, string $parameterId): PropertyId {
+		$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 NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-				->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+			(new ViolationMessage('wbqc-violation-message-parameter-property'))
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+				->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 		);
 	}
 
@@ -213,33 +213,33 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId
 	 */
-	public function parsePropertyParameter( array $constraintParameters, string $constraintTypeItemId ): PropertyId {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertyParameter(array $constraintParameters, string $constraintTypeItemId): PropertyId {
+		$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 NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($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, string $parameterId ): ItemIdSnakValue {
+	private function parseItemIdParameter(PropertyValueSnak $snak, string $parameterId): ItemIdSnakValue {
 		$dataValue = $snak->getDataValue();
-		if ( $dataValue instanceof EntityIdValue ) {
+		if ($dataValue instanceof EntityIdValue) {
 			$entityId = $dataValue->getEntityId();
-			if ( $entityId instanceof ItemId ) {
-				return ItemIdSnakValue::fromItemId( $entityId );
+			if ($entityId instanceof ItemId) {
+				return ItemIdSnakValue::fromItemId($entityId);
 			}
 		}
 		throw new ConstraintParameterException(
-			( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-				->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+			(new ViolationMessage('wbqc-violation-message-parameter-item'))
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+				->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 		);
 	}
 
@@ -257,16 +257,16 @@ 
 		bool $required,
 		string $parameterId = null
 	): array {
-		$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 NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			} else {
 				return [];
@@ -274,11 +274,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();
@@ -306,13 +306,13 @@ 
 		bool $required,
 		string $parameterId
 	): array {
-		return array_map( static function ( ItemIdSnakValue $value ) use ( $parameterId ): ItemId {
-			if ( $value->isValue() ) {
+		return array_map(static function(ItemIdSnakValue $value) use ($parameterId): ItemId {
+			if ($value->isValue()) {
 				return $value->getItemId();
 			} else {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-value'))
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			}
 		}, $this->parseItemsParameter(
@@ -320,7 +320,7 @@ 
 			$constraintTypeItemId,
 			$required,
 			$parameterId
-		) );
+		));
 	}
 
 	/**
@@ -328,18 +328,18 @@ 
 	 * @throws ConstraintParameterException
 	 * @return mixed elements of $mapping
 	 */
-	private function mapItemId( ItemId $itemId, array $mapping, string $parameterId ) {
+	private function mapItemId(ItemId $itemId, array $mapping, string $parameterId) {
 		$serialization = $itemId->getSerialization();
-		if ( array_key_exists( $serialization, $mapping ) ) {
+		if (array_key_exists($serialization, $mapping)) {
 			return $mapping[$serialization];
 		} else {
-			$allowed = array_map( static function ( $id ) {
-				return new ItemId( $id );
-			}, array_keys( $mapping ) );
+			$allowed = array_map(static function($id) {
+				return new ItemId($id);
+			}, array_keys($mapping));
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -350,27 +350,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId[]
 	 */
-	public function parsePropertiesParameter( array $constraintParameters, string $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertiesParameter(array $constraintParameters, string $constraintTypeItemId): array {
+		$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 NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($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;
 	}
@@ -378,24 +378,24 @@ 
 	/**
 	 * @throws ConstraintParameterException
 	 */
-	private function parseValueOrNoValueParameter( array $snakSerialization, string $parameterId ): ?DataValue {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		if ( $snak instanceof PropertyValueSnak ) {
+	private function parseValueOrNoValueParameter(array $snakSerialization, string $parameterId): ?DataValue {
+		$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 NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
 
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, string $parameterId ): ?DataValue {
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, string $parameterId): ?DataValue {
 		try {
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
-		} catch ( ConstraintParameterException $e ) {
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
+		} catch (ConstraintParameterException $e) {
 			// unknown value means “now”
 			return new NowValue();
 		}
@@ -404,14 +404,14 @@ 
 	/**
 	 * Checks whether there is exactly one non-null quantity with the given unit.
 	 */
-	private function exactlyOneQuantityWithUnit( ?DataValue $min, ?DataValue $max, string $unit ): bool {
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
-			!( $max instanceof UnboundedQuantityValue )
+	private function exactlyOneQuantityWithUnit(?DataValue $min, ?DataValue $max, string $unit): bool {
+		if (!($min instanceof UnboundedQuantityValue) ||
+			!($max instanceof UnboundedQuantityValue)
 		) {
 			return false;
 		}
 
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
 	}
 
 	/**
@@ -431,42 +431,42 @@ 
 		string $constraintTypeItemId,
 		string $type
 	): array {
-		$this->checkError( $constraintParameters );
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
-			!array_key_exists( $maximumId, $constraintParameters )
+		$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 NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new NumericPropertyId( $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 NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new NumericPropertyId($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 NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		return [ $min, $max ];
+		return [$min, $max];
 	}
 
 	/**
@@ -476,11 +476,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, string $constraintTypeItemId ): array {
+	public function parseQuantityRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
 			$constraintTypeItemId,
 			'quantity'
 		);
@@ -493,11 +493,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, string $constraintTypeItemId ): array {
+	public function parseTimeRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
 			$constraintTypeItemId,
 			'time'
 		);
@@ -510,20 +510,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return string[]
 	 */
-	public function parseLanguageParameter( array $constraintParameters, string $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$languagePropertyId = $this->config->get( 'WBQualityConstraintsLanguagePropertyId' );
-		if ( !array_key_exists( $languagePropertyId, $constraintParameters ) ) {
+	public function parseLanguageParameter(array $constraintParameters, string $constraintTypeItemId): array {
+		$this->checkError($constraintParameters);
+		$languagePropertyId = $this->config->get('WBQualityConstraintsLanguagePropertyId');
+		if (!array_key_exists($languagePropertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $languagePropertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($languagePropertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$languages = [];
-		foreach ( $constraintParameters[$languagePropertyId] as $snak ) {
-			$languages[] = $this->parseStringParameter( $snak, $languagePropertyId );
+		foreach ($constraintParameters[$languagePropertyId] as $snak) {
+			$languages[] = $this->parseStringParameter($snak, $languagePropertyId);
 		}
 		return $languages;
 	}
@@ -532,17 +532,17 @@ 
 	 * Parse a single string parameter.
 	 * @throws ConstraintParameterException
 	 */
-	private function parseStringParameter( array $snakSerialization, string $parameterId ): string {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseStringParameter(array $snakSerialization, string $parameterId): string {
+		$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 NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -553,15 +553,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseNamespaceParameter( array $constraintParameters, string $constraintTypeItemId ): string {
-		$this->checkError( $constraintParameters );
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
+	public function parseNamespaceParameter(array $constraintParameters, string $constraintTypeItemId): string {
+		$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);
 	}
 
 	/**
@@ -570,19 +570,19 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseFormatParameter( array $constraintParameters, string $constraintTypeItemId ): string {
-		$this->checkError( $constraintParameters );
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
+	public function parseFormatParameter(array $constraintParameters, string $constraintTypeItemId): string {
+		$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 NumericPropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($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);
 	}
 
 	/**
@@ -590,16 +590,16 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return EntityId[]
 	 */
-	public function parseExceptionParameter( array $constraintParameters ): array {
-		$this->checkError( $constraintParameters );
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
+	public function parseExceptionParameter(array $constraintParameters): array {
+		$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]
 		);
@@ -610,39 +610,39 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string|null 'mandatory', 'suggestion' or null
 	 */
-	public function parseConstraintStatusParameter( array $constraintParameters ): ?string {
-		$this->checkError( $constraintParameters );
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
+	public function parseConstraintStatusParameter(array $constraintParameters): ?string {
+		$this->checkError($constraintParameters);
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
 			return null;
 		}
 
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
-		$supportedStatuses = [ new ItemId( $mandatoryId ) ];
-		if ( $this->config->get( 'WBQualityConstraintsEnableSuggestionConstraintStatus' ) ) {
-			$suggestionId = $this->config->get( 'WBQualityConstraintsSuggestionConstraintId' );
-			$supportedStatuses[] = new ItemId( $suggestionId );
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
+		$supportedStatuses = [new ItemId($mandatoryId)];
+		if ($this->config->get('WBQualityConstraintsEnableSuggestionConstraintStatus')) {
+			$suggestionId = $this->config->get('WBQualityConstraintsSuggestionConstraintId');
+			$supportedStatuses[] = new ItemId($suggestionId);
 		} else {
 			$suggestionId = null;
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
-		$this->requireValueParameter( $snak, $constraintStatusId );
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
+		$this->requireValueParameter($snak, $constraintStatusId);
 		'@phan-var \Wikibase\DataModel\Snak\PropertyValueSnak $snak';
 		$dataValue = $snak->getDataValue();
 		'@phan-var EntityIdValue $dataValue';
 		$entityId = $dataValue->getEntityId();
 		$statusId = $entityId->getSerialization();
 
-		if ( $statusId === $mandatoryId ) {
+		if ($statusId === $mandatoryId) {
 			return 'mandatory';
-		} elseif ( $statusId === $suggestionId ) {
+		} elseif ($statusId === $suggestionId) {
 			return 'suggestion';
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new NumericPropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new NumericPropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 					->withEntityIdList(
 						$supportedStatuses,
 						Role::CONSTRAINT_PARAMETER_VALUE
@@ -655,12 +655,12 @@ 
 	 * Require that $dataValue is a {@link MonolingualTextValue}.
 	 * @throws ConstraintParameterException
 	 */
-	private function requireMonolingualTextParameter( DataValue $dataValue, string $parameterId ): void {
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
+	private function requireMonolingualTextParameter(DataValue $dataValue, string $parameterId): void {
+		if (!($dataValue instanceof MonolingualTextValue)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -670,31 +670,31 @@ 
 	 *
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
 	 */
-	private function parseMultilingualTextParameter( array $snakSerializations, string $parameterId ): MultilingualTextValue {
+	private function parseMultilingualTextParameter(array $snakSerializations, string $parameterId): MultilingualTextValue {
 		$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 */
 			'@phan-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 NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-						->withLanguage( $code )
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+						->withLanguage($code)
 				);
 			}
 
 			$result[$code] = $value;
 		}
 
-		return new MultilingualTextValue( $result );
+		return new MultilingualTextValue($result);
 	}
 
 	/**
@@ -702,11 +702,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseSyntaxClarificationParameter( array $constraintParameters ): MultilingualTextValue {
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
+	public function parseSyntaxClarificationParameter(array $constraintParameters): MultilingualTextValue {
+		$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(
@@ -722,11 +722,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseConstraintClarificationParameter( array $constraintParameters ): MultilingualTextValue {
-		$constraintClarificationId = $this->config->get( 'WBQualityConstraintsConstraintClarificationId' );
+	public function parseConstraintClarificationParameter(array $constraintParameters): MultilingualTextValue {
+		$constraintClarificationId = $this->config->get('WBQualityConstraintsConstraintClarificationId');
 
-		if ( !array_key_exists( $constraintClarificationId, $constraintParameters ) ) {
-			return new MultilingualTextValue( [] );
+		if (!array_key_exists($constraintClarificationId, $constraintParameters)) {
+			return new MultilingualTextValue([]);
 		}
 
 		$constraintClarifications = $this->parseMultilingualTextParameter(
@@ -759,14 +759,14 @@ 
 		array $validContextTypes,
 		array $validEntityTypes
 	): array {
-		$contextTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
+		$contextTypeParameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
 		$contextTypeItemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
 			false,
 			$contextTypeParameterId
 		);
-		$entityTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintEntityTypesId' );
+		$entityTypeParameterId = $this->config->get('WBQualityConstraintsConstraintEntityTypesId');
 		$entityTypeItemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -782,26 +782,26 @@ 
 		$contextTypes = null;
 		$entityTypes = null;
 
-		if ( $contextTypeParameterId === $entityTypeParameterId ) {
+		if ($contextTypeParameterId === $entityTypeParameterId) {
 			$itemIds = $contextTypeItemIds;
 			$mapping = $contextTypeMapping + $entityTypeMapping;
-			foreach ( $itemIds as $itemId ) {
-				$mapped = $this->mapItemId( $itemId, $mapping, $contextTypeParameterId );
-				if ( in_array( $mapped, $contextTypeMapping, true ) ) {
+			foreach ($itemIds as $itemId) {
+				$mapped = $this->mapItemId($itemId, $mapping, $contextTypeParameterId);
+				if (in_array($mapped, $contextTypeMapping, true)) {
 					$contextTypes[] = $mapped;
 				} else {
 					$entityTypes[] = $mapped;
 				}
 			}
 		} else {
-			foreach ( $contextTypeItemIds as $contextTypeItemId ) {
+			foreach ($contextTypeItemIds as $contextTypeItemId) {
 				$contextTypes[] = $this->mapItemId(
 					$contextTypeItemId,
 					$contextTypeMapping,
 					$contextTypeParameterId
 				);
 			}
-			foreach ( $entityTypeItemIds as $entityTypeItemId ) {
+			foreach ($entityTypeItemIds as $entityTypeItemId) {
 				$entityTypes[] = $this->mapItemId(
 					$entityTypeItemId,
 					$entityTypeMapping,
@@ -810,21 +810,21 @@ 
 			}
 		}
 
-		$this->checkValidScope( $constraintTypeItemId, $contextTypes, $validContextTypes );
-		$this->checkValidScope( $constraintTypeItemId, $entityTypes, $validEntityTypes );
+		$this->checkValidScope($constraintTypeItemId, $contextTypes, $validContextTypes);
+		$this->checkValidScope($constraintTypeItemId, $entityTypes, $validEntityTypes);
 
-		return [ $contextTypes, $entityTypes ];
+		return [$contextTypes, $entityTypes];
 	}
 
-	private function checkValidScope( string $constraintTypeItemId, ?array $types, array $validTypes ): void {
-		$invalidTypes = array_diff( $types ?: [], $validTypes );
-		if ( $invalidTypes !== [] ) {
-			$invalidType = array_pop( $invalidTypes );
+	private function checkValidScope(string $constraintTypeItemId, ?array $types, array $validTypes): void {
+		$invalidTypes = array_diff($types ?: [], $validTypes);
+		if ($invalidTypes !== []) {
+			$invalidType = array_pop($invalidTypes);
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
-					->withConstraintScope( $invalidType, Role::CONSTRAINT_PARAMETER_VALUE )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withConstraintScopeList( $validTypes, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-invalid-scope'))
+					->withConstraintScope($invalidType, Role::CONSTRAINT_PARAMETER_VALUE)
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withConstraintScopeList($validTypes, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -832,8 +832,8 @@ 
 	/**
 	 * Turn an item ID into a full unit string (using the concept URI).
 	 */
-	private function parseUnitParameter( ItemId $unitId ): string {
-		return $this->unitItemConceptBaseUri . $unitId->getSerialization();
+	private function parseUnitParameter(ItemId $unitId): string {
+		return $this->unitItemConceptBaseUri.$unitId->getSerialization();
 	}
 
 	/**
@@ -841,23 +841,23 @@ 
 	 *
 	 * @throws ConstraintParameterException
 	 */
-	private function parseUnitItem( ItemIdSnakValue $item ): UnitsParameter {
-		switch ( true ) {
+	private function parseUnitItem(ItemIdSnakValue $item): UnitsParameter {
+		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 NumericPropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+						->withEntityId(new NumericPropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			case $item->isNoValue():
-				return new UnitsParameter( [], [], true );
+				return new UnitsParameter([], [], true);
 		}
 	}
 
@@ -867,36 +867,36 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return UnitsParameter
 	 */
-	public function parseUnitsParameter( array $constraintParameters, string $constraintTypeItemId ): UnitsParameter {
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
+	public function parseUnitsParameter(array $constraintParameters, string $constraintTypeItemId): UnitsParameter {
+		$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);
 	}
 
 	private function getEntityTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsWikibaseItemId' ) => 'item',
-			$this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) => 'property',
-			$this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) => 'lexeme',
-			$this->config->get( 'WBQualityConstraintsWikibaseFormId' ) => 'form',
-			$this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) => 'sense',
-			$this->config->get( 'WBQualityConstraintsWikibaseMediaInfoId' ) => 'mediainfo',
+			$this->config->get('WBQualityConstraintsWikibaseItemId') => 'item',
+			$this->config->get('WBQualityConstraintsWikibasePropertyId') => 'property',
+			$this->config->get('WBQualityConstraintsWikibaseLexemeId') => 'lexeme',
+			$this->config->get('WBQualityConstraintsWikibaseFormId') => 'form',
+			$this->config->get('WBQualityConstraintsWikibaseSenseId') => 'sense',
+			$this->config->get('WBQualityConstraintsWikibaseMediaInfoId') => 'mediainfo',
 		];
 	}
 
@@ -906,10 +906,10 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return EntityTypesParameter
 	 */
-	public function parseEntityTypesParameter( array $constraintParameters, string $constraintTypeItemId ): EntityTypesParameter {
+	public function parseEntityTypesParameter(array $constraintParameters, string $constraintTypeItemId): EntityTypesParameter {
 		$entityTypes = [];
 		$entityTypeItemIds = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 		$itemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -918,22 +918,22 @@ 
 		);
 
 		$mapping = $this->getEntityTypeMapping();
-		foreach ( $itemIds as $itemId ) {
-			$entityType = $this->mapItemId( $itemId, $mapping, $parameterId );
+		foreach ($itemIds as $itemId) {
+			$entityType = $this->mapItemId($itemId, $mapping, $parameterId);
 			$entityTypes[] = $entityType;
 			$entityTypeItemIds[] = $itemId;
 		}
 
-		if ( $entityTypes === [] ) {
+		if ($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);
 	}
 
 	/**
@@ -941,18 +941,18 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return PropertyId[]
 	 */
-	public function parseSeparatorsParameter( array $constraintParameters ): array {
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
+	public function parseSeparatorsParameter(array $constraintParameters): array {
+		$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;
@@ -960,17 +960,17 @@ 
 
 	private function getConstraintScopeContextTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' ) => Context::TYPE_STATEMENT,
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' ) => Context::TYPE_QUALIFIER,
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' ) => Context::TYPE_REFERENCE,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId') => Context::TYPE_STATEMENT,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId') => Context::TYPE_QUALIFIER,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId') => Context::TYPE_REFERENCE,
 		];
 	}
 
 	private function getPropertyScopeContextTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsAsMainValueId' ) => Context::TYPE_STATEMENT,
-			$this->config->get( 'WBQualityConstraintsAsQualifiersId' ) => Context::TYPE_QUALIFIER,
-			$this->config->get( 'WBQualityConstraintsAsReferencesId' ) => Context::TYPE_REFERENCE,
+			$this->config->get('WBQualityConstraintsAsMainValueId') => Context::TYPE_STATEMENT,
+			$this->config->get('WBQualityConstraintsAsQualifiersId') => Context::TYPE_QUALIFIER,
+			$this->config->get('WBQualityConstraintsAsReferencesId') => Context::TYPE_REFERENCE,
 		];
 	}
 
@@ -980,9 +980,9 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] list of Context::TYPE_* constants
 	 */
-	public function parsePropertyScopeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
+	public function parsePropertyScopeParameter(array $constraintParameters, string $constraintTypeItemId): array {
 		$contextTypes = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
 		$itemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -991,14 +991,14 @@ 
 		);
 
 		$mapping = $this->getPropertyScopeContextTypeMapping();
-		foreach ( $itemIds as $itemId ) {
-			$contextTypes[] = $this->mapItemId( $itemId, $mapping, $parameterId );
+		foreach ($itemIds as $itemId) {
+			$contextTypes[] = $this->mapItemId($itemId, $mapping, $parameterId);
 		}
 
-		if ( $contextTypes === [] ) {
+		if ($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/ConstraintCheck/Helper/LoggingHelper.php

Spacing +32 added lines, -32 removed lines

@@ -53,12 +53,12 @@ 
 		$this->dataFactory = $dataFactory;
 		$this->logger = $logger;
 		$this->constraintCheckDurationLimits = [
-			'info' => $config->get( 'WBQualityConstraintsCheckDurationInfoSeconds' ),
-			'warning' => $config->get( 'WBQualityConstraintsCheckDurationWarningSeconds' ),
+			'info' => $config->get('WBQualityConstraintsCheckDurationInfoSeconds'),
+			'warning' => $config->get('WBQualityConstraintsCheckDurationWarningSeconds'),
 		];
 		$this->constraintCheckOnEntityDurationLimits = [
-			'info' => $config->get( 'WBQualityConstraintsCheckOnEntityDurationInfoSeconds' ),
-			'warning' => $config->get( 'WBQualityConstraintsCheckOnEntityDurationWarningSeconds' ),
+			'info' => $config->get('WBQualityConstraintsCheckOnEntityDurationInfoSeconds'),
+			'warning' => $config->get('WBQualityConstraintsCheckOnEntityDurationWarningSeconds'),
 		];
 	}
 
@@ -69,23 +69,23 @@ 
 	 * @param float $durationSeconds
 	 * @return array [ $limitSeconds, $logLevel ]
 	 */
-	private function findLimit( $limits, $durationSeconds ) {
+	private function findLimit($limits, $durationSeconds) {
 		$limitSeconds = null;
 		$logLevel = null;
 
-		foreach ( $limits as $level => $limit ) {
+		foreach ($limits as $level => $limit) {
 			if (
 				// duration exceeds this limit
 				$limit !== null && $durationSeconds > $limit &&
 				// this limit is longer than previous longest limit
-				( $limitSeconds === null || $limit > $limitSeconds )
+				($limitSeconds === null || $limit > $limitSeconds)
 			) {
 				$limitSeconds = $limit;
 				$logLevel = $level;
 			}
 		}
 
-		return [ $limitSeconds, $logLevel ];
+		return [$limitSeconds, $logLevel];
 	}
 
 	/**
@@ -110,31 +110,31 @@ 
 		$durationSeconds,
 		$method
 	) {
-		$constraintCheckerClassShortName = substr( strrchr( $constraintCheckerClass, '\\' ), 1 );
+		$constraintCheckerClassShortName = substr(strrchr($constraintCheckerClass, '\\'), 1);
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
 
 		$this->dataFactory->timing(
-			'wikibase.quality.constraints.check.timing.' .
-				$constraintTypeItemId . '-' .
+			'wikibase.quality.constraints.check.timing.'.
+				$constraintTypeItemId.'-'.
 				$constraintCheckerClassShortName,
 			$durationSeconds * 1000
 		);
 
 		// find the longest limit (and associated log level) that the duration exceeds
-		[ $limitSeconds, $logLevel ] = $this->findLimit(
+		[$limitSeconds, $logLevel] = $this->findLimit(
 			$this->constraintCheckDurationLimits,
 			$durationSeconds
 		);
-		if ( $limitSeconds === null ) {
+		if ($limitSeconds === null) {
 			return;
 		}
-		if ( $context->getType() !== Context::TYPE_STATEMENT ) {
+		if ($context->getType() !== Context::TYPE_STATEMENT) {
 			// TODO log less details but still log something
 			return;
 		}
 
 		$resultMessage = $result->getMessage();
-		if ( $resultMessage !== null ) {
+		if ($resultMessage !== null) {
 			$resultMessageKey = $resultMessage->getMessageKey();
 		} else {
 			$resultMessageKey = null;
@@ -142,8 +142,8 @@ 
 
 		$this->logger->log(
 			$logLevel,
-			'Constraint check with {constraintCheckerClassShortName} ' .
-			'took longer than {limitSeconds} second(s) ' .
+			'Constraint check with {constraintCheckerClassShortName} '.
+			'took longer than {limitSeconds} second(s) '.
 			'(duration: {durationSeconds} seconds).',
 			[
 				'method' => $method,
@@ -153,7 +153,7 @@ 
 				'constraintId' => $constraint->getConstraintId(),
 				'constraintPropertyId' => $constraint->getPropertyId()->getSerialization(),
 				'constraintTypeItemId' => $constraintTypeItemId,
-				'constraintParameters' => json_encode( $constraint->getConstraintParameters() ),
+				'constraintParameters' => json_encode($constraint->getConstraintParameters()),
 				'constraintCheckerClass' => $constraintCheckerClass,
 				'constraintCheckerClassShortName' => $constraintCheckerClassShortName,
 				'entityId' => $context->getEntity()->getId()->getSerialization(),
@@ -188,18 +188,18 @@ 
 		);
 
 		// find the longest limit (and associated log level) that the duration exceeds
-		[ $limitSeconds, $logLevel ] = $this->findLimit(
+		[$limitSeconds, $logLevel] = $this->findLimit(
 			$this->constraintCheckOnEntityDurationLimits,
 			$durationSeconds
 		);
-		if ( $limitSeconds === null ) {
+		if ($limitSeconds === null) {
 			return;
 		}
 
 		$this->logger->log(
 			$logLevel,
-			'Full constraint check on {entityId} ' .
-			'took longer than {limitSeconds} second(s) ' .
+			'Full constraint check on {entityId} '.
+			'took longer than {limitSeconds} second(s) '.
 			'(duration: {durationSeconds} seconds).',
 			[
 				'method' => $method,
@@ -217,7 +217,7 @@ 
 	 *
 	 * @param EntityId $entityId
 	 */
-	public function logCheckConstraintsCacheHit( EntityId $entityId ) {
+	public function logCheckConstraintsCacheHit(EntityId $entityId) {
 		$this->dataFactory->increment(
 			'wikibase.quality.constraints.cache.entity.hit'
 		);
@@ -228,10 +228,10 @@ 
 	 *
 	 * @param EntityId[] $entityIds
 	 */
-	public function logCheckConstraintsCacheMisses( array $entityIds ) {
+	public function logCheckConstraintsCacheMisses(array $entityIds) {
 		$this->dataFactory->updateCount(
 			'wikibase.quality.constraints.cache.entity.miss',
-			count( $entityIds )
+			count($entityIds)
 		);
 	}
 
@@ -258,17 +258,17 @@ 
 	 * @param EntityId[] $entityIds
 	 * @param int $maxRevisionIds
 	 */
-	public function logHugeDependencyMetadata( array $entityIds, $maxRevisionIds ) {
+	public function logHugeDependencyMetadata(array $entityIds, $maxRevisionIds) {
 		$this->logger->log(
 			'warning',
-			'Dependency metadata for constraint check result has huge set of entity IDs ' .
-			'(count ' . count( $entityIds ) . ', limit ' . $maxRevisionIds . '); ' .
+			'Dependency metadata for constraint check result has huge set of entity IDs '.
+			'(count '.count($entityIds).', limit '.$maxRevisionIds.'); '.
 			'caching disabled for this check result.',
 			[
 				'loggingMethod' => __METHOD__,
 				'entityIds' => json_encode(
 					array_map(
-						static function ( EntityId $entityId ) {
+						static function(EntityId $entityId) {
 							return $entityId->getSerialization();
 						},
 						$entityIds
@@ -287,17 +287,17 @@ 
 			'Sparql API replied with status 429 and a retry-after header. Requesting to retry after {retryAfterTime}',
 			[
 				'retryAfterTime' => $retryAfterTime,
-				'responseHeaders' => json_encode( $request->getResponseHeaders() ),
+				'responseHeaders' => json_encode($request->getResponseHeaders()),
 				'responseContent' => $request->getContent(),
 			]
 		);
 	}
 
-	public function logSparqlHelperTooManyRequestsRetryAfterInvalid( MWHttpRequest $request ) {
+	public function logSparqlHelperTooManyRequestsRetryAfterInvalid(MWHttpRequest $request) {
 		$this->logger->warning(
 			'Sparql API replied with status 429 and no valid retry-after header.',
 			[
-				'responseHeaders' => json_encode( $request->getResponseHeaders() ),
+				'responseHeaders' => json_encode($request->getResponseHeaders()),
 				'responseContent' => $request->getContent(),
 			]
 		);