wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintsServices.php

Spacing +27 added lines, -27 removed lines

@@ -43,95 +43,95 @@
 	public const VIOLATION_MESSAGE_RENDERER_FACTORY = 'WBQC_ViolationMessageRendererFactory';
 
 	/** @return mixed */
-	private static function getService( ?MediaWikiServices $services, string $name ) {
+	private static function getService(?MediaWikiServices $services, string $name) {
 		$services ??= MediaWikiServices::getInstance();
-		return $services->getService( $name );
+		return $services->getService($name);
 	}
 
-	public static function getLogger( ?MediaWikiServices $services = null ): LoggerInterface {
-		return self::getService( $services, self::LOGGER );
+	public static function getLogger(?MediaWikiServices $services = null): LoggerInterface {
+		return self::getService($services, self::LOGGER);
 	}
 
-	public static function getLoggingHelper( ?MediaWikiServices $services = null ): LoggingHelper {
-		return self::getService( $services, self::LOGGING_HELPER );
+	public static function getLoggingHelper(?MediaWikiServices $services = null): LoggingHelper {
+		return self::getService($services, self::LOGGING_HELPER);
 	}
 
 	public static function getConstraintStore(
 		?MediaWikiServices $services = null
 	): ConstraintStore {
-		return self::getService( $services, self::CONSTRAINT_STORE );
+		return self::getService($services, self::CONSTRAINT_STORE);
 	}
 
-	public static function getConstraintLookup( ?MediaWikiServices $services = null ): ConstraintLookup {
-		return self::getService( $services, self::CONSTRAINT_LOOKUP );
+	public static function getConstraintLookup(?MediaWikiServices $services = null): ConstraintLookup {
+		return self::getService($services, self::CONSTRAINT_LOOKUP);
 	}
 
 	public static function getCheckResultSerializer(
 		?MediaWikiServices $services = null
 	): CheckResultSerializer {
-		return self::getService( $services, self::CHECK_RESULT_SERIALIZER );
+		return self::getService($services, self::CHECK_RESULT_SERIALIZER);
 	}
 
 	public static function getCheckResultDeserializer(
 		?MediaWikiServices $services = null
 	): CheckResultDeserializer {
-		return self::getService( $services, self::CHECK_RESULT_DESERIALIZER );
+		return self::getService($services, self::CHECK_RESULT_DESERIALIZER);
 	}
 
 	public static function getViolationMessageSerializer(
 		?MediaWikiServices $services = null
 	): ViolationMessageSerializer {
-		return self::getService( $services, self::VIOLATION_MESSAGE_SERIALIZER );
+		return self::getService($services, self::VIOLATION_MESSAGE_SERIALIZER);
 	}
 
 	public static function getViolationMessageDeserializer(
 		?MediaWikiServices $services = null
 	): ViolationMessageDeserializer {
-		return self::getService( $services, self::VIOLATION_MESSAGE_DESERIALIZER );
+		return self::getService($services, self::VIOLATION_MESSAGE_DESERIALIZER);
 	}
 
 	public static function getConstraintParameterParser(
 		?MediaWikiServices $services = null
 	): ConstraintParameterParser {
-		return self::getService( $services, self::CONSTRAINT_PARAMETER_PARSER );
+		return self::getService($services, self::CONSTRAINT_PARAMETER_PARSER);
 	}
 
 	public static function getConnectionCheckerHelper(
 		?MediaWikiServices $services = null
 	): ConnectionCheckerHelper {
-		return self::getService( $services, self::CONNECTION_CHECKER_HELPER );
+		return self::getService($services, self::CONNECTION_CHECKER_HELPER);
 	}
 
-	public static function getRangeCheckerHelper( ?MediaWikiServices $services = null ): RangeCheckerHelper {
-		return self::getService( $services, self::RANGE_CHECKER_HELPER );
+	public static function getRangeCheckerHelper(?MediaWikiServices $services = null): RangeCheckerHelper {
+		return self::getService($services, self::RANGE_CHECKER_HELPER);
 	}
 
-	public static function getSparqlHelper( ?MediaWikiServices $services = null ): SparqlHelper {
-		return self::getService( $services, self::SPARQL_HELPER );
+	public static function getSparqlHelper(?MediaWikiServices $services = null): SparqlHelper {
+		return self::getService($services, self::SPARQL_HELPER);
 	}
 
-	public static function getTypeCheckerHelper( ?MediaWikiServices $services = null ): TypeCheckerHelper {
-		return self::getService( $services, self::TYPE_CHECKER_HELPER );
+	public static function getTypeCheckerHelper(?MediaWikiServices $services = null): TypeCheckerHelper {
+		return self::getService($services, self::TYPE_CHECKER_HELPER);
 	}
 
 	public static function getDelegatingConstraintChecker(
 		?MediaWikiServices $services = null
 	): DelegatingConstraintChecker {
-		return self::getService( $services, self::DELEGATING_CONSTRAINT_CHECKER );
+		return self::getService($services, self::DELEGATING_CONSTRAINT_CHECKER);
 	}
 
-	public static function getResultsSource( ?MediaWikiServices $services = null ): ResultsSource {
-		return self::getService( $services, self::RESULTS_SOURCE );
+	public static function getResultsSource(?MediaWikiServices $services = null): ResultsSource {
+		return self::getService($services, self::RESULTS_SOURCE);
 	}
 
-	public static function getExpiryLock( ?MediaWikiServices $services = null ): ExpiryLock {
-		return self::getService( $services, self::EXPIRY_LOCK );
+	public static function getExpiryLock(?MediaWikiServices $services = null): ExpiryLock {
+		return self::getService($services, self::EXPIRY_LOCK);
 	}
 
 	public static function getViolationMessageRendererFactory(
 		?MediaWikiServices $services = null
 	): ViolationMessageRendererFactory {
-		return self::getService( $services, self::VIOLATION_MESSAGE_RENDERER_FACTORY );
+		return self::getService($services, self::VIOLATION_MESSAGE_RENDERER_FACTORY);
 	}
 
 }

src/ConstraintRepositoryStore.php

Spacing +19 added lines, -19 removed lines

@@ -24,16 +24,16 @@ 
 	 * then using the main DBLoadBalancer service may be incorrect.
 	 * @param string|false $dbName Database name ($domain for ILoadBalancer methods).
 	 */
-	public function __construct( ILoadBalancer $lb, $dbName ) {
+	public function __construct(ILoadBalancer $lb, $dbName) {
 		$this->lb = $lb;
 		$this->dbName = $dbName;
 	}
 
-	private function encodeConstraintParameters( array $constraintParameters ): string {
-		$json = json_encode( $constraintParameters, JSON_FORCE_OBJECT );
+	private function encodeConstraintParameters(array $constraintParameters): string {
+		$json = json_encode($constraintParameters, JSON_FORCE_OBJECT);
 
-		if ( strlen( $json ) > 50000 ) {
-			$json = json_encode( [ '@error' => [ 'toolong' => true ] ] );
+		if (strlen($json) > 50000) {
+			$json = json_encode(['@error' => ['toolong' => true]]);
 		}
 
 		return $json;
@@ -44,28 +44,28 @@ 
 	 *
 	 * @throws DBUnexpectedError
 	 */
-	public function insertBatch( array $constraints ) {
-		if ( !$constraints ) {
+	public function insertBatch(array $constraints) {
+		if (!$constraints) {
 			return;
 		}
 
 		$accumulator = array_map(
-			function ( Constraint $constraint ) {
+			function(Constraint $constraint) {
 				return [
 					'constraint_guid' => $constraint->getConstraintId(),
 					'pid' => $constraint->getPropertyId()->getNumericId(),
 					'constraint_type_qid' => $constraint->getConstraintTypeItemId(),
-					'constraint_parameters' => $this->encodeConstraintParameters( $constraint->getConstraintParameters() ),
+					'constraint_parameters' => $this->encodeConstraintParameters($constraint->getConstraintParameters()),
 				];
 			},
 			$constraints
 		);
 
-		$dbw = $this->lb->getConnection( ILoadBalancer::DB_PRIMARY, [], $this->dbName );
+		$dbw = $this->lb->getConnection(ILoadBalancer::DB_PRIMARY, [], $this->dbName);
 		$dbw->newInsertQueryBuilder()
-			->insertInto( 'wbqc_constraints' )
-			->rows( $accumulator )
-			->caller( __METHOD__ )
+			->insertInto('wbqc_constraints')
+			->rows($accumulator)
+			->caller(__METHOD__)
 			->execute();
 	}
 
@@ -76,14 +76,14 @@ 
 	 *
 	 * @throws DBUnexpectedError
 	 */
-	public function deleteForProperty( NumericPropertyId $propertyId ) {
-		$dbw = $this->lb->getConnection( ILoadBalancer::DB_PRIMARY, [], $this->dbName );
+	public function deleteForProperty(NumericPropertyId $propertyId) {
+		$dbw = $this->lb->getConnection(ILoadBalancer::DB_PRIMARY, [], $this->dbName);
 		$dbw->newDeleteQueryBuilder()
-			->deleteFrom( 'wbqc_constraints' )
-			->where( [
+			->deleteFrom('wbqc_constraints')
+			->where([
 				'pid' => $propertyId->getNumericId(),
-			] )
-			->caller( __METHOD__ )
+			])
+			->caller(__METHOD__)
 			->execute();
 	}
 

src/ConstraintCheck/Context/ContextCursor.php

Spacing +2 added lines, -2 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Context;
 
@@ -61,6 +61,6 @@ 
 	 * @param ?array $result
 	 * @param array[] &$container
 	 */
-	public function storeCheckResultInArray( ?array $result, array &$container ): void;
+	public function storeCheckResultInArray(?array $result, array &$container): void;
 
 }

src/ConstraintCheck/Context/QualifierContextCursor.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\Context;
 
@@ -60,29 +60,29 @@ 
 		return $this->snakHash;
 	}
 
-	protected function &getMainArray( array &$container ): array {
-		$statementArray = &$this->getStatementArray( $container );
+	protected function &getMainArray(array &$container): array {
+		$statementArray = &$this->getStatementArray($container);
 
-		if ( !array_key_exists( 'qualifiers', $statementArray ) ) {
+		if (!array_key_exists('qualifiers', $statementArray)) {
 			$statementArray['qualifiers'] = [];
 		}
 		$qualifiersArray = &$statementArray['qualifiers'];
 
 		$snakPropertyId = $this->getSnakPropertyId();
-		if ( !array_key_exists( $snakPropertyId, $qualifiersArray ) ) {
+		if (!array_key_exists($snakPropertyId, $qualifiersArray)) {
 			$qualifiersArray[$snakPropertyId] = [];
 		}
 		$propertyArray = &$qualifiersArray[$snakPropertyId];
 
 		$snakHash = $this->getSnakHash();
-		foreach ( $propertyArray as &$potentialQualifierArray ) {
-			if ( $potentialQualifierArray['hash'] === $snakHash ) {
+		foreach ($propertyArray as &$potentialQualifierArray) {
+			if ($potentialQualifierArray['hash'] === $snakHash) {
 				$qualifierArray = &$potentialQualifierArray;
 				break;
 			}
 		}
-		if ( !isset( $qualifierArray ) ) {
-			$qualifierArray = [ 'hash' => $snakHash ];
+		if (!isset($qualifierArray)) {
+			$qualifierArray = ['hash' => $snakHash];
 			$propertyArray[] = &$qualifierArray;
 		}
 

src/ConstraintCheck/Context/EntityContextCursor.php

Spacing +12 added lines, -12 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Context;
 
@@ -32,7 +32,7 @@ 
 	 * @codeCoverageIgnore This method is not supported.
 	 */
 	public function getType(): string {
-		throw new LogicException( 'EntityContextCursor has no full associated context' );
+		throw new LogicException('EntityContextCursor has no full associated context');
 	}
 
 	public function getEntityId(): string {
@@ -43,35 +43,35 @@ 
 	 * @codeCoverageIgnore This method is not supported.
 	 */
 	public function getStatementPropertyId(): string {
-		throw new LogicException( 'EntityContextCursor has no full associated context' );
+		throw new LogicException('EntityContextCursor has no full associated context');
 	}
 
 	/**
 	 * @codeCoverageIgnore This method is not supported.
 	 */
 	public function getStatementGuid(): string {
-		throw new LogicException( 'EntityContextCursor has no full associated context' );
+		throw new LogicException('EntityContextCursor has no full associated context');
 	}
 
 	/**
 	 * @codeCoverageIgnore This method is not supported.
 	 */
 	public function getSnakPropertyId(): string {
-		throw new LogicException( 'EntityContextCursor has no full associated context' );
+		throw new LogicException('EntityContextCursor has no full associated context');
 	}
 
 	/**
 	 * @codeCoverageIgnore This method is not supported.
 	 */
 	public function getSnakHash(): string {
-		throw new LogicException( 'EntityContextCursor has no full associated context' );
+		throw new LogicException('EntityContextCursor has no full associated context');
 	}
 
 	/**
 	 * @codeCoverageIgnore This method is not supported.
 	 */
-	public function &getMainArray( array &$container ): array {
-		throw new LogicException( 'EntityContextCursor cannot store check results' );
+	public function &getMainArray(array &$container): array {
+		throw new LogicException('EntityContextCursor cannot store check results');
 	}
 
 	/**
@@ -80,14 +80,14 @@ 
 	 * @param ?array $result must be null
 	 * @param array[] &$container
 	 */
-	public function storeCheckResultInArray( ?array $result, array &$container ): void {
-		if ( $result !== null ) {
-			throw new LogicException( 'EntityContextCursor cannot store check results' );
+	public function storeCheckResultInArray(?array $result, array &$container): void {
+		if ($result !== null) {
+			throw new LogicException('EntityContextCursor cannot store check results');
 		}
 
 		// this ensures that the claims array is present in the $container,
 		// populating it if necessary, even though we ignore the return value
-		$this->getClaimsArray( $container );
+		$this->getClaimsArray($container);
 	}
 
 }

src/ConstraintCheck/Context/ApiV2ContextCursor.php

Spacing +16 added lines, -16 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Context;
 
@@ -29,15 +29,15 @@ 
 	 * @param array[] &$container
 	 * @return array
 	 */
-	protected function &getClaimsArray( array &$container ): array {
+	protected function &getClaimsArray(array &$container): array {
 		$entityId = $this->getEntityId();
 
-		if ( !array_key_exists( $entityId, $container ) ) {
+		if (!array_key_exists($entityId, $container)) {
 			$container[$entityId] = [];
 		}
 		$entityContainer = &$container[$entityId];
 
-		if ( !array_key_exists( 'claims', $entityContainer ) ) {
+		if (!array_key_exists('claims', $entityContainer)) {
 			$entityContainer['claims'] = [];
 		}
 		$claimsArray = &$entityContainer['claims'];
@@ -51,25 +51,25 @@ 
 	 * @param array[] &$container
 	 * @return array
 	 */
-	protected function &getStatementArray( array &$container ): array {
+	protected function &getStatementArray(array &$container): array {
 		$statementPropertyId = $this->getStatementPropertyId();
 		$statementGuid = $this->getStatementGuid();
 
-		$claimsContainer = &$this->getClaimsArray( $container );
+		$claimsContainer = &$this->getClaimsArray($container);
 
-		if ( !array_key_exists( $statementPropertyId, $claimsContainer ) ) {
+		if (!array_key_exists($statementPropertyId, $claimsContainer)) {
 			$claimsContainer[$statementPropertyId] = [];
 		}
 		$propertyContainer = &$claimsContainer[$statementPropertyId];
 
-		foreach ( $propertyContainer as &$statement ) {
-			if ( $statement['id'] === $statementGuid ) {
+		foreach ($propertyContainer as &$statement) {
+			if ($statement['id'] === $statementGuid) {
 				$statementArray = &$statement;
 				break;
 			}
 		}
-		if ( !isset( $statementArray ) ) {
-			$statementArray = [ 'id' => $statementGuid ];
+		if (!isset($statementArray)) {
+			$statementArray = ['id' => $statementGuid];
 			$propertyContainer[] = &$statementArray;
 		}
 
@@ -84,19 +84,19 @@ 
 	 * @param array[] &$container
 	 * @return array
 	 */
-	abstract protected function &getMainArray( array &$container ): array;
+	abstract protected function &getMainArray(array &$container): array;
 
 	/**
 	 * @param ?array $result
 	 * @param array[] &$container
 	 */
-	public function storeCheckResultInArray( ?array $result, array &$container ): void {
-		$mainArray = &$this->getMainArray( $container );
-		if ( !array_key_exists( 'results', $mainArray ) ) {
+	public function storeCheckResultInArray(?array $result, array &$container): void {
+		$mainArray = &$this->getMainArray($container);
+		if (!array_key_exists('results', $mainArray)) {
 			$mainArray['results'] = [];
 		}
 
-		if ( $result !== null ) {
+		if ($result !== null) {
 			$mainArray['results'][] = $result;
 		}
 	}

src/ConstraintCheck/Context/MainSnakContextCursor.php

Spacing +5 added lines, -5 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Context;
 
@@ -56,12 +56,12 @@ 
 		return $this->snakHash;
 	}
 
-	protected function &getMainArray( array &$container ): array {
-		$statementArray = &$this->getStatementArray( $container );
+	protected function &getMainArray(array &$container): array {
+		$statementArray = &$this->getStatementArray($container);
 
-		if ( !array_key_exists( 'mainsnak', $statementArray ) ) {
+		if (!array_key_exists('mainsnak', $statementArray)) {
 			$snakHash = $this->getSnakHash();
-			$statementArray['mainsnak'] = [ 'hash' => $snakHash ];
+			$statementArray['mainsnak'] = ['hash' => $snakHash];
 		}
 		$mainsnakArray = &$statementArray['mainsnak'];
 

src/ConstraintCheck/Context/ReferenceContextCursor.php

Spacing +13 added lines, -13 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Context;
 
@@ -68,43 +68,43 @@ 
 		return $this->referenceHash;
 	}
 
-	protected function &getMainArray( array &$container ): array {
-		$statementArray = &$this->getStatementArray( $container );
+	protected function &getMainArray(array &$container): array {
+		$statementArray = &$this->getStatementArray($container);
 
-		if ( !array_key_exists( 'references', $statementArray ) ) {
+		if (!array_key_exists('references', $statementArray)) {
 			$statementArray['references'] = [];
 		}
 		$referencesArray = &$statementArray['references'];
 
 		$referenceHash = $this->getReferenceHash();
-		foreach ( $referencesArray as &$potentialReferenceArray ) {
-			if ( $potentialReferenceArray['hash'] === $referenceHash ) {
+		foreach ($referencesArray as &$potentialReferenceArray) {
+			if ($potentialReferenceArray['hash'] === $referenceHash) {
 				$referenceArray = &$potentialReferenceArray;
 				break;
 			}
 		}
-		if ( !isset( $referenceArray ) ) {
-			$referenceArray = [ 'hash' => $referenceHash, 'snaks' => [] ];
+		if (!isset($referenceArray)) {
+			$referenceArray = ['hash' => $referenceHash, 'snaks' => []];
 			$referencesArray[] = &$referenceArray;
 		}
 
 		$snaksArray = &$referenceArray['snaks'];
 
 		$snakPropertyId = $this->getSnakPropertyId();
-		if ( !array_key_exists( $snakPropertyId, $snaksArray ) ) {
+		if (!array_key_exists($snakPropertyId, $snaksArray)) {
 			$snaksArray[$snakPropertyId] = [];
 		}
 		$propertyArray = &$snaksArray[$snakPropertyId];
 
 		$snakHash = $this->getSnakHash();
-		foreach ( $propertyArray as &$potentialSnakArray ) {
-			if ( $potentialSnakArray['hash'] === $snakHash ) {
+		foreach ($propertyArray as &$potentialSnakArray) {
+			if ($potentialSnakArray['hash'] === $snakHash) {
 				$snakArray = &$potentialSnakArray;
 				break;
 			}
 		}
-		if ( !isset( $snakArray ) ) {
-			$snakArray = [ 'hash' => $snakHash ];
+		if (!isset($snakArray)) {
+			$snakArray = ['hash' => $snakHash];
 			$propertyArray[] = &$snakArray;
 		}
 

src/ConstraintCheck/Helper/SparqlHelper.php

Spacing +232 added lines, -236 removed lines

@@ -1,6 +1,6 @@ 
 <?php
 
-declare( strict_types = 1 );
+declare(strict_types=1);
 
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Helper;
 
@@ -166,143 +166,143 @@ 
 		$this->defaultUserAgent = $defaultUserAgent;
 		$this->requestFactory = $requestFactory;
 		$this->entityPrefixes = [];
-		foreach ( $rdfVocabulary->entityNamespaceNames as $namespaceName ) {
-			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI( $namespaceName );
+		foreach ($rdfVocabulary->entityNamespaceNames as $namespaceName) {
+			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI($namespaceName);
 		}
 
-		$this->primaryEndpoint = $config->get( 'WBQualityConstraintsSparqlEndpoint' );
-		$this->additionalEndpoints = $config->get( 'WBQualityConstraintsAdditionalSparqlEndpoints' ) ?: [];
-		$this->maxQueryTimeMillis = $config->get( 'WBQualityConstraintsSparqlMaxMillis' );
-		$this->subclassOfId = new NumericPropertyId( $config->get( 'WBQualityConstraintsSubclassOfId' ) );
-		$this->cacheMapSize = $config->get( 'WBQualityConstraintsFormatCacheMapSize' );
+		$this->primaryEndpoint = $config->get('WBQualityConstraintsSparqlEndpoint');
+		$this->additionalEndpoints = $config->get('WBQualityConstraintsAdditionalSparqlEndpoints') ?: [];
+		$this->maxQueryTimeMillis = $config->get('WBQualityConstraintsSparqlMaxMillis');
+		$this->subclassOfId = new NumericPropertyId($config->get('WBQualityConstraintsSubclassOfId'));
+		$this->cacheMapSize = $config->get('WBQualityConstraintsFormatCacheMapSize');
 		$this->timeoutExceptionClasses = $config->get(
 			'WBQualityConstraintsSparqlTimeoutExceptionClasses'
 		);
 		$this->sparqlHasWikibaseSupport = $config->get(
 			'WBQualityConstraintsSparqlHasWikibaseSupport'
 		);
-		$this->sparqlThrottlingFallbackDuration = (int)$config->get(
+		$this->sparqlThrottlingFallbackDuration = (int) $config->get(
 			'WBQualityConstraintsSparqlThrottlingFallbackDuration'
 		);
 
-		$this->prefixes = $this->getQueryPrefixes( $rdfVocabulary );
+		$this->prefixes = $this->getQueryPrefixes($rdfVocabulary);
 
 		$this->rdfVocabularyWithoutNormalization = clone $rdfVocabulary;
 		// @phan-suppress-next-line PhanTypeMismatchProperty
 		$this->rdfVocabularyWithoutNormalization->normalizedPropertyValueNamespace = array_fill_keys(
-			array_keys( $rdfVocabulary->normalizedPropertyValueNamespace ),
+			array_keys($rdfVocabulary->normalizedPropertyValueNamespace),
 			null
 		);
 	}
 
-	private function getQueryPrefixes( RdfVocabulary $rdfVocabulary ): string {
+	private function getQueryPrefixes(RdfVocabulary $rdfVocabulary): string {
 		// TODO: it would probably be smarter that RdfVocabulary exposed these prefixes somehow
 		$prefixes = '';
-		foreach ( $rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName ) {
+		foreach ($rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName) {
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 
-		foreach ( $rdfVocabulary->statementNamespaceNames as $sourceName => $sourceNamespaces ) {
+		foreach ($rdfVocabulary->statementNamespaceNames as $sourceName => $sourceNamespaces) {
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NS_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 
-		foreach ( $rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces ) {
+		foreach ($rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces) {
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_DIRECT_CLAIM];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM_STATEMENT];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 		$namespaceName = RdfVocabulary::NS_ONTOLOGY;
 		$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		return $prefixes;
 	}
 
 	/** Return a SPARQL term like `wd:Q123` for the given ID. */
-	private function wd( EntityId $id ): string {
-		$repository = $this->rdfVocabulary->getEntityRepositoryName( $id );
+	private function wd(EntityId $id): string {
+		$repository = $this->rdfVocabulary->getEntityRepositoryName($id);
 		$prefix = $this->rdfVocabulary->entityNamespaceNames[$repository];
 		return "$prefix:{$id->getSerialization()}";
 	}
 
 	/** Return a SPARQL term like `wdt:P123` for the given ID. */
-	private function wdt( PropertyId $id ): string {
-		$repository = $this->rdfVocabulary->getEntityRepositoryName( $id );
+	private function wdt(PropertyId $id): string {
+		$repository = $this->rdfVocabulary->getEntityRepositoryName($id);
 		$prefix = $this->rdfVocabulary->propertyNamespaceNames[$repository][RdfVocabulary::NSP_DIRECT_CLAIM];
 		return "$prefix:{$id->getSerialization()}";
 	}
 
 	/** Return a SPARQL term like `p:P123` for the given ID. */
-	private function p( PropertyId $id ): string {
-		$repository = $this->rdfVocabulary->getEntityRepositoryName( $id );
+	private function p(PropertyId $id): string {
+		$repository = $this->rdfVocabulary->getEntityRepositoryName($id);
 		$prefix = $this->rdfVocabulary->propertyNamespaceNames[$repository][RdfVocabulary::NSP_CLAIM];
 		return "$prefix:{$id->getSerialization()}";
 	}
 
 	/** Return a SPARQL term like `pq:P123` for the given ID. */
-	private function pq( PropertyId $id ): string {
-		$repository = $this->rdfVocabulary->getEntityRepositoryName( $id );
+	private function pq(PropertyId $id): string {
+		$repository = $this->rdfVocabulary->getEntityRepositoryName($id);
 		$prefix = $this->rdfVocabulary->propertyNamespaceNames[$repository][RdfVocabulary::NSP_QUALIFIER];
 		return "$prefix:{$id->getSerialization()}";
 	}
 
 	/** Return a SPARQL term like `wdno:P123` for the given ID. */
-	private function wdno( PropertyId $id ): string {
-		$repository = $this->rdfVocabulary->getEntityRepositoryName( $id );
+	private function wdno(PropertyId $id): string {
+		$repository = $this->rdfVocabulary->getEntityRepositoryName($id);
 		$prefix = $this->rdfVocabulary->propertyNamespaceNames[$repository][RdfVocabulary::NSP_NOVALUE];
 		return "$prefix:{$id->getSerialization()}";
 	}
 
 	/** Return a SPARQL term like `prov:NAME` for the given name. */
-	private function prov( string $name ): string {
+	private function prov(string $name): string {
 		$prefix = RdfVocabulary::NS_PROV;
 		return "$prefix:$name";
 	}
 
 	/** Return a SPARQL term like `wikibase:NAME` for the given name. */
-	private function wikibase( string $name ): string {
+	private function wikibase(string $name): string {
 		$prefix = RdfVocabulary::NS_ONTOLOGY;
 		return "$prefix:$name";
 	}
 
 	/** Return a SPARQL snippet like `MINUS { ?var wikibase:rank wikibase:DeprecatedRank. }`. */
-	private function minusDeprecatedRank( string $varName ): string {
+	private function minusDeprecatedRank(string $varName): string {
 		$deprecatedRank = RdfVocabulary::RANK_MAP[Statement::RANK_DEPRECATED];
-		return "MINUS { $varName {$this->wikibase( 'rank' )} {$this->wikibase( $deprecatedRank )}. }";
+		return "MINUS { $varName {$this->wikibase('rank')} {$this->wikibase($deprecatedRank)}. }";
 	}
 
 	/**
@@ -312,43 +312,42 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function hasType( EntityId $id, array $classes ): CachedBool {
+	public function hasType(EntityId $id, array $classes): CachedBool {
 		// TODO hint:gearing is a workaround for T168973 and can hopefully be removed eventually
 		$gearingHint = $this->sparqlHasWikibaseSupport ?
-			' hint:Prior hint:gearing "forward".' :
-			'';
+			' hint:Prior hint:gearing "forward".' : '';
 
 		$metadatas = [];
 
-		foreach ( array_chunk( $classes, 20 ) as $classesChunk ) {
-			$classesValues = implode( ' ', array_map(
-				function ( string $class ) {
-					return $this->wd( new ItemId( $class ) );
+		foreach (array_chunk($classes, 20) as $classesChunk) {
+			$classesValues = implode(' ', array_map(
+				function(string $class) {
+					return $this->wd(new ItemId($class));
 				},
 				$classesChunk
-			) );
+			));
 
 			$query = <<<EOF
 ASK {
-  BIND({$this->wd( $id )} AS ?item)
+  BIND({$this->wd($id)} AS ?item)
   VALUES ?class { $classesValues }
-  ?item {$this->wdt( $this->subclassOfId )}* ?class.$gearingHint
+  ?item {$this->wdt($this->subclassOfId)}* ?class.$gearingHint
 }
 EOF;
 
-			$result = $this->runQuery( $query, $this->primaryEndpoint );
+			$result = $this->runQuery($query, $this->primaryEndpoint);
 			$metadatas[] = $result->getMetadata();
-			if ( $result->getArray()['boolean'] ) {
+			if ($result->getArray()['boolean']) {
 				return new CachedBool(
 					true,
-					Metadata::merge( $metadatas )
+					Metadata::merge($metadatas)
 				);
 			}
 		}
 
 		return new CachedBool(
 			false,
-			Metadata::merge( $metadatas )
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -366,12 +365,12 @@ 
 		array $separators
 	): CachedEntityIds {
 		$mainSnak = $statement->getMainSnak();
-		if ( !( $mainSnak instanceof PropertyValueSnak ) ) {
-			return new CachedEntityIds( [], Metadata::blank() );
+		if (!($mainSnak instanceof PropertyValueSnak)) {
+			return new CachedEntityIds([], Metadata::blank());
 		}
 
 		$propertyId = $statement->getPropertyId();
-		$pPredicateAndObject = "{$this->p( $propertyId )} ?otherStatement."; // p:P123 ?otherStatement.
+		$pPredicateAndObject = "{$this->p($propertyId)} ?otherStatement."; // p:P123 ?otherStatement.
 		$otherStatementPredicateAndObject = $this->getSnakPredicateAndObject(
 			$entityId,
 			$mainSnak,
@@ -380,57 +379,57 @@ 
 
 		$isSeparator = [];
 		$unusedSeparators = [];
-		foreach ( $separators as $separator ) {
+		foreach ($separators as $separator) {
 			$isSeparator[$separator->getSerialization()] = true;
 			$unusedSeparators[$separator->getSerialization()] = $separator;
 		}
 		$separatorFilters = '';
-		foreach ( $statement->getQualifiers() as $qualifier ) {
+		foreach ($statement->getQualifiers() as $qualifier) {
 			$qualPropertyId = $qualifier->getPropertyId();
-			if ( !( $isSeparator[$qualPropertyId->getSerialization()] ?? false ) ) {
+			if (!($isSeparator[$qualPropertyId->getSerialization()] ?? false)) {
 				continue;
 			}
-			unset( $unusedSeparators[$qualPropertyId->getSerialization()] );
+			unset($unusedSeparators[$qualPropertyId->getSerialization()]);
 			// only look for other statements with the same qualifier
-			if ( $qualifier instanceof PropertyValueSnak ) {
+			if ($qualifier instanceof PropertyValueSnak) {
 				$sepPredicateAndObject = $this->getSnakPredicateAndObject(
 					$entityId,
 					$qualifier,
 					RdfVocabulary::NSP_QUALIFIER
 				);
 				$separatorFilters .= "  ?otherStatement $sepPredicateAndObject\n";
-			} elseif ( $qualifier instanceof PropertyNoValueSnak ) {
-				$sepPredicateAndObject = "a {$this->wdno( $qualPropertyId )}."; // a wdno:P123.
+			} elseif ($qualifier instanceof PropertyNoValueSnak) {
+				$sepPredicateAndObject = "a {$this->wdno($qualPropertyId)}."; // a wdno:P123.
 				$separatorFilters .= "  ?otherStatement $sepPredicateAndObject\n";
 			} else {
 				// "some value" / "unknown value" is always different from everything else,
 				// therefore the whole statement has no duplicates and we can return immediately
-				return new CachedEntityIds( [], Metadata::blank() );
+				return new CachedEntityIds([], Metadata::blank());
 			}
 		}
-		foreach ( $unusedSeparators as $unusedSeparator ) {
+		foreach ($unusedSeparators as $unusedSeparator) {
 			// exclude other statements which have a separator that this one lacks
-			$separatorFilters .= "  MINUS { ?otherStatement {$this->pq( $unusedSeparator )} []. }\n";
-			$separatorFilters .= "  MINUS { ?otherStatement a {$this->wdno( $unusedSeparator )}. }\n";
+			$separatorFilters .= "  MINUS { ?otherStatement {$this->pq($unusedSeparator)} []. }\n";
+			$separatorFilters .= "  MINUS { ?otherStatement a {$this->wdno($unusedSeparator)}. }\n";
 		}
 
 		$query = <<<SPARQL
 SELECT DISTINCT ?otherEntity WHERE {
   ?otherEntity $pPredicateAndObject
   ?otherStatement $otherStatementPredicateAndObject
-  {$this->minusDeprecatedRank( '?otherStatement' )}
-  FILTER(?otherEntity != {$this->wd( $entityId )})
+  {$this->minusDeprecatedRank('?otherStatement')}
+  FILTER(?otherEntity != {$this->wd($entityId)})
 $separatorFilters
 }
 LIMIT 10
 SPARQL;
 
-		$results = [ $this->runQuery( $query, $this->primaryEndpoint ) ];
-		foreach ( $this->additionalEndpoints as $endpoint ) {
-			$results[] = $this->runQuery( $query, $endpoint );
+		$results = [$this->runQuery($query, $this->primaryEndpoint)];
+		foreach ($this->additionalEndpoints as $endpoint) {
+			$results[] = $this->runQuery($query, $endpoint);
 		}
 
-		return $this->getOtherEntities( $results );
+		return $this->getOtherEntities($results);
 	}
 
 	/**
@@ -449,40 +448,38 @@ 
 		bool $ignoreDeprecatedStatements
 	): CachedEntityIds {
 		$propertyId = $snak->getPropertyId();
-		$pPredicateAndObject = "{$this->p( $propertyId )} ?otherStatement."; // p:P123 ?otherStatement.
+		$pPredicateAndObject = "{$this->p($propertyId)} ?otherStatement."; // p:P123 ?otherStatement.
 
 		$otherSubject = $type === Context::TYPE_QUALIFIER ?
-			'?otherStatement' :
-			"?otherStatement {$this->prov( 'wasDerivedFrom' )} ?reference.\n  ?reference";
+			'?otherStatement' : "?otherStatement {$this->prov('wasDerivedFrom')} ?reference.\n  ?reference";
 		$otherPredicateAndObject = $this->getSnakPredicateAndObject(
 			$entityId,
 			$snak,
 			$type === Context::TYPE_QUALIFIER ?
-				RdfVocabulary::NSP_QUALIFIER :
-				RdfVocabulary::NSP_REFERENCE
+				RdfVocabulary::NSP_QUALIFIER : RdfVocabulary::NSP_REFERENCE
 		);
 
 		$deprecatedFilter = '';
-		if ( $ignoreDeprecatedStatements ) {
-			$deprecatedFilter = '  ' . $this->minusDeprecatedRank( '?otherStatement' );
+		if ($ignoreDeprecatedStatements) {
+			$deprecatedFilter = '  '.$this->minusDeprecatedRank('?otherStatement');
 		}
 
 		$query = <<<SPARQL
 SELECT DISTINCT ?otherEntity WHERE {
   ?otherEntity $pPredicateAndObject
   $otherSubject $otherPredicateAndObject
-  FILTER(?otherEntity != {$this->wd( $entityId )})
+  FILTER(?otherEntity != {$this->wd($entityId)})
 $deprecatedFilter
 }
 LIMIT 10
 SPARQL;
 
-		$results = [ $this->runQuery( $query, $this->primaryEndpoint ) ];
-		foreach ( $this->additionalEndpoints as $endpoint ) {
-			$results[] = $this->runQuery( $query, $endpoint );
+		$results = [$this->runQuery($query, $this->primaryEndpoint)];
+		foreach ($this->additionalEndpoints as $endpoint) {
+			$results[] = $this->runQuery($query, $endpoint);
 		}
 
-		return $this->getOtherEntities( $results );
+		return $this->getOtherEntities($results);
 	}
 
 	/**
@@ -513,13 +510,13 @@ 
 		$writer->start();
 		$writer->drain();
 		$placeholder1 = 'wbqc';
-		$placeholder2 = 'x' . wfRandomString( 32 );
-		$writer->about( $placeholder1, $placeholder2 );
+		$placeholder2 = 'x'.wfRandomString(32);
+		$writer->about($placeholder1, $placeholder2);
 
 		$propertyId = $snak->getPropertyId();
 		$pid = $propertyId->getSerialization();
-		$propertyRepository = $this->rdfVocabulary->getEntityRepositoryName( $propertyId );
-		$entityRepository = $this->rdfVocabulary->getEntityRepositoryName( $entityId );
+		$propertyRepository = $this->rdfVocabulary->getEntityRepositoryName($propertyId);
+		$entityRepository = $this->rdfVocabulary->getEntityRepositoryName($entityId);
 		$propertyNamespace = $this->rdfVocabulary->propertyNamespaceNames[$propertyRepository][$namespace];
 		$value = $snak->getDataValue();
 		if (
@@ -550,21 +547,21 @@ 
 				$writer,
 				$propertyNamespace,
 				$pid,
-				$this->propertyDataTypeLookup->getDataTypeIdForProperty( $propertyId ),
+				$this->propertyDataTypeLookup->getDataTypeIdForProperty($propertyId),
 				$this->rdfVocabulary->statementNamespaceNames[$entityRepository][RdfVocabulary::NS_VALUE], // should be unused
 				$snak
 			);
 		}
 
 		$triple = $writer->drain(); // wbqc:xRANDOM ps:PID "value". or similar
-		return trim( str_replace( "$placeholder1:$placeholder2", '', $triple ) );
+		return trim(str_replace("$placeholder1:$placeholder2", '', $triple));
 	}
 
 	/**
 	 * Return SPARQL code for a string literal with $text as content.
 	 */
-	private function stringLiteral( string $text ): string {
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
+	private function stringLiteral(string $text): string {
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
 	}
 
 	/**
@@ -574,26 +571,26 @@ 
 	 *
 	 * @return CachedEntityIds
 	 */
-	private function getOtherEntities( array $results ): CachedEntityIds {
+	private function getOtherEntities(array $results): CachedEntityIds {
 		$allResultBindings = [];
 		$metadatas = [];
 
-		foreach ( $results as $result ) {
+		foreach ($results as $result) {
 			$metadatas[] = $result->getMetadata();
-			$allResultBindings = array_merge( $allResultBindings, $result->getArray()['results']['bindings'] );
+			$allResultBindings = array_merge($allResultBindings, $result->getArray()['results']['bindings']);
 		}
 
 		$entityIds = array_map(
-			function ( $resultBindings ) {
+			function($resultBindings) {
 				$entityIRI = $resultBindings['otherEntity']['value'];
-				foreach ( $this->entityPrefixes as $entityPrefix ) {
-					$entityPrefixLength = strlen( $entityPrefix );
-					if ( substr( $entityIRI, 0, $entityPrefixLength ) === $entityPrefix ) {
+				foreach ($this->entityPrefixes as $entityPrefix) {
+					$entityPrefixLength = strlen($entityPrefix);
+					if (substr($entityIRI, 0, $entityPrefixLength) === $entityPrefix) {
 						try {
 							return $this->entityIdParser->parse(
-								substr( $entityIRI, $entityPrefixLength )
+								substr($entityIRI, $entityPrefixLength)
 							);
-						} catch ( EntityIdParsingException $e ) {
+						} catch (EntityIdParsingException $e) {
 							// fall through
 						}
 					}
@@ -607,8 +604,8 @@ 
 		);
 
 		return new CachedEntityIds(
-			array_values( array_filter( array_unique( $entityIds ) ) ),
-			Metadata::merge( $metadatas )
+			array_values(array_filter(array_unique($entityIds))),
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -616,63 +613,63 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpression( string $text, string $regex ): bool {
+	public function matchesRegularExpression(string $text, string $regex): bool {
 		// caching wrapper around matchesRegularExpressionWithSparql
 
-		$textHash = hash( 'sha256', $text );
+		$textHash = hash('sha256', $text);
 		$cacheKey = $this->cache->makeKey(
 			'WikibaseQualityConstraints', // extension
 			'regex', // action
 			'WDQS-Java', // regex flavor
-			hash( 'sha256', $regex )
+			hash('sha256', $regex)
 		);
 
 		$baseRegexCacheKey = 'wikibase.quality.constraints.regex.cache';
-		$metric = $this->statsFactory->getCounter( 'regex_cache_total' );
+		$metric = $this->statsFactory->getCounter('regex_cache_total');
 
 		$cacheMapArray = $this->cache->getWithSetCallback(
 			$cacheKey,
 			WANObjectCache::TTL_DAY,
-			function ( $cacheMapArray ) use ( $text, $regex, $textHash, $metric, $baseRegexCacheKey ) {
+			function($cacheMapArray) use ($text, $regex, $textHash, $metric, $baseRegexCacheKey) {
 				// Initialize the cache map if not set
-				if ( $cacheMapArray === false ) {
+				if ($cacheMapArray === false) {
 					$metric
-						->setLabel( 'operation', 'refresh' )
-						->setLabel( 'status', 'init' )
-						->copyToStatsdAt( [
+						->setLabel('operation', 'refresh')
+						->setLabel('status', 'init')
+						->copyToStatsdAt([
 							"$baseRegexCacheKey.refresh.init",
-						] )->increment();
+						])->increment();
 
 					return [];
 				}
 
-				$cacheMap = MapCacheLRU::newFromArray( $cacheMapArray, $this->cacheMapSize );
-				if ( $cacheMap->has( $textHash ) ) {
+				$cacheMap = MapCacheLRU::newFromArray($cacheMapArray, $this->cacheMapSize);
+				if ($cacheMap->has($textHash)) {
 					$metric
-						->setLabel( 'operation', 'refresh' )
-						->setLabel( 'status', 'hit' )
-						->copyToStatsdAt( [
+						->setLabel('operation', 'refresh')
+						->setLabel('status', 'hit')
+						->copyToStatsdAt([
 							"$baseRegexCacheKey.refresh",
 							"$baseRegexCacheKey.refresh.hit",
-						] )
+						])
 						->increment();
 
-					$cacheMap->get( $textHash ); // ping cache
+					$cacheMap->get($textHash); // ping cache
 				} else {
 					$metric
-						->setLabel( 'operation', 'refresh' )
-						->setLabel( 'status', 'miss' )
-						->copyToStatsdAt( [
+						->setLabel('operation', 'refresh')
+						->setLabel('status', 'miss')
+						->copyToStatsdAt([
 							"$baseRegexCacheKey.refresh",
 							"$baseRegexCacheKey.refresh.miss",
-						] )
+						])
 						->increment();
 
 					try {
-						$matches = $this->matchesRegularExpressionWithSparql( $text, $regex );
-					} catch ( ConstraintParameterException $e ) {
-						$matches = $this->serializeConstraintParameterException( $e );
-					} catch ( SparqlHelperException $e ) {
+						$matches = $this->matchesRegularExpressionWithSparql($text, $regex);
+					} catch (ConstraintParameterException $e) {
+						$matches = $this->serializeConstraintParameterException($e);
+					} catch (SparqlHelperException $e) {
 						// don’t cache this
 						return $cacheMap->toArray();
 					}
@@ -696,54 +693,54 @@ 
 			]
 		);
 
-		if ( isset( $cacheMapArray[$textHash] ) ) {
+		if (isset($cacheMapArray[$textHash])) {
 			$metric
-				->setLabel( 'operation', 'none' )
-				->setLabel( 'status', 'hit' )
-				->copyToStatsdAt( [
+				->setLabel('operation', 'none')
+				->setLabel('status', 'hit')
+				->copyToStatsdAt([
 					"$baseRegexCacheKey.hit",
-				] )
+				])
 				->increment();
 
 			$matches = $cacheMapArray[$textHash];
-			if ( is_bool( $matches ) ) {
+			if (is_bool($matches)) {
 				return $matches;
-			} elseif ( is_array( $matches ) &&
-				$matches['type'] == ConstraintParameterException::class ) {
-				throw $this->deserializeConstraintParameterException( $matches );
+			} elseif (is_array($matches) &&
+				$matches['type'] == ConstraintParameterException::class) {
+				throw $this->deserializeConstraintParameterException($matches);
 			} else {
 				throw new UnexpectedValueException(
-					'Value of unknown type in object cache (' .
-					'cache key: ' . $cacheKey . ', ' .
-					'cache map key: ' . $textHash . ', ' .
-					'value type: ' . get_debug_type( $matches ) . ')'
+					'Value of unknown type in object cache ('.
+					'cache key: '.$cacheKey.', '.
+					'cache map key: '.$textHash.', '.
+					'value type: '.get_debug_type($matches).')'
 				);
 			}
 		} else {
 			$metric
-				->setLabel( 'operation', 'none' )
-				->setLabel( 'status', 'miss' )
-				->copyToStatsdAt( [
+				->setLabel('operation', 'none')
+				->setLabel('status', 'miss')
+				->copyToStatsdAt([
 					"$baseRegexCacheKey.miss",
-				] )
+				])
 				->increment();
 
-			return $this->matchesRegularExpressionWithSparql( $text, $regex );
+			return $this->matchesRegularExpressionWithSparql($text, $regex);
 		}
 	}
 
-	private function serializeConstraintParameterException( ConstraintParameterException $cpe ): array {
+	private function serializeConstraintParameterException(ConstraintParameterException $cpe): array {
 		return [
 			'type' => ConstraintParameterException::class,
-			'violationMessage' => $this->violationMessageSerializer->serialize( $cpe->getViolationMessage() ),
+			'violationMessage' => $this->violationMessageSerializer->serialize($cpe->getViolationMessage()),
 		];
 	}
 
-	private function deserializeConstraintParameterException( array $serialization ): ConstraintParameterException {
+	private function deserializeConstraintParameterException(array $serialization): ConstraintParameterException {
 		$message = $this->violationMessageDeserializer->deserialize(
 			$serialization['violationMessage']
 		);
-		return new ConstraintParameterException( $message );
+		return new ConstraintParameterException($message);
 	}
 
 	/**
@@ -753,25 +750,25 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpressionWithSparql( string $text, string $regex ): bool {
-		$textStringLiteral = $this->stringLiteral( $text );
-		$regexStringLiteral = $this->stringLiteral( '^(?:' . $regex . ')$' );
+	public function matchesRegularExpressionWithSparql(string $text, string $regex): bool {
+		$textStringLiteral = $this->stringLiteral($text);
+		$regexStringLiteral = $this->stringLiteral('^(?:'.$regex.')$');
 
 		$query = <<<EOF
 SELECT (REGEX($textStringLiteral, $regexStringLiteral) AS ?matches) {}
 EOF;
 
-		$result = $this->runQuery( $query, $this->primaryEndpoint, false );
+		$result = $this->runQuery($query, $this->primaryEndpoint, false);
 
 		$vars = $result->getArray()['results']['bindings'][0];
-		if ( array_key_exists( 'matches', $vars ) ) {
+		if (array_key_exists('matches', $vars)) {
 			// true or false ⇒ regex okay, text matches or not
 			return $vars['matches']['value'] === 'true';
 		} else {
 			// empty result: regex broken
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-regex' ) )
-					->withInlineCode( $regex, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-regex'))
+					->withInlineCode($regex, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -779,14 +776,14 @@ 
 	/**
 	 * Check whether the text content of an error response indicates a query timeout.
 	 */
-	public function isTimeout( string $responseContent ): bool {
-		$timeoutRegex = implode( '|', array_map(
-			static function ( $fqn ) {
-				return preg_quote( $fqn, '/' );
+	public function isTimeout(string $responseContent): bool {
+		$timeoutRegex = implode('|', array_map(
+			static function($fqn) {
+				return preg_quote($fqn, '/');
 			},
 			$this->timeoutExceptionClasses
-		) );
-		return (bool)preg_match( '/' . $timeoutRegex . '/', $responseContent );
+		));
+		return (bool) preg_match('/'.$timeoutRegex.'/', $responseContent);
 	}
 
 	/**
@@ -798,17 +795,17 @@ 
 	 * @return int|bool the max-age (in seconds)
 	 * or a plain boolean if no max-age can be determined
 	 */
-	public function getCacheMaxAge( array $responseHeaders ) {
+	public function getCacheMaxAge(array $responseHeaders) {
 		if (
-			array_key_exists( 'x-cache-status', $responseHeaders ) &&
-			preg_match( '/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0] )
+			array_key_exists('x-cache-status', $responseHeaders) &&
+			preg_match('/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0])
 		) {
 			$maxage = [];
 			if (
-				array_key_exists( 'cache-control', $responseHeaders ) &&
-				preg_match( '/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage )
+				array_key_exists('cache-control', $responseHeaders) &&
+				preg_match('/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage)
 			) {
-				return intval( $maxage[1] );
+				return intval($maxage[1]);
 			} else {
 				return true;
 			}
@@ -829,34 +826,34 @@ 
 	 * or SparlHelper::EMPTY_RETRY_AFTER if there is an empty Retry-After
 	 * or SparlHelper::INVALID_RETRY_AFTER if there is something wrong with the format
 	 */
-	public function getThrottling( MWHttpRequest $request ) {
-		$retryAfterValue = $request->getResponseHeader( 'Retry-After' );
-		if ( $retryAfterValue === null ) {
+	public function getThrottling(MWHttpRequest $request) {
+		$retryAfterValue = $request->getResponseHeader('Retry-After');
+		if ($retryAfterValue === null) {
 			return self::NO_RETRY_AFTER;
 		}
 
-		$trimmedRetryAfterValue = trim( $retryAfterValue );
-		if ( $trimmedRetryAfterValue === '' ) {
+		$trimmedRetryAfterValue = trim($retryAfterValue);
+		if ($trimmedRetryAfterValue === '') {
 			return self::EMPTY_RETRY_AFTER;
 		}
 
-		if ( is_numeric( $trimmedRetryAfterValue ) ) {
-			$delaySeconds = (int)$trimmedRetryAfterValue;
-			if ( $delaySeconds >= 0 ) {
-				return $this->getTimestampInFuture( new DateInterval( 'PT' . $delaySeconds . 'S' ) );
+		if (is_numeric($trimmedRetryAfterValue)) {
+			$delaySeconds = (int) $trimmedRetryAfterValue;
+			if ($delaySeconds >= 0) {
+				return $this->getTimestampInFuture(new DateInterval('PT'.$delaySeconds.'S'));
 			}
 		} else {
-			$return = strtotime( $trimmedRetryAfterValue );
-			if ( $return !== false ) {
-				return new ConvertibleTimestamp( $return );
+			$return = strtotime($trimmedRetryAfterValue);
+			if ($return !== false) {
+				return new ConvertibleTimestamp($return);
 			}
 		}
 		return self::INVALID_RETRY_AFTER;
 	}
 
-	private function getTimestampInFuture( DateInterval $delta ): ConvertibleTimestamp {
+	private function getTimestampInFuture(DateInterval $delta): ConvertibleTimestamp {
 		$now = new ConvertibleTimestamp();
-		return new ConvertibleTimestamp( $now->timestamp->add( $delta ) );
+		return new ConvertibleTimestamp($now->timestamp->add($delta));
 	}
 
 	/**
@@ -871,109 +868,108 @@ 
 	 *
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	protected function runQuery( string $query, string $endpoint, bool $needsPrefixes = true ): CachedQueryResults {
+	protected function runQuery(string $query, string $endpoint, bool $needsPrefixes = true): CachedQueryResults {
 		$baseSPARQLKey = 'wikibase.quality.constraints.sparql';
 
-		if ( $this->throttlingLock->isLocked( self::EXPIRY_LOCK_ID ) ) {
+		if ($this->throttlingLock->isLocked(self::EXPIRY_LOCK_ID)) {
 			$this->statsFactory
-				->getCounter( 'sparql_throttling_total' )
-				->copyToStatsdAt( "$baseSPARQLKey.throttling" )
+				->getCounter('sparql_throttling_total')
+				->copyToStatsdAt("$baseSPARQLKey.throttling")
 				->increment();
 
 			throw new TooManySparqlRequestsException();
 		}
 
-		if ( $this->sparqlHasWikibaseSupport ) {
+		if ($this->sparqlHasWikibaseSupport) {
 			$needsPrefixes = false;
 		}
 
-		if ( $needsPrefixes ) {
-			$query = $this->prefixes . $query;
+		if ($needsPrefixes) {
+			$query = $this->prefixes.$query;
 		}
-		$query = "#wbqc\n" . $query;
+		$query = "#wbqc\n".$query;
 
-		$url = $endpoint . '?' . http_build_query(
+		$url = $endpoint.'?'.http_build_query(
 			[
 				'query' => $query,
 				'format' => 'json',
 				'maxQueryTimeMillis' => $this->maxQueryTimeMillis,
 			],
-			'', ini_get( 'arg_separator.output' ),
+			'', ini_get('arg_separator.output'),
 			// encode spaces with %20, not +
 			PHP_QUERY_RFC3986
 		);
 
 		$options = [
 			'method' => 'GET',
-			'timeout' => (int)round( ( $this->maxQueryTimeMillis + 1000 ) / 1000 ),
+			'timeout' => (int) round(($this->maxQueryTimeMillis + 1000) / 1000),
 			'connectTimeout' => 'default',
 			'userAgent' => $this->defaultUserAgent,
 		];
-		$request = $this->requestFactory->create( $url, $options, __METHOD__ );
+		$request = $this->requestFactory->create($url, $options, __METHOD__);
 
 		$timing = $this->statsFactory
-			->getTiming( 'sparql_runQuery_duration_seconds' )
-			->copyToStatsdAt( "$baseSPARQLKey.timing" );
+			->getTiming('sparql_runQuery_duration_seconds')
+			->copyToStatsdAt("$baseSPARQLKey.timing");
 
 		$timing->start();
 		$requestStatus = $request->execute();
 		$timing->stop();
 
-		$this->guardAgainstTooManyRequestsError( $request );
+		$this->guardAgainstTooManyRequestsError($request);
 
-		$maxAge = $this->getCacheMaxAge( $request->getResponseHeaders() );
-		if ( $maxAge ) {
-			$this->statsFactory->getCounter( 'sparql_cached_total' )
-				->copyToStatsdAt( "$baseSPARQLKey.cached" )
+		$maxAge = $this->getCacheMaxAge($request->getResponseHeaders());
+		if ($maxAge) {
+			$this->statsFactory->getCounter('sparql_cached_total')
+				->copyToStatsdAt("$baseSPARQLKey.cached")
 				->increment();
 		}
 
 		$sparqlErrorKey = "$baseSPARQLKey.error";
-		$metric = $this->statsFactory->getCounter( 'sparql_error_total' );
-		if ( $requestStatus->isOK() ) {
+		$metric = $this->statsFactory->getCounter('sparql_error_total');
+		if ($requestStatus->isOK()) {
 			$json = $request->getContent();
-			$jsonStatus = FormatJson::parse( $json, FormatJson::FORCE_ASSOC );
-			if ( $jsonStatus->isOK() ) {
+			$jsonStatus = FormatJson::parse($json, FormatJson::FORCE_ASSOC);
+			if ($jsonStatus->isOK()) {
 				return new CachedQueryResults(
 					$jsonStatus->getValue(),
 					Metadata::ofCachingMetadata(
 						$maxAge ?
-							CachingMetadata::ofMaximumAgeInSeconds( $maxAge ) :
-							CachingMetadata::fresh()
+							CachingMetadata::ofMaximumAgeInSeconds($maxAge) : CachingMetadata::fresh()
 					)
 				);
 			} else {
 				$jsonErrorCode = $jsonStatus->getErrors()[0]['message'];
 				$metric
-					->setLabel( 'type', 'json' )
-					->setLabel( 'code', "$jsonErrorCode" )
-					->copyToStatsdAt( [
+					->setLabel('type', 'json')
+					->setLabel('code', "$jsonErrorCode")
+					->copyToStatsdAt([
 						"$sparqlErrorKey",
 						"$sparqlErrorKey.json.$jsonErrorCode",
-					] )
+					])
 					->increment();
 				// fall through to general error handling
 			}
 		} else {
 			$metric
-				->setLabel( 'type', 'http' )
-				->setLabel( 'code', "{$request->getStatus()}" )
-				->copyToStatsdAt( [
+				->setLabel('type', 'http')
+				->setLabel('code', "{$request->getStatus()}")
+				->copyToStatsdAt([
 					"$sparqlErrorKey",
 					"$sparqlErrorKey.http.{$request->getStatus()}",
-				] )
+				])
 				->increment();
 			// fall through to general error handling
 		}
 
-		if ( $this->isTimeout( $request->getContent() ) ) {
+		if ($this->isTimeout($request->getContent())) {
 			$metric
-				->setLabel( 'type', 'timeout' )
-				->setLabel( 'code', 'none' )
-				->copyToStatsdAt( [
+				->setLabel('type', 'timeout')
+				->setLabel('code', 'none')
+				->copyToStatsdAt([
 					"$sparqlErrorKey",
 					"$sparqlErrorKey.timeout",
-				] )
+				])
 				->increment();
 		}
 
@@ -986,33 +982,33 @@ 
 	 * @param MWHttpRequest $request
 	 * @throws TooManySparqlRequestsException
 	 */
-	private function guardAgainstTooManyRequestsError( MWHttpRequest $request ): void {
-		if ( $request->getStatus() !== self::HTTP_TOO_MANY_REQUESTS ) {
+	private function guardAgainstTooManyRequestsError(MWHttpRequest $request): void {
+		if ($request->getStatus() !== self::HTTP_TOO_MANY_REQUESTS) {
 			return;
 		}
 
 		$fallbackBlockDuration = $this->sparqlThrottlingFallbackDuration;
 
-		if ( $fallbackBlockDuration < 0 ) {
-			throw new InvalidArgumentException( 'Fallback duration must be positive int but is: ' .
-				$fallbackBlockDuration );
+		if ($fallbackBlockDuration < 0) {
+			throw new InvalidArgumentException('Fallback duration must be positive int but is: '.
+				$fallbackBlockDuration);
 		}
 
 		$throttlingKey = "wikibase.quality.constraints.sparql.throttling";
-		$this->statsFactory->getCounter( 'sparql_throttling_total' )
-			->copyToStatsdAt( $throttlingKey )
+		$this->statsFactory->getCounter('sparql_throttling_total')
+			->copyToStatsdAt($throttlingKey)
 			->increment();
 
-		$throttlingUntil = $this->getThrottling( $request );
-		if ( !( $throttlingUntil instanceof ConvertibleTimestamp ) ) {
-			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid( $request );
+		$throttlingUntil = $this->getThrottling($request);
+		if (!($throttlingUntil instanceof ConvertibleTimestamp)) {
+			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid($request);
 			$this->throttlingLock->lock(
 				self::EXPIRY_LOCK_ID,
-				$this->getTimestampInFuture( new DateInterval( 'PT' . $fallbackBlockDuration . 'S' ) )
+				$this->getTimestampInFuture(new DateInterval('PT'.$fallbackBlockDuration.'S'))
 			);
 		} else {
-			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent( $throttlingUntil, $request );
-			$this->throttlingLock->lock( self::EXPIRY_LOCK_ID, $throttlingUntil );
+			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent($throttlingUntil, $request);
+			$this->throttlingLock->lock(self::EXPIRY_LOCK_ID, $throttlingUntil);
 		}
 		throw new TooManySparqlRequestsException();
 	}