wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Cache/CachedEntityIds.php

Spacing +1 added lines, -1 removed lines

@@ -1,6 +1,6 @@
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Cache;
 

src/WikibaseQualityConstraintsSchemaHooks.php

Spacing +3 added lines, -3 removed lines

@@ -15,12 +15,12 @@
 	/**
 	 * @param DatabaseUpdater $updater
 	 */
-	public function onLoadExtensionSchemaUpdates( $updater ) {
-		$dir = dirname( __DIR__ ) . '/sql/';
+	public function onLoadExtensionSchemaUpdates($updater) {
+		$dir = dirname(__DIR__).'/sql/';
 
 		$updater->addExtensionTable(
 			'wbqc_constraints',
-			$dir . "/{$updater->getDB()->getType()}/tables-generated.sql"
+			$dir."/{$updater->getDB()->getType()}/tables-generated.sql"
 		);
 	}
 

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/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/DelegatingConstraintChecker.php

Spacing +167 added lines, -167 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck;
 
@@ -123,10 +123,10 @@ 
 		?callable $defaultResultsPerEntity = null
 	): array {
 		$checkResults = [];
-		$entity = $this->entityLookup->getEntity( $entityId );
+		$entity = $this->entityLookup->getEntity($entityId);
 
-		if ( $entity instanceof StatementListProvidingEntity ) {
-			$startTime = microtime( true );
+		if ($entity instanceof StatementListProvidingEntity) {
+			$startTime = microtime(true);
 
 			$checkResults = $this->checkEveryStatement(
 				$entity,
@@ -134,9 +134,9 @@ 
 				$defaultResultsPerContext
 			);
 
-			$endTime = microtime( true );
+			$endTime = microtime(true);
 
-			if ( $constraintIds === null ) { // only log full constraint checks
+			if ($constraintIds === null) { // only log full constraint checks
 				$this->loggingHelper->logConstraintCheckOnEntity(
 					$entityId,
 					$checkResults,
@@ -146,11 +146,11 @@ 
 			}
 		}
 
-		if ( $defaultResultsPerEntity !== null ) {
-			$checkResults = array_merge( $defaultResultsPerEntity( $entityId ), $checkResults );
+		if ($defaultResultsPerEntity !== null) {
+			$checkResults = array_merge($defaultResultsPerEntity($entityId), $checkResults);
 		}
 
-		return $this->sortResult( $checkResults );
+		return $this->sortResult($checkResults);
 	}
 
 	/**
@@ -172,19 +172,19 @@ 
 		?callable $defaultResults = null
 	): array {
 
-		$parsedGuid = $this->statementGuidParser->parse( $guid );
+		$parsedGuid = $this->statementGuidParser->parse($guid);
 		$entityId = $parsedGuid->getEntityId();
-		$entity = $this->entityLookup->getEntity( $entityId );
-		if ( $entity instanceof StatementListProvidingEntity ) {
-			$statement = $entity->getStatements()->getFirstStatementWithGuid( $guid );
-			if ( $statement ) {
+		$entity = $this->entityLookup->getEntity($entityId);
+		if ($entity instanceof StatementListProvidingEntity) {
+			$statement = $entity->getStatements()->getFirstStatementWithGuid($guid);
+			if ($statement) {
 				$result = $this->checkStatement(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResults
 				);
-				$output = $this->sortResult( $result );
+				$output = $this->sortResult($result);
 				return $output;
 			}
 		}
@@ -192,8 +192,8 @@ 
 		return [];
 	}
 
-	private function getValidContextTypes( Constraint $constraint ): array {
-		if ( !array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+	private function getValidContextTypes(Constraint $constraint): array {
+		if (!array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 			return [
 				Context::TYPE_STATEMENT,
 				Context::TYPE_QUALIFIER,
@@ -201,21 +201,21 @@ 
 			];
 		}
 
-		return array_keys( array_filter(
+		return array_keys(array_filter(
 			$this->checkerMap[$constraint->getConstraintTypeItemId()]->getSupportedContextTypes(),
-			static fn ( $status ) => $status !== CheckResult::STATUS_NOT_IN_SCOPE
-		) );
+			static fn ($status) => $status !== CheckResult::STATUS_NOT_IN_SCOPE
+		));
 	}
 
-	private function getValidEntityTypes( Constraint $constraint ): array {
-		if ( !array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
-			return array_keys( ConstraintChecker::ALL_ENTITY_TYPES_SUPPORTED );
+	private function getValidEntityTypes(Constraint $constraint): array {
+		if (!array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
+			return array_keys(ConstraintChecker::ALL_ENTITY_TYPES_SUPPORTED);
 		}
 
-		return array_keys( array_filter(
+		return array_keys(array_filter(
 			$this->checkerMap[$constraint->getConstraintTypeItemId()]->getSupportedEntityTypes(),
-			static fn ( $status ) => $status !== CheckResult::STATUS_NOT_IN_SCOPE
-		) );
+			static fn ($status) => $status !== CheckResult::STATUS_NOT_IN_SCOPE
+		));
 	}
 
 	/**
@@ -226,38 +226,38 @@ 
 	 *
 	 * @return ConstraintParameterException[]
 	 */
-	private function checkCommonConstraintParameters( Constraint $constraint ): array {
+	private function checkCommonConstraintParameters(Constraint $constraint): array {
 		$constraintParameters = $constraint->getConstraintParameters();
 		try {
-			$this->constraintParameterParser->checkError( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
-			return [ $e ];
+			$this->constraintParameterParser->checkError($constraintParameters);
+		} catch (ConstraintParameterException $e) {
+			return [$e];
 		}
 
 		$problems = [];
 		try {
-			$this->constraintParameterParser->parseExceptionParameter( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseExceptionParameter($constraintParameters);
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		try {
-			$this->constraintParameterParser->parseConstraintClarificationParameter( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseConstraintClarificationParameter($constraintParameters);
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		try {
-			$this->constraintParameterParser->parseConstraintStatusParameter( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseConstraintStatusParameter($constraintParameters);
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		try {
 			$this->constraintParameterParser->parseConstraintScopeParameters(
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId(),
-				$this->getValidContextTypes( $constraint ),
-				$this->getValidEntityTypes( $constraint )
+				$this->getValidContextTypes($constraint),
+				$this->getValidEntityTypes($constraint)
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		return $problems;
@@ -270,16 +270,16 @@ 
 	 * @return ConstraintParameterException[][] first level indexed by constraint ID,
 	 * second level like checkConstraintParametersOnConstraintId (but without possibility of null)
 	 */
-	public function checkConstraintParametersOnPropertyId( NumericPropertyId $propertyId ): array {
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
+	public function checkConstraintParametersOnPropertyId(NumericPropertyId $propertyId): array {
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
 		$result = [];
 
-		foreach ( $constraints as $constraint ) {
-			$problems = $this->checkCommonConstraintParameters( $constraint );
+		foreach ($constraints as $constraint) {
+			$problems = $this->checkCommonConstraintParameters($constraint);
 
-			if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+			if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 				$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
-				$problems = array_merge( $problems, $checker->checkConstraintParameters( $constraint ) );
+				$problems = array_merge($problems, $checker->checkConstraintParameters($constraint));
 			}
 
 			$result[$constraint->getConstraintId()] = $problems;
@@ -296,18 +296,18 @@ 
 	 * @return ConstraintParameterException[]|null list of constraint parameter exceptions
 	 * (empty means all parameters okay), or null if constraint is not found
 	 */
-	public function checkConstraintParametersOnConstraintId( string $constraintId ): ?array {
-		$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
+	public function checkConstraintParametersOnConstraintId(string $constraintId): ?array {
+		$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
 		'@phan-var NumericPropertyId $propertyId';
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
 
-		foreach ( $constraints as $constraint ) {
-			if ( $constraint->getConstraintId() === $constraintId ) {
-				$problems = $this->checkCommonConstraintParameters( $constraint );
+		foreach ($constraints as $constraint) {
+			if ($constraint->getConstraintId() === $constraintId) {
+				$problems = $this->checkCommonConstraintParameters($constraint);
 
-				if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+				if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 					$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
-					$problems = array_merge( $problems, $checker->checkConstraintParameters( $constraint ) );
+					$problems = array_merge($problems, $checker->checkConstraintParameters($constraint));
 				}
 
 				return $problems;
@@ -332,14 +332,14 @@ 
 		$result = [];
 
 		/** @var Statement $statement */
-		foreach ( $entity->getStatements() as $statement ) {
-			$result = array_merge( $result,
+		foreach ($entity->getStatements() as $statement) {
+			$result = array_merge($result,
 				$this->checkStatement(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResultsPerContext
-				) );
+				));
 		}
 
 		return $result;
@@ -361,32 +361,32 @@ 
 	): array {
 		$result = [];
 
-		$result = array_merge( $result,
+		$result = array_merge($result,
 			$this->checkConstraintsForMainSnak(
 				$entity,
 				$statement,
 				$constraintIds,
 				$defaultResultsPerContext
-			) );
+			));
 
-		if ( $this->checkQualifiers ) {
-			$result = array_merge( $result,
+		if ($this->checkQualifiers) {
+			$result = array_merge($result,
 				$this->checkConstraintsForQualifiers(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResultsPerContext
-				) );
+				));
 		}
 
-		if ( $this->checkReferences ) {
-			$result = array_merge( $result,
+		if ($this->checkReferences) {
+			$result = array_merge($result,
 				$this->checkConstraintsForReferences(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResultsPerContext
-				) );
+				));
 		}
 
 		return $result;
@@ -401,17 +401,17 @@ 
 	 * @param string[]|null $constraintIds
 	 * @return Constraint[]
 	 */
-	private function getConstraintsToUse( PropertyId $propertyId, ?array $constraintIds ): array {
-		if ( !( $propertyId instanceof NumericPropertyId ) ) {
+	private function getConstraintsToUse(PropertyId $propertyId, ?array $constraintIds): array {
+		if (!($propertyId instanceof NumericPropertyId)) {
 			throw new InvalidArgumentException(
-				'Non-numeric property ID not supported:' . $propertyId->getSerialization()
+				'Non-numeric property ID not supported:'.$propertyId->getSerialization()
 			);
 		}
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
-		if ( $constraintIds !== null ) {
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
+		if ($constraintIds !== null) {
 			$constraintsToUse = [];
-			foreach ( $constraints as $constraint ) {
-				if ( in_array( $constraint->getConstraintId(), $constraintIds ) ) {
+			foreach ($constraints as $constraint) {
+				if (in_array($constraint->getConstraintId(), $constraintIds)) {
 					$constraintsToUse[] = $constraint;
 				}
 			}
@@ -435,18 +435,18 @@ 
 		?array $constraintIds,
 		?callable $defaultResults
 	): array {
-		$context = new MainSnakContext( $entity, $statement );
+		$context = new MainSnakContext($entity, $statement);
 		$constraints = $this->getConstraintsToUse(
 			$statement->getPropertyId(),
 			$constraintIds
 		);
-		$result = $defaultResults !== null ? $defaultResults( $context ) : [];
+		$result = $defaultResults !== null ? $defaultResults($context) : [];
 
-		foreach ( $constraints as $constraint ) {
+		foreach ($constraints as $constraint) {
 			$parameters = $constraint->getConstraintParameters();
 			try {
-				$exceptions = $this->constraintParameterParser->parseExceptionParameter( $parameters );
-			} catch ( ConstraintParameterException $e ) {
+				$exceptions = $this->constraintParameterParser->parseExceptionParameter($parameters);
+			} catch (ConstraintParameterException $e) {
 				$result[] = new CheckResult(
 					$context,
 					$constraint,
@@ -456,13 +456,13 @@ 
 				continue;
 			}
 
-			if ( in_array( $entity->getId(), $exceptions ) ) {
-				$message = new ViolationMessage( 'wbqc-violation-message-exception' );
-				$result[] = new CheckResult( $context, $constraint, CheckResult::STATUS_EXCEPTION, $message );
+			if (in_array($entity->getId(), $exceptions)) {
+				$message = new ViolationMessage('wbqc-violation-message-exception');
+				$result[] = new CheckResult($context, $constraint, CheckResult::STATUS_EXCEPTION, $message);
 				continue;
 			}
 
-			$result[] = $this->getCheckResultFor( $context, $constraint );
+			$result[] = $this->getCheckResultFor($context, $constraint);
 		}
 
 		return $result;
@@ -484,24 +484,24 @@ 
 	): array {
 		$result = [];
 
-		if ( in_array(
+		if (in_array(
 			$statement->getPropertyId()->getSerialization(),
 			$this->propertiesWithViolatingQualifiers
-		) ) {
+		)) {
 			return $result;
 		}
 
-		foreach ( $statement->getQualifiers() as $qualifier ) {
-			$qualifierContext = new QualifierContext( $entity, $statement, $qualifier );
-			if ( $defaultResultsPerContext !== null ) {
-				$result = array_merge( $result, $defaultResultsPerContext( $qualifierContext ) );
+		foreach ($statement->getQualifiers() as $qualifier) {
+			$qualifierContext = new QualifierContext($entity, $statement, $qualifier);
+			if ($defaultResultsPerContext !== null) {
+				$result = array_merge($result, $defaultResultsPerContext($qualifierContext));
 			}
 			$qualifierConstraints = $this->getConstraintsToUse(
 				$qualifierContext->getSnak()->getPropertyId(),
 				$constraintIds
 			);
-			foreach ( $qualifierConstraints as $qualifierConstraint ) {
-				$result[] = $this->getCheckResultFor( $qualifierContext, $qualifierConstraint );
+			foreach ($qualifierConstraints as $qualifierConstraint) {
+				$result[] = $this->getCheckResultFor($qualifierContext, $qualifierConstraint);
 			}
 		}
 
@@ -525,19 +525,19 @@ 
 		$result = [];
 
 		/** @var Reference $reference */
-		foreach ( $statement->getReferences() as $reference ) {
-			foreach ( $reference->getSnaks() as $snak ) {
+		foreach ($statement->getReferences() as $reference) {
+			foreach ($reference->getSnaks() as $snak) {
 				$referenceContext = new ReferenceContext(
 					$entity, $statement, $reference, $snak
 				);
-				if ( $defaultResultsPerContext !== null ) {
-					$result = array_merge( $result, $defaultResultsPerContext( $referenceContext ) );
+				if ($defaultResultsPerContext !== null) {
+					$result = array_merge($result, $defaultResultsPerContext($referenceContext));
 				}
 				$referenceConstraints = $this->getConstraintsToUse(
 					$referenceContext->getSnak()->getPropertyId(),
 					$constraintIds
 				);
-				foreach ( $referenceConstraints as $referenceConstraint ) {
+				foreach ($referenceConstraints as $referenceConstraint) {
 					$result[] = $this->getCheckResultFor(
 						$referenceContext,
 						$referenceConstraint
@@ -549,50 +549,50 @@ 
 		return $result;
 	}
 
-	private function getCheckResultFor( Context $context, Constraint $constraint ): CheckResult {
-		if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+	private function getCheckResultFor(Context $context, Constraint $constraint): CheckResult {
+		if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 			$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
-			$result = $this->handleScope( $checker, $context, $constraint );
+			$result = $this->handleScope($checker, $context, $constraint);
 
-			if ( $result !== null ) {
-				$this->addMetadata( $context, $result );
+			if ($result !== null) {
+				$this->addMetadata($context, $result);
 				return $result;
 			}
 
-			$startTime = microtime( true );
+			$startTime = microtime(true);
 			try {
-				$result = $checker->checkConstraint( $context, $constraint );
-			} catch ( ConstraintParameterException $e ) {
+				$result = $checker->checkConstraint($context, $constraint);
+			} catch (ConstraintParameterException $e) {
 				$result = new CheckResult(
 					$context,
 					$constraint,
 					CheckResult::STATUS_BAD_PARAMETERS,
 					$e->getViolationMessage()
 				);
-			} catch ( SparqlHelperException $e ) {
-				$message = new ViolationMessage( 'wbqc-violation-message-sparql-error' );
-				$result = new CheckResult( $context, $constraint, CheckResult::STATUS_TODO, $message );
+			} catch (SparqlHelperException $e) {
+				$message = new ViolationMessage('wbqc-violation-message-sparql-error');
+				$result = new CheckResult($context, $constraint, CheckResult::STATUS_TODO, $message);
 			}
-			$endTime = microtime( true );
+			$endTime = microtime(true);
 
-			$this->addMetadata( $context, $result );
+			$this->addMetadata($context, $result);
 
-			$this->addConstraintClarification( $result );
+			$this->addConstraintClarification($result);
 
-			$this->downgradeResultStatus( $result );
+			$this->downgradeResultStatus($result);
 
 			$this->loggingHelper->logConstraintCheck(
 				$context,
 				$constraint,
 				$result,
-				get_class( $checker ),
+				get_class($checker),
 				$endTime - $startTime,
 				__METHOD__
 			);
 
 			return $result;
 		} else {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_TODO, null );
+			return new CheckResult($context, $constraint, CheckResult::STATUS_TODO, null);
 		}
 	}
 
@@ -601,87 +601,87 @@ 
 		Context $context,
 		Constraint $constraint
 	): ?CheckResult {
-		$validContextTypes = $this->getValidContextTypes( $constraint );
-		$validEntityTypes = $this->getValidEntityTypes( $constraint );
+		$validContextTypes = $this->getValidContextTypes($constraint);
+		$validEntityTypes = $this->getValidEntityTypes($constraint);
 		try {
-			[ $checkedContextTypes, $checkedEntityTypes ] = $this->constraintParameterParser->parseConstraintScopeParameters(
+			[$checkedContextTypes, $checkedEntityTypes] = $this->constraintParameterParser->parseConstraintScopeParameters(
 				$constraint->getConstraintParameters(),
 				$constraint->getConstraintTypeItemId(),
 				$validContextTypes,
 				$validEntityTypes
 			);
-		} catch ( ConstraintParameterException $e ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage() );
+		} catch (ConstraintParameterException $e) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage());
 		}
 
 		$checkedContextTypes ??= $checker->getDefaultContextTypes();
 		$contextType = $context->getType();
-		if ( !in_array( $contextType, $checkedContextTypes ) ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_NOT_IN_SCOPE, null );
+		if (!in_array($contextType, $checkedContextTypes)) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_NOT_IN_SCOPE, null);
 		}
-		if ( $checker->getSupportedContextTypes()[$contextType] === CheckResult::STATUS_TODO ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_TODO, null );
+		if ($checker->getSupportedContextTypes()[$contextType] === CheckResult::STATUS_TODO) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_TODO, null);
 		}
 
 		$checkedEntityTypes ??= $validEntityTypes;
 		$entityType = $context->getEntity()->getType();
-		if ( !in_array( $entityType, $checkedEntityTypes ) ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_NOT_IN_SCOPE, null );
+		if (!in_array($entityType, $checkedEntityTypes)) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_NOT_IN_SCOPE, null);
 		}
-		if ( $checker->getSupportedEntityTypes()[$entityType] === CheckResult::STATUS_TODO ) {
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_TODO, null );
+		if ($checker->getSupportedEntityTypes()[$entityType] === CheckResult::STATUS_TODO) {
+			return new CheckResult($context, $constraint, CheckResult::STATUS_TODO, null);
 		}
 
 		return null;
 	}
 
-	private function addMetadata( Context $context, CheckResult $result ): void {
-		$result->withMetadata( Metadata::merge( [
+	private function addMetadata(Context $context, CheckResult $result): void {
+		$result->withMetadata(Metadata::merge([
 			$result->getMetadata(),
-			Metadata::ofDependencyMetadata( DependencyMetadata::merge( [
-				DependencyMetadata::ofEntityId( $context->getEntity()->getId() ),
-				DependencyMetadata::ofEntityId( $result->getConstraint()->getPropertyId() ),
-			] ) ),
-		] ) );
+			Metadata::ofDependencyMetadata(DependencyMetadata::merge([
+				DependencyMetadata::ofEntityId($context->getEntity()->getId()),
+				DependencyMetadata::ofEntityId($result->getConstraint()->getPropertyId()),
+			])),
+		]));
 	}
 
-	private function addConstraintClarification( CheckResult $result ): void {
+	private function addConstraintClarification(CheckResult $result): void {
 		$constraint = $result->getConstraint();
 		try {
 			$constraintClarification = $this->constraintParameterParser
-				->parseConstraintClarificationParameter( $constraint->getConstraintParameters() );
-			$result->setConstraintClarification( $constraintClarification );
-		} catch ( ConstraintParameterException $e ) {
-			$result->setStatus( CheckResult::STATUS_BAD_PARAMETERS );
-			$result->setMessage( $e->getViolationMessage() );
+				->parseConstraintClarificationParameter($constraint->getConstraintParameters());
+			$result->setConstraintClarification($constraintClarification);
+		} catch (ConstraintParameterException $e) {
+			$result->setStatus(CheckResult::STATUS_BAD_PARAMETERS);
+			$result->setMessage($e->getViolationMessage());
 		}
 	}
 
-	private function downgradeResultStatus( CheckResult $result ): void {
+	private function downgradeResultStatus(CheckResult $result): void {
 		$constraint = $result->getConstraint();
 		try {
 			$constraintStatus = $this->constraintParameterParser
-				->parseConstraintStatusParameter( $constraint->getConstraintParameters() );
-		} catch ( ConstraintParameterException $e ) {
-			$result->setStatus( CheckResult::STATUS_BAD_PARAMETERS );
-			$result->setMessage( $e->getViolationMessage() );
+				->parseConstraintStatusParameter($constraint->getConstraintParameters());
+		} catch (ConstraintParameterException $e) {
+			$result->setStatus(CheckResult::STATUS_BAD_PARAMETERS);
+			$result->setMessage($e->getViolationMessage());
 			return;
 		}
-		if ( $constraintStatus === null ) {
+		if ($constraintStatus === null) {
 			// downgrade violation to warning
-			if ( $result->getStatus() === CheckResult::STATUS_VIOLATION ) {
-				$result->setStatus( CheckResult::STATUS_WARNING );
+			if ($result->getStatus() === CheckResult::STATUS_VIOLATION) {
+				$result->setStatus(CheckResult::STATUS_WARNING);
 			}
-		} elseif ( $constraintStatus === 'suggestion' ) {
+		} elseif ($constraintStatus === 'suggestion') {
 			// downgrade violation to suggestion
-			if ( $result->getStatus() === CheckResult::STATUS_VIOLATION ) {
-				$result->setStatus( CheckResult::STATUS_SUGGESTION );
+			if ($result->getStatus() === CheckResult::STATUS_VIOLATION) {
+				$result->setStatus(CheckResult::STATUS_SUGGESTION);
 			}
 		} else {
-			if ( $constraintStatus !== 'mandatory' ) {
+			if ($constraintStatus !== 'mandatory') {
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					"Unknown constraint status '$constraintStatus', " .
+					"Unknown constraint status '$constraintStatus', ".
 					"only known statuses are 'mandatory' and 'suggestion'"
 				);
 				// @codeCoverageIgnoreEnd
@@ -694,12 +694,12 @@ 
 	 *
 	 * @return CheckResult[]
 	 */
-	private function sortResult( array $result ): array {
-		if ( count( $result ) < 2 ) {
+	private function sortResult(array $result): array {
+		if (count($result) < 2) {
 			return $result;
 		}
 
-		$sortFunction = static function ( CheckResult $a, CheckResult $b ) {
+		$sortFunction = static function(CheckResult $a, CheckResult $b) {
 			$orderNum = 0;
 			$order = [
 				CheckResult::STATUS_BAD_PARAMETERS => $orderNum++,
@@ -716,55 +716,55 @@ 
 			$statusA = $a->getStatus();
 			$statusB = $b->getStatus();
 
-			$orderA = array_key_exists( $statusA, $order ) ? $order[ $statusA ] : $order[ 'other' ];
-			$orderB = array_key_exists( $statusB, $order ) ? $order[ $statusB ] : $order[ 'other' ];
+			$orderA = array_key_exists($statusA, $order) ? $order[$statusA] : $order['other'];
+			$orderB = array_key_exists($statusB, $order) ? $order[$statusB] : $order['other'];
 
-			if ( $orderA === $orderB ) {
+			if ($orderA === $orderB) {
 				$cursorA = $a->getContextCursor();
 				$cursorB = $b->getContextCursor();
 
-				if ( $cursorA instanceof EntityContextCursor ) {
+				if ($cursorA instanceof EntityContextCursor) {
 					return $cursorB instanceof EntityContextCursor ? 0 : -1;
 				}
-				if ( $cursorB instanceof EntityContextCursor ) {
+				if ($cursorB instanceof EntityContextCursor) {
 					return $cursorA instanceof EntityContextCursor ? 0 : 1;
 				}
 
 				$pidA = $cursorA->getSnakPropertyId();
 				$pidB = $cursorB->getSnakPropertyId();
 
-				if ( $pidA === $pidB ) {
+				if ($pidA === $pidB) {
 					$hashA = $cursorA->getSnakHash();
 					$hashB = $cursorB->getSnakHash();
 
-					if ( $hashA === $hashB ) {
-						if ( $a instanceof NullResult ) {
+					if ($hashA === $hashB) {
+						if ($a instanceof NullResult) {
 							return $b instanceof NullResult ? 0 : -1;
 						}
-						if ( $b instanceof NullResult ) {
+						if ($b instanceof NullResult) {
 							return $a instanceof NullResult ? 0 : 1;
 						}
 
 						$typeA = $a->getConstraint()->getConstraintTypeItemId();
 						$typeB = $b->getConstraint()->getConstraintTypeItemId();
 
-						if ( $typeA == $typeB ) {
+						if ($typeA == $typeB) {
 							return 0;
 						} else {
-							return ( $typeA > $typeB ) ? 1 : -1;
+							return ($typeA > $typeB) ? 1 : -1;
 						}
 					} else {
-						return ( $hashA > $hashB ) ? 1 : -1;
+						return ($hashA > $hashB) ? 1 : -1;
 					}
 				} else {
-					return ( $pidA > $pidB ) ? 1 : -1;
+					return ($pidA > $pidB) ? 1 : -1;
 				}
 			} else {
-				return ( $orderA > $orderB ) ? 1 : -1;
+				return ($orderA > $orderB) ? 1 : -1;
 			}
 		};
 
-		uasort( $result, $sortFunction );
+		uasort($result, $sortFunction);
 
 		return $result;
 	}