wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/Api/CheckConstraints.php

Spacing +30 added lines, -30 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\Api;
 
@@ -81,11 +81,11 @@ 
 		CheckResultsRendererFactory $checkResultsRendererFactory,
 		IBufferingStatsdDataFactory $dataFactory
 	) {
-		parent::__construct( $main, $name );
+		parent::__construct($main, $name);
 		$this->entityIdParser = $entityIdParser;
 		$this->statementGuidValidator = $statementGuidValidator;
-		$this->resultBuilder = $apiHelperFactory->getResultBuilder( $this );
-		$this->errorReporter = $apiHelperFactory->getErrorReporter( $this );
+		$this->resultBuilder = $apiHelperFactory->getResultBuilder($this);
+		$this->errorReporter = $apiHelperFactory->getErrorReporter($this);
 		$this->resultsSource = $resultsSource;
 		$this->checkResultsRendererFactory = $checkResultsRendererFactory;
 		$this->dataFactory = $dataFactory;
@@ -101,14 +101,14 @@ 
 
 		$params = $this->extractRequestParams();
 
-		$this->validateParameters( $params );
-		$entityIds = $this->parseEntityIds( $params );
-		$claimIds = $this->parseClaimIds( $params );
+		$this->validateParameters($params);
+		$entityIds = $this->parseEntityIds($params);
+		$claimIds = $this->parseClaimIds($params);
 		$constraintIDs = $params[self::PARAM_CONSTRAINT_ID];
 		$statuses = $params[self::PARAM_STATUS];
 
 		$checkResultsRenderer = $this->checkResultsRendererFactory
-			->getCheckResultsRenderer( $this->getLanguage(), $this );
+			->getCheckResultsRenderer($this->getLanguage(), $this);
 
 		$this->getResult()->addValue(
 			null,
@@ -122,7 +122,7 @@ 
 				)
 			)->getArray()
 		);
-		$this->resultBuilder->markSuccess( 1 );
+		$this->resultBuilder->markSuccess(1);
 	}
 
 	/**
@@ -130,24 +130,24 @@ 
 	 *
 	 * @return EntityId[]
 	 */
-	private function parseEntityIds( array $params ): array {
+	private function parseEntityIds(array $params): array {
 		$ids = $params[self::PARAM_ID];
 
-		if ( $ids === null ) {
+		if ($ids === null) {
 			return [];
-		} elseif ( $ids === [] ) {
+		} elseif ($ids === []) {
 			$this->errorReporter->dieError(
-				'If ' . self::PARAM_ID . ' is specified, it must be nonempty.', 'no-data' );
+				'If '.self::PARAM_ID.' is specified, it must be nonempty.', 'no-data' );
 		}
 
-		return array_map( function ( $id ) {
+		return array_map(function($id) {
 			try {
-				return $this->entityIdParser->parse( $id );
-			} catch ( EntityIdParsingException $e ) {
+				return $this->entityIdParser->parse($id);
+			} catch (EntityIdParsingException $e) {
 				$this->errorReporter->dieError(
-					"Invalid id: $id", 'invalid-entity-id', 0, [ self::PARAM_ID => $id ] );
+					"Invalid id: $id", 'invalid-entity-id', 0, [self::PARAM_ID => $id] );
 			}
-		}, $ids );
+		}, $ids);
 	}
 
 	/**
@@ -155,35 +155,35 @@ 
 	 *
 	 * @return string[]
 	 */
-	private function parseClaimIds( array $params ): array {
+	private function parseClaimIds(array $params): array {
 		$ids = $params[self::PARAM_CLAIM_ID];
 
-		if ( $ids === null ) {
+		if ($ids === null) {
 			return [];
-		} elseif ( $ids === [] ) {
+		} elseif ($ids === []) {
 			$this->errorReporter->dieError(
-				'If ' . self::PARAM_CLAIM_ID . ' is specified, it must be nonempty.', 'no-data' );
+				'If '.self::PARAM_CLAIM_ID.' is specified, it must be nonempty.', 'no-data' );
 		}
 
-		foreach ( $ids as $id ) {
-			if ( !$this->statementGuidValidator->validate( $id ) ) {
+		foreach ($ids as $id) {
+			if (!$this->statementGuidValidator->validate($id)) {
 				$this->errorReporter->dieError(
-					"Invalid claim id: $id", 'invalid-guid', 0, [ self::PARAM_CLAIM_ID => $id ] );
+					"Invalid claim id: $id", 'invalid-guid', 0, [self::PARAM_CLAIM_ID => $id] );
 			}
 		}
 
 		return $ids;
 	}
 
-	private function validateParameters( array $params ): void {
-		if ( $params[self::PARAM_CONSTRAINT_ID] !== null
-			 && empty( $params[self::PARAM_CONSTRAINT_ID] )
+	private function validateParameters(array $params): void {
+		if ($params[self::PARAM_CONSTRAINT_ID] !== null
+			 && empty($params[self::PARAM_CONSTRAINT_ID])
 		) {
 			$paramConstraintId = self::PARAM_CONSTRAINT_ID;
 			$this->errorReporter->dieError(
 				"If $paramConstraintId is specified, it must be nonempty.", 'no-data' );
 		}
-		if ( $params[self::PARAM_ID] === null && $params[self::PARAM_CLAIM_ID] === null ) {
+		if ($params[self::PARAM_ID] === null && $params[self::PARAM_CLAIM_ID] === null) {
 			$paramId = self::PARAM_ID;
 			$paramClaimId = self::PARAM_CLAIM_ID;
 			$this->errorReporter->dieError(
@@ -224,7 +224,7 @@ 
 				],
 				ParamValidator::PARAM_ISMULTI => true,
 				ParamValidator::PARAM_ALL => true,
-				ParamValidator::PARAM_DEFAULT => implode( '|', CachingResultsSource::CACHED_STATUSES ),
+				ParamValidator::PARAM_DEFAULT => implode('|', CachingResultsSource::CACHED_STATUSES),
 				ApiBase::PARAM_HELP_MSG_PER_VALUE => [],
 			],
 		];

src/Api/CheckConstraintParameters.php

Spacing +48 added lines, -48 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\Api;
 
@@ -79,9 +79,9 @@ 
 		StatementGuidParser $statementGuidParser,
 		IBufferingStatsdDataFactory $dataFactory
 	) {
-		parent::__construct( $main, $name );
+		parent::__construct($main, $name);
 
-		$this->apiErrorReporter = $apiHelperFactory->getErrorReporter( $this );
+		$this->apiErrorReporter = $apiHelperFactory->getErrorReporter($this);
 		$this->languageFallbackChainFactory = $languageFallbackChainFactory;
 		$this->delegatingConstraintChecker = $delegatingConstraintChecker;
 		$this->violationMessageRendererFactory = $violationMessageRendererFactory;
@@ -97,39 +97,39 @@ 
 		$params = $this->extractRequestParams();
 		$result = $this->getResult();
 
-		$propertyIds = $this->parsePropertyIds( $params[self::PARAM_PROPERTY_ID] );
-		$constraintIds = $this->parseConstraintIds( $params[self::PARAM_CONSTRAINT_ID] );
+		$propertyIds = $this->parsePropertyIds($params[self::PARAM_PROPERTY_ID]);
+		$constraintIds = $this->parseConstraintIds($params[self::PARAM_CONSTRAINT_ID]);
 
-		$this->checkPropertyIds( $propertyIds, $result );
-		$this->checkConstraintIds( $constraintIds, $result );
+		$this->checkPropertyIds($propertyIds, $result);
+		$this->checkConstraintIds($constraintIds, $result);
 
-		$result->addValue( null, 'success', 1 );
+		$result->addValue(null, 'success', 1);
 	}
 
 	/**
 	 * @param array|null $propertyIdSerializations
 	 * @return NumericPropertyId[]
 	 */
-	private function parsePropertyIds( ?array $propertyIdSerializations ): array {
-		if ( $propertyIdSerializations === null ) {
+	private function parsePropertyIds(?array $propertyIdSerializations): array {
+		if ($propertyIdSerializations === null) {
 			return [];
-		} elseif ( empty( $propertyIdSerializations ) ) {
+		} elseif (empty($propertyIdSerializations)) {
 			$this->apiErrorReporter->dieError(
-				'If ' . self::PARAM_PROPERTY_ID . ' is specified, it must be nonempty.',
+				'If '.self::PARAM_PROPERTY_ID.' is specified, it must be nonempty.',
 				'no-data'
 			);
 		}
 
 		return array_map(
-			function ( $propertyIdSerialization ) {
+			function($propertyIdSerialization) {
 				try {
-					return new NumericPropertyId( $propertyIdSerialization );
-				} catch ( InvalidArgumentException $e ) {
+					return new NumericPropertyId($propertyIdSerialization);
+				} catch (InvalidArgumentException $e) {
 					$this->apiErrorReporter->dieError(
 						"Invalid id: $propertyIdSerialization",
 						'invalid-property-id',
 						0, // default argument
-						[ self::PARAM_PROPERTY_ID => $propertyIdSerialization ]
+						[self::PARAM_PROPERTY_ID => $propertyIdSerialization]
 					);
 				}
 			},
@@ -141,35 +141,35 @@ 
 	 * @param array|null $constraintIds
 	 * @return string[]
 	 */
-	private function parseConstraintIds( ?array $constraintIds ): array {
-		if ( $constraintIds === null ) {
+	private function parseConstraintIds(?array $constraintIds): array {
+		if ($constraintIds === null) {
 			return [];
-		} elseif ( empty( $constraintIds ) ) {
+		} elseif (empty($constraintIds)) {
 			$this->apiErrorReporter->dieError(
-				'If ' . self::PARAM_CONSTRAINT_ID . ' is specified, it must be nonempty.',
+				'If '.self::PARAM_CONSTRAINT_ID.' is specified, it must be nonempty.',
 				'no-data'
 			);
 		}
 
 		return array_map(
-			function ( $constraintId ) {
+			function($constraintId) {
 				try {
-					$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
-					if ( !$propertyId instanceof NumericPropertyId ) {
+					$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
+					if (!$propertyId instanceof NumericPropertyId) {
 						$this->apiErrorReporter->dieError(
 							"Invalid property ID: {$propertyId->getSerialization()}",
 							'invalid-property-id',
 							0, // default argument
-							[ self::PARAM_CONSTRAINT_ID => $constraintId ]
+							[self::PARAM_CONSTRAINT_ID => $constraintId]
 						);
 					}
 					return $constraintId;
-				} catch ( StatementGuidParsingException $e ) {
+				} catch (StatementGuidParsingException $e) {
 					$this->apiErrorReporter->dieError(
 						"Invalid statement GUID: $constraintId",
 						'invalid-guid',
 						0, // default argument
-						[ self::PARAM_CONSTRAINT_ID => $constraintId ]
+						[self::PARAM_CONSTRAINT_ID => $constraintId]
 					);
 				}
 			},
@@ -181,12 +181,12 @@ 
 	 * @param NumericPropertyId[] $propertyIds
 	 * @param ApiResult $result
 	 */
-	private function checkPropertyIds( array $propertyIds, ApiResult $result ): void {
-		foreach ( $propertyIds as $propertyId ) {
-			$result->addArrayType( $this->getResultPathForPropertyId( $propertyId ), 'assoc' );
+	private function checkPropertyIds(array $propertyIds, ApiResult $result): void {
+		foreach ($propertyIds as $propertyId) {
+			$result->addArrayType($this->getResultPathForPropertyId($propertyId), 'assoc');
 			$allConstraintExceptions = $this->delegatingConstraintChecker
-				->checkConstraintParametersOnPropertyId( $propertyId );
-			foreach ( $allConstraintExceptions as $constraintId => $constraintParameterExceptions ) {
+				->checkConstraintParametersOnPropertyId($propertyId);
+			foreach ($allConstraintExceptions as $constraintId => $constraintParameterExceptions) {
 				$this->addConstraintParameterExceptionsToResult(
 					$constraintId,
 					$constraintParameterExceptions,
@@ -200,15 +200,15 @@ 
 	 * @param string[] $constraintIds
 	 * @param ApiResult $result
 	 */
-	private function checkConstraintIds( array $constraintIds, ApiResult $result ): void {
-		foreach ( $constraintIds as $constraintId ) {
-			if ( $result->getResultData( $this->getResultPathForConstraintId( $constraintId ) ) ) {
+	private function checkConstraintIds(array $constraintIds, ApiResult $result): void {
+		foreach ($constraintIds as $constraintId) {
+			if ($result->getResultData($this->getResultPathForConstraintId($constraintId))) {
 				// already checked as part of checkPropertyIds()
 				continue;
 			}
 			$constraintParameterExceptions = $this->delegatingConstraintChecker
-				->checkConstraintParametersOnConstraintId( $constraintId );
-			$this->addConstraintParameterExceptionsToResult( $constraintId, $constraintParameterExceptions, $result );
+				->checkConstraintParametersOnConstraintId($constraintId);
+			$this->addConstraintParameterExceptionsToResult($constraintId, $constraintParameterExceptions, $result);
 		}
 	}
 
@@ -216,18 +216,18 @@ 
 	 * @param NumericPropertyId $propertyId
 	 * @return string[]
 	 */
-	private function getResultPathForPropertyId( NumericPropertyId $propertyId ): array {
-		return [ $this->getModuleName(), $propertyId->getSerialization() ];
+	private function getResultPathForPropertyId(NumericPropertyId $propertyId): array {
+		return [$this->getModuleName(), $propertyId->getSerialization()];
 	}
 
 	/**
 	 * @param string $constraintId
 	 * @return string[]
 	 */
-	private function getResultPathForConstraintId( string $constraintId ): array {
-		$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
+	private function getResultPathForConstraintId(string $constraintId): array {
+		$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
 		'@phan-var NumericPropertyId $propertyId';
-		return array_merge( $this->getResultPathForPropertyId( $propertyId ), [ $constraintId ] );
+		return array_merge($this->getResultPathForPropertyId($propertyId), [$constraintId]);
 	}
 
 	/**
@@ -242,8 +242,8 @@ 
 		?array $constraintParameterExceptions,
 		ApiResult $result
 	): void {
-		$path = $this->getResultPathForConstraintId( $constraintId );
-		if ( $constraintParameterExceptions === null ) {
+		$path = $this->getResultPathForConstraintId($constraintId);
+		if ($constraintParameterExceptions === null) {
 			$result->addValue(
 				$path,
 				self::KEY_STATUS,
@@ -253,18 +253,18 @@ 
 			$result->addValue(
 				$path,
 				self::KEY_STATUS,
-				empty( $constraintParameterExceptions ) ? self::STATUS_OKAY : self::STATUS_NOT_OKAY
+				empty($constraintParameterExceptions) ? self::STATUS_OKAY : self::STATUS_NOT_OKAY
 			);
 
 			$language = $this->getLanguage();
 			$violationMessageRenderer = $this->violationMessageRendererFactory
 				->getViolationMessageRenderer(
 					$language,
-					$this->languageFallbackChainFactory->newFromLanguage( $language ),
+					$this->languageFallbackChainFactory->newFromLanguage($language),
 					$this
 				);
 			$problems = [];
-			foreach ( $constraintParameterExceptions as $constraintParameterException ) {
+			foreach ($constraintParameterExceptions as $constraintParameterException) {
 				$problems[] = [
 					self::KEY_MESSAGE_HTML => $violationMessageRenderer->render(
 						$constraintParameterException->getViolationMessage() ),
@@ -303,8 +303,8 @@ 
 		return [
 			'action=wbcheckconstraintparameters&propertyid=P247'
 				=> 'apihelp-wbcheckconstraintparameters-example-propertyid-1',
-			'action=wbcheckconstraintparameters&' .
-			'constraintid=P247$0fe1711e-4c0f-82ce-3af0-830b721d0fba|' .
+			'action=wbcheckconstraintparameters&'.
+			'constraintid=P247$0fe1711e-4c0f-82ce-3af0-830b721d0fba|'.
 			'P225$cdc71e4a-47a0-12c5-dfb3-3f6fc0b6613f'
 				=> 'apihelp-wbcheckconstraintparameters-example-constraintid-2',
 		];

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;
 
@@ -27,13 +27,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'],
@@ -41,22 +41,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();
 		}
 	}
@@ -67,14 +67,14 @@ 
 	 * @return array[]|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/ViolationMessageRendererFactory.php

Spacing +4 added lines, -4 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Message;
 
@@ -43,12 +43,12 @@ 
 	): ViolationMessageRenderer {
 		$userLanguageCode = $userLanguage->getCode();
 		$formatterOptions = new FormatterOptions();
-		$formatterOptions->setOption( SnakFormatter::OPT_LANG, $userLanguageCode );
+		$formatterOptions->setOption(SnakFormatter::OPT_LANG, $userLanguageCode);
 		return new MultilingualTextViolationMessageRenderer(
 			$this->entityIdHtmlLinkFormatterFactory
-				->getEntityIdFormatter( $userLanguage ),
+				->getEntityIdFormatter($userLanguage),
 			$this->valueFormatterFactory
-				->getValueFormatter( SnakFormatter::FORMAT_HTML, $formatterOptions ),
+				->getValueFormatter(SnakFormatter::FORMAT_HTML, $formatterOptions),
 			$this->languageNameUtils,
 			$userLanguageCode,
 			$languageFallbackChain,

src/Api/ResultsCache.php

Spacing +8 added lines, -8 removed lines

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

src/Api/CheckResultsRendererFactory.php

Spacing +3 added lines, -3 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\Api;
 
@@ -37,12 +37,12 @@ 
 		Language $userLanguage,
 		MessageLocalizer $messageLocalizer
 	): CheckResultsRenderer {
-		$languageFallbackChain = $this->languageFallbackChainFactory->newFromLanguage( $userLanguage );
+		$languageFallbackChain = $this->languageFallbackChainFactory->newFromLanguage($userLanguage);
 
 		return new CheckResultsRenderer(
 			$this->entityTitleLookup,
 			$this->entityIdLabelFormatterFactory
-				->getEntityIdFormatter( $userLanguage ),
+				->getEntityIdFormatter($userLanguage),
 			$languageFallbackChain,
 			$this->violationMessageRendererFactory
 				->getViolationMessageRenderer(

src/ConstraintCheck/Helper/ConstraintParameterParser.php

Spacing +291 added lines, -291 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Helper;
 
@@ -68,15 +68,15 @@ 
 	 * Check if any errors are recorded in the constraint parameters.
 	 * @throws ConstraintParameterException
 	 */
-	public function checkError( array $parameters ): void {
-		if ( array_key_exists( '@error', $parameters ) ) {
+	public function checkError(array $parameters): void {
+		if (array_key_exists('@error', $parameters)) {
 			$error = $parameters['@error'];
-			if ( array_key_exists( 'toolong', $error ) && $error['toolong'] ) {
+			if (array_key_exists('toolong', $error) && $error['toolong']) {
 				$msg = 'wbqc-violation-message-parameters-error-toolong';
 			} else {
 				$msg = 'wbqc-violation-message-parameters-error-unknown';
 			}
-			throw new ConstraintParameterException( new ViolationMessage( $msg ) );
+			throw new ConstraintParameterException(new ViolationMessage($msg));
 		}
 	}
 
@@ -84,11 +84,11 @@ 
 	 * Require that $parameters contains exactly one $parameterId parameter.
 	 * @throws ConstraintParameterException
 	 */
-	private function requireSingleParameter( array $parameters, string $parameterId ): void {
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
+	private function requireSingleParameter(array $parameters, string $parameterId): void {
+		if (count($parameters[$parameterId]) !== 1) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-single' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-single'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -97,11 +97,11 @@ 
 	 * Require that $snak is a {@link PropertyValueSnak}.
 	 * @throws ConstraintParameterException
 	 */
-	private function requireValueParameter( Snak $snak, string $parameterId ): void {
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
+	private function requireValueParameter(Snak $snak, string $parameterId): void {
+		if (!($snak instanceof PropertyValueSnak)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -110,17 +110,17 @@ 
 	 * Parse a single entity ID parameter.
 	 * @throws ConstraintParameterException
 	 */
-	private function parseEntityIdParameter( array $snakSerialization, string $parameterId ): EntityId {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseEntityIdParameter(array $snakSerialization, string $parameterId): EntityId {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			return $value->getEntityId();
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-entity' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-entity'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -131,20 +131,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] class entity ID serializations
 	 */
-	public function parseClassParameter( array $constraintParameters, string $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
+	public function parseClassParameter(array $constraintParameters, string $constraintTypeItemId): array {
+		$this->checkError($constraintParameters);
+		$classId = $this->config->get('WBQualityConstraintsClassId');
+		if (!array_key_exists($classId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $classId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($classId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$classes = [];
-		foreach ( $constraintParameters[$classId] as $class ) {
-			$classes[] = $this->parseEntityIdParameter( $class, $classId )->getSerialization();
+		foreach ($constraintParameters[$classId] as $class) {
+			$classes[] = $this->parseEntityIdParameter($class, $classId)->getSerialization();
 		}
 		return $classes;
 	}
@@ -155,31 +155,31 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
 	 */
-	public function parseRelationParameter( array $constraintParameters, string $constraintTypeItemId ): string {
-		$this->checkError( $constraintParameters );
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
+	public function parseRelationParameter(array $constraintParameters, string $constraintTypeItemId): string {
+		$this->checkError($constraintParameters);
+		$relationId = $this->config->get('WBQualityConstraintsRelationId');
+		if (!array_key_exists($relationId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $relationId );
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
-		if ( !( $relationEntityId instanceof ItemId ) ) {
+		$this->requireSingleParameter($constraintParameters, $relationId);
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
+		if (!($relationEntityId instanceof ItemId)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( new EntityIdValue( $relationEntityId ), Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue(new EntityIdValue($relationEntityId), Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
-		return $this->mapItemId( $relationEntityId, [
-			$this->config->get( 'WBQualityConstraintsInstanceOfRelationId' ) => 'instance',
-			$this->config->get( 'WBQualityConstraintsSubclassOfRelationId' ) => 'subclass',
-			$this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' ) => 'instanceOrSubclass',
-		], $relationId );
+		return $this->mapItemId($relationEntityId, [
+			$this->config->get('WBQualityConstraintsInstanceOfRelationId') => 'instance',
+			$this->config->get('WBQualityConstraintsSubclassOfRelationId') => 'subclass',
+			$this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId') => 'instanceOrSubclass',
+		], $relationId);
 	}
 
 	/**
@@ -189,20 +189,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return PropertyId
 	 */
-	private function parsePropertyIdParameter( array $snakSerialization, string $parameterId ): PropertyId {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parsePropertyIdParameter(array $snakSerialization, string $parameterId): PropertyId {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			$id = $value->getEntityId();
-			if ( $id instanceof PropertyId ) {
+			if ($id instanceof PropertyId) {
 				return $id;
 			}
 		}
 		throw new ConstraintParameterException(
-			( new ViolationMessage( 'wbqc-violation-message-parameter-property' ) )
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-				->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+			(new ViolationMessage('wbqc-violation-message-parameter-property'))
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+				->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 		);
 	}
 
@@ -213,33 +213,33 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId
 	 */
-	public function parsePropertyParameter( array $constraintParameters, string $constraintTypeItemId ): PropertyId {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertyParameter(array $constraintParameters, string $constraintTypeItemId): PropertyId {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $propertyId );
-		return $this->parsePropertyIdParameter( $constraintParameters[$propertyId][0], $propertyId );
+		$this->requireSingleParameter($constraintParameters, $propertyId);
+		return $this->parsePropertyIdParameter($constraintParameters[$propertyId][0], $propertyId);
 	}
 
-	private function parseItemIdParameter( PropertyValueSnak $snak, string $parameterId ): ItemIdSnakValue {
+	private function parseItemIdParameter(PropertyValueSnak $snak, string $parameterId): ItemIdSnakValue {
 		$dataValue = $snak->getDataValue();
-		if ( $dataValue instanceof EntityIdValue ) {
+		if ($dataValue instanceof EntityIdValue) {
 			$entityId = $dataValue->getEntityId();
-			if ( $entityId instanceof ItemId ) {
-				return ItemIdSnakValue::fromItemId( $entityId );
+			if ($entityId instanceof ItemId) {
+				return ItemIdSnakValue::fromItemId($entityId);
 			}
 		}
 		throw new ConstraintParameterException(
-			( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-				->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+			(new ViolationMessage('wbqc-violation-message-parameter-item'))
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+				->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 		);
 	}
 
@@ -257,16 +257,16 @@ 
 		bool $required,
 		string $parameterId = null
 	): array {
-		$this->checkError( $constraintParameters );
-		if ( $parameterId === null ) {
-			$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+		$this->checkError($constraintParameters);
+		if ($parameterId === null) {
+			$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 		}
-		if ( !array_key_exists( $parameterId, $constraintParameters ) ) {
-			if ( $required ) {
+		if (!array_key_exists($parameterId, $constraintParameters)) {
+			if ($required) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			} else {
 				return [];
@@ -274,11 +274,11 @@ 
 		}
 
 		$values = [];
-		foreach ( $constraintParameters[$parameterId] as $parameter ) {
-			$snak = $this->snakDeserializer->deserialize( $parameter );
-			switch ( true ) {
+		foreach ($constraintParameters[$parameterId] as $parameter) {
+			$snak = $this->snakDeserializer->deserialize($parameter);
+			switch (true) {
 				case $snak instanceof PropertyValueSnak:
-					$values[] = $this->parseItemIdParameter( $snak, $parameterId );
+					$values[] = $this->parseItemIdParameter($snak, $parameterId);
 					break;
 				case $snak instanceof PropertySomeValueSnak:
 					$values[] = ItemIdSnakValue::someValue();
@@ -306,13 +306,13 @@ 
 		bool $required,
 		string $parameterId
 	): array {
-		return array_map( static function ( ItemIdSnakValue $value ) use ( $parameterId ): ItemId {
-			if ( $value->isValue() ) {
+		return array_map(static function(ItemIdSnakValue $value) use ($parameterId): ItemId {
+			if ($value->isValue()) {
 				return $value->getItemId();
 			} else {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-value'))
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			}
 		}, $this->parseItemsParameter(
@@ -320,7 +320,7 @@ 
 			$constraintTypeItemId,
 			$required,
 			$parameterId
-		) );
+		));
 	}
 
 	/**
@@ -328,18 +328,18 @@ 
 	 * @throws ConstraintParameterException
 	 * @return mixed elements of $mapping
 	 */
-	private function mapItemId( ItemId $itemId, array $mapping, string $parameterId ) {
+	private function mapItemId(ItemId $itemId, array $mapping, string $parameterId) {
 		$serialization = $itemId->getSerialization();
-		if ( array_key_exists( $serialization, $mapping ) ) {
+		if (array_key_exists($serialization, $mapping)) {
 			return $mapping[$serialization];
 		} else {
-			$allowed = array_map( static function ( $id ) {
-				return new ItemId( $id );
-			}, array_keys( $mapping ) );
+			$allowed = array_map(static function($id) {
+				return new ItemId($id);
+			}, array_keys($mapping));
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -350,27 +350,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId[]
 	 */
-	public function parsePropertiesParameter( array $constraintParameters, string $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertiesParameter(array $constraintParameters, string $constraintTypeItemId): array {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$parameters = $constraintParameters[$propertyId];
-		if ( count( $parameters ) === 1 &&
-			$this->snakDeserializer->deserialize( $parameters[0] ) instanceof PropertyNoValueSnak
+		if (count($parameters) === 1 &&
+			$this->snakDeserializer->deserialize($parameters[0]) instanceof PropertyNoValueSnak
 		) {
 			return [];
 		}
 
 		$properties = [];
-		foreach ( $parameters as $parameter ) {
-			$properties[] = $this->parsePropertyIdParameter( $parameter, $propertyId );
+		foreach ($parameters as $parameter) {
+			$properties[] = $this->parsePropertyIdParameter($parameter, $propertyId);
 		}
 		return $properties;
 	}
@@ -378,24 +378,24 @@ 
 	/**
 	 * @throws ConstraintParameterException
 	 */
-	private function parseValueOrNoValueParameter( array $snakSerialization, string $parameterId ): ?DataValue {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		if ( $snak instanceof PropertyValueSnak ) {
+	private function parseValueOrNoValueParameter(array $snakSerialization, string $parameterId): ?DataValue {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		if ($snak instanceof PropertyValueSnak) {
 			return $snak->getDataValue();
-		} elseif ( $snak instanceof PropertyNoValueSnak ) {
+		} elseif ($snak instanceof PropertyNoValueSnak) {
 			return null;
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
 
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, string $parameterId ): ?DataValue {
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, string $parameterId): ?DataValue {
 		try {
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
-		} catch ( ConstraintParameterException $e ) {
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
+		} catch (ConstraintParameterException $e) {
 			// unknown value means “now”
 			return new NowValue();
 		}
@@ -404,14 +404,14 @@ 
 	/**
 	 * Checks whether there is exactly one non-null quantity with the given unit.
 	 */
-	private function exactlyOneQuantityWithUnit( ?DataValue $min, ?DataValue $max, string $unit ): bool {
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
-			!( $max instanceof UnboundedQuantityValue )
+	private function exactlyOneQuantityWithUnit(?DataValue $min, ?DataValue $max, string $unit): bool {
+		if (!($min instanceof UnboundedQuantityValue) ||
+			!($max instanceof UnboundedQuantityValue)
 		) {
 			return false;
 		}
 
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
 	}
 
 	/**
@@ -431,41 +431,41 @@ 
 		string $constraintTypeItemId,
 		string $type
 	): array {
-		$this->checkError( $constraintParameters );
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
-			!array_key_exists( $maximumId, $constraintParameters )
+		$this->checkError($constraintParameters);
+		if (!array_key_exists($minimumId, $constraintParameters) ||
+			!array_key_exists($maximumId, $constraintParameters)
 		) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-needed' ) )
-					->withDataValueType( $type )
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-needed'))
+					->withDataValueType($type)
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $minimumId );
-		$this->requireSingleParameter( $constraintParameters, $maximumId );
+		$this->requireSingleParameter($constraintParameters, $minimumId);
+		$this->requireSingleParameter($constraintParameters, $maximumId);
 		$parseFunction = $type === 'time' ? 'parseValueOrNoValueOrNowParameter' : 'parseValueOrNoValueParameter';
-		$min = $this->$parseFunction( $constraintParameters[$minimumId][0], $minimumId );
-		$max = $this->$parseFunction( $constraintParameters[$maximumId][0], $maximumId );
+		$min = $this->$parseFunction($constraintParameters[$minimumId][0], $minimumId);
+		$max = $this->$parseFunction($constraintParameters[$maximumId][0], $maximumId);
 
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
-		if ( $this->exactlyOneQuantityWithUnit( $min, $max, $yearUnit ) ) {
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
+		if ($this->exactlyOneQuantityWithUnit($min, $max, $yearUnit)) {
 			throw new ConstraintParameterException(
-				new ViolationMessage( 'wbqc-violation-message-range-parameters-one-year' )
+				new ViolationMessage('wbqc-violation-message-range-parameters-one-year')
 			);
 		}
-		if ( $min === null && $max === null ||
-			$min !== null && $max !== null && $min->equals( $max ) ) {
+		if ($min === null && $max === null ||
+			$min !== null && $max !== null && $min->equals($max)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-same' ) )
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		return [ $min, $max ];
+		return [$min, $max];
 	}
 
 	/**
@@ -475,11 +475,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseQuantityRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
+	public function parseQuantityRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
 			$constraintTypeItemId,
 			'quantity'
 		);
@@ -492,11 +492,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseTimeRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
+	public function parseTimeRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
 			$constraintTypeItemId,
 			'time'
 		);
@@ -509,20 +509,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return string[]
 	 */
-	public function parseLanguageParameter( array $constraintParameters, string $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$languagePropertyId = $this->config->get( 'WBQualityConstraintsLanguagePropertyId' );
-		if ( !array_key_exists( $languagePropertyId, $constraintParameters ) ) {
+	public function parseLanguageParameter(array $constraintParameters, string $constraintTypeItemId): array {
+		$this->checkError($constraintParameters);
+		$languagePropertyId = $this->config->get('WBQualityConstraintsLanguagePropertyId');
+		if (!array_key_exists($languagePropertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $languagePropertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($languagePropertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$languages = [];
-		foreach ( $constraintParameters[$languagePropertyId] as $snak ) {
-			$languages[] = $this->parseStringParameter( $snak, $languagePropertyId );
+		foreach ($constraintParameters[$languagePropertyId] as $snak) {
+			$languages[] = $this->parseStringParameter($snak, $languagePropertyId);
 		}
 		return $languages;
 	}
@@ -531,17 +531,17 @@ 
 	 * Parse a single string parameter.
 	 * @throws ConstraintParameterException
 	 */
-	private function parseStringParameter( array $snakSerialization, string $parameterId ): string {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseStringParameter(array $snakSerialization, string $parameterId): string {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof StringValue ) {
+		if ($value instanceof StringValue) {
 			return $value->getValue();
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-string' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -552,15 +552,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseNamespaceParameter( array $constraintParameters, string $constraintTypeItemId ): string {
-		$this->checkError( $constraintParameters );
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
+	public function parseNamespaceParameter(array $constraintParameters, string $constraintTypeItemId): string {
+		$this->checkError($constraintParameters);
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
 			return '';
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
 	}
 
 	/**
@@ -569,19 +569,19 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseFormatParameter( array $constraintParameters, string $constraintTypeItemId ): string {
-		$this->checkError( $constraintParameters );
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
+	public function parseFormatParameter(array $constraintParameters, string $constraintTypeItemId): string {
+		$this->checkError($constraintParameters);
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
+		if (!array_key_exists($formatId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new NumericPropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new NumericPropertyId($formatId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $formatId );
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
+		$this->requireSingleParameter($constraintParameters, $formatId);
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
 	}
 
 	/**
@@ -589,16 +589,16 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return EntityId[]
 	 */
-	public function parseExceptionParameter( array $constraintParameters ): array {
-		$this->checkError( $constraintParameters );
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
+	public function parseExceptionParameter(array $constraintParameters): array {
+		$this->checkError($constraintParameters);
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
 			return [];
 		}
 
 		return array_map(
-			function ( $snakSerialization ) use ( $exceptionId ) {
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
+			function($snakSerialization) use ($exceptionId) {
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
 			},
 			$constraintParameters[$exceptionId]
 		);
@@ -609,39 +609,39 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string|null 'mandatory', 'suggestion' or null
 	 */
-	public function parseConstraintStatusParameter( array $constraintParameters ): ?string {
-		$this->checkError( $constraintParameters );
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
+	public function parseConstraintStatusParameter(array $constraintParameters): ?string {
+		$this->checkError($constraintParameters);
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
 			return null;
 		}
 
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
-		$supportedStatuses = [ new ItemId( $mandatoryId ) ];
-		if ( $this->config->get( 'WBQualityConstraintsEnableSuggestionConstraintStatus' ) ) {
-			$suggestionId = $this->config->get( 'WBQualityConstraintsSuggestionConstraintId' );
-			$supportedStatuses[] = new ItemId( $suggestionId );
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
+		$supportedStatuses = [new ItemId($mandatoryId)];
+		if ($this->config->get('WBQualityConstraintsEnableSuggestionConstraintStatus')) {
+			$suggestionId = $this->config->get('WBQualityConstraintsSuggestionConstraintId');
+			$supportedStatuses[] = new ItemId($suggestionId);
 		} else {
 			$suggestionId = null;
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
-		$this->requireValueParameter( $snak, $constraintStatusId );
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
+		$this->requireValueParameter($snak, $constraintStatusId);
 		'@phan-var \Wikibase\DataModel\Snak\PropertyValueSnak $snak';
 		$dataValue = $snak->getDataValue();
 		'@phan-var EntityIdValue $dataValue';
 		$entityId = $dataValue->getEntityId();
 		$statusId = $entityId->getSerialization();
 
-		if ( $statusId === $mandatoryId ) {
+		if ($statusId === $mandatoryId) {
 			return 'mandatory';
-		} elseif ( $statusId === $suggestionId ) {
+		} elseif ($statusId === $suggestionId) {
 			return 'suggestion';
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new NumericPropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new NumericPropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 					->withEntityIdList(
 						$supportedStatuses,
 						Role::CONSTRAINT_PARAMETER_VALUE
@@ -654,12 +654,12 @@ 
 	 * Require that $dataValue is a {@link MonolingualTextValue}.
 	 * @throws ConstraintParameterException
 	 */
-	private function requireMonolingualTextParameter( DataValue $dataValue, string $parameterId ): void {
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
+	private function requireMonolingualTextParameter(DataValue $dataValue, string $parameterId): void {
+		if (!($dataValue instanceof MonolingualTextValue)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -669,31 +669,31 @@ 
 	 *
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
 	 */
-	private function parseMultilingualTextParameter( array $snakSerializations, string $parameterId ): MultilingualTextValue {
+	private function parseMultilingualTextParameter(array $snakSerializations, string $parameterId): MultilingualTextValue {
 		$result = [];
 
-		foreach ( $snakSerializations as $snakSerialization ) {
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-			$this->requireValueParameter( $snak, $parameterId );
+		foreach ($snakSerializations as $snakSerialization) {
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
+			$this->requireValueParameter($snak, $parameterId);
 
 			$value = $snak->getDataValue();
-			$this->requireMonolingualTextParameter( $value, $parameterId );
+			$this->requireMonolingualTextParameter($value, $parameterId);
 			/** @var MonolingualTextValue $value */
 			'@phan-var MonolingualTextValue $value';
 
 			$code = $value->getLanguageCode();
-			if ( array_key_exists( $code, $result ) ) {
+			if (array_key_exists($code, $result)) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-single-per-language' ) )
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-						->withLanguage( $code )
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+						->withLanguage($code)
 				);
 			}
 
 			$result[$code] = $value;
 		}
 
-		return new MultilingualTextValue( $result );
+		return new MultilingualTextValue($result);
 	}
 
 	/**
@@ -701,11 +701,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseSyntaxClarificationParameter( array $constraintParameters ): MultilingualTextValue {
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
+	public function parseSyntaxClarificationParameter(array $constraintParameters): MultilingualTextValue {
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
 
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
-			return new MultilingualTextValue( [] );
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
+			return new MultilingualTextValue([]);
 		}
 
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -721,11 +721,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseConstraintClarificationParameter( array $constraintParameters ): MultilingualTextValue {
-		$constraintClarificationId = $this->config->get( 'WBQualityConstraintsConstraintClarificationId' );
+	public function parseConstraintClarificationParameter(array $constraintParameters): MultilingualTextValue {
+		$constraintClarificationId = $this->config->get('WBQualityConstraintsConstraintClarificationId');
 
-		if ( !array_key_exists( $constraintClarificationId, $constraintParameters ) ) {
-			return new MultilingualTextValue( [] );
+		if (!array_key_exists($constraintClarificationId, $constraintParameters)) {
+			return new MultilingualTextValue([]);
 		}
 
 		$constraintClarifications = $this->parseMultilingualTextParameter(
@@ -758,14 +758,14 @@ 
 		array $validContextTypes,
 		array $validEntityTypes
 	): array {
-		$contextTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
+		$contextTypeParameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
 		$contextTypeItemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
 			false,
 			$contextTypeParameterId
 		);
-		$entityTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintEntityTypesId' );
+		$entityTypeParameterId = $this->config->get('WBQualityConstraintsConstraintEntityTypesId');
 		$entityTypeItemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -781,26 +781,26 @@ 
 		$contextTypes = null;
 		$entityTypes = null;
 
-		if ( $contextTypeParameterId === $entityTypeParameterId ) {
+		if ($contextTypeParameterId === $entityTypeParameterId) {
 			$itemIds = $contextTypeItemIds;
 			$mapping = $contextTypeMapping + $entityTypeMapping;
-			foreach ( $itemIds as $itemId ) {
-				$mapped = $this->mapItemId( $itemId, $mapping, $contextTypeParameterId );
-				if ( in_array( $mapped, $contextTypeMapping, true ) ) {
+			foreach ($itemIds as $itemId) {
+				$mapped = $this->mapItemId($itemId, $mapping, $contextTypeParameterId);
+				if (in_array($mapped, $contextTypeMapping, true)) {
 					$contextTypes[] = $mapped;
 				} else {
 					$entityTypes[] = $mapped;
 				}
 			}
 		} else {
-			foreach ( $contextTypeItemIds as $contextTypeItemId ) {
+			foreach ($contextTypeItemIds as $contextTypeItemId) {
 				$contextTypes[] = $this->mapItemId(
 					$contextTypeItemId,
 					$contextTypeMapping,
 					$contextTypeParameterId
 				);
 			}
-			foreach ( $entityTypeItemIds as $entityTypeItemId ) {
+			foreach ($entityTypeItemIds as $entityTypeItemId) {
 				$entityTypes[] = $this->mapItemId(
 					$entityTypeItemId,
 					$entityTypeMapping,
@@ -809,21 +809,21 @@ 
 			}
 		}
 
-		$this->checkValidScope( $constraintTypeItemId, $contextTypes, $validContextTypes );
-		$this->checkValidScope( $constraintTypeItemId, $entityTypes, $validEntityTypes );
+		$this->checkValidScope($constraintTypeItemId, $contextTypes, $validContextTypes);
+		$this->checkValidScope($constraintTypeItemId, $entityTypes, $validEntityTypes);
 
-		return [ $contextTypes, $entityTypes ];
+		return [$contextTypes, $entityTypes];
 	}
 
-	private function checkValidScope( string $constraintTypeItemId, ?array $types, array $validTypes ): void {
-		$invalidTypes = array_diff( $types ?: [], $validTypes );
-		if ( $invalidTypes !== [] ) {
-			$invalidType = array_pop( $invalidTypes );
+	private function checkValidScope(string $constraintTypeItemId, ?array $types, array $validTypes): void {
+		$invalidTypes = array_diff($types ?: [], $validTypes);
+		if ($invalidTypes !== []) {
+			$invalidType = array_pop($invalidTypes);
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
-					->withConstraintScope( $invalidType, Role::CONSTRAINT_PARAMETER_VALUE )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withConstraintScopeList( $validTypes, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-invalid-scope'))
+					->withConstraintScope($invalidType, Role::CONSTRAINT_PARAMETER_VALUE)
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withConstraintScopeList($validTypes, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -831,8 +831,8 @@ 
 	/**
 	 * Turn an item ID into a full unit string (using the concept URI).
 	 */
-	private function parseUnitParameter( ItemId $unitId ): string {
-		return $this->unitItemConceptBaseUri . $unitId->getSerialization();
+	private function parseUnitParameter(ItemId $unitId): string {
+		return $this->unitItemConceptBaseUri.$unitId->getSerialization();
 	}
 
 	/**
@@ -840,23 +840,23 @@ 
 	 *
 	 * @throws ConstraintParameterException
 	 */
-	private function parseUnitItem( ItemIdSnakValue $item ): UnitsParameter {
-		switch ( true ) {
+	private function parseUnitItem(ItemIdSnakValue $item): UnitsParameter {
+		switch (true) {
 			case $item->isValue():
-				$unit = $this->parseUnitParameter( $item->getItemId() );
+				$unit = $this->parseUnitParameter($item->getItemId());
 				return new UnitsParameter(
-					[ $item->getItemId() ],
-					[ UnboundedQuantityValue::newFromNumber( 1, $unit ) ],
+					[$item->getItemId()],
+					[UnboundedQuantityValue::newFromNumber(1, $unit)],
 					false
 				);
 			case $item->isSomeValue():
-				$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+				$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
-						->withEntityId( new NumericPropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+						->withEntityId(new NumericPropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			case $item->isNoValue():
-				return new UnitsParameter( [], [], true );
+				return new UnitsParameter([], [], true);
 		}
 	}
 
@@ -866,36 +866,36 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return UnitsParameter
 	 */
-	public function parseUnitsParameter( array $constraintParameters, string $constraintTypeItemId ): UnitsParameter {
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
+	public function parseUnitsParameter(array $constraintParameters, string $constraintTypeItemId): UnitsParameter {
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
 		$unitItems = [];
 		$unitQuantities = [];
 		$unitlessAllowed = false;
 
-		foreach ( $items as $item ) {
-			$unit = $this->parseUnitItem( $item );
-			$unitItems = array_merge( $unitItems, $unit->getUnitItemIds() );
-			$unitQuantities = array_merge( $unitQuantities, $unit->getUnitQuantities() );
+		foreach ($items as $item) {
+			$unit = $this->parseUnitItem($item);
+			$unitItems = array_merge($unitItems, $unit->getUnitItemIds());
+			$unitQuantities = array_merge($unitQuantities, $unit->getUnitQuantities());
 			$unitlessAllowed = $unitlessAllowed || $unit->getUnitlessAllowed();
 		}
 
-		if ( $unitQuantities === [] && !$unitlessAllowed ) {
+		if ($unitQuantities === [] && !$unitlessAllowed) {
 			throw new LogicException(
 				'The "units" parameter is required, and yet we seem to be missing any allowed unit'
 			);
 		}
 
-		return new UnitsParameter( $unitItems, $unitQuantities, $unitlessAllowed );
+		return new UnitsParameter($unitItems, $unitQuantities, $unitlessAllowed);
 	}
 
 	private function getEntityTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsWikibaseItemId' ) => 'item',
-			$this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) => 'property',
-			$this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) => 'lexeme',
-			$this->config->get( 'WBQualityConstraintsWikibaseFormId' ) => 'form',
-			$this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) => 'sense',
-			$this->config->get( 'WBQualityConstraintsWikibaseMediaInfoId' ) => 'mediainfo',
+			$this->config->get('WBQualityConstraintsWikibaseItemId') => 'item',
+			$this->config->get('WBQualityConstraintsWikibasePropertyId') => 'property',
+			$this->config->get('WBQualityConstraintsWikibaseLexemeId') => 'lexeme',
+			$this->config->get('WBQualityConstraintsWikibaseFormId') => 'form',
+			$this->config->get('WBQualityConstraintsWikibaseSenseId') => 'sense',
+			$this->config->get('WBQualityConstraintsWikibaseMediaInfoId') => 'mediainfo',
 		];
 	}
 
@@ -905,10 +905,10 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return EntityTypesParameter
 	 */
-	public function parseEntityTypesParameter( array $constraintParameters, string $constraintTypeItemId ): EntityTypesParameter {
+	public function parseEntityTypesParameter(array $constraintParameters, string $constraintTypeItemId): EntityTypesParameter {
 		$entityTypes = [];
 		$entityTypeItemIds = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 		$itemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -917,22 +917,22 @@ 
 		);
 
 		$mapping = $this->getEntityTypeMapping();
-		foreach ( $itemIds as $itemId ) {
-			$entityType = $this->mapItemId( $itemId, $mapping, $parameterId );
+		foreach ($itemIds as $itemId) {
+			$entityType = $this->mapItemId($itemId, $mapping, $parameterId);
 			$entityTypes[] = $entityType;
 			$entityTypeItemIds[] = $itemId;
 		}
 
-		if ( empty( $entityTypes ) ) {
+		if (empty($entityTypes)) {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'The "entity types" parameter is required, ' .
+				'The "entity types" parameter is required, '.
 				'and yet we seem to be missing any allowed entity type'
 			);
 			// @codeCoverageIgnoreEnd
 		}
 
-		return new EntityTypesParameter( $entityTypes, $entityTypeItemIds );
+		return new EntityTypesParameter($entityTypes, $entityTypeItemIds);
 	}
 
 	/**
@@ -940,18 +940,18 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return PropertyId[]
 	 */
-	public function parseSeparatorsParameter( array $constraintParameters ): array {
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
+	public function parseSeparatorsParameter(array $constraintParameters): array {
+		$separatorId = $this->config->get('WBQualityConstraintsSeparatorId');
 
-		if ( !array_key_exists( $separatorId, $constraintParameters ) ) {
+		if (!array_key_exists($separatorId, $constraintParameters)) {
 			return [];
 		}
 
 		$parameters = $constraintParameters[$separatorId];
 		$separators = [];
 
-		foreach ( $parameters as $parameter ) {
-			$separators[] = $this->parsePropertyIdParameter( $parameter, $separatorId );
+		foreach ($parameters as $parameter) {
+			$separators[] = $this->parsePropertyIdParameter($parameter, $separatorId);
 		}
 
 		return $separators;
@@ -959,17 +959,17 @@ 
 
 	private function getConstraintScopeContextTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' ) => Context::TYPE_STATEMENT,
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' ) => Context::TYPE_QUALIFIER,
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' ) => Context::TYPE_REFERENCE,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId') => Context::TYPE_STATEMENT,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId') => Context::TYPE_QUALIFIER,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId') => Context::TYPE_REFERENCE,
 		];
 	}
 
 	private function getPropertyScopeContextTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsAsMainValueId' ) => Context::TYPE_STATEMENT,
-			$this->config->get( 'WBQualityConstraintsAsQualifiersId' ) => Context::TYPE_QUALIFIER,
-			$this->config->get( 'WBQualityConstraintsAsReferencesId' ) => Context::TYPE_REFERENCE,
+			$this->config->get('WBQualityConstraintsAsMainValueId') => Context::TYPE_STATEMENT,
+			$this->config->get('WBQualityConstraintsAsQualifiersId') => Context::TYPE_QUALIFIER,
+			$this->config->get('WBQualityConstraintsAsReferencesId') => Context::TYPE_REFERENCE,
 		];
 	}
 
@@ -979,9 +979,9 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] list of Context::TYPE_* constants
 	 */
-	public function parsePropertyScopeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
+	public function parsePropertyScopeParameter(array $constraintParameters, string $constraintTypeItemId): array {
 		$contextTypes = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
 		$itemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -990,14 +990,14 @@ 
 		);
 
 		$mapping = $this->getPropertyScopeContextTypeMapping();
-		foreach ( $itemIds as $itemId ) {
-			$contextTypes[] = $this->mapItemId( $itemId, $mapping, $parameterId );
+		foreach ($itemIds as $itemId) {
+			$contextTypes[] = $this->mapItemId($itemId, $mapping, $parameterId);
 		}
 
-		if ( empty( $contextTypes ) ) {
+		if (empty($contextTypes)) {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'The "property scope" parameter is required, ' .
+				'The "property scope" parameter is required, '.
 				'and yet we seem to be missing any allowed scope'
 			);
 			// @codeCoverageIgnoreEnd

src/ConstraintCheck/DelegatingConstraintChecker.php

Spacing +171 added lines, -171 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,25 +201,25 @@ 
 			];
 		}
 
-		return array_keys( array_filter(
+		return array_keys(array_filter(
 			$this->checkerMap[$constraint->getConstraintTypeItemId()]->getSupportedContextTypes(),
-			static function ( $resultStatus ) {
+			static function($resultStatus) {
 				return $resultStatus !== 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 function ( $resultStatus ) {
+			static function($resultStatus) {
 				return $resultStatus !== CheckResult::STATUS_NOT_IN_SCOPE;
 			}
-		) );
+		));
 	}
 
 	/**
@@ -230,38 +230,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;
@@ -274,16 +274,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;
@@ -300,18 +300,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;
@@ -336,14 +336,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;
@@ -365,32 +365,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;
@@ -405,17 +405,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;
 				}
 			}
@@ -439,18 +439,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,
@@ -460,13 +460,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;
@@ -488,24 +488,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);
 			}
 		}
 
@@ -529,19 +529,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
@@ -553,20 +553,20 @@ 
 		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,
@@ -574,30 +574,30 @@ 
 					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);
 		}
 	}
 
@@ -606,97 +606,97 @@ 
 		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());
 		}
 
-		if ( $checkedContextTypes === null ) {
+		if ($checkedContextTypes === null) {
 			$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);
 		}
 
-		if ( $checkedEntityTypes === null ) {
+		if ($checkedEntityTypes === 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);
 			}
-			$result->addParameter( 'constraint_status', $constraintStatus );
+			$result->addParameter('constraint_status', $constraintStatus);
 		} 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
 			}
-			$result->addParameter( 'constraint_status', $constraintStatus );
+			$result->addParameter('constraint_status', $constraintStatus);
 		}
 	}
 
@@ -705,12 +705,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++,
@@ -727,55 +727,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;
 	}

src/ConstraintCheck/Result/CheckResult.php

Spacing +9 added lines, -9 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Result;
 
@@ -117,12 +117,12 @@ 
 		string $status = self::STATUS_TODO,
 		ViolationMessage $message = null
 	) {
-		if ( $contextCursor instanceof Context ) {
+		if ($contextCursor instanceof Context) {
 			$context = $contextCursor;
 			$this->contextCursor = $context->getCursor();
 			$this->snakType = $context->getSnak()->getType();
 			$mainSnak = $context->getSnak();
-			if ( $mainSnak instanceof PropertyValueSnak ) {
+			if ($mainSnak instanceof PropertyValueSnak) {
 				$this->dataValue = $mainSnak->getDataValue();
 			} else {
 				$this->dataValue = null;
@@ -137,7 +137,7 @@ 
 		$this->status = $status;
 		$this->message = $message;
 		$this->metadata = Metadata::blank();
-		$this->constraintClarification = new MultilingualTextValue( [] );
+		$this->constraintClarification = new MultilingualTextValue([]);
 	}
 
 	public function getContextCursor(): ContextCursor {
@@ -173,7 +173,7 @@ 
 		return $this->parameters;
 	}
 
-	public function addParameter( string $key, string $value ): void {
+	public function addParameter(string $key, string $value): void {
 		$this->parameters[$key][] = $value;
 	}
 
@@ -184,7 +184,7 @@ 
 		return $this->status;
 	}
 
-	public function setStatus( string $status ): void {
+	public function setStatus(string $status): void {
 		$this->status = $status;
 	}
 
@@ -192,11 +192,11 @@ 
 		return $this->message;
 	}
 
-	public function setMessage( ?ViolationMessage $message ) {
+	public function setMessage(?ViolationMessage $message) {
 		$this->message = $message;
 	}
 
-	public function withMetadata( Metadata $metadata ): self {
+	public function withMetadata(Metadata $metadata): self {
 		$this->metadata = $metadata;
 		return $this;
 	}
@@ -209,7 +209,7 @@ 
 		return $this->constraintClarification;
 	}
 
-	public function setConstraintClarification( MultilingualTextValue $constraintClarification ) {
+	public function setConstraintClarification(MultilingualTextValue $constraintClarification) {
 		$this->constraintClarification = $constraintClarification;
 	}