wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Checker/LabelInLanguageChecker.php

Spacing +14 added lines, -14 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Checker;
 
@@ -22,7 +22,7 @@ 
 
 	private ConstraintParameterParser $constraintParameterParser;
 
-	public function __construct( ConstraintParameterParser $constraintParameterParser ) {
+	public function __construct(ConstraintParameterParser $constraintParameterParser) {
 		$this->constraintParameterParser = $constraintParameterParser;
 	}
 
@@ -64,9 +64,9 @@ 
 	 *
 	 * @throws ConstraintParameterException
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint ): CheckResult {
-		if ( $context->getSnakRank() === Statement::RANK_DEPRECATED ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_DEPRECATED );
+	public function checkConstraint(Context $context, Constraint $constraint): CheckResult {
+		if ($context->getSnakRank() === Statement::RANK_DEPRECATED) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_DEPRECATED);
 		}
 
 		$constraintParameters = $constraint->getConstraintParameters();
@@ -77,21 +77,21 @@ 
 		);
 
 		$status = CheckResult::STATUS_VIOLATION;
-		$message = ( new ViolationMessage( 'wbqc-violation-message-label-lacking' ) )
-			->withEntityId( $context->getSnak()->getPropertyId(), Role::PREDICATE )
-			->withLanguages( $languages );
+		$message = (new ViolationMessage('wbqc-violation-message-label-lacking'))
+			->withEntityId($context->getSnak()->getPropertyId(), Role::PREDICATE)
+			->withLanguages($languages);
 
 		/** @var LabelsProvider $entity */
 		$entity = $context->getEntity();
 		'@phan-var LabelsProvider $entity';
 		$labels = $entity->getLabels();
 
-		if ( $labels->hasTermForLanguage( 'mul' ) ) {
+		if ($labels->hasTermForLanguage('mul')) {
 			$message = null;
 			$status = CheckResult::STATUS_COMPLIANCE;
 		} else {
-			foreach ( $languages as $language ) {
-				if ( $labels->hasTermForLanguage( $language ) ) {
+			foreach ($languages as $language) {
+				if ($labels->hasTermForLanguage($language)) {
 					$message = null;
 					$status = CheckResult::STATUS_COMPLIANCE;
 					break;
@@ -99,10 +99,10 @@ 
 			}
 		}
 
-		return new CheckResult( $context, $constraint, $status, $message );
+		return new CheckResult($context, $constraint, $status, $message);
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ): array {
+	public function checkConstraintParameters(Constraint $constraint): array {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$exceptions = [];
 		try {
@@ -110,7 +110,7 @@ 
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId()
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/Html/HtmlTableHeaderBuilder.php

Spacing +7 added lines, -7 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\Html;
 
@@ -33,8 +33,8 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	public function __construct( $content, bool $isSortable = false ) {
-		Assert::parameterType( [ 'string', HtmlArmor::class ], $content, '$content' );
+	public function __construct($content, bool $isSortable = false) {
+		Assert::parameterType(['string', HtmlArmor::class], $content, '$content');
 
 		$this->content = $content;
 		$this->isSortable = $isSortable;
@@ -44,7 +44,7 @@ 
 	 * @return string HTML
 	 */
 	public function getContent(): string {
-		return HtmlArmor::getHtml( $this->content );
+		return HtmlArmor::getHtml($this->content);
 	}
 
 	public function getIsSortable(): bool {
@@ -57,13 +57,13 @@ 
 	 * @return string HTML
 	 */
 	public function toHtml(): string {
-		$attributes = [ 'role' => 'columnheader button' ];
+		$attributes = ['role' => 'columnheader button'];
 
-		if ( !$this->isSortable ) {
+		if (!$this->isSortable) {
 			$attributes['class'] = 'unsortable';
 		}
 
-		return Html::rawElement( 'th', $attributes, $this->getContent() );
+		return Html::rawElement('th', $attributes, $this->getContent());
 	}
 
 }

src/ConstraintCheck/Message/ViolationMessageSerializer.php

Spacing +30 added lines, -30 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Message;
 
@@ -21,26 +21,26 @@ 
  */
 class ViolationMessageSerializer implements Serializer {
 
-	private function abbreviateViolationMessageKey( string $fullMessageKey ): string {
-		return substr( $fullMessageKey, strlen( ViolationMessage::MESSAGE_KEY_PREFIX ) );
+	private function abbreviateViolationMessageKey(string $fullMessageKey): string {
+		return substr($fullMessageKey, strlen(ViolationMessage::MESSAGE_KEY_PREFIX));
 	}
 
 	/**
 	 * @param ViolationMessage $object
 	 * @return array
 	 */
-	public function serialize( $object ): array {
+	public function serialize($object): array {
 		/** @var ViolationMessage $object */
-		Assert::parameterType( ViolationMessage::class, $object, '$object' );
+		Assert::parameterType(ViolationMessage::class, $object, '$object');
 
 		$arguments = $object->getArguments();
 		$serializedArguments = [];
-		foreach ( $arguments as $argument ) {
-			$serializedArguments[] = $this->serializeArgument( $argument );
+		foreach ($arguments as $argument) {
+			$serializedArguments[] = $this->serializeArgument($argument);
 		}
 
 		return [
-			'k' => $this->abbreviateViolationMessageKey( $object->getMessageKey() ),
+			'k' => $this->abbreviateViolationMessageKey($object->getMessageKey()),
 			'a' => $serializedArguments,
 		];
 	}
@@ -49,7 +49,7 @@ 
 	 * @param array $argument element of ViolationMessage::getArguments()
 	 * @return array [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
 	 */
-	private function serializeArgument( array $argument ): array {
+	private function serializeArgument(array $argument): array {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'serializeEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'serializeEntityIdList',
@@ -71,12 +71,12 @@ 
 		$value = $argument['value'];
 		$role = $argument['role'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$serializedValue = $this->$method( $value );
+			$serializedValue = $this->$method($value);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
@@ -93,7 +93,7 @@ 
 	 * @param string $string any value that shall simply be serialized to itself
 	 * @return string that same value, unchanged
 	 */
-	private function serializeStringByIdentity( string $string ): string {
+	private function serializeStringByIdentity(string $string): string {
 		return $string;
 	}
 
@@ -101,8 +101,8 @@ 
 	 * @param string[] $strings
 	 * @return string[]
 	 */
-	private function serializeStringListByIdentity( array $strings ): array {
-		Assert::parameterElementType( 'string', $strings, '$strings' );
+	private function serializeStringListByIdentity(array $strings): array {
+		Assert::parameterElementType('string', $strings, '$strings');
 		return $strings;
 	}
 
@@ -110,7 +110,7 @@ 
 	 * @param EntityId $entityId
 	 * @return string entity ID serialization
 	 */
-	private function serializeEntityId( EntityId $entityId ): string {
+	private function serializeEntityId(EntityId $entityId): string {
 		return $entityId->getSerialization();
 	}
 
@@ -118,8 +118,8 @@ 
 	 * @param EntityId[] $entityIdList
 	 * @return string[] entity ID serializations
 	 */
-	private function serializeEntityIdList( array $entityIdList ): array {
-		return array_map( [ $this, 'serializeEntityId' ], $entityIdList );
+	private function serializeEntityIdList(array $entityIdList): array {
+		return array_map([$this, 'serializeEntityId'], $entityIdList);
 	}
 
 	/**
@@ -127,10 +127,10 @@ 
 	 * @return string entity ID serialization, '::somevalue', or '::novalue'
 	 * (according to EntityId::PATTERN, entity ID serializations can never begin with two colons)
 	 */
-	private function serializeItemIdSnakValue( ItemIdSnakValue $value ): string {
-		switch ( true ) {
+	private function serializeItemIdSnakValue(ItemIdSnakValue $value): string {
+		switch (true) {
 			case $value->isValue():
-				return $this->serializeEntityId( $value->getItemId() );
+				return $this->serializeEntityId($value->getItemId());
 			case $value->isSomeValue():
 				return '::somevalue';
 			case $value->isNoValue():
@@ -148,15 +148,15 @@ 
 	 * @param ItemIdSnakValue[] $valueList
 	 * @return string[] array of entity ID serializations, '::somevalue's or '::novalue's
 	 */
-	private function serializeItemIdSnakValueList( array $valueList ): array {
-		return array_map( [ $this, 'serializeItemIdSnakValue' ], $valueList );
+	private function serializeItemIdSnakValueList(array $valueList): array {
+		return array_map([$this, 'serializeItemIdSnakValue'], $valueList);
 	}
 
 	/**
 	 * @param DataValue $dataValue
 	 * @return array the data value in array form
 	 */
-	private function serializeDataValue( DataValue $dataValue ): array {
+	private function serializeDataValue(DataValue $dataValue): array {
 		return $dataValue->toArray();
 	}
 
@@ -164,8 +164,8 @@ 
 	 * @param string $contextType one of the Context::TYPE_* constants
 	 * @return string the abbreviated context type
 	 */
-	private function serializeContextType( string $contextType ): string {
-		switch ( $contextType ) {
+	private function serializeContextType(string $contextType): string {
+		switch ($contextType) {
 			case Context::TYPE_STATEMENT:
 				return 's';
 			case Context::TYPE_QUALIFIER:
@@ -175,7 +175,7 @@ 
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					'Unknown context type ' . $contextType
+					'Unknown context type '.$contextType
 				);
 				// @codeCoverageIgnoreEnd
 		}
@@ -185,15 +185,15 @@ 
 	 * @param string[] $contextTypeList Context::TYPE_* constants
 	 * @return string[] abbreviated context types
 	 */
-	private function serializeContextTypeList( array $contextTypeList ): array {
-		return array_map( [ $this, 'serializeContextType' ], $contextTypeList );
+	private function serializeContextTypeList(array $contextTypeList): array {
+		return array_map([$this, 'serializeContextType'], $contextTypeList);
 	}
 
 	/**
 	 * @param MultilingualTextValue $text
 	 * @return mixed {@see MultilingualTextValue::getArrayValue}
 	 */
-	private function serializeMultilingualText( MultilingualTextValue $text ) {
+	private function serializeMultilingualText(MultilingualTextValue $text) {
 		return $text->getArrayValue();
 	}
 

src/Api/ExpiryLock.php

Spacing +18 added lines, -18 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\Api;
 
@@ -21,7 +21,7 @@ 
 
 	private BagOStuff $cache;
 
-	public function __construct( BagOStuff $cache ) {
+	public function __construct(BagOStuff $cache) {
 		$this->cache = $cache;
 	}
 
@@ -32,9 +32,9 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	private function makeKey( string $id ): string {
-		if ( trim( $id ) === '' ) {
-			throw new ParameterTypeException( '$id', 'non-empty string' );
+	private function makeKey(string $id): string {
+		if (trim($id) === '') {
+			throw new ParameterTypeException('$id', 'non-empty string');
 		}
 
 		return $this->cache->makeKey(
@@ -52,15 +52,15 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	public function lock( string $id, ConvertibleTimestamp $expiryTimestamp ): bool {
+	public function lock(string $id, ConvertibleTimestamp $expiryTimestamp): bool {
 
-		$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;
@@ -74,20 +74,20 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	private function isLockedInternal( string $cacheId ): bool {
-		$expiryTime = $this->cache->get( $cacheId );
-		if ( !$expiryTime ) {
+	private function isLockedInternal(string $cacheId): bool {
+		$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;
@@ -101,8 +101,8 @@ 
 	 *
 	 * @throws \Wikimedia\Assert\ParameterTypeException
 	 */
-	public function isLocked( string $id ): bool {
-		return $this->isLockedInternal( $this->makeKey( $id ) );
+	public function isLocked(string $id): bool {
+		return $this->isLockedInternal($this->makeKey($id));
 	}
 
 }

src/ConstraintCheck/Helper/SparqlHelper.php

Spacing +184 added lines, -187 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Helper;
 
@@ -146,73 +146,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->primaryEndpoint = $config->get( 'WBQualityConstraintsSparqlEndpoint' );
-		$this->additionalEndpoints = $config->get( 'WBQualityConstraintsAdditionalSparqlEndpoints' ) ?: [];
-		$this->maxQueryTimeMillis = $config->get( 'WBQualityConstraintsSparqlMaxMillis' );
-		$this->subclassOfId = $config->get( 'WBQualityConstraintsSubclassOfId' );
-		$this->cacheMapSize = $config->get( 'WBQualityConstraintsFormatCacheMapSize' );
+		$this->primaryEndpoint = $config->get('WBQualityConstraintsSparqlEndpoint');
+		$this->additionalEndpoints = $config->get('WBQualityConstraintsAdditionalSparqlEndpoints') ?: [];
+		$this->maxQueryTimeMillis = $config->get('WBQualityConstraintsSparqlMaxMillis');
+		$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 ): string {
+	private function getQueryPrefixes(RdfVocabulary $rdfVocabulary): string {
 		// TODO: it would probably be smarter that RdfVocabulary 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;
 	}
@@ -224,21 +224,20 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function hasType( string $id, array $classes ): CachedBool {
+	public function hasType(string $id, array $classes): CachedBool {
 		// 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 {
@@ -248,19 +247,19 @@ 
 }
 EOF;
 
-			$result = $this->runQuery( $query, $this->primaryEndpoint );
+			$result = $this->runQuery($query, $this->primaryEndpoint);
 			$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)
 		);
 	}
 
@@ -268,7 +267,7 @@ 
 	 * Helper function used by findEntitiesWithSameStatement to filter
 	 * out entities with different qualifiers or no qualifier value.
 	 */
-	private function nestedSeparatorFilter( PropertyId $separator ): string {
+	private function nestedSeparatorFilter(PropertyId $separator): string {
 		$filter = <<<EOF
   MINUS {
     ?statement pq:$separator ?qualifier.
@@ -305,14 +304,14 @@ 
 	 * @return CachedEntityIds
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function findEntitiesWithSameStatement( Statement $statement, array $separators ): CachedEntityIds {
+	public function findEntitiesWithSameStatement(Statement $statement, array $separators): CachedEntityIds {
 		$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 {
@@ -330,12 +329,12 @@ 
 LIMIT 10
 EOF;
 
-		$results = [ $this->runQuery( $query, $this->primaryEndpoint ) ];
-		foreach ( $this->additionalEndpoints as $endpoint ) {
-			$results[] = $this->runQuery( $query, $endpoint );
+		$results = [$this->runQuery($query, $this->primaryEndpoint)];
+		foreach ($this->additionalEndpoints as $endpoint) {
+			$results[] = $this->runQuery($query, $endpoint);
 		}
 
-		return $this->getOtherEntities( $results );
+		return $this->getOtherEntities($results);
 	}
 
 	/**
@@ -360,16 +359,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;
@@ -389,19 +387,19 @@ 
 LIMIT 10
 EOF;
 
-		$results = [ $this->runQuery( $query, $this->primaryEndpoint ) ];
-		foreach ( $this->additionalEndpoints as $endpoint ) {
-			$results[] = $this->runQuery( $query, $endpoint );
+		$results = [$this->runQuery($query, $this->primaryEndpoint)];
+		foreach ($this->additionalEndpoints as $endpoint) {
+			$results[] = $this->runQuery($query, $endpoint);
 		}
 
-		return $this->getOtherEntities( $results );
+		return $this->getOtherEntities($results);
 	}
 
 	/**
 	 * Return SPARQL code for a string literal with $text as content.
 	 */
-	private function stringLiteral( string $text ): string {
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
+	private function stringLiteral(string $text): string {
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
 	}
 
 	/**
@@ -411,26 +409,26 @@ 
 	 *
 	 * @return CachedEntityIds
 	 */
-	private function getOtherEntities( array $results ): CachedEntityIds {
+	private function getOtherEntities(array $results): CachedEntityIds {
 		$allResultBindings = [];
 		$metadatas = [];
 
-		foreach ( $results as $result ) {
+		foreach ($results as $result) {
 			$metadatas[] = $result->getMetadata();
-			$allResultBindings = array_merge( $allResultBindings, $result->getArray()['results']['bindings'] );
+			$allResultBindings = array_merge($allResultBindings, $result->getArray()['results']['bindings']);
 		}
 
 		$entityIds = array_map(
-			function ( $resultBindings ) {
+			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
 						}
 					}
@@ -444,8 +442,8 @@ 
 		);
 
 		return new CachedEntityIds(
-			array_values( array_filter( array_unique( $entityIds ) ) ),
-			Metadata::merge( $metadatas )
+			array_values(array_filter(array_unique($entityIds))),
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -456,50 +454,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( string $dataType, DataValue $dataValue ): array {
-		switch ( $dataType ) {
+	private function getRdfLiteral(string $dataType, DataValue $dataValue): array {
+		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
@@ -508,43 +506,43 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpression( string $text, string $regex ): bool {
+	public function matchesRegularExpression(string $text, string $regex): bool {
 		// 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();
 					}
@@ -568,42 +566,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: ' . get_debug_type( $matches ) . ')'
+					'Value of unknown type in object cache ('.
+					'cache key: '.$cacheKey.', '.
+					'cache map key: '.$textHash.', '.
+					'value type: '.get_debug_type($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 ): array {
+	private function serializeConstraintParameterException(ConstraintParameterException $cpe): array {
 		return [
 			'type' => ConstraintParameterException::class,
-			'violationMessage' => $this->violationMessageSerializer->serialize( $cpe->getViolationMessage() ),
+			'violationMessage' => $this->violationMessageSerializer->serialize($cpe->getViolationMessage()),
 		];
 	}
 
-	private function deserializeConstraintParameterException( array $serialization ): ConstraintParameterException {
+	private function deserializeConstraintParameterException(array $serialization): ConstraintParameterException {
 		$message = $this->violationMessageDeserializer->deserialize(
 			$serialization['violationMessage']
 		);
-		return new ConstraintParameterException( $message );
+		return new ConstraintParameterException($message);
 	}
 
 	/**
@@ -613,25 +611,25 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpressionWithSparql( string $text, string $regex ): bool {
-		$textStringLiteral = $this->stringLiteral( $text );
-		$regexStringLiteral = $this->stringLiteral( '^(?:' . $regex . ')$' );
+	public function matchesRegularExpressionWithSparql(string $text, string $regex): bool {
+		$textStringLiteral = $this->stringLiteral($text);
+		$regexStringLiteral = $this->stringLiteral('^(?:'.$regex.')$');
 
 		$query = <<<EOF
 SELECT (REGEX($textStringLiteral, $regexStringLiteral) AS ?matches) {}
 EOF;
 
-		$result = $this->runQuery( $query, $this->primaryEndpoint, false );
+		$result = $this->runQuery($query, $this->primaryEndpoint, 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)
 			);
 		}
 	}
@@ -639,14 +637,14 @@ 
 	/**
 	 * Check whether the text content of an error response indicates a query timeout.
 	 */
-	public function isTimeout( string $responseContent ): bool {
-		$timeoutRegex = implode( '|', array_map(
-			static function ( $fqn ) {
-				return preg_quote( $fqn, '/' );
+	public function isTimeout(string $responseContent): bool {
+		$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);
 	}
 
 	/**
@@ -658,17 +656,17 @@ 
 	 * @return int|boolean the max-age (in seconds)
 	 * or a plain boolean if no max-age can be determined
 	 */
-	public function getCacheMaxAge( array $responseHeaders ) {
+	public function getCacheMaxAge(array $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;
 			}
@@ -689,34 +687,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));
 	}
 
 	/**
@@ -731,64 +729,63 @@ 
 	 *
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	protected function runQuery( string $query, string $endpoint, bool $needsPrefixes = true ): CachedQueryResults {
-		if ( $this->throttlingLock->isLocked( self::EXPIRY_LOCK_ID ) ) {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
+	protected function runQuery(string $query, string $endpoint, bool $needsPrefixes = true): CachedQueryResults {
+		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 = $endpoint . '?' . http_build_query(
+		$url = $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 {
@@ -805,9 +802,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'
 			);
@@ -822,29 +819,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/ServiceWiring-Wikibase.php

Spacing +6 added lines, -6 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport;
 
@@ -11,16 +11,16 @@ 
 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)
 		);
 	},
 ];

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(
-			WikibaseRepo::getPropertyDataTypeLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services )
+			WikibaseRepo::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/ConstraintCheck/Message/MultilingualTextViolationMessageRenderer.php

Spacing +21 added lines, -21 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Message;
 
@@ -28,13 +28,13 @@ 
 		'wbqc-violation-message-format-clarification' => 'wbqc-violation-message-format',
 	];
 
-	public function render( ViolationMessage $violationMessage ): string {
-		if ( !array_key_exists( $violationMessage->getMessageKey(), self::ALTERNATIVE_MESSAGE_KEYS ) ) {
-			return parent::render( $violationMessage );
+	public function render(ViolationMessage $violationMessage): string {
+		if (!array_key_exists($violationMessage->getMessageKey(), self::ALTERNATIVE_MESSAGE_KEYS)) {
+			return parent::render($violationMessage);
 		}
 
 		$arguments = $violationMessage->getArguments();
-		$multilingualTextArgument = array_pop( $arguments );
+		$multilingualTextArgument = array_pop($arguments);
 		$multilingualTextParams = $this->renderMultilingualText(
 			// @phan-suppress-next-line PhanTypeArraySuspiciousNullable TODO Ensure this is not an actual issue
 			$multilingualTextArgument['value'],
@@ -42,22 +42,22 @@ 
 			$multilingualTextArgument['role']
 		);
 
-		$paramsLists = [ [] ];
-		foreach ( $arguments as $argument ) {
-			$paramsLists[] = $this->renderArgument( $argument );
+		$paramsLists = [[]];
+		foreach ($arguments as $argument) {
+			$paramsLists[] = $this->renderArgument($argument);
 		}
-		$regularParams = call_user_func_array( 'array_merge', $paramsLists );
+		$regularParams = call_user_func_array('array_merge', $paramsLists);
 
-		if ( $multilingualTextParams === null ) {
+		if ($multilingualTextParams === null) {
 			return $this->messageLocalizer
-				->msg( self::ALTERNATIVE_MESSAGE_KEYS[$violationMessage->getMessageKey()] )
-				->params( $regularParams )
+				->msg(self::ALTERNATIVE_MESSAGE_KEYS[$violationMessage->getMessageKey()])
+				->params($regularParams)
 				->escaped();
 		} else {
 			return $this->messageLocalizer
-				->msg( $violationMessage->getMessageKey() )
-				->params( $regularParams )
-				->params( $multilingualTextParams )
+				->msg($violationMessage->getMessageKey())
+				->params($regularParams)
+				->params($multilingualTextParams)
 				->escaped();
 		}
 	}
@@ -68,14 +68,14 @@ 
 	 * @return MessageParam[]|null list of parameters as accepted by Message::params(),
 	 * or null if the text is not available in the user’s language
 	 */
-	protected function renderMultilingualText( MultilingualTextValue $text, ?string $role ): ?array {
+	protected function renderMultilingualText(MultilingualTextValue $text, ?string $role): ?array {
 		$texts = $text->getTexts();
-		foreach ( $this->languageFallbackChain->getFetchLanguageCodes() as $languageCode ) {
-			if ( array_key_exists( $languageCode, $texts ) ) {
-				return [ Message::rawParam( $this->addRole(
-					htmlspecialchars( $texts[$languageCode]->getText() ),
+		foreach ($this->languageFallbackChain->getFetchLanguageCodes() as $languageCode) {
+			if (array_key_exists($languageCode, $texts)) {
+				return [Message::rawParam($this->addRole(
+					htmlspecialchars($texts[$languageCode]->getText()),
 					$role
-				) ) ];
+				))];
 			}
 		}
 

src/ConstraintCheck/Message/ViolationMessageRenderer.php

Spacing +87 added lines, -87 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Message;
 
@@ -67,17 +67,17 @@ 
 		$this->maxListLength = $maxListLength;
 	}
 
-	public function render( ViolationMessage $violationMessage ): string {
+	public function render(ViolationMessage $violationMessage): string {
 		$messageKey = $violationMessage->getMessageKey();
-		$paramsLists = [ [] ];
-		foreach ( $violationMessage->getArguments() as $argument ) {
-			$params = $this->renderArgument( $argument );
+		$paramsLists = [[]];
+		foreach ($violationMessage->getArguments() as $argument) {
+			$params = $this->renderArgument($argument);
 			$paramsLists[] = $params;
 		}
-		$allParams = call_user_func_array( 'array_merge', $paramsLists );
+		$allParams = call_user_func_array('array_merge', $paramsLists);
 		return $this->messageLocalizer
-			->msg( $messageKey )
-			->params( $allParams )
+			->msg($messageKey)
+			->params($allParams)
 			->escaped();
 	}
 
@@ -86,13 +86,13 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return string HTML
 	 */
-	protected function addRole( string $value, ?string $role ): string {
-		if ( $role === null ) {
+	protected function addRole(string $value, ?string $role): string {
+		if ($role === null) {
 			return $value;
 		}
 
-		return '<span class="wbqc-role wbqc-role-' . htmlspecialchars( $role ) . '">' .
-			$value .
+		return '<span class="wbqc-role wbqc-role-'.htmlspecialchars($role).'">'.
+			$value.
 			'</span>';
 	}
 
@@ -100,15 +100,15 @@ 
 	 * @param string $key message key
 	 * @return string HTML
 	 */
-	protected function msgEscaped( string $key ): string {
-		return $this->messageLocalizer->msg( $key )->escaped();
+	protected function msgEscaped(string $key): string {
+		return $this->messageLocalizer->msg($key)->escaped();
 	}
 
 	/**
 	 * @param array $argument
 	 * @return MessageParam[] params (for Message::params)
 	 */
-	protected function renderArgument( array $argument ): array {
+	protected function renderArgument(array $argument): array {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'renderEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'renderEntityIdList',
@@ -129,12 +129,12 @@ 
 		$value = $argument['value'];
 		$role = $argument['role'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$params = $this->$method( $value, $role );
+			$params = $this->$method($value, $role);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
@@ -148,36 +148,36 @@ 
 	 * and return a single-element array with a raw message param (i. e. [ Message::rawParam( … ) ])
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderList( array $list, ?string $role, callable $render ): array {
-		if ( $list === [] ) {
+	private function renderList(array $list, ?string $role, callable $render): array {
+		if ($list === []) {
 			return [
-				Message::numParam( 0 ),
-				Message::rawParam( '<ul></ul>' ),
+				Message::numParam(0),
+				Message::rawParam('<ul></ul>'),
 			];
 		}
 
-		if ( count( $list ) > $this->maxListLength ) {
-			$list = array_slice( $list, 0, $this->maxListLength );
+		if (count($list) > $this->maxListLength) {
+			$list = array_slice($list, 0, $this->maxListLength);
 			$truncated = true;
 		}
 
 		$renderedParamsLists = array_map(
 			$render,
 			$list,
-			array_fill( 0, count( $list ), $role )
+			array_fill(0, count($list), $role)
 		);
-		$renderedParams = array_column( $renderedParamsLists, 0 );
-		$renderedElements = array_map( fn ( MessageParam $msg ) => $msg->getValue(), $renderedParams );
-		if ( isset( $truncated ) ) {
-			$renderedElements[] = $this->msgEscaped( 'ellipsis' );
+		$renderedParams = array_column($renderedParamsLists, 0);
+		$renderedElements = array_map(fn (MessageParam $msg) => $msg->getValue(), $renderedParams);
+		if (isset($truncated)) {
+			$renderedElements[] = $this->msgEscaped('ellipsis');
 		}
 
 		return array_merge(
 			[
-				Message::numParam( count( $list ) ),
+				Message::numParam(count($list)),
 				Message::rawParam(
-					'<ul><li>' .
-					implode( '</li><li>', $renderedElements ) .
+					'<ul><li>'.
+					implode('</li><li>', $renderedElements).
 					'</li></ul>'
 				),
 			],
@@ -190,11 +190,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderEntityId( EntityId $entityId, ?string $role ): array {
-		return [ Message::rawParam( $this->addRole(
-			$this->entityIdFormatter->formatEntityId( $entityId ),
+	private function renderEntityId(EntityId $entityId, ?string $role): array {
+		return [Message::rawParam($this->addRole(
+			$this->entityIdFormatter->formatEntityId($entityId),
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -202,8 +202,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderEntityIdList( array $entityIdList, ?string $role ): array {
-		return $this->renderList( $entityIdList, $role, [ $this, 'renderEntityId' ] );
+	private function renderEntityIdList(array $entityIdList, ?string $role): array {
+		return $this->renderList($entityIdList, $role, [$this, 'renderEntityId']);
 	}
 
 	/**
@@ -211,24 +211,24 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderItemIdSnakValue( ItemIdSnakValue $value, ?string $role ): array {
-		switch ( true ) {
+	private function renderItemIdSnakValue(ItemIdSnakValue $value, ?string $role): array {
+		switch (true) {
 			case $value->isValue():
-				return $this->renderEntityId( $value->getItemId(), $role );
+				return $this->renderEntityId($value->getItemId(), $role);
 			case $value->isSomeValue():
-				return [ Message::rawParam( $this->addRole(
-					'<span class="wikibase-snakview-variation-somevaluesnak">' .
-						$this->msgEscaped( 'wikibase-snakview-snaktypeselector-somevalue' ) .
+				return [Message::rawParam($this->addRole(
+					'<span class="wikibase-snakview-variation-somevaluesnak">'.
+						$this->msgEscaped('wikibase-snakview-snaktypeselector-somevalue').
 						'</span>',
 					$role
-				) ) ];
+				))];
 			case $value->isNoValue():
-				return [ Message::rawParam( $this->addRole(
-					'<span class="wikibase-snakview-variation-novaluesnak">' .
-					$this->msgEscaped( 'wikibase-snakview-snaktypeselector-novalue' ) .
+				return [Message::rawParam($this->addRole(
+					'<span class="wikibase-snakview-variation-novaluesnak">'.
+					$this->msgEscaped('wikibase-snakview-snaktypeselector-novalue').
 						'</span>',
 					$role
-				) ) ];
+				))];
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
@@ -243,8 +243,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderItemIdSnakValueList( array $valueList, ?string $role ): array {
-		return $this->renderList( $valueList, $role, [ $this, 'renderItemIdSnakValue' ] );
+	private function renderItemIdSnakValueList(array $valueList, ?string $role): array {
+		return $this->renderList($valueList, $role, [$this, 'renderItemIdSnakValue']);
 	}
 
 	/**
@@ -252,11 +252,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderDataValue( DataValue $dataValue, ?string $role ): array {
-		return [ Message::rawParam( $this->addRole(
-			$this->dataValueFormatter->format( $dataValue ),
+	private function renderDataValue(DataValue $dataValue, ?string $role): array {
+		return [Message::rawParam($this->addRole(
+			$this->dataValueFormatter->format($dataValue),
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -264,7 +264,7 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderDataValueType( string $dataValueType, ?string $role ): array {
+	private function renderDataValueType(string $dataValueType, ?string $role): array {
 		$messageKeys = [
 			'string' => 'datatypes-type-string',
 			'monolingualtext' => 'datatypes-type-monolingualtext',
@@ -273,15 +273,15 @@ 
 			'wikibase-entityid' => 'wbqc-dataValueType-wikibase-entityid',
 		];
 
-		if ( array_key_exists( $dataValueType, $messageKeys ) ) {
-			return [ Message::rawParam( $this->addRole(
-				$this->msgEscaped( $messageKeys[$dataValueType] ),
+		if (array_key_exists($dataValueType, $messageKeys)) {
+			return [Message::rawParam($this->addRole(
+				$this->msgEscaped($messageKeys[$dataValueType]),
 				$role
-			) ) ];
+			))];
 		} else {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'Unknown data value type ' . $dataValueType
+				'Unknown data value type '.$dataValueType
 			);
 			// @codeCoverageIgnoreEnd
 		}
@@ -292,11 +292,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderInlineCode( string $code, ?string $role ): array {
-		return [ Message::rawParam( $this->addRole(
-			'<code>' . htmlspecialchars( $code ) . '</code>',
+	private function renderInlineCode(string $code, ?string $role): array {
+		return [Message::rawParam($this->addRole(
+			'<code>'.htmlspecialchars($code).'</code>',
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -304,8 +304,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderConstraintScope( string $scope, ?string $role ): array {
-		switch ( $scope ) {
+	private function renderConstraintScope(string $scope, ?string $role): array {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
 				$itemId = $this->config->get(
 					'WBQualityConstraintsConstraintCheckedOnMainValueId'
@@ -325,10 +325,10 @@ 
 				// callers should never let this happen, but if it does happen,
 				// showing “unknown value” seems reasonable
 				// @codeCoverageIgnoreStart
-				return $this->renderItemIdSnakValue( ItemIdSnakValue::someValue(), $role );
+				return $this->renderItemIdSnakValue(ItemIdSnakValue::someValue(), $role);
 				// @codeCoverageIgnoreEnd
 		}
-		return $this->renderEntityId( new ItemId( $itemId ), $role );
+		return $this->renderEntityId(new ItemId($itemId), $role);
 	}
 
 	/**
@@ -336,8 +336,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderConstraintScopeList( array $scopeList, ?string $role ): array {
-		return $this->renderList( $scopeList, $role, [ $this, 'renderConstraintScope' ] );
+	private function renderConstraintScopeList(array $scopeList, ?string $role): array {
+		return $this->renderList($scopeList, $role, [$this, 'renderConstraintScope']);
 	}
 
 	/**
@@ -345,25 +345,25 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderPropertyScope( string $scope, ?string $role ): array {
-		switch ( $scope ) {
+	private function renderPropertyScope(string $scope, ?string $role): array {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsMainValueId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsMainValueId');
 				break;
 			case Context::TYPE_QUALIFIER:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsQualifiersId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsQualifiersId');
 				break;
 			case Context::TYPE_REFERENCE:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsReferencesId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsReferencesId');
 				break;
 			default:
 				// callers should never let this happen, but if it does happen,
 				// showing “unknown value” seems reasonable
 				// @codeCoverageIgnoreStart
-				return $this->renderItemIdSnakValue( ItemIdSnakValue::someValue(), $role );
+				return $this->renderItemIdSnakValue(ItemIdSnakValue::someValue(), $role);
 				// @codeCoverageIgnoreEnd
 		}
-		return $this->renderEntityId( new ItemId( $itemId ), $role );
+		return $this->renderEntityId(new ItemId($itemId), $role);
 	}
 
 	/**
@@ -371,8 +371,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderPropertyScopeList( array $scopeList, ?string $role ): array {
-		return $this->renderList( $scopeList, $role, [ $this, 'renderPropertyScope' ] );
+	private function renderPropertyScopeList(array $scopeList, ?string $role): array {
+		return $this->renderList($scopeList, $role, [$this, 'renderPropertyScope']);
 	}
 
 	/**
@@ -380,14 +380,14 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderLanguage( string $languageCode, ?string $role ): array {
+	private function renderLanguage(string $languageCode, ?string $role): array {
 		return [
 			// ::renderList (through ::renderLanguageList) requires 'raw' parameter
 			// so we effectively build Message::plaintextParam here
-			Message::rawParam( htmlspecialchars(
-				$this->languageNameUtils->getLanguageName( $languageCode, $this->userLanguageCode )
-			) ),
-			Message::plaintextParam( $languageCode ),
+			Message::rawParam(htmlspecialchars(
+				$this->languageNameUtils->getLanguageName($languageCode, $this->userLanguageCode)
+			)),
+			Message::plaintextParam($languageCode),
 		];
 	}
 
@@ -396,8 +396,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return MessageParam[] list of parameters as accepted by Message::params()
 	 */
-	private function renderLanguageList( array $languageCodes, ?string $role ): array {
-		return $this->renderList( $languageCodes, $role, [ $this, 'renderLanguage' ] );
+	private function renderLanguageList(array $languageCodes, ?string $role): array {
+		return $this->renderList($languageCodes, $role, [$this, 'renderLanguage']);
 	}
 
 }