Completed
Push — master ( 82ff84...f27064 )
by
unknown
43s
created
src/ConstraintCheck/Helper/LoggingHelper.php 1 patch
Spacing   +33 added lines, -33 removed lines patch added patch discarded remove patch
@@ -53,12 +53,12 @@  discard block
 block discarded – undo
53 53
 		$this->dataFactory = $dataFactory;
54 54
 		$this->logger = $logger;
55 55
 		$this->constraintCheckDurationLimits = [
56
-			'info' => $config->get( 'WBQualityConstraintsCheckDurationInfoSeconds' ),
57
-			'warning' => $config->get( 'WBQualityConstraintsCheckDurationWarningSeconds' ),
56
+			'info' => $config->get('WBQualityConstraintsCheckDurationInfoSeconds'),
57
+			'warning' => $config->get('WBQualityConstraintsCheckDurationWarningSeconds'),
58 58
 		];
59 59
 		$this->constraintCheckOnEntityDurationLimits = [
60
-			'info' => $config->get( 'WBQualityConstraintsCheckOnEntityDurationInfoSeconds' ),
61
-			'warning' => $config->get( 'WBQualityConstraintsCheckOnEntityDurationWarningSeconds' ),
60
+			'info' => $config->get('WBQualityConstraintsCheckOnEntityDurationInfoSeconds'),
61
+			'warning' => $config->get('WBQualityConstraintsCheckOnEntityDurationWarningSeconds'),
62 62
 		];
63 63
 	}
64 64
 
@@ -69,23 +69,23 @@  discard block
 block discarded – undo
69 69
 	 * @param float $durationSeconds
70 70
 	 * @return array [ $limitSeconds, $logLevel ]
71 71
 	 */
72
-	private function findLimit( $limits, $durationSeconds ) {
72
+	private function findLimit($limits, $durationSeconds) {
73 73
 		$limitSeconds = null;
74 74
 		$logLevel = null;
75 75
 
76
-		foreach ( $limits as $level => $limit ) {
76
+		foreach ($limits as $level => $limit) {
77 77
 			if (
78 78
 				// duration exceeds this limit
79
-				isset( $limit ) && $durationSeconds > $limit &&
79
+				isset($limit) && $durationSeconds > $limit &&
80 80
 				// this limit is longer than previous longest limit
81
-				( $limitSeconds === null || $limit > $limitSeconds )
81
+				($limitSeconds === null || $limit > $limitSeconds)
82 82
 			) {
83 83
 				$limitSeconds = $limit;
84 84
 				$logLevel = $level;
85 85
 			}
86 86
 		}
87 87
 
88
-		return [ $limitSeconds, $logLevel ];
88
+		return [$limitSeconds, $logLevel];
89 89
 	}
90 90
 
91 91
 	/**
@@ -110,31 +110,31 @@  discard block
 block discarded – undo
110 110
 		$durationSeconds,
111 111
 		$method
112 112
 	) {
113
-		$constraintCheckerClassShortName = substr( strrchr( $constraintCheckerClass, '\\' ), 1 );
113
+		$constraintCheckerClassShortName = substr(strrchr($constraintCheckerClass, '\\'), 1);
114 114
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
115 115
 
116 116
 		$this->dataFactory->timing(
117
-			'wikibase.quality.constraints.check.timing.' .
118
-				$constraintTypeItemId . '-' .
117
+			'wikibase.quality.constraints.check.timing.'.
118
+				$constraintTypeItemId.'-'.
119 119
 				$constraintCheckerClassShortName,
120 120
 			$durationSeconds * 1000
121 121
 		);
122 122
 
123 123
 		// find the longest limit (and associated log level) that the duration exceeds
124
-		[ $limitSeconds, $logLevel ] = $this->findLimit(
124
+		[$limitSeconds, $logLevel] = $this->findLimit(
125 125
 			$this->constraintCheckDurationLimits,
126 126
 			$durationSeconds
127 127
 		);
128
-		if ( $limitSeconds === null ) {
128
+		if ($limitSeconds === null) {
129 129
 			return;
130 130
 		}
131
-		if ( $context->getType() !== Context::TYPE_STATEMENT ) {
131
+		if ($context->getType() !== Context::TYPE_STATEMENT) {
132 132
 			// TODO log less details but still log something
133 133
 			return;
134 134
 		}
135 135
 
136 136
 		$resultMessage = $result->getMessage();
137
-		if ( $resultMessage !== null ) {
137
+		if ($resultMessage !== null) {
138 138
 			$resultMessageKey = $resultMessage->getMessageKey();
139 139
 		} else {
140 140
 			$resultMessageKey = null;
@@ -142,8 +142,8 @@  discard block
 block discarded – undo
142 142
 
143 143
 		$this->logger->log(
144 144
 			$logLevel,
145
-			'Constraint check with {constraintCheckerClassShortName} ' .
146
-			'took longer than {limitSeconds} second(s) ' .
145
+			'Constraint check with {constraintCheckerClassShortName} '.
146
+			'took longer than {limitSeconds} second(s) '.
147 147
 			'(duration: {durationSeconds} seconds).',
148 148
 			[
149 149
 				'method' => $method,
@@ -153,7 +153,7 @@  discard block
 block discarded – undo
153 153
 				'constraintId' => $constraint->getConstraintId(),
154 154
 				'constraintPropertyId' => $constraint->getPropertyId()->getSerialization(),
155 155
 				'constraintTypeItemId' => $constraintTypeItemId,
156
-				'constraintParameters' => json_encode( $constraint->getConstraintParameters() ),
156
+				'constraintParameters' => json_encode($constraint->getConstraintParameters()),
157 157
 				'constraintCheckerClass' => $constraintCheckerClass,
158 158
 				'constraintCheckerClassShortName' => $constraintCheckerClassShortName,
159 159
 				'entityId' => $context->getEntity()->getId()->getSerialization(),
@@ -188,18 +188,18 @@  discard block
 block discarded – undo
188 188
 		);
189 189
 
190 190
 		// find the longest limit (and associated log level) that the duration exceeds
191
-		[ $limitSeconds, $logLevel ] = $this->findLimit(
191
+		[$limitSeconds, $logLevel] = $this->findLimit(
192 192
 			$this->constraintCheckOnEntityDurationLimits,
193 193
 			$durationSeconds
194 194
 		);
195
-		if ( $limitSeconds === null ) {
195
+		if ($limitSeconds === null) {
196 196
 			return;
197 197
 		}
198 198
 
199 199
 		$this->logger->log(
200 200
 			$logLevel,
201
-			'Full constraint check on {entityId} ' .
202
-			'took longer than {limitSeconds} second(s) ' .
201
+			'Full constraint check on {entityId} '.
202
+			'took longer than {limitSeconds} second(s) '.
203 203
 			'(duration: {durationSeconds} seconds).',
204 204
 			[
205 205
 				'method' => $method,
@@ -217,7 +217,7 @@  discard block
 block discarded – undo
217 217
 	 *
218 218
 	 * @param EntityId $entityId
219 219
 	 */
220
-	public function logCheckConstraintsCacheHit( EntityId $entityId ) {
220
+	public function logCheckConstraintsCacheHit(EntityId $entityId) {
221 221
 		$this->dataFactory->increment(
222 222
 			'wikibase.quality.constraints.cache.entity.hit'
223 223
 		);
@@ -228,10 +228,10 @@  discard block
 block discarded – undo
228 228
 	 *
229 229
 	 * @param EntityId[] $entityIds
230 230
 	 */
231
-	public function logCheckConstraintsCacheMisses( array $entityIds ) {
231
+	public function logCheckConstraintsCacheMisses(array $entityIds) {
232 232
 		$this->dataFactory->updateCount(
233 233
 			'wikibase.quality.constraints.cache.entity.miss',
234
-			count( $entityIds )
234
+			count($entityIds)
235 235
 		);
236 236
 	}
237 237
 
@@ -258,17 +258,17 @@  discard block
 block discarded – undo
258 258
 	 * @param EntityId[] $entityIds
259 259
 	 * @param int $maxRevisionIds
260 260
 	 */
261
-	public function logHugeDependencyMetadata( array $entityIds, $maxRevisionIds ) {
261
+	public function logHugeDependencyMetadata(array $entityIds, $maxRevisionIds) {
262 262
 		$this->logger->log(
263 263
 			'warning',
264
-			'Dependency metadata for constraint check result has huge set of entity IDs ' .
265
-			'(count ' . count( $entityIds ) . ', limit ' . $maxRevisionIds . '); ' .
264
+			'Dependency metadata for constraint check result has huge set of entity IDs '.
265
+			'(count '.count($entityIds).', limit '.$maxRevisionIds.'); '.
266 266
 			'caching disabled for this check result.',
267 267
 			[
268 268
 				'loggingMethod' => __METHOD__,
269 269
 				'entityIds' => json_encode(
270 270
 					array_map(
271
-						static function ( EntityId $entityId ) {
271
+						static function(EntityId $entityId) {
272 272
 							return $entityId->getSerialization();
273 273
 						},
274 274
 						$entityIds
@@ -287,17 +287,17 @@  discard block
 block discarded – undo
287 287
 			'Sparql API replied with status 429 and a retry-after header. Requesting to retry after {retryAfterTime}',
288 288
 			[
289 289
 				'retryAfterTime' => $retryAfterTime,
290
-				'responseHeaders' => json_encode( $request->getResponseHeaders() ),
290
+				'responseHeaders' => json_encode($request->getResponseHeaders()),
291 291
 				'responseContent' => $request->getContent(),
292 292
 			]
293 293
 		);
294 294
 	}
295 295
 
296
-	public function logSparqlHelperTooManyRequestsRetryAfterInvalid( MWHttpRequest $request ) {
296
+	public function logSparqlHelperTooManyRequestsRetryAfterInvalid(MWHttpRequest $request) {
297 297
 		$this->logger->warning(
298 298
 			'Sparql API replied with status 429 and no valid retry-after header.',
299 299
 			[
300
-				'responseHeaders' => json_encode( $request->getResponseHeaders() ),
300
+				'responseHeaders' => json_encode($request->getResponseHeaders()),
301 301
 				'responseContent' => $request->getContent(),
302 302
 			]
303 303
 		);
Please login to merge, or discard this patch.
src/ConstraintCheck/Helper/SparqlHelper.php 1 patch
Spacing   +176 added lines, -179 removed lines patch added patch discarded remove patch
@@ -200,73 +200,73 @@  discard block
 block discarded – undo
200 200
 		$this->defaultUserAgent = $defaultUserAgent;
201 201
 		$this->requestFactory = $requestFactory;
202 202
 		$this->entityPrefixes = [];
203
-		foreach ( $rdfVocabulary->entityNamespaceNames as $namespaceName ) {
204
-			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI( $namespaceName );
203
+		foreach ($rdfVocabulary->entityNamespaceNames as $namespaceName) {
204
+			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI($namespaceName);
205 205
 		}
206 206
 
207
-		$this->endpoint = $config->get( 'WBQualityConstraintsSparqlEndpoint' );
208
-		$this->maxQueryTimeMillis = $config->get( 'WBQualityConstraintsSparqlMaxMillis' );
209
-		$this->instanceOfId = $config->get( 'WBQualityConstraintsInstanceOfId' );
210
-		$this->subclassOfId = $config->get( 'WBQualityConstraintsSubclassOfId' );
211
-		$this->cacheMapSize = $config->get( 'WBQualityConstraintsFormatCacheMapSize' );
207
+		$this->endpoint = $config->get('WBQualityConstraintsSparqlEndpoint');
208
+		$this->maxQueryTimeMillis = $config->get('WBQualityConstraintsSparqlMaxMillis');
209
+		$this->instanceOfId = $config->get('WBQualityConstraintsInstanceOfId');
210
+		$this->subclassOfId = $config->get('WBQualityConstraintsSubclassOfId');
211
+		$this->cacheMapSize = $config->get('WBQualityConstraintsFormatCacheMapSize');
212 212
 		$this->timeoutExceptionClasses = $config->get(
213 213
 			'WBQualityConstraintsSparqlTimeoutExceptionClasses'
214 214
 		);
215 215
 		$this->sparqlHasWikibaseSupport = $config->get(
216 216
 			'WBQualityConstraintsSparqlHasWikibaseSupport'
217 217
 		);
218
-		$this->sparqlThrottlingFallbackDuration = (int)$config->get(
218
+		$this->sparqlThrottlingFallbackDuration = (int) $config->get(
219 219
 			'WBQualityConstraintsSparqlThrottlingFallbackDuration'
220 220
 		);
221 221
 
222
-		$this->prefixes = $this->getQueryPrefixes( $rdfVocabulary );
222
+		$this->prefixes = $this->getQueryPrefixes($rdfVocabulary);
223 223
 	}
224 224
 
225
-	private function getQueryPrefixes( RdfVocabulary $rdfVocabulary ) {
225
+	private function getQueryPrefixes(RdfVocabulary $rdfVocabulary) {
226 226
 		// TODO: it would probably be smarter that RdfVocubulary exposed these prefixes somehow
227 227
 		$prefixes = '';
228
-		foreach ( $rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName ) {
228
+		foreach ($rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName) {
229 229
 			$prefixes .= <<<END
230
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
230
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
231 231
 END;
232 232
 		}
233 233
 		$prefixes .= <<<END
234
-PREFIX wds: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_STATEMENT )}>
235
-PREFIX wdv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_VALUE )}>\n
234
+PREFIX wds: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_STATEMENT)}>
235
+PREFIX wdv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_VALUE)}>\n
236 236
 END;
237 237
 
238
-		foreach ( $rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces ) {
238
+		foreach ($rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces) {
239 239
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_DIRECT_CLAIM];
240 240
 			$prefixes .= <<<END
241
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
241
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
242 242
 END;
243 243
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM];
244 244
 			$prefixes .= <<<END
245
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
245
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
246 246
 END;
247 247
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM_STATEMENT];
248 248
 			$prefixes .= <<<END
249
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
249
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
250 250
 END;
251 251
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER];
252 252
 			$prefixes .= <<<END
253
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
253
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
254 254
 END;
255 255
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER_VALUE];
256 256
 			$prefixes .= <<<END
257
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
257
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
258 258
 END;
259 259
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE];
260 260
 			$prefixes .= <<<END
261
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
261
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
262 262
 END;
263 263
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE_VALUE];
264 264
 			$prefixes .= <<<END
265
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
265
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
266 266
 END;
267 267
 		}
268 268
 		$prefixes .= <<<END
269
-PREFIX wikibase: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ONTOLOGY )}>\n
269
+PREFIX wikibase: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ONTOLOGY)}>\n
270 270
 END;
271 271
 		return $prefixes;
272 272
 	}
@@ -278,21 +278,20 @@  discard block
 block discarded – undo
278 278
 	 * @return CachedBool
279 279
 	 * @throws SparqlHelperException if the query times out or some other error occurs
280 280
 	 */
281
-	public function hasType( $id, array $classes ) {
281
+	public function hasType($id, array $classes) {
282 282
 		// TODO hint:gearing is a workaround for T168973 and can hopefully be removed eventually
283 283
 		$gearingHint = $this->sparqlHasWikibaseSupport ?
284
-			' hint:Prior hint:gearing "forward".' :
285
-			'';
284
+			' hint:Prior hint:gearing "forward".' : '';
286 285
 
287 286
 		$metadatas = [];
288 287
 
289
-		foreach ( array_chunk( $classes, 20 ) as $classesChunk ) {
290
-			$classesValues = implode( ' ', array_map(
291
-				static function ( $class ) {
292
-					return 'wd:' . $class;
288
+		foreach (array_chunk($classes, 20) as $classesChunk) {
289
+			$classesValues = implode(' ', array_map(
290
+				static function($class) {
291
+					return 'wd:'.$class;
293 292
 				},
294 293
 				$classesChunk
295
-			) );
294
+			));
296 295
 
297 296
 			$query = <<<EOF
298 297
 ASK {
@@ -302,19 +301,19 @@  discard block
 block discarded – undo
302 301
 }
303 302
 EOF;
304 303
 
305
-			$result = $this->runQuery( $query );
304
+			$result = $this->runQuery($query);
306 305
 			$metadatas[] = $result->getMetadata();
307
-			if ( $result->getArray()['boolean'] ) {
306
+			if ($result->getArray()['boolean']) {
308 307
 				return new CachedBool(
309 308
 					true,
310
-					Metadata::merge( $metadatas )
309
+					Metadata::merge($metadatas)
311 310
 				);
312 311
 			}
313 312
 		}
314 313
 
315 314
 		return new CachedBool(
316 315
 			false,
317
-			Metadata::merge( $metadatas )
316
+			Metadata::merge($metadatas)
318 317
 		);
319 318
 	}
320 319
 
@@ -325,7 +324,7 @@  discard block
 block discarded – undo
325 324
 	 * @param PropertyId $separator
326 325
 	 * @return string
327 326
 	 */
328
-	private function nestedSeparatorFilter( PropertyId $separator ) {
327
+	private function nestedSeparatorFilter(PropertyId $separator) {
329 328
 		$filter = <<<EOF
330 329
   MINUS {
331 330
     ?statement pq:$separator ?qualifier.
@@ -369,10 +368,10 @@  discard block
 block discarded – undo
369 368
 		$pid = $statement->getPropertyId()->getSerialization();
370 369
 		$guid = $statement->getGuid();
371 370
 		'@phan-var string $guid'; // statement must have a non-null GUID
372
-		$guidForRdf = str_replace( '$', '-', $guid );
371
+		$guidForRdf = str_replace('$', '-', $guid);
373 372
 
374
-		$separatorFilters = array_map( [ $this, 'nestedSeparatorFilter' ], $separators );
375
-		$finalSeparatorFilter = implode( "\n", $separatorFilters );
373
+		$separatorFilters = array_map([$this, 'nestedSeparatorFilter'], $separators);
374
+		$finalSeparatorFilter = implode("\n", $separatorFilters);
376 375
 
377 376
 		$query = <<<EOF
378 377
 SELECT DISTINCT ?otherEntity WHERE {
@@ -390,9 +389,9 @@  discard block
 block discarded – undo
390 389
 LIMIT 10
391 390
 EOF;
392 391
 
393
-		$result = $this->runQuery( $query );
392
+		$result = $this->runQuery($query);
394 393
 
395
-		return $this->getOtherEntities( $result );
394
+		return $this->getOtherEntities($result);
396 395
 	}
397 396
 
398 397
 	/**
@@ -417,16 +416,15 @@  discard block
 block discarded – undo
417 416
 		$dataType = $this->propertyDataTypeLookup->getDataTypeIdForProperty(
418 417
 			$snak->getPropertyId()
419 418
 		);
420
-		[ $value, $isFullValue ] = $this->getRdfLiteral( $dataType, $dataValue );
421
-		if ( $isFullValue ) {
419
+		[$value, $isFullValue] = $this->getRdfLiteral($dataType, $dataValue);
420
+		if ($isFullValue) {
422 421
 			$prefix .= 'v';
423 422
 		}
424 423
 		$path = $type === Context::TYPE_QUALIFIER ?
425
-			"$prefix:$pid" :
426
-			"prov:wasDerivedFrom/$prefix:$pid";
424
+			"$prefix:$pid" : "prov:wasDerivedFrom/$prefix:$pid";
427 425
 
428 426
 		$deprecatedFilter = '';
429
-		if ( $ignoreDeprecatedStatements ) {
427
+		if ($ignoreDeprecatedStatements) {
430 428
 			$deprecatedFilter = <<< EOF
431 429
   MINUS { ?otherStatement wikibase:rank wikibase:DeprecatedRank. }
432 430
 EOF;
@@ -446,9 +444,9 @@  discard block
 block discarded – undo
446 444
 LIMIT 10
447 445
 EOF;
448 446
 
449
-		$result = $this->runQuery( $query );
447
+		$result = $this->runQuery($query);
450 448
 
451
-		return $this->getOtherEntities( $result );
449
+		return $this->getOtherEntities($result);
452 450
 	}
453 451
 
454 452
 	/**
@@ -458,8 +456,8 @@  discard block
 block discarded – undo
458 456
 	 *
459 457
 	 * @return string
460 458
 	 */
461
-	private function stringLiteral( $text ) {
462
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
459
+	private function stringLiteral($text) {
460
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
463 461
 	}
464 462
 
465 463
 	/**
@@ -469,18 +467,18 @@  discard block
 block discarded – undo
469 467
 	 *
470 468
 	 * @return CachedEntityIds
471 469
 	 */
472
-	private function getOtherEntities( CachedQueryResults $results ) {
473
-		return new CachedEntityIds( array_map(
474
-			function ( $resultBindings ) {
470
+	private function getOtherEntities(CachedQueryResults $results) {
471
+		return new CachedEntityIds(array_map(
472
+			function($resultBindings) {
475 473
 				$entityIRI = $resultBindings['otherEntity']['value'];
476
-				foreach ( $this->entityPrefixes as $entityPrefix ) {
477
-					$entityPrefixLength = strlen( $entityPrefix );
478
-					if ( substr( $entityIRI, 0, $entityPrefixLength ) === $entityPrefix ) {
474
+				foreach ($this->entityPrefixes as $entityPrefix) {
475
+					$entityPrefixLength = strlen($entityPrefix);
476
+					if (substr($entityIRI, 0, $entityPrefixLength) === $entityPrefix) {
479 477
 						try {
480 478
 							return $this->entityIdParser->parse(
481
-								substr( $entityIRI, $entityPrefixLength )
479
+								substr($entityIRI, $entityPrefixLength)
482 480
 							);
483
-						} catch ( EntityIdParsingException $e ) {
481
+						} catch (EntityIdParsingException $e) {
484 482
 							// fall through
485 483
 						}
486 484
 					}
@@ -491,7 +489,7 @@  discard block
 block discarded – undo
491 489
 				return null;
492 490
 			},
493 491
 			$results->getArray()['results']['bindings']
494
-		), $results->getMetadata() );
492
+		), $results->getMetadata());
495 493
 	}
496 494
 
497 495
 	// phpcs:disable Generic.Metrics.CyclomaticComplexity,Squiz.WhiteSpace.FunctionSpacing
@@ -504,50 +502,50 @@  discard block
 block discarded – undo
504 502
 	 * @return array the literal or IRI as a string in SPARQL syntax,
505 503
 	 * and a boolean indicating whether it refers to a full value node or not
506 504
 	 */
507
-	private function getRdfLiteral( $dataType, DataValue $dataValue ) {
508
-		switch ( $dataType ) {
505
+	private function getRdfLiteral($dataType, DataValue $dataValue) {
506
+		switch ($dataType) {
509 507
 			case 'string':
510 508
 			case 'external-id':
511
-				return [ $this->stringLiteral( $dataValue->getValue() ), false ];
509
+				return [$this->stringLiteral($dataValue->getValue()), false];
512 510
 			case 'commonsMedia':
513
-				$url = $this->rdfVocabulary->getMediaFileURI( $dataValue->getValue() );
514
-				return [ '<' . $url . '>', false ];
511
+				$url = $this->rdfVocabulary->getMediaFileURI($dataValue->getValue());
512
+				return ['<'.$url.'>', false];
515 513
 			case 'geo-shape':
516
-				$url = $this->rdfVocabulary->getGeoShapeURI( $dataValue->getValue() );
517
-				return [ '<' . $url . '>', false ];
514
+				$url = $this->rdfVocabulary->getGeoShapeURI($dataValue->getValue());
515
+				return ['<'.$url.'>', false];
518 516
 			case 'tabular-data':
519
-				$url = $this->rdfVocabulary->getTabularDataURI( $dataValue->getValue() );
520
-				return [ '<' . $url . '>', false ];
517
+				$url = $this->rdfVocabulary->getTabularDataURI($dataValue->getValue());
518
+				return ['<'.$url.'>', false];
521 519
 			case 'url':
522 520
 				$url = $dataValue->getValue();
523
-				if ( !preg_match( '/^[^<>"{}\\\\|^`\\x00-\\x20]*$/D', $url ) ) {
521
+				if (!preg_match('/^[^<>"{}\\\\|^`\\x00-\\x20]*$/D', $url)) {
524 522
 					// not a valid URL for SPARQL (see SPARQL spec, production 139 IRIREF)
525 523
 					// such an URL should never reach us, so just throw
526
-					throw new InvalidArgumentException( 'invalid URL: ' . $url );
524
+					throw new InvalidArgumentException('invalid URL: '.$url);
527 525
 				}
528
-				return [ '<' . $url . '>', false ];
526
+				return ['<'.$url.'>', false];
529 527
 			case 'wikibase-item':
530 528
 			case 'wikibase-property':
531 529
 				/** @var EntityIdValue $dataValue */
532 530
 				'@phan-var EntityIdValue $dataValue';
533
-				return [ 'wd:' . $dataValue->getEntityId()->getSerialization(), false ];
531
+				return ['wd:'.$dataValue->getEntityId()->getSerialization(), false];
534 532
 			case 'monolingualtext':
535 533
 				/** @var MonolingualTextValue $dataValue */
536 534
 				'@phan-var MonolingualTextValue $dataValue';
537 535
 				$lang = $dataValue->getLanguageCode();
538
-				if ( !preg_match( '/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/D', $lang ) ) {
536
+				if (!preg_match('/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/D', $lang)) {
539 537
 					// not a valid language tag for SPARQL (see SPARQL spec, production 145 LANGTAG)
540 538
 					// such a language tag should never reach us, so just throw
541
-					throw new InvalidArgumentException( 'invalid language tag: ' . $lang );
539
+					throw new InvalidArgumentException('invalid language tag: '.$lang);
542 540
 				}
543
-				return [ $this->stringLiteral( $dataValue->getText() ) . '@' . $lang, false ];
541
+				return [$this->stringLiteral($dataValue->getText()).'@'.$lang, false];
544 542
 			case 'globe-coordinate':
545 543
 			case 'quantity':
546 544
 			case 'time':
547 545
 				// @phan-suppress-next-line PhanUndeclaredMethod
548
-				return [ 'wdv:' . $dataValue->getHash(), true ];
546
+				return ['wdv:'.$dataValue->getHash(), true];
549 547
 			default:
550
-				throw new InvalidArgumentException( 'unknown data type: ' . $dataType );
548
+				throw new InvalidArgumentException('unknown data type: '.$dataType);
551 549
 		}
552 550
 	}
553 551
 	// phpcs:enable
@@ -560,43 +558,43 @@  discard block
 block discarded – undo
560 558
 	 * @throws SparqlHelperException if the query times out or some other error occurs
561 559
 	 * @throws ConstraintParameterException if the $regex is invalid
562 560
 	 */
563
-	public function matchesRegularExpression( $text, $regex ) {
561
+	public function matchesRegularExpression($text, $regex) {
564 562
 		// caching wrapper around matchesRegularExpressionWithSparql
565 563
 
566
-		$textHash = hash( 'sha256', $text );
564
+		$textHash = hash('sha256', $text);
567 565
 		$cacheKey = $this->cache->makeKey(
568 566
 			'WikibaseQualityConstraints', // extension
569 567
 			'regex', // action
570 568
 			'WDQS-Java', // regex flavor
571
-			hash( 'sha256', $regex )
569
+			hash('sha256', $regex)
572 570
 		);
573 571
 
574 572
 		$cacheMapArray = $this->cache->getWithSetCallback(
575 573
 			$cacheKey,
576 574
 			WANObjectCache::TTL_DAY,
577
-			function ( $cacheMapArray ) use ( $text, $regex, $textHash ) {
575
+			function($cacheMapArray) use ($text, $regex, $textHash) {
578 576
 				// Initialize the cache map if not set
579
-				if ( $cacheMapArray === false ) {
577
+				if ($cacheMapArray === false) {
580 578
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.init';
581
-					$this->dataFactory->increment( $key );
579
+					$this->dataFactory->increment($key);
582 580
 					return [];
583 581
 				}
584 582
 
585 583
 				$key = 'wikibase.quality.constraints.regex.cache.refresh';
586
-				$this->dataFactory->increment( $key );
587
-				$cacheMap = MapCacheLRU::newFromArray( $cacheMapArray, $this->cacheMapSize );
588
-				if ( $cacheMap->has( $textHash ) ) {
584
+				$this->dataFactory->increment($key);
585
+				$cacheMap = MapCacheLRU::newFromArray($cacheMapArray, $this->cacheMapSize);
586
+				if ($cacheMap->has($textHash)) {
589 587
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.hit';
590
-					$this->dataFactory->increment( $key );
591
-					$cacheMap->get( $textHash ); // ping cache
588
+					$this->dataFactory->increment($key);
589
+					$cacheMap->get($textHash); // ping cache
592 590
 				} else {
593 591
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.miss';
594
-					$this->dataFactory->increment( $key );
592
+					$this->dataFactory->increment($key);
595 593
 					try {
596
-						$matches = $this->matchesRegularExpressionWithSparql( $text, $regex );
597
-					} catch ( ConstraintParameterException $e ) {
598
-						$matches = $this->serializeConstraintParameterException( $e );
599
-					} catch ( SparqlHelperException $e ) {
594
+						$matches = $this->matchesRegularExpressionWithSparql($text, $regex);
595
+					} catch (ConstraintParameterException $e) {
596
+						$matches = $this->serializeConstraintParameterException($e);
597
+					} catch (SparqlHelperException $e) {
600 598
 						// don’t cache this
601 599
 						return $cacheMap->toArray();
602 600
 					}
@@ -620,42 +618,42 @@  discard block
 block discarded – undo
620 618
 			]
621 619
 		);
622 620
 
623
-		if ( isset( $cacheMapArray[$textHash] ) ) {
621
+		if (isset($cacheMapArray[$textHash])) {
624 622
 			$key = 'wikibase.quality.constraints.regex.cache.hit';
625
-			$this->dataFactory->increment( $key );
623
+			$this->dataFactory->increment($key);
626 624
 			$matches = $cacheMapArray[$textHash];
627
-			if ( is_bool( $matches ) ) {
625
+			if (is_bool($matches)) {
628 626
 				return $matches;
629
-			} elseif ( is_array( $matches ) &&
630
-				$matches['type'] == ConstraintParameterException::class ) {
631
-				throw $this->deserializeConstraintParameterException( $matches );
627
+			} elseif (is_array($matches) &&
628
+				$matches['type'] == ConstraintParameterException::class) {
629
+				throw $this->deserializeConstraintParameterException($matches);
632 630
 			} else {
633 631
 				throw new UnexpectedValueException(
634
-					'Value of unknown type in object cache (' .
635
-					'cache key: ' . $cacheKey . ', ' .
636
-					'cache map key: ' . $textHash . ', ' .
637
-					'value type: ' . gettype( $matches ) . ')'
632
+					'Value of unknown type in object cache ('.
633
+					'cache key: '.$cacheKey.', '.
634
+					'cache map key: '.$textHash.', '.
635
+					'value type: '.gettype($matches).')'
638 636
 				);
639 637
 			}
640 638
 		} else {
641 639
 			$key = 'wikibase.quality.constraints.regex.cache.miss';
642
-			$this->dataFactory->increment( $key );
643
-			return $this->matchesRegularExpressionWithSparql( $text, $regex );
640
+			$this->dataFactory->increment($key);
641
+			return $this->matchesRegularExpressionWithSparql($text, $regex);
644 642
 		}
645 643
 	}
646 644
 
647
-	private function serializeConstraintParameterException( ConstraintParameterException $cpe ) {
645
+	private function serializeConstraintParameterException(ConstraintParameterException $cpe) {
648 646
 		return [
649 647
 			'type' => ConstraintParameterException::class,
650
-			'violationMessage' => $this->violationMessageSerializer->serialize( $cpe->getViolationMessage() ),
648
+			'violationMessage' => $this->violationMessageSerializer->serialize($cpe->getViolationMessage()),
651 649
 		];
652 650
 	}
653 651
 
654
-	private function deserializeConstraintParameterException( array $serialization ) {
652
+	private function deserializeConstraintParameterException(array $serialization) {
655 653
 		$message = $this->violationMessageDeserializer->deserialize(
656 654
 			$serialization['violationMessage']
657 655
 		);
658
-		return new ConstraintParameterException( $message );
656
+		return new ConstraintParameterException($message);
659 657
 	}
660 658
 
661 659
 	/**
@@ -669,25 +667,25 @@  discard block
 block discarded – undo
669 667
 	 * @throws SparqlHelperException if the query times out or some other error occurs
670 668
 	 * @throws ConstraintParameterException if the $regex is invalid
671 669
 	 */
672
-	public function matchesRegularExpressionWithSparql( $text, $regex ) {
673
-		$textStringLiteral = $this->stringLiteral( $text );
674
-		$regexStringLiteral = $this->stringLiteral( '^(?:' . $regex . ')$' );
670
+	public function matchesRegularExpressionWithSparql($text, $regex) {
671
+		$textStringLiteral = $this->stringLiteral($text);
672
+		$regexStringLiteral = $this->stringLiteral('^(?:'.$regex.')$');
675 673
 
676 674
 		$query = <<<EOF
677 675
 SELECT (REGEX($textStringLiteral, $regexStringLiteral) AS ?matches) {}
678 676
 EOF;
679 677
 
680
-		$result = $this->runQuery( $query, false );
678
+		$result = $this->runQuery($query, false);
681 679
 
682 680
 		$vars = $result->getArray()['results']['bindings'][0];
683
-		if ( array_key_exists( 'matches', $vars ) ) {
681
+		if (array_key_exists('matches', $vars)) {
684 682
 			// true or false ⇒ regex okay, text matches or not
685 683
 			return $vars['matches']['value'] === 'true';
686 684
 		} else {
687 685
 			// empty result: regex broken
688 686
 			throw new ConstraintParameterException(
689
-				( new ViolationMessage( 'wbqc-violation-message-parameter-regex' ) )
690
-					->withInlineCode( $regex, Role::CONSTRAINT_PARAMETER_VALUE )
687
+				(new ViolationMessage('wbqc-violation-message-parameter-regex'))
688
+					->withInlineCode($regex, Role::CONSTRAINT_PARAMETER_VALUE)
691 689
 			);
692 690
 		}
693 691
 	}
@@ -699,14 +697,14 @@  discard block
 block discarded – undo
699 697
 	 *
700 698
 	 * @return boolean
701 699
 	 */
702
-	public function isTimeout( $responseContent ) {
703
-		$timeoutRegex = implode( '|', array_map(
704
-			static function ( $fqn ) {
705
-				return preg_quote( $fqn, '/' );
700
+	public function isTimeout($responseContent) {
701
+		$timeoutRegex = implode('|', array_map(
702
+			static function($fqn) {
703
+				return preg_quote($fqn, '/');
706 704
 			},
707 705
 			$this->timeoutExceptionClasses
708
-		) );
709
-		return (bool)preg_match( '/' . $timeoutRegex . '/', $responseContent );
706
+		));
707
+		return (bool) preg_match('/'.$timeoutRegex.'/', $responseContent);
710 708
 	}
711 709
 
712 710
 	/**
@@ -718,17 +716,17 @@  discard block
 block discarded – undo
718 716
 	 * @return int|boolean the max-age (in seconds)
719 717
 	 * or a plain boolean if no max-age can be determined
720 718
 	 */
721
-	public function getCacheMaxAge( $responseHeaders ) {
719
+	public function getCacheMaxAge($responseHeaders) {
722 720
 		if (
723
-			array_key_exists( 'x-cache-status', $responseHeaders ) &&
724
-			preg_match( '/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0] )
721
+			array_key_exists('x-cache-status', $responseHeaders) &&
722
+			preg_match('/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0])
725 723
 		) {
726 724
 			$maxage = [];
727 725
 			if (
728
-				array_key_exists( 'cache-control', $responseHeaders ) &&
729
-				preg_match( '/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage )
726
+				array_key_exists('cache-control', $responseHeaders) &&
727
+				preg_match('/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage)
730 728
 			) {
731
-				return intval( $maxage[1] );
729
+				return intval($maxage[1]);
732 730
 			} else {
733 731
 				return true;
734 732
 			}
@@ -749,34 +747,34 @@  discard block
 block discarded – undo
749 747
 	 * or SparlHelper::EMPTY_RETRY_AFTER if there is an empty Retry-After
750 748
 	 * or SparlHelper::INVALID_RETRY_AFTER if there is something wrong with the format
751 749
 	 */
752
-	public function getThrottling( MWHttpRequest $request ) {
753
-		$retryAfterValue = $request->getResponseHeader( 'Retry-After' );
754
-		if ( $retryAfterValue === null ) {
750
+	public function getThrottling(MWHttpRequest $request) {
751
+		$retryAfterValue = $request->getResponseHeader('Retry-After');
752
+		if ($retryAfterValue === null) {
755 753
 			return self::NO_RETRY_AFTER;
756 754
 		}
757 755
 
758
-		$trimmedRetryAfterValue = trim( $retryAfterValue );
759
-		if ( $trimmedRetryAfterValue === '' ) {
756
+		$trimmedRetryAfterValue = trim($retryAfterValue);
757
+		if ($trimmedRetryAfterValue === '') {
760 758
 			return self::EMPTY_RETRY_AFTER;
761 759
 		}
762 760
 
763
-		if ( is_numeric( $trimmedRetryAfterValue ) ) {
764
-			$delaySeconds = (int)$trimmedRetryAfterValue;
765
-			if ( $delaySeconds >= 0 ) {
766
-				return $this->getTimestampInFuture( new DateInterval( 'PT' . $delaySeconds . 'S' ) );
761
+		if (is_numeric($trimmedRetryAfterValue)) {
762
+			$delaySeconds = (int) $trimmedRetryAfterValue;
763
+			if ($delaySeconds >= 0) {
764
+				return $this->getTimestampInFuture(new DateInterval('PT'.$delaySeconds.'S'));
767 765
 			}
768 766
 		} else {
769
-			$return = strtotime( $trimmedRetryAfterValue );
770
-			if ( $return !== false ) {
771
-				return new ConvertibleTimestamp( $return );
767
+			$return = strtotime($trimmedRetryAfterValue);
768
+			if ($return !== false) {
769
+				return new ConvertibleTimestamp($return);
772 770
 			}
773 771
 		}
774 772
 		return self::INVALID_RETRY_AFTER;
775 773
 	}
776 774
 
777
-	private function getTimestampInFuture( DateInterval $delta ) {
775
+	private function getTimestampInFuture(DateInterval $delta) {
778 776
 		$now = new ConvertibleTimestamp();
779
-		return new ConvertibleTimestamp( $now->timestamp->add( $delta ) );
777
+		return new ConvertibleTimestamp($now->timestamp->add($delta));
780 778
 	}
781 779
 
782 780
 	/**
@@ -790,65 +788,64 @@  discard block
 block discarded – undo
790 788
 	 *
791 789
 	 * @throws SparqlHelperException if the query times out or some other error occurs
792 790
 	 */
793
-	public function runQuery( $query, $needsPrefixes = true ) {
791
+	public function runQuery($query, $needsPrefixes = true) {
794 792
 
795
-		if ( $this->throttlingLock->isLocked( self::EXPIRY_LOCK_ID ) ) {
796
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
793
+		if ($this->throttlingLock->isLocked(self::EXPIRY_LOCK_ID)) {
794
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.throttling');
797 795
 			throw new TooManySparqlRequestsException();
798 796
 		}
799 797
 
800
-		if ( $this->sparqlHasWikibaseSupport ) {
798
+		if ($this->sparqlHasWikibaseSupport) {
801 799
 			$needsPrefixes = false;
802 800
 		}
803 801
 
804
-		if ( $needsPrefixes ) {
805
-			$query = $this->prefixes . $query;
802
+		if ($needsPrefixes) {
803
+			$query = $this->prefixes.$query;
806 804
 		}
807
-		$query = "#wbqc\n" . $query;
805
+		$query = "#wbqc\n".$query;
808 806
 
809
-		$url = $this->endpoint . '?' . http_build_query(
807
+		$url = $this->endpoint.'?'.http_build_query(
810 808
 			[
811 809
 				'query' => $query,
812 810
 				'format' => 'json',
813 811
 				'maxQueryTimeMillis' => $this->maxQueryTimeMillis,
814 812
 			],
815
-			'', ini_get( 'arg_separator.output' ),
813
+			'', ini_get('arg_separator.output'),
816 814
 			// encode spaces with %20, not +
817 815
 			PHP_QUERY_RFC3986
818 816
 		);
819 817
 
820 818
 		$options = [
821 819
 			'method' => 'GET',
822
-			'timeout' => (int)round( ( $this->maxQueryTimeMillis + 1000 ) / 1000 ),
820
+			'timeout' => (int) round(($this->maxQueryTimeMillis + 1000) / 1000),
823 821
 			'connectTimeout' => 'default',
824 822
 			'userAgent' => $this->defaultUserAgent,
825 823
 		];
826
-		$request = $this->requestFactory->create( $url, $options, __METHOD__ );
827
-		$startTime = microtime( true );
824
+		$request = $this->requestFactory->create($url, $options, __METHOD__);
825
+		$startTime = microtime(true);
828 826
 		$requestStatus = $request->execute();
829
-		$endTime = microtime( true );
827
+		$endTime = microtime(true);
830 828
 		$this->dataFactory->timing(
831 829
 			'wikibase.quality.constraints.sparql.timing',
832
-			( $endTime - $startTime ) * 1000
830
+			($endTime - $startTime) * 1000
833 831
 		);
834 832
 
835
-		$this->guardAgainstTooManyRequestsError( $request );
833
+		$this->guardAgainstTooManyRequestsError($request);
836 834
 
837
-		$maxAge = $this->getCacheMaxAge( $request->getResponseHeaders() );
838
-		if ( $maxAge ) {
839
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.cached' );
835
+		$maxAge = $this->getCacheMaxAge($request->getResponseHeaders());
836
+		if ($maxAge) {
837
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.cached');
840 838
 		}
841 839
 
842
-		if ( $requestStatus->isOK() ) {
840
+		if ($requestStatus->isOK()) {
843 841
 			$json = $request->getContent();
844
-			$jsonStatus = FormatJson::parse( $json, FormatJson::FORCE_ASSOC );
845
-			if ( $jsonStatus->isOK() ) {
842
+			$jsonStatus = FormatJson::parse($json, FormatJson::FORCE_ASSOC);
843
+			if ($jsonStatus->isOK()) {
846 844
 				return new CachedQueryResults(
847 845
 					$jsonStatus->getValue(),
848 846
 					Metadata::ofCachingMetadata(
849 847
 						$maxAge ?
850
-							CachingMetadata::ofMaximumAgeInSeconds( $maxAge ) :
851
-							CachingMetadata::fresh()
848
+							CachingMetadata::ofMaximumAgeInSeconds($maxAge) : CachingMetadata::fresh()
852 849
 					)
853 850
 				);
854 851
 			} else {
@@ -865,9 +862,9 @@  discard block
 block discarded – undo
865 862
 			// fall through to general error handling
866 863
 		}
867 864
 
868
-		$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.error' );
865
+		$this->dataFactory->increment('wikibase.quality.constraints.sparql.error');
869 866
 
870
-		if ( $this->isTimeout( $request->getContent() ) ) {
867
+		if ($this->isTimeout($request->getContent())) {
871 868
 			$this->dataFactory->increment(
872 869
 				'wikibase.quality.constraints.sparql.error.timeout'
873 870
 			);
@@ -882,29 +879,29 @@  discard block
 block discarded – undo
882 879
 	 * @param MWHttpRequest $request
883 880
 	 * @throws TooManySparqlRequestsException
884 881
 	 */
885
-	private function guardAgainstTooManyRequestsError( MWHttpRequest $request ): void {
886
-		if ( $request->getStatus() !== self::HTTP_TOO_MANY_REQUESTS ) {
882
+	private function guardAgainstTooManyRequestsError(MWHttpRequest $request): void {
883
+		if ($request->getStatus() !== self::HTTP_TOO_MANY_REQUESTS) {
887 884
 			return;
888 885
 		}
889 886
 
890 887
 		$fallbackBlockDuration = $this->sparqlThrottlingFallbackDuration;
891 888
 
892
-		if ( $fallbackBlockDuration < 0 ) {
893
-			throw new InvalidArgumentException( 'Fallback duration must be positive int but is: ' .
894
-				$fallbackBlockDuration );
889
+		if ($fallbackBlockDuration < 0) {
890
+			throw new InvalidArgumentException('Fallback duration must be positive int but is: '.
891
+				$fallbackBlockDuration);
895 892
 		}
896 893
 
897
-		$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
898
-		$throttlingUntil = $this->getThrottling( $request );
899
-		if ( !( $throttlingUntil instanceof ConvertibleTimestamp ) ) {
900
-			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid( $request );
894
+		$this->dataFactory->increment('wikibase.quality.constraints.sparql.throttling');
895
+		$throttlingUntil = $this->getThrottling($request);
896
+		if (!($throttlingUntil instanceof ConvertibleTimestamp)) {
897
+			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid($request);
901 898
 			$this->throttlingLock->lock(
902 899
 				self::EXPIRY_LOCK_ID,
903
-				$this->getTimestampInFuture( new DateInterval( 'PT' . $fallbackBlockDuration . 'S' ) )
900
+				$this->getTimestampInFuture(new DateInterval('PT'.$fallbackBlockDuration.'S'))
904 901
 			);
905 902
 		} else {
906
-			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent( $throttlingUntil, $request );
907
-			$this->throttlingLock->lock( self::EXPIRY_LOCK_ID, $throttlingUntil );
903
+			$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent($throttlingUntil, $request);
904
+			$this->throttlingLock->lock(self::EXPIRY_LOCK_ID, $throttlingUntil);
908 905
 		}
909 906
 		throw new TooManySparqlRequestsException();
910 907
 	}
Please login to merge, or discard this patch.
src/ConstraintCheck/Checker/ContemporaryChecker.php 1 patch
Spacing   +42 added lines, -43 removed lines patch added patch discarded remove patch
@@ -80,7 +80,7 @@  discard block
 block discarded – undo
80 80
 	 * @codeCoverageIgnore This method is purely declarative.
81 81
 	 */
82 82
 	public function getDefaultContextTypes() {
83
-		return [ Context::TYPE_STATEMENT ];
83
+		return [Context::TYPE_STATEMENT];
84 84
 	}
85 85
 
86 86
 	/** @codeCoverageIgnore This method is purely declarative. */
@@ -97,31 +97,31 @@  discard block
 block discarded – undo
97 97
 	 * @return CheckResult
98 98
 	 * @throws ConfigException
99 99
 	 */
100
-	public function checkConstraint( Context $context, Constraint $constraint ) {
101
-		if ( $context->getSnakRank() === Statement::RANK_DEPRECATED ) {
102
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_DEPRECATED );
100
+	public function checkConstraint(Context $context, Constraint $constraint) {
101
+		if ($context->getSnakRank() === Statement::RANK_DEPRECATED) {
102
+			return new CheckResult($context, $constraint, CheckResult::STATUS_DEPRECATED);
103 103
 		}
104 104
 		$snak = $context->getSnak();
105
-		if ( !$snak instanceof PropertyValueSnak ) {
105
+		if (!$snak instanceof PropertyValueSnak) {
106 106
 			// nothing to check
107
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_COMPLIANCE );
107
+			return new CheckResult($context, $constraint, CheckResult::STATUS_COMPLIANCE);
108 108
 		}
109 109
 
110 110
 		$dataValue = $snak->getDataValue();
111
-		if ( !$dataValue instanceof EntityIdValue ) {
111
+		if (!$dataValue instanceof EntityIdValue) {
112 112
 			// wrong data type
113
-			$message = ( new ViolationMessage( 'wbqc-violation-message-value-needed-of-type' ) )
114
-				->withEntityId( new ItemId( $constraint->getConstraintTypeItemId() ), Role::CONSTRAINT_TYPE_ITEM )
115
-				->withDataValueType( 'wikibase-entityid' );
116
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_VIOLATION, $message );
113
+			$message = (new ViolationMessage('wbqc-violation-message-value-needed-of-type'))
114
+				->withEntityId(new ItemId($constraint->getConstraintTypeItemId()), Role::CONSTRAINT_TYPE_ITEM)
115
+				->withDataValueType('wikibase-entityid');
116
+			return new CheckResult($context, $constraint, CheckResult::STATUS_VIOLATION, $message);
117 117
 		}
118 118
 
119 119
 		$objectId = $dataValue->getEntityId();
120
-		$objectItem = $this->entityLookup->getEntity( $objectId );
121
-		if ( !( $objectItem instanceof StatementListProvider ) ) {
120
+		$objectItem = $this->entityLookup->getEntity($objectId);
121
+		if (!($objectItem instanceof StatementListProvider)) {
122 122
 			// object was deleted/doesn't exist
123
-			$message = new ViolationMessage( 'wbqc-violation-message-value-entity-must-exist' );
124
-			return new CheckResult( $context, $constraint, CheckResult::STATUS_VIOLATION, $message );
123
+			$message = new ViolationMessage('wbqc-violation-message-value-entity-must-exist');
124
+			return new CheckResult($context, $constraint, CheckResult::STATUS_VIOLATION, $message);
125 125
 		}
126 126
 		/** @var Statement[] $objectStatements */
127 127
 		$objectStatements = $objectItem->getStatements()->toArray();
@@ -129,9 +129,9 @@  discard block
 block discarded – undo
129 129
 		$subjectId = $context->getEntity()->getId();
130 130
 		$subjectStatements = $context->getEntity()->getStatements()->toArray();
131 131
 		/** @var String[] $startPropertyIds */
132
-		$startPropertyIds = $this->config->get( self::CONFIG_VARIABLE_START_PROPERTY_IDS );
132
+		$startPropertyIds = $this->config->get(self::CONFIG_VARIABLE_START_PROPERTY_IDS);
133 133
 		/** @var String[] $endPropertyIds */
134
-		$endPropertyIds = $this->config->get( self::CONFIG_VARIABLE_END_PROPERTY_IDS );
134
+		$endPropertyIds = $this->config->get(self::CONFIG_VARIABLE_END_PROPERTY_IDS);
135 135
 		$subjectStartValue = $this->getExtremeValue(
136 136
 			$startPropertyIds,
137 137
 			$subjectStatements,
@@ -153,15 +153,15 @@  discard block
 block discarded – undo
153 153
 			'end'
154 154
 		);
155 155
 		if (
156
-			$this->rangeCheckerHelper->getComparison( $subjectStartValue, $subjectEndValue ) <= 0 &&
157
-			$this->rangeCheckerHelper->getComparison( $objectStartValue, $objectEndValue ) <= 0 && (
158
-				$this->rangeCheckerHelper->getComparison( $subjectEndValue, $objectStartValue ) < 0 ||
159
-				$this->rangeCheckerHelper->getComparison( $objectEndValue, $subjectStartValue ) < 0
156
+			$this->rangeCheckerHelper->getComparison($subjectStartValue, $subjectEndValue) <= 0 &&
157
+			$this->rangeCheckerHelper->getComparison($objectStartValue, $objectEndValue) <= 0 && (
158
+				$this->rangeCheckerHelper->getComparison($subjectEndValue, $objectStartValue) < 0 ||
159
+				$this->rangeCheckerHelper->getComparison($objectEndValue, $subjectStartValue) < 0
160 160
 			)
161 161
 		) {
162 162
 			if (
163 163
 				$subjectEndValue == null ||
164
-				$this->rangeCheckerHelper->getComparison( $objectEndValue, $subjectEndValue ) < 0
164
+				$this->rangeCheckerHelper->getComparison($objectEndValue, $subjectEndValue) < 0
165 165
 			) {
166 166
 				$earlierEntityId = $objectId;
167 167
 				$minEndValue = $objectEndValue;
@@ -186,7 +186,7 @@  discard block
 block discarded – undo
186 186
 			$message = null;
187 187
 			$status = CheckResult::STATUS_COMPLIANCE;
188 188
 		}
189
-		return new CheckResult( $context, $constraint, $status, $message );
189
+		return new CheckResult($context, $constraint, $status, $message);
190 190
 	}
191 191
 
192 192
 	/**
@@ -196,19 +196,19 @@  discard block
 block discarded – undo
196 196
 	 *
197 197
 	 * @return DataValue|null
198 198
 	 */
199
-	private function getExtremeValue( $extremePropertyIds, $statements, $startOrEnd ) {
200
-		if ( $startOrEnd !== 'start' && $startOrEnd !== 'end' ) {
201
-			throw new \InvalidArgumentException( '$startOrEnd must be \'start\' or \'end\'.' );
199
+	private function getExtremeValue($extremePropertyIds, $statements, $startOrEnd) {
200
+		if ($startOrEnd !== 'start' && $startOrEnd !== 'end') {
201
+			throw new \InvalidArgumentException('$startOrEnd must be \'start\' or \'end\'.');
202 202
 		}
203 203
 		$extremeValue = null;
204
-		foreach ( $extremePropertyIds as $extremePropertyId ) {
205
-			$statementList = new StatementList( ...$statements );
206
-			$extremeStatements = $statementList->getByPropertyId( new NumericPropertyId( $extremePropertyId ) );
204
+		foreach ($extremePropertyIds as $extremePropertyId) {
205
+			$statementList = new StatementList(...$statements);
206
+			$extremeStatements = $statementList->getByPropertyId(new NumericPropertyId($extremePropertyId));
207 207
 			/** @var Statement $extremeStatement */
208
-			foreach ( $extremeStatements as $extremeStatement ) {
209
-				if ( $extremeStatement->getRank() !== Statement::RANK_DEPRECATED ) {
208
+			foreach ($extremeStatements as $extremeStatement) {
209
+				if ($extremeStatement->getRank() !== Statement::RANK_DEPRECATED) {
210 210
 					$snak = $extremeStatement->getMainSnak();
211
-					if ( !$snak instanceof PropertyValueSnak ) {
211
+					if (!$snak instanceof PropertyValueSnak) {
212 212
 						return null;
213 213
 					} else {
214 214
 						$comparison = $this->rangeCheckerHelper->getComparison(
@@ -217,8 +217,8 @@  discard block
 block discarded – undo
217 217
 						);
218 218
 						if (
219 219
 							$extremeValue === null ||
220
-							( $startOrEnd === 'start' && $comparison < 0 ) ||
221
-							( $startOrEnd === 'end' && $comparison > 0 )
220
+							($startOrEnd === 'start' && $comparison < 0) ||
221
+							($startOrEnd === 'end' && $comparison > 0)
222 222
 						) {
223 223
 							$extremeValue = $snak->getDataValue();
224 224
 						}
@@ -248,17 +248,16 @@  discard block
 block discarded – undo
248 248
 		DataValue $maxStartValue
249 249
 	) {
250 250
 		$messageKey = $earlierEntityId === $subjectId ?
251
-			'wbqc-violation-message-contemporary-subject-earlier' :
252
-			'wbqc-violation-message-contemporary-value-earlier';
253
-		return ( new ViolationMessage( $messageKey ) )
254
-			->withEntityId( $subjectId, Role::SUBJECT )
255
-			->withEntityId( $propertyId, Role::PREDICATE )
256
-			->withEntityId( $objectId, Role::OBJECT )
257
-			->withDataValue( $minEndValue, Role::OBJECT )
258
-			->withDataValue( $maxStartValue, Role::OBJECT );
251
+			'wbqc-violation-message-contemporary-subject-earlier' : 'wbqc-violation-message-contemporary-value-earlier';
252
+		return (new ViolationMessage($messageKey))
253
+			->withEntityId($subjectId, Role::SUBJECT)
254
+			->withEntityId($propertyId, Role::PREDICATE)
255
+			->withEntityId($objectId, Role::OBJECT)
256
+			->withDataValue($minEndValue, Role::OBJECT)
257
+			->withDataValue($maxStartValue, Role::OBJECT);
259 258
 	}
260 259
 
261
-	public function checkConstraintParameters( Constraint $constraint ) {
260
+	public function checkConstraintParameters(Constraint $constraint) {
262 261
 		// no parameters
263 262
 		return [];
264 263
 	}
Please login to merge, or discard this patch.
src/ConstraintCheck/Helper/TypeCheckerHelper.php 1 patch
Spacing   +54 added lines, -54 removed lines patch added patch discarded remove patch
@@ -81,26 +81,26 @@  discard block
 block discarded – undo
81 81
 	 * @return bool
82 82
 	 * @throws OverflowException if $entitiesChecked exceeds the configured limit
83 83
 	 */
84
-	private function isSubclassOf( EntityId $comparativeClass, array $classesToCheck, &$entitiesChecked = 0 ) {
85
-		$maxEntities = $this->config->get( 'WBQualityConstraintsTypeCheckMaxEntities' );
84
+	private function isSubclassOf(EntityId $comparativeClass, array $classesToCheck, &$entitiesChecked = 0) {
85
+		$maxEntities = $this->config->get('WBQualityConstraintsTypeCheckMaxEntities');
86 86
 		if ( ++$entitiesChecked > $maxEntities ) {
87
-			throw new OverflowException( 'Too many entities to check' );
87
+			throw new OverflowException('Too many entities to check');
88 88
 		}
89 89
 
90
-		$item = $this->entityLookup->getEntity( $comparativeClass );
91
-		if ( !( $item instanceof StatementListProvider ) ) {
90
+		$item = $this->entityLookup->getEntity($comparativeClass);
91
+		if (!($item instanceof StatementListProvider)) {
92 92
 			return false; // lookup failed, probably because item doesn't exist
93 93
 		}
94 94
 
95
-		$subclassId = $this->config->get( 'WBQualityConstraintsSubclassOfId' );
95
+		$subclassId = $this->config->get('WBQualityConstraintsSubclassOfId');
96 96
 		$statements = $item->getStatements()
97
-			->getByPropertyId( new NumericPropertyId( $subclassId ) )
97
+			->getByPropertyId(new NumericPropertyId($subclassId))
98 98
 			->getBestStatements();
99 99
 		/** @var Statement $statement */
100
-		foreach ( $statements as $statement ) {
100
+		foreach ($statements as $statement) {
101 101
 			$mainSnak = $statement->getMainSnak();
102 102
 
103
-			if ( !$this->hasCorrectType( $mainSnak ) ) {
103
+			if (!$this->hasCorrectType($mainSnak)) {
104 104
 				continue;
105 105
 			}
106 106
 			/** @var PropertyValueSnak $mainSnak */
@@ -110,11 +110,11 @@  discard block
 block discarded – undo
110 110
 			'@phan-var EntityIdValue $dataValue';
111 111
 			$comparativeClass = $dataValue->getEntityId();
112 112
 
113
-			if ( in_array( $comparativeClass->getSerialization(), $classesToCheck ) ) {
113
+			if (in_array($comparativeClass->getSerialization(), $classesToCheck)) {
114 114
 				return true;
115 115
 			}
116 116
 
117
-			if ( $this->isSubclassOf( $comparativeClass, $classesToCheck, $entitiesChecked ) ) {
117
+			if ($this->isSubclassOf($comparativeClass, $classesToCheck, $entitiesChecked)) {
118 118
 				return true;
119 119
 			}
120 120
 		}
@@ -135,40 +135,40 @@  discard block
 block discarded – undo
135 135
 	 * @return CachedBool
136 136
 	 * @throws SparqlHelperException if SPARQL is used and the query times out or some other error occurs
137 137
 	 */
138
-	public function isSubclassOfWithSparqlFallback( EntityId $comparativeClass, array $classesToCheck ) {
139
-		$timing = $this->statsFactory->getTiming( 'isSubclassOf_duration_seconds' )
140
-			->setLabel( 'result', 'success' )
141
-			->setLabel( 'TypeCheckerImplementation', 'php' )
142
-			->copyToStatsdAt( 'wikibase.quality.constraints.type.php.success.timing' );
138
+	public function isSubclassOfWithSparqlFallback(EntityId $comparativeClass, array $classesToCheck) {
139
+		$timing = $this->statsFactory->getTiming('isSubclassOf_duration_seconds')
140
+			->setLabel('result', 'success')
141
+			->setLabel('TypeCheckerImplementation', 'php')
142
+			->copyToStatsdAt('wikibase.quality.constraints.type.php.success.timing');
143 143
 		$timing->start();
144 144
 
145 145
 		try {
146 146
 			$entitiesChecked = 0;
147
-			$isSubclass = $this->isSubclassOf( $comparativeClass, $classesToCheck, $entitiesChecked );
147
+			$isSubclass = $this->isSubclassOf($comparativeClass, $classesToCheck, $entitiesChecked);
148 148
 			$timing->stop();
149 149
 
150 150
 			// not really a timing, but works like one (we want percentiles etc.)
151 151
 			// TODO: probably a good candidate for T348796
152
-			$this->statsFactory->getTiming( 'isSubclassOf_entities_total' )
153
-				->setLabel( 'TypeCheckerImplementation', 'php' )
154
-				->setLabel( 'result', 'success' )
155
-				->copyToStatsdAt( 'wikibase.quality.constraints.type.php.success.entities' )
156
-				->observe( $entitiesChecked );
157
-
158
-			return new CachedBool( $isSubclass, Metadata::blank() );
159
-		} catch ( OverflowException $e ) {
160
-			$timing->setLabel( 'result', 'overflow' )
161
-				->copyToStatsdAt( 'wikibase.quality.constraints.type.php.overflow.timing' )
152
+			$this->statsFactory->getTiming('isSubclassOf_entities_total')
153
+				->setLabel('TypeCheckerImplementation', 'php')
154
+				->setLabel('result', 'success')
155
+				->copyToStatsdAt('wikibase.quality.constraints.type.php.success.entities')
156
+				->observe($entitiesChecked);
157
+
158
+			return new CachedBool($isSubclass, Metadata::blank());
159
+		} catch (OverflowException $e) {
160
+			$timing->setLabel('result', 'overflow')
161
+				->copyToStatsdAt('wikibase.quality.constraints.type.php.overflow.timing')
162 162
 				->stop();
163 163
 
164
-			if ( !( $this->sparqlHelper instanceof DummySparqlHelper ) ) {
165
-				$this->statsFactory->getCounter( 'sparql_typeFallback_total' )
166
-					->copyToStatsdAt( 'wikibase.quality.constraints.sparql.typeFallback' )
164
+			if (!($this->sparqlHelper instanceof DummySparqlHelper)) {
165
+				$this->statsFactory->getCounter('sparql_typeFallback_total')
166
+					->copyToStatsdAt('wikibase.quality.constraints.sparql.typeFallback')
167 167
 					->increment();
168 168
 
169
-				$timing->setLabel( 'TypeCheckerImplementation', 'sparql' )
170
-					->setLabel( 'result', 'success' )
171
-					->copyToStatsdAt( 'wikibase.quality.constraints.type.sparql.success.timing' )
169
+				$timing->setLabel('TypeCheckerImplementation', 'sparql')
170
+					->setLabel('result', 'success')
171
+					->copyToStatsdAt('wikibase.quality.constraints.type.sparql.success.timing')
172 172
 					->start();
173 173
 
174 174
 				$hasType = $this->sparqlHelper->hasType(
@@ -180,7 +180,7 @@  discard block
 block discarded – undo
180 180
 
181 181
 				return $hasType;
182 182
 			} else {
183
-				return new CachedBool( false, Metadata::blank() );
183
+				return new CachedBool(false, Metadata::blank());
184 184
 			}
185 185
 		}
186 186
 	}
@@ -198,13 +198,13 @@  discard block
 block discarded – undo
198 198
 	 * @return CachedBool
199 199
 	 * @throws SparqlHelperException if SPARQL is used and the query times out or some other error occurs
200 200
 	 */
201
-	public function hasClassInRelation( StatementList $statements, array $relationIds, array $classesToCheck ) {
201
+	public function hasClassInRelation(StatementList $statements, array $relationIds, array $classesToCheck) {
202 202
 		$metadatas = [];
203 203
 
204
-		foreach ( $this->getBestStatementsByPropertyIds( $statements, $relationIds ) as $statement ) {
204
+		foreach ($this->getBestStatementsByPropertyIds($statements, $relationIds) as $statement) {
205 205
 			$mainSnak = $statement->getMainSnak();
206 206
 
207
-			if ( !$this->hasCorrectType( $mainSnak ) ) {
207
+			if (!$this->hasCorrectType($mainSnak)) {
208 208
 				continue;
209 209
 			}
210 210
 			/** @var PropertyValueSnak $mainSnak */
@@ -214,24 +214,24 @@  discard block
 block discarded – undo
214 214
 			'@phan-var EntityIdValue $dataValue';
215 215
 			$comparativeClass = $dataValue->getEntityId();
216 216
 
217
-			if ( in_array( $comparativeClass->getSerialization(), $classesToCheck ) ) {
217
+			if (in_array($comparativeClass->getSerialization(), $classesToCheck)) {
218 218
 				// discard $metadatas, we know this is fresh
219
-				return new CachedBool( true, Metadata::blank() );
219
+				return new CachedBool(true, Metadata::blank());
220 220
 			}
221 221
 
222
-			$result = $this->isSubclassOfWithSparqlFallback( $comparativeClass, $classesToCheck );
222
+			$result = $this->isSubclassOfWithSparqlFallback($comparativeClass, $classesToCheck);
223 223
 			$metadatas[] = $result->getMetadata();
224
-			if ( $result->getBool() ) {
224
+			if ($result->getBool()) {
225 225
 				return new CachedBool(
226 226
 					true,
227
-					Metadata::merge( $metadatas )
227
+					Metadata::merge($metadatas)
228 228
 				);
229 229
 			}
230 230
 		}
231 231
 
232 232
 		return new CachedBool(
233 233
 			false,
234
-			Metadata::merge( $metadatas )
234
+			Metadata::merge($metadatas)
235 235
 		);
236 236
 	}
237 237
 
@@ -240,7 +240,7 @@  discard block
 block discarded – undo
240 240
 	 * @return bool
241 241
 	 * @phan-assert PropertyValueSnak $mainSnak
242 242
 	 */
243
-	private function hasCorrectType( Snak $mainSnak ) {
243
+	private function hasCorrectType(Snak $mainSnak) {
244 244
 		return $mainSnak instanceof PropertyValueSnak
245 245
 			&& $mainSnak->getDataValue()->getType() === 'wikibase-entityid';
246 246
 	}
@@ -257,15 +257,15 @@  discard block
 block discarded – undo
257 257
 	) {
258 258
 		$statementArrays = [];
259 259
 
260
-		foreach ( $propertyIdSerializations as $propertyIdSerialization ) {
261
-			$propertyId = new NumericPropertyId( $propertyIdSerialization );
260
+		foreach ($propertyIdSerializations as $propertyIdSerialization) {
261
+			$propertyId = new NumericPropertyId($propertyIdSerialization);
262 262
 			$statementArrays[] = $statements
263
-				->getByPropertyId( $propertyId )
263
+				->getByPropertyId($propertyId)
264 264
 				->getBestStatements()
265 265
 				->toArray();
266 266
 		}
267 267
 
268
-		return call_user_func_array( 'array_merge', $statementArrays );
268
+		return call_user_func_array('array_merge', $statementArrays);
269 269
 	}
270 270
 
271 271
 	/**
@@ -285,8 +285,8 @@  discard block
 block discarded – undo
285 285
 		$relation
286 286
 	) {
287 287
 		$classes = array_map(
288
-			static function ( $itemIdSerialization ) {
289
-				return new ItemId( $itemIdSerialization );
288
+			static function($itemIdSerialization) {
289
+				return new ItemId($itemIdSerialization);
290 290
 			},
291 291
 			$classes
292 292
 		);
@@ -298,10 +298,10 @@  discard block
 block discarded – undo
298 298
 		// wbqc-violation-message-valueType-instance
299 299
 		// wbqc-violation-message-valueType-subclass
300 300
 		// wbqc-violation-message-valueType-instanceOrSubclass
301
-		return ( new ViolationMessage( 'wbqc-violation-message-' . $checker . '-' . $relation ) )
302
-			->withEntityId( $propertyId, Role::CONSTRAINT_PROPERTY )
303
-			->withEntityId( $entityId, Role::SUBJECT )
304
-			->withEntityIdList( $classes, Role::OBJECT );
301
+		return (new ViolationMessage('wbqc-violation-message-'.$checker.'-'.$relation))
302
+			->withEntityId($propertyId, Role::CONSTRAINT_PROPERTY)
303
+			->withEntityId($entityId, Role::SUBJECT)
304
+			->withEntityIdList($classes, Role::OBJECT);
305 305
 	}
306 306
 
307 307
 }
Please login to merge, or discard this patch.
src/ServiceWiring.php 1 patch
Spacing   +144 added lines, -144 removed lines patch added patch discarded remove patch
@@ -31,53 +31,53 @@  discard block
 block discarded – undo
31 31
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResultSerializer;
32 32
 
33 33
 return [
34
-	ConstraintsServices::EXPIRY_LOCK => static function ( MediaWikiServices $services ): ExpiryLock {
35
-		return new ExpiryLock( ObjectCache::getInstance( CACHE_ANYTHING ) );
34
+	ConstraintsServices::EXPIRY_LOCK => static function(MediaWikiServices $services): ExpiryLock {
35
+		return new ExpiryLock(ObjectCache::getInstance(CACHE_ANYTHING));
36 36
 	},
37 37
 
38
-	ConstraintsServices::LOGGING_HELPER => static function ( MediaWikiServices $services ): LoggingHelper {
38
+	ConstraintsServices::LOGGING_HELPER => static function(MediaWikiServices $services): LoggingHelper {
39 39
 		return new LoggingHelper(
40 40
 			$services->getStatsdDataFactory(),
41
-			LoggerFactory::getInstance( 'WikibaseQualityConstraints' ),
41
+			LoggerFactory::getInstance('WikibaseQualityConstraints'),
42 42
 			$services->getMainConfig()
43 43
 		);
44 44
 	},
45 45
 
46
-	ConstraintsServices::CONSTRAINT_STORE => static function ( MediaWikiServices $services ): ConstraintRepositoryStore {
47
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
48
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
49
-		if ( $propertySource === null ) {
50
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for properties not stored in a database.' );
46
+	ConstraintsServices::CONSTRAINT_STORE => static function(MediaWikiServices $services): ConstraintRepositoryStore {
47
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
48
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
49
+		if ($propertySource === null) {
50
+			throw new RuntimeException('Can\'t get a ConstraintStore for properties not stored in a database.');
51 51
 		}
52 52
 
53
-		$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
54
-		if ( $propertySource->getSourceName() !== $localEntitySourceName ) {
55
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for a non local entity source.' );
53
+		$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
54
+		if ($propertySource->getSourceName() !== $localEntitySourceName) {
55
+			throw new RuntimeException('Can\'t get a ConstraintStore for a non local entity source.');
56 56
 		}
57 57
 
58 58
 		$dbName = $propertySource->getDatabaseName();
59 59
 		return new ConstraintRepositoryStore(
60
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
60
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
61 61
 			$dbName
62 62
 		);
63 63
 	},
64 64
 
65
-	ConstraintsServices::CONSTRAINT_LOOKUP => static function ( MediaWikiServices $services ): ConstraintLookup {
66
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
67
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
68
-		if ( $propertySource === null ) {
69
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for properties not stored in a database.' );
65
+	ConstraintsServices::CONSTRAINT_LOOKUP => static function(MediaWikiServices $services): ConstraintLookup {
66
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
67
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
68
+		if ($propertySource === null) {
69
+			throw new RuntimeException('Can\'t get a ConstraintStore for properties not stored in a database.');
70 70
 		}
71 71
 
72 72
 		$dbName = $propertySource->getDatabaseName();
73 73
 		$rawLookup = new ConstraintRepositoryLookup(
74
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
74
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
75 75
 			$dbName
76 76
 		);
77
-		return new CachingConstraintLookup( $rawLookup );
77
+		return new CachingConstraintLookup($rawLookup);
78 78
 	},
79 79
 
80
-	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function ( MediaWikiServices $services ): CheckResultSerializer {
80
+	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function(MediaWikiServices $services): CheckResultSerializer {
81 81
 		return new CheckResultSerializer(
82 82
 			new ConstraintSerializer(
83 83
 				false // constraint parameters are not exposed
@@ -88,9 +88,9 @@  discard block
 block discarded – undo
88 88
 		);
89 89
 	},
90 90
 
91
-	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function ( MediaWikiServices $services ): CheckResultDeserializer {
92
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
93
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
91
+	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function(MediaWikiServices $services): CheckResultDeserializer {
92
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
93
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
94 94
 
95 95
 		return new CheckResultDeserializer(
96 96
 			new ConstraintDeserializer(),
@@ -103,17 +103,17 @@  discard block
 block discarded – undo
103 103
 		);
104 104
 	},
105 105
 
106
-	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function (
106
+	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function(
107 107
 		MediaWikiServices $services
108 108
 	): ViolationMessageSerializer {
109 109
 		return new ViolationMessageSerializer();
110 110
 	},
111 111
 
112
-	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function (
112
+	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function(
113 113
 		MediaWikiServices $services
114 114
 	): ViolationMessageDeserializer {
115
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
116
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
115
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
116
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
117 117
 
118 118
 		return new ViolationMessageDeserializer(
119 119
 			$entityIdParser,
@@ -121,39 +121,39 @@  discard block
 block discarded – undo
121 121
 		);
122 122
 	},
123 123
 
124
-	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function (
124
+	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function(
125 125
 		MediaWikiServices $services
126 126
 	): ConstraintParameterParser {
127
-		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory( $services );
128
-		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
127
+		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory($services);
128
+		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
129 129
 
130 130
 		return new ConstraintParameterParser(
131 131
 			$services->getMainConfig(),
132 132
 			$deserializerFactory,
133
-			$entitySourceDefinitions->getDatabaseSourceForEntityType( 'item' )->getConceptBaseUri()
133
+			$entitySourceDefinitions->getDatabaseSourceForEntityType('item')->getConceptBaseUri()
134 134
 		);
135 135
 	},
136 136
 
137
-	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function ( MediaWikiServices $services ): ConnectionCheckerHelper {
137
+	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function(MediaWikiServices $services): ConnectionCheckerHelper {
138 138
 		return new ConnectionCheckerHelper();
139 139
 	},
140 140
 
141
-	ConstraintsServices::RANGE_CHECKER_HELPER => static function ( MediaWikiServices $services ): RangeCheckerHelper {
141
+	ConstraintsServices::RANGE_CHECKER_HELPER => static function(MediaWikiServices $services): RangeCheckerHelper {
142 142
 		return new RangeCheckerHelper(
143 143
 			$services->getMainConfig(),
144
-			WikibaseRepo::getUnitConverter( $services )
144
+			WikibaseRepo::getUnitConverter($services)
145 145
 		);
146 146
 	},
147 147
 
148
-	ConstraintsServices::SPARQL_HELPER => static function ( MediaWikiServices $services ): SparqlHelper {
149
-		$endpoint = $services->getMainConfig()->get( 'WBQualityConstraintsSparqlEndpoint' );
150
-		if ( $endpoint === '' ) {
148
+	ConstraintsServices::SPARQL_HELPER => static function(MediaWikiServices $services): SparqlHelper {
149
+		$endpoint = $services->getMainConfig()->get('WBQualityConstraintsSparqlEndpoint');
150
+		if ($endpoint === '') {
151 151
 			return new DummySparqlHelper();
152 152
 		}
153 153
 
154
-		$rdfVocabulary = WikibaseRepo::getRdfVocabulary( $services );
155
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
156
-		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup( $services );
154
+		$rdfVocabulary = WikibaseRepo::getRdfVocabulary($services);
155
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
156
+		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup($services);
157 157
 
158 158
 		return new SparqlHelper(
159 159
 			$services->getMainConfig(),
@@ -161,128 +161,128 @@  discard block
 block discarded – undo
161 161
 			$entityIdParser,
162 162
 			$propertyDataTypeLookup,
163 163
 			$services->getMainWANObjectCache(),
164
-			ConstraintsServices::getViolationMessageSerializer( $services ),
165
-			ConstraintsServices::getViolationMessageDeserializer( $services ),
164
+			ConstraintsServices::getViolationMessageSerializer($services),
165
+			ConstraintsServices::getViolationMessageDeserializer($services),
166 166
 			$services->getStatsdDataFactory(),
167
-			ConstraintsServices::getExpiryLock( $services ),
168
-			ConstraintsServices::getLoggingHelper( $services ),
169
-			WikiMap::getCurrentWikiId() . ' WikibaseQualityConstraints ' . $services->getHttpRequestFactory()->getUserAgent(),
167
+			ConstraintsServices::getExpiryLock($services),
168
+			ConstraintsServices::getLoggingHelper($services),
169
+			WikiMap::getCurrentWikiId().' WikibaseQualityConstraints '.$services->getHttpRequestFactory()->getUserAgent(),
170 170
 			$services->getHttpRequestFactory()
171 171
 		);
172 172
 	},
173 173
 
174
-	ConstraintsServices::TYPE_CHECKER_HELPER => static function ( MediaWikiServices $services ): TypeCheckerHelper {
174
+	ConstraintsServices::TYPE_CHECKER_HELPER => static function(MediaWikiServices $services): TypeCheckerHelper {
175 175
 		return new TypeCheckerHelper(
176
-			WikibaseServices::getEntityLookup( $services ),
176
+			WikibaseServices::getEntityLookup($services),
177 177
 			$services->getMainConfig(),
178
-			ConstraintsServices::getSparqlHelper( $services ),
179
-			$services->getStatsFactory()->withComponent( 'WikibaseQualityConstraints' )
178
+			ConstraintsServices::getSparqlHelper($services),
179
+			$services->getStatsFactory()->withComponent('WikibaseQualityConstraints')
180 180
 		);
181 181
 	},
182 182
 
183
-	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function (
183
+	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function(
184 184
 		MediaWikiServices $services
185 185
 	): DelegatingConstraintChecker {
186
-		$statementGuidParser = WikibaseRepo::getStatementGuidParser( $services );
186
+		$statementGuidParser = WikibaseRepo::getStatementGuidParser($services);
187 187
 
188 188
 		$config = $services->getMainConfig();
189 189
 		$checkerMap = [
190
-			$config->get( 'WBQualityConstraintsConflictsWithConstraintId' )
191
-				=> ConstraintCheckerServices::getConflictsWithChecker( $services ),
192
-			$config->get( 'WBQualityConstraintsItemRequiresClaimConstraintId' )
193
-				=> ConstraintCheckerServices::getItemChecker( $services ),
194
-			$config->get( 'WBQualityConstraintsValueRequiresClaimConstraintId' )
195
-				=> ConstraintCheckerServices::getTargetRequiredClaimChecker( $services ),
196
-			$config->get( 'WBQualityConstraintsSymmetricConstraintId' )
197
-				=> ConstraintCheckerServices::getSymmetricChecker( $services ),
198
-			$config->get( 'WBQualityConstraintsInverseConstraintId' )
199
-				=> ConstraintCheckerServices::getInverseChecker( $services ),
200
-			$config->get( 'WBQualityConstraintsUsedAsQualifierConstraintId' )
201
-				=> ConstraintCheckerServices::getQualifierChecker( $services ),
202
-			$config->get( 'WBQualityConstraintsAllowedQualifiersConstraintId' )
203
-				=> ConstraintCheckerServices::getQualifiersChecker( $services ),
204
-			$config->get( 'WBQualityConstraintsMandatoryQualifierConstraintId' )
205
-				=> ConstraintCheckerServices::getMandatoryQualifiersChecker( $services ),
206
-			$config->get( 'WBQualityConstraintsRangeConstraintId' )
207
-				=> ConstraintCheckerServices::getRangeChecker( $services ),
208
-			$config->get( 'WBQualityConstraintsDifferenceWithinRangeConstraintId' )
209
-				=> ConstraintCheckerServices::getDiffWithinRangeChecker( $services ),
210
-			$config->get( 'WBQualityConstraintsTypeConstraintId' )
211
-				=> ConstraintCheckerServices::getTypeChecker( $services ),
212
-			$config->get( 'WBQualityConstraintsValueTypeConstraintId' )
213
-				=> ConstraintCheckerServices::getValueTypeChecker( $services ),
214
-			$config->get( 'WBQualityConstraintsSingleValueConstraintId' )
215
-				=> ConstraintCheckerServices::getSingleValueChecker( $services ),
216
-			$config->get( 'WBQualityConstraintsMultiValueConstraintId' )
217
-				=> ConstraintCheckerServices::getMultiValueChecker( $services ),
218
-			$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' )
219
-				=> ConstraintCheckerServices::getUniqueValueChecker( $services ),
220
-			$config->get( 'WBQualityConstraintsFormatConstraintId' )
221
-				=> ConstraintCheckerServices::getFormatChecker( $services ),
222
-			$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' )
223
-				=> ConstraintCheckerServices::getCommonsLinkChecker( $services ),
224
-			$config->get( 'WBQualityConstraintsOneOfConstraintId' )
225
-				=> ConstraintCheckerServices::getOneOfChecker( $services ),
226
-			$config->get( 'WBQualityConstraintsUsedForValuesOnlyConstraintId' )
227
-				=> ConstraintCheckerServices::getValueOnlyChecker( $services ),
228
-			$config->get( 'WBQualityConstraintsUsedAsReferenceConstraintId' )
229
-				=> ConstraintCheckerServices::getReferenceChecker( $services ),
230
-			$config->get( 'WBQualityConstraintsNoBoundsConstraintId' )
231
-				=> ConstraintCheckerServices::getNoBoundsChecker( $services ),
232
-			$config->get( 'WBQualityConstraintsAllowedUnitsConstraintId' )
233
-				=> ConstraintCheckerServices::getAllowedUnitsChecker( $services ),
234
-			$config->get( 'WBQualityConstraintsSingleBestValueConstraintId' )
235
-				=> ConstraintCheckerServices::getSingleBestValueChecker( $services ),
236
-			$config->get( 'WBQualityConstraintsAllowedEntityTypesConstraintId' )
237
-				=> ConstraintCheckerServices::getEntityTypeChecker( $services ),
238
-			$config->get( 'WBQualityConstraintsNoneOfConstraintId' )
239
-				=> ConstraintCheckerServices::getNoneOfChecker( $services ),
240
-			$config->get( 'WBQualityConstraintsIntegerConstraintId' )
241
-				=> ConstraintCheckerServices::getIntegerChecker( $services ),
242
-			$config->get( 'WBQualityConstraintsCitationNeededConstraintId' )
243
-				=> ConstraintCheckerServices::getCitationNeededChecker( $services ),
244
-			$config->get( 'WBQualityConstraintsPropertyScopeConstraintId' )
245
-				=> ConstraintCheckerServices::getPropertyScopeChecker( $services ),
246
-			$config->get( 'WBQualityConstraintsContemporaryConstraintId' )
247
-				=> ConstraintCheckerServices::getContemporaryChecker( $services ),
248
-			$config->get( 'WBQualityConstraintsLexemeLanguageConstraintId' )
249
-				=> ConstraintCheckerServices::getLexemeLanguageChecker( $services ),
250
-			$config->get( 'WBQualityConstraintsLabelInLanguageConstraintId' )
251
-				=> ConstraintCheckerServices::getLabelInLanguageChecker( $services ),
190
+			$config->get('WBQualityConstraintsConflictsWithConstraintId')
191
+				=> ConstraintCheckerServices::getConflictsWithChecker($services),
192
+			$config->get('WBQualityConstraintsItemRequiresClaimConstraintId')
193
+				=> ConstraintCheckerServices::getItemChecker($services),
194
+			$config->get('WBQualityConstraintsValueRequiresClaimConstraintId')
195
+				=> ConstraintCheckerServices::getTargetRequiredClaimChecker($services),
196
+			$config->get('WBQualityConstraintsSymmetricConstraintId')
197
+				=> ConstraintCheckerServices::getSymmetricChecker($services),
198
+			$config->get('WBQualityConstraintsInverseConstraintId')
199
+				=> ConstraintCheckerServices::getInverseChecker($services),
200
+			$config->get('WBQualityConstraintsUsedAsQualifierConstraintId')
201
+				=> ConstraintCheckerServices::getQualifierChecker($services),
202
+			$config->get('WBQualityConstraintsAllowedQualifiersConstraintId')
203
+				=> ConstraintCheckerServices::getQualifiersChecker($services),
204
+			$config->get('WBQualityConstraintsMandatoryQualifierConstraintId')
205
+				=> ConstraintCheckerServices::getMandatoryQualifiersChecker($services),
206
+			$config->get('WBQualityConstraintsRangeConstraintId')
207
+				=> ConstraintCheckerServices::getRangeChecker($services),
208
+			$config->get('WBQualityConstraintsDifferenceWithinRangeConstraintId')
209
+				=> ConstraintCheckerServices::getDiffWithinRangeChecker($services),
210
+			$config->get('WBQualityConstraintsTypeConstraintId')
211
+				=> ConstraintCheckerServices::getTypeChecker($services),
212
+			$config->get('WBQualityConstraintsValueTypeConstraintId')
213
+				=> ConstraintCheckerServices::getValueTypeChecker($services),
214
+			$config->get('WBQualityConstraintsSingleValueConstraintId')
215
+				=> ConstraintCheckerServices::getSingleValueChecker($services),
216
+			$config->get('WBQualityConstraintsMultiValueConstraintId')
217
+				=> ConstraintCheckerServices::getMultiValueChecker($services),
218
+			$config->get('WBQualityConstraintsDistinctValuesConstraintId')
219
+				=> ConstraintCheckerServices::getUniqueValueChecker($services),
220
+			$config->get('WBQualityConstraintsFormatConstraintId')
221
+				=> ConstraintCheckerServices::getFormatChecker($services),
222
+			$config->get('WBQualityConstraintsCommonsLinkConstraintId')
223
+				=> ConstraintCheckerServices::getCommonsLinkChecker($services),
224
+			$config->get('WBQualityConstraintsOneOfConstraintId')
225
+				=> ConstraintCheckerServices::getOneOfChecker($services),
226
+			$config->get('WBQualityConstraintsUsedForValuesOnlyConstraintId')
227
+				=> ConstraintCheckerServices::getValueOnlyChecker($services),
228
+			$config->get('WBQualityConstraintsUsedAsReferenceConstraintId')
229
+				=> ConstraintCheckerServices::getReferenceChecker($services),
230
+			$config->get('WBQualityConstraintsNoBoundsConstraintId')
231
+				=> ConstraintCheckerServices::getNoBoundsChecker($services),
232
+			$config->get('WBQualityConstraintsAllowedUnitsConstraintId')
233
+				=> ConstraintCheckerServices::getAllowedUnitsChecker($services),
234
+			$config->get('WBQualityConstraintsSingleBestValueConstraintId')
235
+				=> ConstraintCheckerServices::getSingleBestValueChecker($services),
236
+			$config->get('WBQualityConstraintsAllowedEntityTypesConstraintId')
237
+				=> ConstraintCheckerServices::getEntityTypeChecker($services),
238
+			$config->get('WBQualityConstraintsNoneOfConstraintId')
239
+				=> ConstraintCheckerServices::getNoneOfChecker($services),
240
+			$config->get('WBQualityConstraintsIntegerConstraintId')
241
+				=> ConstraintCheckerServices::getIntegerChecker($services),
242
+			$config->get('WBQualityConstraintsCitationNeededConstraintId')
243
+				=> ConstraintCheckerServices::getCitationNeededChecker($services),
244
+			$config->get('WBQualityConstraintsPropertyScopeConstraintId')
245
+				=> ConstraintCheckerServices::getPropertyScopeChecker($services),
246
+			$config->get('WBQualityConstraintsContemporaryConstraintId')
247
+				=> ConstraintCheckerServices::getContemporaryChecker($services),
248
+			$config->get('WBQualityConstraintsLexemeLanguageConstraintId')
249
+				=> ConstraintCheckerServices::getLexemeLanguageChecker($services),
250
+			$config->get('WBQualityConstraintsLabelInLanguageConstraintId')
251
+				=> ConstraintCheckerServices::getLabelInLanguageChecker($services),
252 252
 		];
253 253
 
254 254
 		return new DelegatingConstraintChecker(
255
-			WikibaseServices::getEntityLookup( $services ),
255
+			WikibaseServices::getEntityLookup($services),
256 256
 			$checkerMap,
257
-			ConstraintsServices::getConstraintLookup( $services ),
258
-			ConstraintsServices::getConstraintParameterParser( $services ),
257
+			ConstraintsServices::getConstraintLookup($services),
258
+			ConstraintsServices::getConstraintParameterParser($services),
259 259
 			$statementGuidParser,
260
-			ConstraintsServices::getLoggingHelper( $services ),
261
-			$config->get( 'WBQualityConstraintsCheckQualifiers' ),
262
-			$config->get( 'WBQualityConstraintsCheckReferences' ),
263
-			$config->get( 'WBQualityConstraintsPropertiesWithViolatingQualifiers' )
260
+			ConstraintsServices::getLoggingHelper($services),
261
+			$config->get('WBQualityConstraintsCheckQualifiers'),
262
+			$config->get('WBQualityConstraintsCheckReferences'),
263
+			$config->get('WBQualityConstraintsPropertiesWithViolatingQualifiers')
264 264
 		);
265 265
 	},
266 266
 
267
-	ConstraintsServices::RESULTS_SOURCE => static function ( MediaWikiServices $services ): ResultsSource {
267
+	ConstraintsServices::RESULTS_SOURCE => static function(MediaWikiServices $services): ResultsSource {
268 268
 		$config = $services->getMainConfig();
269 269
 		$resultsSource = new CheckingResultsSource(
270
-			ConstraintsServices::getDelegatingConstraintChecker( $services )
270
+			ConstraintsServices::getDelegatingConstraintChecker($services)
271 271
 		);
272 272
 
273 273
 		$cacheCheckConstraintsResults = false;
274 274
 
275
-		if ( $config->get( 'WBQualityConstraintsCacheCheckConstraintsResults' ) ) {
275
+		if ($config->get('WBQualityConstraintsCacheCheckConstraintsResults')) {
276 276
 			$cacheCheckConstraintsResults = true;
277 277
 			// check that we can use getLocalRepoWikiPageMetaDataAccessor()
278 278
 			// TODO we should always be able to cache constraint check results (T244726)
279
-			$entitySources = WikibaseRepo::getEntitySourceDefinitions( $services )->getSources();
280
-			$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
279
+			$entitySources = WikibaseRepo::getEntitySourceDefinitions($services)->getSources();
280
+			$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
281 281
 
282
-			foreach ( $entitySources as $entitySource ) {
283
-				if ( $entitySource->getSourceName() !== $localEntitySourceName ) {
284
-					LoggerFactory::getInstance( 'WikibaseQualityConstraints' )->warning(
285
-						'Cannot cache constraint check results for non-local source: ' .
282
+			foreach ($entitySources as $entitySource) {
283
+				if ($entitySource->getSourceName() !== $localEntitySourceName) {
284
+					LoggerFactory::getInstance('WikibaseQualityConstraints')->warning(
285
+						'Cannot cache constraint check results for non-local source: '.
286 286
 						$entitySource->getSourceName()
287 287
 					);
288 288
 					$cacheCheckConstraintsResults = false;
@@ -291,42 +291,42 @@  discard block
 block discarded – undo
291 291
 			}
292 292
 		}
293 293
 
294
-		if ( $cacheCheckConstraintsResults ) {
294
+		if ($cacheCheckConstraintsResults) {
295 295
 			$possiblyStaleConstraintTypes = [
296
-				$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' ),
297
-				$config->get( 'WBQualityConstraintsTypeConstraintId' ),
298
-				$config->get( 'WBQualityConstraintsValueTypeConstraintId' ),
299
-				$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' ),
296
+				$config->get('WBQualityConstraintsCommonsLinkConstraintId'),
297
+				$config->get('WBQualityConstraintsTypeConstraintId'),
298
+				$config->get('WBQualityConstraintsValueTypeConstraintId'),
299
+				$config->get('WBQualityConstraintsDistinctValuesConstraintId'),
300 300
 			];
301
-			$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
301
+			$entityIdParser = WikibaseRepo::getEntityIdParser($services);
302 302
 			$wikiPageEntityMetaDataAccessor = WikibaseRepo::getLocalRepoWikiPageMetaDataAccessor(
303 303
 				$services );
304 304
 
305 305
 			$resultsSource = new CachingResultsSource(
306 306
 				$resultsSource,
307 307
 				ResultsCache::getDefaultInstance(),
308
-				ConstraintsServices::getCheckResultSerializer( $services ),
309
-				ConstraintsServices::getCheckResultDeserializer( $services ),
308
+				ConstraintsServices::getCheckResultSerializer($services),
309
+				ConstraintsServices::getCheckResultDeserializer($services),
310 310
 				$wikiPageEntityMetaDataAccessor,
311 311
 				$entityIdParser,
312
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsTTLSeconds' ),
312
+				$config->get('WBQualityConstraintsCacheCheckConstraintsTTLSeconds'),
313 313
 				$possiblyStaleConstraintTypes,
314
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds' ),
315
-				ConstraintsServices::getLoggingHelper( $services )
314
+				$config->get('WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds'),
315
+				ConstraintsServices::getLoggingHelper($services)
316 316
 			);
317 317
 		}
318 318
 
319 319
 		return $resultsSource;
320 320
 	},
321 321
 
322
-	ConstraintsServices::VIOLATION_MESSAGE_RENDERER_FACTORY => static function (
322
+	ConstraintsServices::VIOLATION_MESSAGE_RENDERER_FACTORY => static function(
323 323
 		MediaWikiServices $services
324 324
 	): ViolationMessageRendererFactory {
325 325
 		return new ViolationMessageRendererFactory(
326 326
 			$services->getMainConfig(),
327 327
 			$services->getLanguageNameUtils(),
328
-			WikibaseRepo::getEntityIdHtmlLinkFormatterFactory( $services ),
329
-			WikibaseRepo::getValueFormatterFactory( $services )
328
+			WikibaseRepo::getEntityIdHtmlLinkFormatterFactory($services),
329
+			WikibaseRepo::getValueFormatterFactory($services)
330 330
 		);
331 331
 	},
332 332
 ];
Please login to merge, or discard this patch.
src/ServiceWiring-Wikibase.php 1 patch
Spacing   +7 added lines, -7 removed lines patch added patch discarded remove patch
@@ -10,20 +10,20 @@
 block discarded – undo
10 10
 use Wikibase\Repo\WikibaseRepo;
11 11
 
12 12
 return [
13
-	WikibaseServices::ENTITY_LOOKUP => static function ( MediaWikiServices $services ): EntityLookup {
13
+	WikibaseServices::ENTITY_LOOKUP => static function(MediaWikiServices $services): EntityLookup {
14 14
 		return new ExceptionIgnoringEntityLookup(
15
-			WikibaseRepo::getEntityLookup( $services )
15
+			WikibaseRepo::getEntityLookup($services)
16 16
 		);
17 17
 	},
18 18
 
19
-	WikibaseServices::ENTITY_LOOKUP_WITHOUT_CACHE => static function ( MediaWikiServices $services ): EntityLookup {
19
+	WikibaseServices::ENTITY_LOOKUP_WITHOUT_CACHE => static function(MediaWikiServices $services): EntityLookup {
20 20
 		return new ExceptionIgnoringEntityLookup(
21
-			WikibaseRepo::getStore( $services )
22
-				->getEntityLookup( Store::LOOKUP_CACHING_RETRIEVE_ONLY )
21
+			WikibaseRepo::getStore($services)
22
+				->getEntityLookup(Store::LOOKUP_CACHING_RETRIEVE_ONLY)
23 23
 		);
24 24
 	},
25 25
 
26
-	WikibaseServices::PROPERTY_DATA_TYPE_LOOKUP => static function ( MediaWikiServices $services ): PropertyDataTypeLookup {
27
-		return WikibaseRepo::getPropertyDataTypeLookup( $services );
26
+	WikibaseServices::PROPERTY_DATA_TYPE_LOOKUP => static function(MediaWikiServices $services): PropertyDataTypeLookup {
27
+		return WikibaseRepo::getPropertyDataTypeLookup($services);
28 28
 	},
29 29
 ];
Please login to merge, or discard this patch.
src/ServiceWiring-ConstraintCheckers.php 1 patch
Spacing   +75 added lines, -75 removed lines patch added patch discarded remove patch
@@ -38,216 +38,216 @@
 block discarded – undo
38 38
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\ValueTypeChecker;
39 39
 
40 40
 return [
41
-	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function ( MediaWikiServices $services ): ConflictsWithChecker {
41
+	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function(MediaWikiServices $services): ConflictsWithChecker {
42 42
 		return new ConflictsWithChecker(
43
-			ConstraintsServices::getConstraintParameterParser( $services ),
44
-			ConstraintsServices::getConnectionCheckerHelper( $services )
43
+			ConstraintsServices::getConstraintParameterParser($services),
44
+			ConstraintsServices::getConnectionCheckerHelper($services)
45 45
 		);
46 46
 	},
47 47
 
48
-	ConstraintCheckerServices::ITEM_CHECKER => static function ( MediaWikiServices $services ): ItemChecker {
48
+	ConstraintCheckerServices::ITEM_CHECKER => static function(MediaWikiServices $services): ItemChecker {
49 49
 		return new ItemChecker(
50
-			ConstraintsServices::getConstraintParameterParser( $services ),
51
-			ConstraintsServices::getConnectionCheckerHelper( $services )
50
+			ConstraintsServices::getConstraintParameterParser($services),
51
+			ConstraintsServices::getConnectionCheckerHelper($services)
52 52
 		);
53 53
 	},
54 54
 
55
-	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function (
55
+	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function(
56 56
 		MediaWikiServices $services
57 57
 	): TargetRequiredClaimChecker {
58 58
 		return new TargetRequiredClaimChecker(
59
-			WikibaseServices::getEntityLookup( $services ),
60
-			ConstraintsServices::getConstraintParameterParser( $services ),
61
-			ConstraintsServices::getConnectionCheckerHelper( $services )
59
+			WikibaseServices::getEntityLookup($services),
60
+			ConstraintsServices::getConstraintParameterParser($services),
61
+			ConstraintsServices::getConnectionCheckerHelper($services)
62 62
 		);
63 63
 	},
64 64
 
65
-	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function ( MediaWikiServices $services ): SymmetricChecker {
65
+	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function(MediaWikiServices $services): SymmetricChecker {
66 66
 		return new SymmetricChecker(
67
-			WikibaseServices::getEntityLookupWithoutCache( $services ),
68
-			ConstraintsServices::getConnectionCheckerHelper( $services )
67
+			WikibaseServices::getEntityLookupWithoutCache($services),
68
+			ConstraintsServices::getConnectionCheckerHelper($services)
69 69
 		);
70 70
 	},
71 71
 
72
-	ConstraintCheckerServices::INVERSE_CHECKER => static function ( MediaWikiServices $services ): InverseChecker {
72
+	ConstraintCheckerServices::INVERSE_CHECKER => static function(MediaWikiServices $services): InverseChecker {
73 73
 		return new InverseChecker(
74
-			WikibaseServices::getEntityLookup( $services ),
75
-			ConstraintsServices::getConstraintParameterParser( $services ),
76
-			ConstraintsServices::getConnectionCheckerHelper( $services )
74
+			WikibaseServices::getEntityLookup($services),
75
+			ConstraintsServices::getConstraintParameterParser($services),
76
+			ConstraintsServices::getConnectionCheckerHelper($services)
77 77
 		);
78 78
 	},
79 79
 
80
-	ConstraintCheckerServices::QUALIFIER_CHECKER => static function ( MediaWikiServices $services ): QualifierChecker {
80
+	ConstraintCheckerServices::QUALIFIER_CHECKER => static function(MediaWikiServices $services): QualifierChecker {
81 81
 		return new QualifierChecker();
82 82
 	},
83 83
 
84
-	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function ( MediaWikiServices $services ): QualifiersChecker {
84
+	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function(MediaWikiServices $services): QualifiersChecker {
85 85
 		return new QualifiersChecker(
86
-			ConstraintsServices::getConstraintParameterParser( $services )
86
+			ConstraintsServices::getConstraintParameterParser($services)
87 87
 		);
88 88
 	},
89 89
 
90
-	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function (
90
+	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function(
91 91
 		MediaWikiServices $services
92 92
 	): MandatoryQualifiersChecker {
93 93
 		return new MandatoryQualifiersChecker(
94
-			ConstraintsServices::getConstraintParameterParser( $services )
94
+			ConstraintsServices::getConstraintParameterParser($services)
95 95
 		);
96 96
 	},
97 97
 
98
-	ConstraintCheckerServices::RANGE_CHECKER => static function ( MediaWikiServices $services ): RangeChecker {
98
+	ConstraintCheckerServices::RANGE_CHECKER => static function(MediaWikiServices $services): RangeChecker {
99 99
 		return new RangeChecker(
100
-			WikibaseServices::getPropertyDataTypeLookup( $services ),
101
-			ConstraintsServices::getConstraintParameterParser( $services ),
102
-			ConstraintsServices::getRangeCheckerHelper( $services )
100
+			WikibaseServices::getPropertyDataTypeLookup($services),
101
+			ConstraintsServices::getConstraintParameterParser($services),
102
+			ConstraintsServices::getRangeCheckerHelper($services)
103 103
 		);
104 104
 	},
105 105
 
106
-	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function (
106
+	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function(
107 107
 		MediaWikiServices $services
108 108
 	): DiffWithinRangeChecker {
109 109
 		return new DiffWithinRangeChecker(
110
-			ConstraintsServices::getConstraintParameterParser( $services ),
111
-			ConstraintsServices::getRangeCheckerHelper( $services ),
110
+			ConstraintsServices::getConstraintParameterParser($services),
111
+			ConstraintsServices::getRangeCheckerHelper($services),
112 112
 			$services->getMainConfig()
113 113
 		);
114 114
 	},
115 115
 
116
-	ConstraintCheckerServices::TYPE_CHECKER => static function ( MediaWikiServices $services ): TypeChecker {
116
+	ConstraintCheckerServices::TYPE_CHECKER => static function(MediaWikiServices $services): TypeChecker {
117 117
 		return new TypeChecker(
118
-			ConstraintsServices::getConstraintParameterParser( $services ),
119
-			ConstraintsServices::getTypeCheckerHelper( $services ),
118
+			ConstraintsServices::getConstraintParameterParser($services),
119
+			ConstraintsServices::getTypeCheckerHelper($services),
120 120
 			$services->getMainConfig()
121 121
 		);
122 122
 	},
123 123
 
124
-	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function ( MediaWikiServices $services ): ValueTypeChecker {
124
+	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function(MediaWikiServices $services): ValueTypeChecker {
125 125
 		return new ValueTypeChecker(
126
-			WikibaseServices::getEntityLookup( $services ),
127
-			ConstraintsServices::getConstraintParameterParser( $services ),
128
-			ConstraintsServices::getTypeCheckerHelper( $services ),
126
+			WikibaseServices::getEntityLookup($services),
127
+			ConstraintsServices::getConstraintParameterParser($services),
128
+			ConstraintsServices::getTypeCheckerHelper($services),
129 129
 			$services->getMainConfig()
130 130
 		);
131 131
 	},
132 132
 
133
-	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function ( MediaWikiServices $services ): SingleValueChecker {
133
+	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function(MediaWikiServices $services): SingleValueChecker {
134 134
 		return new SingleValueChecker(
135
-			ConstraintsServices::getConstraintParameterParser( $services )
135
+			ConstraintsServices::getConstraintParameterParser($services)
136 136
 		);
137 137
 	},
138 138
 
139
-	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function ( MediaWikiServices $services ): MultiValueChecker {
139
+	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function(MediaWikiServices $services): MultiValueChecker {
140 140
 		return new MultiValueChecker(
141
-			ConstraintsServices::getConstraintParameterParser( $services )
141
+			ConstraintsServices::getConstraintParameterParser($services)
142 142
 		);
143 143
 	},
144 144
 
145
-	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function ( MediaWikiServices $services ): UniqueValueChecker {
145
+	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function(MediaWikiServices $services): UniqueValueChecker {
146 146
 		// TODO return a different, dummy implementation if SPARQL is not available
147 147
 		return new UniqueValueChecker(
148
-			ConstraintsServices::getSparqlHelper( $services ),
149
-			ConstraintsServices::getConstraintParameterParser( $services )
148
+			ConstraintsServices::getSparqlHelper($services),
149
+			ConstraintsServices::getConstraintParameterParser($services)
150 150
 		);
151 151
 	},
152 152
 
153
-	ConstraintCheckerServices::FORMAT_CHECKER => static function ( MediaWikiServices $services ): FormatChecker {
153
+	ConstraintCheckerServices::FORMAT_CHECKER => static function(MediaWikiServices $services): FormatChecker {
154 154
 		// TODO return a different, dummy implementation if SPARQL is not available
155 155
 		return new FormatChecker(
156
-			ConstraintsServices::getConstraintParameterParser( $services ),
156
+			ConstraintsServices::getConstraintParameterParser($services),
157 157
 			$services->getMainConfig(),
158
-			ConstraintsServices::getSparqlHelper( $services ),
158
+			ConstraintsServices::getSparqlHelper($services),
159 159
 			$services->getShellboxClientFactory()
160 160
 		);
161 161
 	},
162 162
 
163
-	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function ( MediaWikiServices $services ): CommonsLinkChecker {
163
+	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function(MediaWikiServices $services): CommonsLinkChecker {
164 164
 		$pageNameNormalizer = new MediaWikiPageNameNormalizer();
165 165
 		return new CommonsLinkChecker(
166
-			ConstraintsServices::getConstraintParameterParser( $services ),
166
+			ConstraintsServices::getConstraintParameterParser($services),
167 167
 			$pageNameNormalizer,
168
-			WikibaseRepo::getPropertyDataTypeLookup( $services )
168
+			WikibaseRepo::getPropertyDataTypeLookup($services)
169 169
 		);
170 170
 	},
171 171
 
172
-	ConstraintCheckerServices::ONE_OF_CHECKER => static function ( MediaWikiServices $services ): OneOfChecker {
172
+	ConstraintCheckerServices::ONE_OF_CHECKER => static function(MediaWikiServices $services): OneOfChecker {
173 173
 		return new OneOfChecker(
174
-			ConstraintsServices::getConstraintParameterParser( $services )
174
+			ConstraintsServices::getConstraintParameterParser($services)
175 175
 		);
176 176
 	},
177 177
 
178
-	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function ( MediaWikiServices $services ): ValueOnlyChecker {
178
+	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function(MediaWikiServices $services): ValueOnlyChecker {
179 179
 		return new ValueOnlyChecker();
180 180
 	},
181 181
 
182
-	ConstraintCheckerServices::REFERENCE_CHECKER => static function ( MediaWikiServices $services ): ReferenceChecker {
182
+	ConstraintCheckerServices::REFERENCE_CHECKER => static function(MediaWikiServices $services): ReferenceChecker {
183 183
 		return new ReferenceChecker();
184 184
 	},
185 185
 
186
-	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function ( MediaWikiServices $services ): NoBoundsChecker {
186
+	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function(MediaWikiServices $services): NoBoundsChecker {
187 187
 		return new NoBoundsChecker();
188 188
 	},
189 189
 
190
-	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function ( MediaWikiServices $services ): AllowedUnitsChecker {
190
+	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function(MediaWikiServices $services): AllowedUnitsChecker {
191 191
 		return new AllowedUnitsChecker(
192
-			ConstraintsServices::getConstraintParameterParser( $services ),
193
-			WikibaseRepo::getUnitConverter( $services )
192
+			ConstraintsServices::getConstraintParameterParser($services),
193
+			WikibaseRepo::getUnitConverter($services)
194 194
 		);
195 195
 	},
196 196
 
197
-	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function (
197
+	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function(
198 198
 		MediaWikiServices $services
199 199
 	): SingleBestValueChecker {
200 200
 		return new SingleBestValueChecker(
201
-			ConstraintsServices::getConstraintParameterParser( $services )
201
+			ConstraintsServices::getConstraintParameterParser($services)
202 202
 		);
203 203
 	},
204 204
 
205
-	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function ( MediaWikiServices $services ): EntityTypeChecker {
205
+	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function(MediaWikiServices $services): EntityTypeChecker {
206 206
 		return new EntityTypeChecker(
207
-			ConstraintsServices::getConstraintParameterParser( $services )
207
+			ConstraintsServices::getConstraintParameterParser($services)
208 208
 		);
209 209
 	},
210 210
 
211
-	ConstraintCheckerServices::NONE_OF_CHECKER => static function ( MediaWikiServices $services ): NoneOfChecker {
211
+	ConstraintCheckerServices::NONE_OF_CHECKER => static function(MediaWikiServices $services): NoneOfChecker {
212 212
 		return new NoneOfChecker(
213
-			ConstraintsServices::getConstraintParameterParser( $services )
213
+			ConstraintsServices::getConstraintParameterParser($services)
214 214
 		);
215 215
 	},
216 216
 
217
-	ConstraintCheckerServices::INTEGER_CHECKER => static function ( MediaWikiServices $services ): IntegerChecker {
217
+	ConstraintCheckerServices::INTEGER_CHECKER => static function(MediaWikiServices $services): IntegerChecker {
218 218
 		return new IntegerChecker();
219 219
 	},
220 220
 
221
-	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function ( MediaWikiServices $services ): CitationNeededChecker {
221
+	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function(MediaWikiServices $services): CitationNeededChecker {
222 222
 		return new CitationNeededChecker();
223 223
 	},
224 224
 
225
-	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function ( MediaWikiServices $services ): PropertyScopeChecker {
225
+	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function(MediaWikiServices $services): PropertyScopeChecker {
226 226
 		return new PropertyScopeChecker(
227
-			ConstraintsServices::getConstraintParameterParser( $services )
227
+			ConstraintsServices::getConstraintParameterParser($services)
228 228
 		);
229 229
 	},
230 230
 
231
-	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function ( MediaWikiServices $services ): ContemporaryChecker {
231
+	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function(MediaWikiServices $services): ContemporaryChecker {
232 232
 		return new ContemporaryChecker(
233
-			WikibaseServices::getEntityLookup( $services ),
234
-			ConstraintsServices::getRangeCheckerHelper( $services ),
233
+			WikibaseServices::getEntityLookup($services),
234
+			ConstraintsServices::getRangeCheckerHelper($services),
235 235
 			$services->getMainConfig()
236 236
 		);
237 237
 	},
238 238
 
239
-	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function ( MediaWikiServices $services ): LanguageChecker {
239
+	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function(MediaWikiServices $services): LanguageChecker {
240 240
 		return new LanguageChecker(
241
-			ConstraintsServices::getConstraintParameterParser( $services ),
242
-			WikibaseServices::getEntityLookup( $services )
241
+			ConstraintsServices::getConstraintParameterParser($services),
242
+			WikibaseServices::getEntityLookup($services)
243 243
 		);
244 244
 	},
245 245
 
246
-	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function (
246
+	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function(
247 247
 		MediaWikiServices $services
248 248
 	): LabelInLanguageChecker {
249 249
 		return new LabelInLanguageChecker(
250
-			ConstraintsServices::getConstraintParameterParser( $services )
250
+			ConstraintsServices::getConstraintParameterParser($services)
251 251
 		);
252 252
 	},
253 253
 ];
Please login to merge, or discard this patch.
src/Api/ExpiryLock.php 1 patch
Spacing   +19 added lines, -19 removed lines patch added patch discarded remove patch
@@ -26,7 +26,7 @@  discard block
 block discarded – undo
26 26
 	/**
27 27
 	 * @param BagOStuff $cache
28 28
 	 */
29
-	public function __construct( BagOStuff $cache ) {
29
+	public function __construct(BagOStuff $cache) {
30 30
 		$this->cache = $cache;
31 31
 	}
32 32
 
@@ -37,17 +37,17 @@  discard block
 block discarded – undo
37 37
 	 *
38 38
 	 * @throws \Wikimedia\Assert\ParameterTypeException
39 39
 	 */
40
-	private function makeKey( $id ) {
41
-		if ( trim( $id ) === '' ) {
42
-			throw new ParameterTypeException( '$id', 'non-empty string' );
40
+	private function makeKey($id) {
41
+		if (trim($id) === '') {
42
+			throw new ParameterTypeException('$id', 'non-empty string');
43 43
 		}
44 44
 
45
-		Assert::parameterType( 'string', $id, '$id' );
45
+		Assert::parameterType('string', $id, '$id');
46 46
 
47 47
 		return $this->cache->makeKey(
48 48
 			'WikibaseQualityConstraints',
49 49
 			'ExpiryLock',
50
-			(string)$id
50
+			(string) $id
51 51
 		);
52 52
 	}
53 53
 
@@ -59,15 +59,15 @@  discard block
 block discarded – undo
59 59
 	 *
60 60
 	 * @throws \Wikimedia\Assert\ParameterTypeException
61 61
 	 */
62
-	public function lock( $id, ConvertibleTimestamp $expiryTimestamp ) {
62
+	public function lock($id, ConvertibleTimestamp $expiryTimestamp) {
63 63
 
64
-		$cacheId = $this->makeKey( $id );
64
+		$cacheId = $this->makeKey($id);
65 65
 
66
-		if ( !$this->isLockedInternal( $cacheId ) ) {
66
+		if (!$this->isLockedInternal($cacheId)) {
67 67
 			return $this->cache->set(
68 68
 				$cacheId,
69
-				$expiryTimestamp->getTimestamp( TS_UNIX ),
70
-				(int)$expiryTimestamp->getTimestamp( TS_UNIX )
69
+				$expiryTimestamp->getTimestamp(TS_UNIX),
70
+				(int) $expiryTimestamp->getTimestamp(TS_UNIX)
71 71
 			);
72 72
 		} else {
73 73
 			return false;
@@ -81,20 +81,20 @@  discard block
 block discarded – undo
81 81
 	 *
82 82
 	 * @throws \Wikimedia\Assert\ParameterTypeException
83 83
 	 */
84
-	private function isLockedInternal( $cacheId ) {
85
-		$expiryTime = $this->cache->get( $cacheId );
86
-		if ( !$expiryTime ) {
84
+	private function isLockedInternal($cacheId) {
85
+		$expiryTime = $this->cache->get($cacheId);
86
+		if (!$expiryTime) {
87 87
 			return false;
88 88
 		}
89 89
 
90 90
 		try {
91
-			$lockExpiryTimeStamp = new ConvertibleTimestamp( $expiryTime );
92
-		} catch ( TimestampException $exception ) {
91
+			$lockExpiryTimeStamp = new ConvertibleTimestamp($expiryTime);
92
+		} catch (TimestampException $exception) {
93 93
 			return false;
94 94
 		}
95 95
 
96 96
 		$now = new ConvertibleTimestamp();
97
-		if ( $now->timestamp < $lockExpiryTimeStamp->timestamp ) {
97
+		if ($now->timestamp < $lockExpiryTimeStamp->timestamp) {
98 98
 			return true;
99 99
 		} else {
100 100
 			return false;
@@ -108,8 +108,8 @@  discard block
 block discarded – undo
108 108
 	 *
109 109
 	 * @throws \Wikimedia\Assert\ParameterTypeException
110 110
 	 */
111
-	public function isLocked( $id ) {
112
-		return $this->isLockedInternal( $this->makeKey( $id ) );
111
+	public function isLocked($id) {
112
+		return $this->isLockedInternal($this->makeKey($id));
113 113
 	}
114 114
 
115 115
 }
Please login to merge, or discard this patch.
src/ConstraintCheck/Helper/ConstraintParameterParser.php 1 patch
Spacing   +291 added lines, -291 removed lines patch added patch discarded remove patch
@@ -1,6 +1,6 @@  discard block
 block discarded – undo
1 1
 <?php
2 2
 
3
-declare( strict_types = 1 );
3
+declare(strict_types=1);
4 4
 
5 5
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Helper;
6 6
 
@@ -68,15 +68,15 @@  discard block
 block discarded – undo
68 68
 	 * Check if any errors are recorded in the constraint parameters.
69 69
 	 * @throws ConstraintParameterException
70 70
 	 */
71
-	public function checkError( array $parameters ): void {
72
-		if ( array_key_exists( '@error', $parameters ) ) {
71
+	public function checkError(array $parameters): void {
72
+		if (array_key_exists('@error', $parameters)) {
73 73
 			$error = $parameters['@error'];
74
-			if ( array_key_exists( 'toolong', $error ) && $error['toolong'] ) {
74
+			if (array_key_exists('toolong', $error) && $error['toolong']) {
75 75
 				$msg = 'wbqc-violation-message-parameters-error-toolong';
76 76
 			} else {
77 77
 				$msg = 'wbqc-violation-message-parameters-error-unknown';
78 78
 			}
79
-			throw new ConstraintParameterException( new ViolationMessage( $msg ) );
79
+			throw new ConstraintParameterException(new ViolationMessage($msg));
80 80
 		}
81 81
 	}
82 82
 
@@ -84,11 +84,11 @@  discard block
 block discarded – undo
84 84
 	 * Require that $parameters contains exactly one $parameterId parameter.
85 85
 	 * @throws ConstraintParameterException
86 86
 	 */
87
-	private function requireSingleParameter( array $parameters, string $parameterId ): void {
88
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
87
+	private function requireSingleParameter(array $parameters, string $parameterId): void {
88
+		if (count($parameters[$parameterId]) !== 1) {
89 89
 			throw new ConstraintParameterException(
90
-				( new ViolationMessage( 'wbqc-violation-message-parameter-single' ) )
91
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
90
+				(new ViolationMessage('wbqc-violation-message-parameter-single'))
91
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
92 92
 			);
93 93
 		}
94 94
 	}
@@ -97,11 +97,11 @@  discard block
 block discarded – undo
97 97
 	 * Require that $snak is a {@link PropertyValueSnak}.
98 98
 	 * @throws ConstraintParameterException
99 99
 	 */
100
-	private function requireValueParameter( Snak $snak, string $parameterId ): void {
101
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
100
+	private function requireValueParameter(Snak $snak, string $parameterId): void {
101
+		if (!($snak instanceof PropertyValueSnak)) {
102 102
 			throw new ConstraintParameterException(
103
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
104
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
103
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
104
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
105 105
 			);
106 106
 		}
107 107
 	}
@@ -110,17 +110,17 @@  discard block
 block discarded – undo
110 110
 	 * Parse a single entity ID parameter.
111 111
 	 * @throws ConstraintParameterException
112 112
 	 */
113
-	private function parseEntityIdParameter( array $snakSerialization, string $parameterId ): EntityId {
114
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
115
-		$this->requireValueParameter( $snak, $parameterId );
113
+	private function parseEntityIdParameter(array $snakSerialization, string $parameterId): EntityId {
114
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
115
+		$this->requireValueParameter($snak, $parameterId);
116 116
 		$value = $snak->getDataValue();
117
-		if ( $value instanceof EntityIdValue ) {
117
+		if ($value instanceof EntityIdValue) {
118 118
 			return $value->getEntityId();
119 119
 		} else {
120 120
 			throw new ConstraintParameterException(
121
-				( new ViolationMessage( 'wbqc-violation-message-parameter-entity' ) )
122
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
123
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
121
+				(new ViolationMessage('wbqc-violation-message-parameter-entity'))
122
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
123
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
124 124
 			);
125 125
 		}
126 126
 	}
@@ -131,20 +131,20 @@  discard block
 block discarded – undo
131 131
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
132 132
 	 * @return string[] class entity ID serializations
133 133
 	 */
134
-	public function parseClassParameter( array $constraintParameters, string $constraintTypeItemId ): array {
135
-		$this->checkError( $constraintParameters );
136
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
137
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
134
+	public function parseClassParameter(array $constraintParameters, string $constraintTypeItemId): array {
135
+		$this->checkError($constraintParameters);
136
+		$classId = $this->config->get('WBQualityConstraintsClassId');
137
+		if (!array_key_exists($classId, $constraintParameters)) {
138 138
 			throw new ConstraintParameterException(
139
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
140
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
141
-					->withEntityId( new NumericPropertyId( $classId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
139
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
140
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
141
+					->withEntityId(new NumericPropertyId($classId), Role::CONSTRAINT_PARAMETER_PROPERTY)
142 142
 			);
143 143
 		}
144 144
 
145 145
 		$classes = [];
146
-		foreach ( $constraintParameters[$classId] as $class ) {
147
-			$classes[] = $this->parseEntityIdParameter( $class, $classId )->getSerialization();
146
+		foreach ($constraintParameters[$classId] as $class) {
147
+			$classes[] = $this->parseEntityIdParameter($class, $classId)->getSerialization();
148 148
 		}
149 149
 		return $classes;
150 150
 	}
@@ -155,31 +155,31 @@  discard block
 block discarded – undo
155 155
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
156 156
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
157 157
 	 */
158
-	public function parseRelationParameter( array $constraintParameters, string $constraintTypeItemId ): string {
159
-		$this->checkError( $constraintParameters );
160
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
161
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
158
+	public function parseRelationParameter(array $constraintParameters, string $constraintTypeItemId): string {
159
+		$this->checkError($constraintParameters);
160
+		$relationId = $this->config->get('WBQualityConstraintsRelationId');
161
+		if (!array_key_exists($relationId, $constraintParameters)) {
162 162
 			throw new ConstraintParameterException(
163
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
164
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
165
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
163
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
164
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
165
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
166 166
 			);
167 167
 		}
168 168
 
169
-		$this->requireSingleParameter( $constraintParameters, $relationId );
170
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
171
-		if ( !( $relationEntityId instanceof ItemId ) ) {
169
+		$this->requireSingleParameter($constraintParameters, $relationId);
170
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
171
+		if (!($relationEntityId instanceof ItemId)) {
172 172
 			throw new ConstraintParameterException(
173
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
174
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
175
-					->withDataValue( new EntityIdValue( $relationEntityId ), Role::CONSTRAINT_PARAMETER_VALUE )
173
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
174
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
175
+					->withDataValue(new EntityIdValue($relationEntityId), Role::CONSTRAINT_PARAMETER_VALUE)
176 176
 			);
177 177
 		}
178
-		return $this->mapItemId( $relationEntityId, [
179
-			$this->config->get( 'WBQualityConstraintsInstanceOfRelationId' ) => 'instance',
180
-			$this->config->get( 'WBQualityConstraintsSubclassOfRelationId' ) => 'subclass',
181
-			$this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' ) => 'instanceOrSubclass',
182
-		], $relationId );
178
+		return $this->mapItemId($relationEntityId, [
179
+			$this->config->get('WBQualityConstraintsInstanceOfRelationId') => 'instance',
180
+			$this->config->get('WBQualityConstraintsSubclassOfRelationId') => 'subclass',
181
+			$this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId') => 'instanceOrSubclass',
182
+		], $relationId);
183 183
 	}
184 184
 
185 185
 	/**
@@ -189,20 +189,20 @@  discard block
 block discarded – undo
189 189
 	 * @throws ConstraintParameterException
190 190
 	 * @return PropertyId
191 191
 	 */
192
-	private function parsePropertyIdParameter( array $snakSerialization, string $parameterId ): PropertyId {
193
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
194
-		$this->requireValueParameter( $snak, $parameterId );
192
+	private function parsePropertyIdParameter(array $snakSerialization, string $parameterId): PropertyId {
193
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
194
+		$this->requireValueParameter($snak, $parameterId);
195 195
 		$value = $snak->getDataValue();
196
-		if ( $value instanceof EntityIdValue ) {
196
+		if ($value instanceof EntityIdValue) {
197 197
 			$id = $value->getEntityId();
198
-			if ( $id instanceof PropertyId ) {
198
+			if ($id instanceof PropertyId) {
199 199
 				return $id;
200 200
 			}
201 201
 		}
202 202
 		throw new ConstraintParameterException(
203
-			( new ViolationMessage( 'wbqc-violation-message-parameter-property' ) )
204
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
205
-				->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
203
+			(new ViolationMessage('wbqc-violation-message-parameter-property'))
204
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
205
+				->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
206 206
 		);
207 207
 	}
208 208
 
@@ -213,33 +213,33 @@  discard block
 block discarded – undo
213 213
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
214 214
 	 * @return PropertyId
215 215
 	 */
216
-	public function parsePropertyParameter( array $constraintParameters, string $constraintTypeItemId ): PropertyId {
217
-		$this->checkError( $constraintParameters );
218
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
219
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
216
+	public function parsePropertyParameter(array $constraintParameters, string $constraintTypeItemId): PropertyId {
217
+		$this->checkError($constraintParameters);
218
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
219
+		if (!array_key_exists($propertyId, $constraintParameters)) {
220 220
 			throw new ConstraintParameterException(
221
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
222
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
223
-					->withEntityId( new NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
221
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
222
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
223
+					->withEntityId(new NumericPropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
224 224
 			);
225 225
 		}
226 226
 
227
-		$this->requireSingleParameter( $constraintParameters, $propertyId );
228
-		return $this->parsePropertyIdParameter( $constraintParameters[$propertyId][0], $propertyId );
227
+		$this->requireSingleParameter($constraintParameters, $propertyId);
228
+		return $this->parsePropertyIdParameter($constraintParameters[$propertyId][0], $propertyId);
229 229
 	}
230 230
 
231
-	private function parseItemIdParameter( PropertyValueSnak $snak, string $parameterId ): ItemIdSnakValue {
231
+	private function parseItemIdParameter(PropertyValueSnak $snak, string $parameterId): ItemIdSnakValue {
232 232
 		$dataValue = $snak->getDataValue();
233
-		if ( $dataValue instanceof EntityIdValue ) {
233
+		if ($dataValue instanceof EntityIdValue) {
234 234
 			$entityId = $dataValue->getEntityId();
235
-			if ( $entityId instanceof ItemId ) {
236
-				return ItemIdSnakValue::fromItemId( $entityId );
235
+			if ($entityId instanceof ItemId) {
236
+				return ItemIdSnakValue::fromItemId($entityId);
237 237
 			}
238 238
 		}
239 239
 		throw new ConstraintParameterException(
240
-			( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
241
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
242
-				->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
240
+			(new ViolationMessage('wbqc-violation-message-parameter-item'))
241
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
242
+				->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
243 243
 		);
244 244
 	}
245 245
 
@@ -257,16 +257,16 @@  discard block
 block discarded – undo
257 257
 		bool $required,
258 258
 		string $parameterId = null
259 259
 	): array {
260
-		$this->checkError( $constraintParameters );
261
-		if ( $parameterId === null ) {
262
-			$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
260
+		$this->checkError($constraintParameters);
261
+		if ($parameterId === null) {
262
+			$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
263 263
 		}
264
-		if ( !array_key_exists( $parameterId, $constraintParameters ) ) {
265
-			if ( $required ) {
264
+		if (!array_key_exists($parameterId, $constraintParameters)) {
265
+			if ($required) {
266 266
 				throw new ConstraintParameterException(
267
-					( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
268
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
269
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
267
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
268
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
269
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
270 270
 				);
271 271
 			} else {
272 272
 				return [];
@@ -274,11 +274,11 @@  discard block
 block discarded – undo
274 274
 		}
275 275
 
276 276
 		$values = [];
277
-		foreach ( $constraintParameters[$parameterId] as $parameter ) {
278
-			$snak = $this->snakDeserializer->deserialize( $parameter );
279
-			switch ( true ) {
277
+		foreach ($constraintParameters[$parameterId] as $parameter) {
278
+			$snak = $this->snakDeserializer->deserialize($parameter);
279
+			switch (true) {
280 280
 				case $snak instanceof PropertyValueSnak:
281
-					$values[] = $this->parseItemIdParameter( $snak, $parameterId );
281
+					$values[] = $this->parseItemIdParameter($snak, $parameterId);
282 282
 					break;
283 283
 				case $snak instanceof PropertySomeValueSnak:
284 284
 					$values[] = ItemIdSnakValue::someValue();
@@ -306,13 +306,13 @@  discard block
 block discarded – undo
306 306
 		bool $required,
307 307
 		string $parameterId
308 308
 	): array {
309
-		return array_map( static function ( ItemIdSnakValue $value ) use ( $parameterId ): ItemId {
310
-			if ( $value->isValue() ) {
309
+		return array_map(static function(ItemIdSnakValue $value) use ($parameterId): ItemId {
310
+			if ($value->isValue()) {
311 311
 				return $value->getItemId();
312 312
 			} else {
313 313
 				throw new ConstraintParameterException(
314
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
315
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
314
+					(new ViolationMessage('wbqc-violation-message-parameter-value'))
315
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
316 316
 				);
317 317
 			}
318 318
 		}, $this->parseItemsParameter(
@@ -320,7 +320,7 @@  discard block
 block discarded – undo
320 320
 			$constraintTypeItemId,
321 321
 			$required,
322 322
 			$parameterId
323
-		) );
323
+		));
324 324
 	}
325 325
 
326 326
 	/**
@@ -328,18 +328,18 @@  discard block
 block discarded – undo
328 328
 	 * @throws ConstraintParameterException
329 329
 	 * @return mixed elements of $mapping
330 330
 	 */
331
-	private function mapItemId( ItemId $itemId, array $mapping, string $parameterId ) {
331
+	private function mapItemId(ItemId $itemId, array $mapping, string $parameterId) {
332 332
 		$serialization = $itemId->getSerialization();
333
-		if ( array_key_exists( $serialization, $mapping ) ) {
333
+		if (array_key_exists($serialization, $mapping)) {
334 334
 			return $mapping[$serialization];
335 335
 		} else {
336
-			$allowed = array_map( static function ( $id ) {
337
-				return new ItemId( $id );
338
-			}, array_keys( $mapping ) );
336
+			$allowed = array_map(static function($id) {
337
+				return new ItemId($id);
338
+			}, array_keys($mapping));
339 339
 			throw new ConstraintParameterException(
340
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
341
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
342
-					->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
340
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
341
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
342
+					->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
343 343
 			);
344 344
 		}
345 345
 	}
@@ -350,27 +350,27 @@  discard block
 block discarded – undo
350 350
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
351 351
 	 * @return PropertyId[]
352 352
 	 */
353
-	public function parsePropertiesParameter( array $constraintParameters, string $constraintTypeItemId ): array {
354
-		$this->checkError( $constraintParameters );
355
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
356
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
353
+	public function parsePropertiesParameter(array $constraintParameters, string $constraintTypeItemId): array {
354
+		$this->checkError($constraintParameters);
355
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
356
+		if (!array_key_exists($propertyId, $constraintParameters)) {
357 357
 			throw new ConstraintParameterException(
358
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
359
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
360
-					->withEntityId( new NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
358
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
359
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
360
+					->withEntityId(new NumericPropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
361 361
 			);
362 362
 		}
363 363
 
364 364
 		$parameters = $constraintParameters[$propertyId];
365
-		if ( count( $parameters ) === 1 &&
366
-			$this->snakDeserializer->deserialize( $parameters[0] ) instanceof PropertyNoValueSnak
365
+		if (count($parameters) === 1 &&
366
+			$this->snakDeserializer->deserialize($parameters[0]) instanceof PropertyNoValueSnak
367 367
 		) {
368 368
 			return [];
369 369
 		}
370 370
 
371 371
 		$properties = [];
372
-		foreach ( $parameters as $parameter ) {
373
-			$properties[] = $this->parsePropertyIdParameter( $parameter, $propertyId );
372
+		foreach ($parameters as $parameter) {
373
+			$properties[] = $this->parsePropertyIdParameter($parameter, $propertyId);
374 374
 		}
375 375
 		return $properties;
376 376
 	}
@@ -378,24 +378,24 @@  discard block
 block discarded – undo
378 378
 	/**
379 379
 	 * @throws ConstraintParameterException
380 380
 	 */
381
-	private function parseValueOrNoValueParameter( array $snakSerialization, string $parameterId ): ?DataValue {
382
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
383
-		if ( $snak instanceof PropertyValueSnak ) {
381
+	private function parseValueOrNoValueParameter(array $snakSerialization, string $parameterId): ?DataValue {
382
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
383
+		if ($snak instanceof PropertyValueSnak) {
384 384
 			return $snak->getDataValue();
385
-		} elseif ( $snak instanceof PropertyNoValueSnak ) {
385
+		} elseif ($snak instanceof PropertyNoValueSnak) {
386 386
 			return null;
387 387
 		} else {
388 388
 			throw new ConstraintParameterException(
389
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
390
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
389
+				(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
390
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
391 391
 			);
392 392
 		}
393 393
 	}
394 394
 
395
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, string $parameterId ): ?DataValue {
395
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, string $parameterId): ?DataValue {
396 396
 		try {
397
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
398
-		} catch ( ConstraintParameterException $e ) {
397
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
398
+		} catch (ConstraintParameterException $e) {
399 399
 			// unknown value means “now”
400 400
 			return new NowValue();
401 401
 		}
@@ -404,14 +404,14 @@  discard block
 block discarded – undo
404 404
 	/**
405 405
 	 * Checks whether there is exactly one non-null quantity with the given unit.
406 406
 	 */
407
-	private function exactlyOneQuantityWithUnit( ?DataValue $min, ?DataValue $max, string $unit ): bool {
408
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
409
-			!( $max instanceof UnboundedQuantityValue )
407
+	private function exactlyOneQuantityWithUnit(?DataValue $min, ?DataValue $max, string $unit): bool {
408
+		if (!($min instanceof UnboundedQuantityValue) ||
409
+			!($max instanceof UnboundedQuantityValue)
410 410
 		) {
411 411
 			return false;
412 412
 		}
413 413
 
414
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
414
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
415 415
 	}
416 416
 
417 417
 	/**
@@ -431,42 +431,42 @@  discard block
 block discarded – undo
431 431
 		string $constraintTypeItemId,
432 432
 		string $type
433 433
 	): array {
434
-		$this->checkError( $constraintParameters );
435
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
436
-			!array_key_exists( $maximumId, $constraintParameters )
434
+		$this->checkError($constraintParameters);
435
+		if (!array_key_exists($minimumId, $constraintParameters) ||
436
+			!array_key_exists($maximumId, $constraintParameters)
437 437
 		) {
438 438
 			throw new ConstraintParameterException(
439
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-needed' ) )
440
-					->withDataValueType( $type )
441
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
442
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
443
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
439
+				(new ViolationMessage('wbqc-violation-message-range-parameters-needed'))
440
+					->withDataValueType($type)
441
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
442
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
443
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
444 444
 			);
445 445
 		}
446 446
 
447
-		$this->requireSingleParameter( $constraintParameters, $minimumId );
448
-		$this->requireSingleParameter( $constraintParameters, $maximumId );
447
+		$this->requireSingleParameter($constraintParameters, $minimumId);
448
+		$this->requireSingleParameter($constraintParameters, $maximumId);
449 449
 		$parseFunction = $type === 'time' ? 'parseValueOrNoValueOrNowParameter' : 'parseValueOrNoValueParameter';
450
-		$min = $this->$parseFunction( $constraintParameters[$minimumId][0], $minimumId );
451
-		$max = $this->$parseFunction( $constraintParameters[$maximumId][0], $maximumId );
450
+		$min = $this->$parseFunction($constraintParameters[$minimumId][0], $minimumId);
451
+		$max = $this->$parseFunction($constraintParameters[$maximumId][0], $maximumId);
452 452
 
453
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
454
-		if ( $this->exactlyOneQuantityWithUnit( $min, $max, $yearUnit ) ) {
453
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
454
+		if ($this->exactlyOneQuantityWithUnit($min, $max, $yearUnit)) {
455 455
 			throw new ConstraintParameterException(
456
-				new ViolationMessage( 'wbqc-violation-message-range-parameters-one-year' )
456
+				new ViolationMessage('wbqc-violation-message-range-parameters-one-year')
457 457
 			);
458 458
 		}
459
-		if ( ( $min === null && $max === null ) ||
460
-			( $min !== null && $max !== null && $min->equals( $max ) )
459
+		if (($min === null && $max === null) ||
460
+			($min !== null && $max !== null && $min->equals($max))
461 461
 		) {
462 462
 			throw new ConstraintParameterException(
463
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-same' ) )
464
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
465
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
463
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
464
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
465
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
466 466
 			);
467 467
 		}
468 468
 
469
-		return [ $min, $max ];
469
+		return [$min, $max];
470 470
 	}
471 471
 
472 472
 	/**
@@ -476,11 +476,11 @@  discard block
 block discarded – undo
476 476
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
477 477
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
478 478
 	 */
479
-	public function parseQuantityRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
479
+	public function parseQuantityRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
480 480
 		return $this->parseRangeParameter(
481 481
 			$constraintParameters,
482
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
483
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
482
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
483
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
484 484
 			$constraintTypeItemId,
485 485
 			'quantity'
486 486
 		);
@@ -493,11 +493,11 @@  discard block
 block discarded – undo
493 493
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
494 494
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
495 495
 	 */
496
-	public function parseTimeRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
496
+	public function parseTimeRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
497 497
 		return $this->parseRangeParameter(
498 498
 			$constraintParameters,
499
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
500
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
499
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
500
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
501 501
 			$constraintTypeItemId,
502 502
 			'time'
503 503
 		);
@@ -510,20 +510,20 @@  discard block
 block discarded – undo
510 510
 	 * @throws ConstraintParameterException
511 511
 	 * @return string[]
512 512
 	 */
513
-	public function parseLanguageParameter( array $constraintParameters, string $constraintTypeItemId ): array {
514
-		$this->checkError( $constraintParameters );
515
-		$languagePropertyId = $this->config->get( 'WBQualityConstraintsLanguagePropertyId' );
516
-		if ( !array_key_exists( $languagePropertyId, $constraintParameters ) ) {
513
+	public function parseLanguageParameter(array $constraintParameters, string $constraintTypeItemId): array {
514
+		$this->checkError($constraintParameters);
515
+		$languagePropertyId = $this->config->get('WBQualityConstraintsLanguagePropertyId');
516
+		if (!array_key_exists($languagePropertyId, $constraintParameters)) {
517 517
 			throw new ConstraintParameterException(
518
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
519
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
520
-					->withEntityId( new NumericPropertyId( $languagePropertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
518
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
519
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
520
+					->withEntityId(new NumericPropertyId($languagePropertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
521 521
 			);
522 522
 		}
523 523
 
524 524
 		$languages = [];
525
-		foreach ( $constraintParameters[$languagePropertyId] as $snak ) {
526
-			$languages[] = $this->parseStringParameter( $snak, $languagePropertyId );
525
+		foreach ($constraintParameters[$languagePropertyId] as $snak) {
526
+			$languages[] = $this->parseStringParameter($snak, $languagePropertyId);
527 527
 		}
528 528
 		return $languages;
529 529
 	}
@@ -532,17 +532,17 @@  discard block
 block discarded – undo
532 532
 	 * Parse a single string parameter.
533 533
 	 * @throws ConstraintParameterException
534 534
 	 */
535
-	private function parseStringParameter( array $snakSerialization, string $parameterId ): string {
536
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
537
-		$this->requireValueParameter( $snak, $parameterId );
535
+	private function parseStringParameter(array $snakSerialization, string $parameterId): string {
536
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
537
+		$this->requireValueParameter($snak, $parameterId);
538 538
 		$value = $snak->getDataValue();
539
-		if ( $value instanceof StringValue ) {
539
+		if ($value instanceof StringValue) {
540 540
 			return $value->getValue();
541 541
 		} else {
542 542
 			throw new ConstraintParameterException(
543
-				( new ViolationMessage( 'wbqc-violation-message-parameter-string' ) )
544
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
545
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
543
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
544
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
545
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
546 546
 			);
547 547
 		}
548 548
 	}
@@ -553,15 +553,15 @@  discard block
 block discarded – undo
553 553
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
554 554
 	 * @return string
555 555
 	 */
556
-	public function parseNamespaceParameter( array $constraintParameters, string $constraintTypeItemId ): string {
557
-		$this->checkError( $constraintParameters );
558
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
559
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
556
+	public function parseNamespaceParameter(array $constraintParameters, string $constraintTypeItemId): string {
557
+		$this->checkError($constraintParameters);
558
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
559
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
560 560
 			return '';
561 561
 		}
562 562
 
563
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
564
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
563
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
564
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
565 565
 	}
566 566
 
567 567
 	/**
@@ -570,19 +570,19 @@  discard block
 block discarded – undo
570 570
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
571 571
 	 * @return string
572 572
 	 */
573
-	public function parseFormatParameter( array $constraintParameters, string $constraintTypeItemId ): string {
574
-		$this->checkError( $constraintParameters );
575
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
576
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
573
+	public function parseFormatParameter(array $constraintParameters, string $constraintTypeItemId): string {
574
+		$this->checkError($constraintParameters);
575
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
576
+		if (!array_key_exists($formatId, $constraintParameters)) {
577 577
 			throw new ConstraintParameterException(
578
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
579
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
580
-					->withEntityId( new NumericPropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
578
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
579
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
580
+					->withEntityId(new NumericPropertyId($formatId), Role::CONSTRAINT_PARAMETER_PROPERTY)
581 581
 			);
582 582
 		}
583 583
 
584
-		$this->requireSingleParameter( $constraintParameters, $formatId );
585
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
584
+		$this->requireSingleParameter($constraintParameters, $formatId);
585
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
586 586
 	}
587 587
 
588 588
 	/**
@@ -590,16 +590,16 @@  discard block
 block discarded – undo
590 590
 	 * @throws ConstraintParameterException if the parameter is invalid
591 591
 	 * @return EntityId[]
592 592
 	 */
593
-	public function parseExceptionParameter( array $constraintParameters ): array {
594
-		$this->checkError( $constraintParameters );
595
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
596
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
593
+	public function parseExceptionParameter(array $constraintParameters): array {
594
+		$this->checkError($constraintParameters);
595
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
596
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
597 597
 			return [];
598 598
 		}
599 599
 
600 600
 		return array_map(
601
-			function ( $snakSerialization ) use ( $exceptionId ) {
602
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
601
+			function($snakSerialization) use ($exceptionId) {
602
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
603 603
 			},
604 604
 			$constraintParameters[$exceptionId]
605 605
 		);
@@ -610,39 +610,39 @@  discard block
 block discarded – undo
610 610
 	 * @throws ConstraintParameterException if the parameter is invalid
611 611
 	 * @return string|null 'mandatory', 'suggestion' or null
612 612
 	 */
613
-	public function parseConstraintStatusParameter( array $constraintParameters ): ?string {
614
-		$this->checkError( $constraintParameters );
615
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
616
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
613
+	public function parseConstraintStatusParameter(array $constraintParameters): ?string {
614
+		$this->checkError($constraintParameters);
615
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
616
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
617 617
 			return null;
618 618
 		}
619 619
 
620
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
621
-		$supportedStatuses = [ new ItemId( $mandatoryId ) ];
622
-		if ( $this->config->get( 'WBQualityConstraintsEnableSuggestionConstraintStatus' ) ) {
623
-			$suggestionId = $this->config->get( 'WBQualityConstraintsSuggestionConstraintId' );
624
-			$supportedStatuses[] = new ItemId( $suggestionId );
620
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
621
+		$supportedStatuses = [new ItemId($mandatoryId)];
622
+		if ($this->config->get('WBQualityConstraintsEnableSuggestionConstraintStatus')) {
623
+			$suggestionId = $this->config->get('WBQualityConstraintsSuggestionConstraintId');
624
+			$supportedStatuses[] = new ItemId($suggestionId);
625 625
 		} else {
626 626
 			$suggestionId = null;
627 627
 		}
628 628
 
629
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
630
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
631
-		$this->requireValueParameter( $snak, $constraintStatusId );
629
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
630
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
631
+		$this->requireValueParameter($snak, $constraintStatusId);
632 632
 		'@phan-var \Wikibase\DataModel\Snak\PropertyValueSnak $snak';
633 633
 		$dataValue = $snak->getDataValue();
634 634
 		'@phan-var EntityIdValue $dataValue';
635 635
 		$entityId = $dataValue->getEntityId();
636 636
 		$statusId = $entityId->getSerialization();
637 637
 
638
-		if ( $statusId === $mandatoryId ) {
638
+		if ($statusId === $mandatoryId) {
639 639
 			return 'mandatory';
640
-		} elseif ( $statusId === $suggestionId ) {
640
+		} elseif ($statusId === $suggestionId) {
641 641
 			return 'suggestion';
642 642
 		} else {
643 643
 			throw new ConstraintParameterException(
644
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
645
-					->withEntityId( new NumericPropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
644
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
645
+					->withEntityId(new NumericPropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
646 646
 					->withEntityIdList(
647 647
 						$supportedStatuses,
648 648
 						Role::CONSTRAINT_PARAMETER_VALUE
@@ -655,12 +655,12 @@  discard block
 block discarded – undo
655 655
 	 * Require that $dataValue is a {@link MonolingualTextValue}.
656 656
 	 * @throws ConstraintParameterException
657 657
 	 */
658
-	private function requireMonolingualTextParameter( DataValue $dataValue, string $parameterId ): void {
659
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
658
+	private function requireMonolingualTextParameter(DataValue $dataValue, string $parameterId): void {
659
+		if (!($dataValue instanceof MonolingualTextValue)) {
660 660
 			throw new ConstraintParameterException(
661
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
662
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
663
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
661
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
662
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
663
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
664 664
 			);
665 665
 		}
666 666
 	}
@@ -670,31 +670,31 @@  discard block
 block discarded – undo
670 670
 	 *
671 671
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
672 672
 	 */
673
-	private function parseMultilingualTextParameter( array $snakSerializations, string $parameterId ): MultilingualTextValue {
673
+	private function parseMultilingualTextParameter(array $snakSerializations, string $parameterId): MultilingualTextValue {
674 674
 		$result = [];
675 675
 
676
-		foreach ( $snakSerializations as $snakSerialization ) {
677
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
678
-			$this->requireValueParameter( $snak, $parameterId );
676
+		foreach ($snakSerializations as $snakSerialization) {
677
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
678
+			$this->requireValueParameter($snak, $parameterId);
679 679
 
680 680
 			$value = $snak->getDataValue();
681
-			$this->requireMonolingualTextParameter( $value, $parameterId );
681
+			$this->requireMonolingualTextParameter($value, $parameterId);
682 682
 			/** @var MonolingualTextValue $value */
683 683
 			'@phan-var MonolingualTextValue $value';
684 684
 
685 685
 			$code = $value->getLanguageCode();
686
-			if ( array_key_exists( $code, $result ) ) {
686
+			if (array_key_exists($code, $result)) {
687 687
 				throw new ConstraintParameterException(
688
-					( new ViolationMessage( 'wbqc-violation-message-parameter-single-per-language' ) )
689
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
690
-						->withLanguage( $code )
688
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
689
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
690
+						->withLanguage($code)
691 691
 				);
692 692
 			}
693 693
 
694 694
 			$result[$code] = $value;
695 695
 		}
696 696
 
697
-		return new MultilingualTextValue( $result );
697
+		return new MultilingualTextValue($result);
698 698
 	}
699 699
 
700 700
 	/**
@@ -702,11 +702,11 @@  discard block
 block discarded – undo
702 702
 	 * @throws ConstraintParameterException if the parameter is invalid
703 703
 	 * @return MultilingualTextValue
704 704
 	 */
705
-	public function parseSyntaxClarificationParameter( array $constraintParameters ): MultilingualTextValue {
706
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
705
+	public function parseSyntaxClarificationParameter(array $constraintParameters): MultilingualTextValue {
706
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
707 707
 
708
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
709
-			return new MultilingualTextValue( [] );
708
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
709
+			return new MultilingualTextValue([]);
710 710
 		}
711 711
 
712 712
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -722,11 +722,11 @@  discard block
 block discarded – undo
722 722
 	 * @throws ConstraintParameterException if the parameter is invalid
723 723
 	 * @return MultilingualTextValue
724 724
 	 */
725
-	public function parseConstraintClarificationParameter( array $constraintParameters ): MultilingualTextValue {
726
-		$constraintClarificationId = $this->config->get( 'WBQualityConstraintsConstraintClarificationId' );
725
+	public function parseConstraintClarificationParameter(array $constraintParameters): MultilingualTextValue {
726
+		$constraintClarificationId = $this->config->get('WBQualityConstraintsConstraintClarificationId');
727 727
 
728
-		if ( !array_key_exists( $constraintClarificationId, $constraintParameters ) ) {
729
-			return new MultilingualTextValue( [] );
728
+		if (!array_key_exists($constraintClarificationId, $constraintParameters)) {
729
+			return new MultilingualTextValue([]);
730 730
 		}
731 731
 
732 732
 		$constraintClarifications = $this->parseMultilingualTextParameter(
@@ -759,14 +759,14 @@  discard block
 block discarded – undo
759 759
 		array $validContextTypes,
760 760
 		array $validEntityTypes
761 761
 	): array {
762
-		$contextTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
762
+		$contextTypeParameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
763 763
 		$contextTypeItemIds = $this->parseItemIdsParameter(
764 764
 			$constraintParameters,
765 765
 			$constraintTypeItemId,
766 766
 			false,
767 767
 			$contextTypeParameterId
768 768
 		);
769
-		$entityTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintEntityTypesId' );
769
+		$entityTypeParameterId = $this->config->get('WBQualityConstraintsConstraintEntityTypesId');
770 770
 		$entityTypeItemIds = $this->parseItemIdsParameter(
771 771
 			$constraintParameters,
772 772
 			$constraintTypeItemId,
@@ -782,26 +782,26 @@  discard block
 block discarded – undo
782 782
 		$contextTypes = null;
783 783
 		$entityTypes = null;
784 784
 
785
-		if ( $contextTypeParameterId === $entityTypeParameterId ) {
785
+		if ($contextTypeParameterId === $entityTypeParameterId) {
786 786
 			$itemIds = $contextTypeItemIds;
787 787
 			$mapping = $contextTypeMapping + $entityTypeMapping;
788
-			foreach ( $itemIds as $itemId ) {
789
-				$mapped = $this->mapItemId( $itemId, $mapping, $contextTypeParameterId );
790
-				if ( in_array( $mapped, $contextTypeMapping, true ) ) {
788
+			foreach ($itemIds as $itemId) {
789
+				$mapped = $this->mapItemId($itemId, $mapping, $contextTypeParameterId);
790
+				if (in_array($mapped, $contextTypeMapping, true)) {
791 791
 					$contextTypes[] = $mapped;
792 792
 				} else {
793 793
 					$entityTypes[] = $mapped;
794 794
 				}
795 795
 			}
796 796
 		} else {
797
-			foreach ( $contextTypeItemIds as $contextTypeItemId ) {
797
+			foreach ($contextTypeItemIds as $contextTypeItemId) {
798 798
 				$contextTypes[] = $this->mapItemId(
799 799
 					$contextTypeItemId,
800 800
 					$contextTypeMapping,
801 801
 					$contextTypeParameterId
802 802
 				);
803 803
 			}
804
-			foreach ( $entityTypeItemIds as $entityTypeItemId ) {
804
+			foreach ($entityTypeItemIds as $entityTypeItemId) {
805 805
 				$entityTypes[] = $this->mapItemId(
806 806
 					$entityTypeItemId,
807 807
 					$entityTypeMapping,
@@ -810,21 +810,21 @@  discard block
 block discarded – undo
810 810
 			}
811 811
 		}
812 812
 
813
-		$this->checkValidScope( $constraintTypeItemId, $contextTypes, $validContextTypes );
814
-		$this->checkValidScope( $constraintTypeItemId, $entityTypes, $validEntityTypes );
813
+		$this->checkValidScope($constraintTypeItemId, $contextTypes, $validContextTypes);
814
+		$this->checkValidScope($constraintTypeItemId, $entityTypes, $validEntityTypes);
815 815
 
816
-		return [ $contextTypes, $entityTypes ];
816
+		return [$contextTypes, $entityTypes];
817 817
 	}
818 818
 
819
-	private function checkValidScope( string $constraintTypeItemId, ?array $types, array $validTypes ): void {
820
-		$invalidTypes = array_diff( $types ?: [], $validTypes );
821
-		if ( $invalidTypes !== [] ) {
822
-			$invalidType = array_pop( $invalidTypes );
819
+	private function checkValidScope(string $constraintTypeItemId, ?array $types, array $validTypes): void {
820
+		$invalidTypes = array_diff($types ?: [], $validTypes);
821
+		if ($invalidTypes !== []) {
822
+			$invalidType = array_pop($invalidTypes);
823 823
 			throw new ConstraintParameterException(
824
-				( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
825
-					->withConstraintScope( $invalidType, Role::CONSTRAINT_PARAMETER_VALUE )
826
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
827
-					->withConstraintScopeList( $validTypes, Role::CONSTRAINT_PARAMETER_VALUE )
824
+				(new ViolationMessage('wbqc-violation-message-invalid-scope'))
825
+					->withConstraintScope($invalidType, Role::CONSTRAINT_PARAMETER_VALUE)
826
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
827
+					->withConstraintScopeList($validTypes, Role::CONSTRAINT_PARAMETER_VALUE)
828 828
 			);
829 829
 		}
830 830
 	}
@@ -832,8 +832,8 @@  discard block
 block discarded – undo
832 832
 	/**
833 833
 	 * Turn an item ID into a full unit string (using the concept URI).
834 834
 	 */
835
-	private function parseUnitParameter( ItemId $unitId ): string {
836
-		return $this->unitItemConceptBaseUri . $unitId->getSerialization();
835
+	private function parseUnitParameter(ItemId $unitId): string {
836
+		return $this->unitItemConceptBaseUri.$unitId->getSerialization();
837 837
 	}
838 838
 
839 839
 	/**
@@ -841,23 +841,23 @@  discard block
 block discarded – undo
841 841
 	 *
842 842
 	 * @throws ConstraintParameterException
843 843
 	 */
844
-	private function parseUnitItem( ItemIdSnakValue $item ): UnitsParameter {
845
-		switch ( true ) {
844
+	private function parseUnitItem(ItemIdSnakValue $item): UnitsParameter {
845
+		switch (true) {
846 846
 			case $item->isValue():
847
-				$unit = $this->parseUnitParameter( $item->getItemId() );
847
+				$unit = $this->parseUnitParameter($item->getItemId());
848 848
 				return new UnitsParameter(
849
-					[ $item->getItemId() ],
850
-					[ UnboundedQuantityValue::newFromNumber( 1, $unit ) ],
849
+					[$item->getItemId()],
850
+					[UnboundedQuantityValue::newFromNumber(1, $unit)],
851 851
 					false
852 852
 				);
853 853
 			case $item->isSomeValue():
854
-				$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
854
+				$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
855 855
 				throw new ConstraintParameterException(
856
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
857
-						->withEntityId( new NumericPropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
856
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
857
+						->withEntityId(new NumericPropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
858 858
 				);
859 859
 			case $item->isNoValue():
860
-				return new UnitsParameter( [], [], true );
860
+				return new UnitsParameter([], [], true);
861 861
 		}
862 862
 	}
863 863
 
@@ -867,36 +867,36 @@  discard block
 block discarded – undo
867 867
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
868 868
 	 * @return UnitsParameter
869 869
 	 */
870
-	public function parseUnitsParameter( array $constraintParameters, string $constraintTypeItemId ): UnitsParameter {
871
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
870
+	public function parseUnitsParameter(array $constraintParameters, string $constraintTypeItemId): UnitsParameter {
871
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
872 872
 		$unitItems = [];
873 873
 		$unitQuantities = [];
874 874
 		$unitlessAllowed = false;
875 875
 
876
-		foreach ( $items as $item ) {
877
-			$unit = $this->parseUnitItem( $item );
878
-			$unitItems = array_merge( $unitItems, $unit->getUnitItemIds() );
879
-			$unitQuantities = array_merge( $unitQuantities, $unit->getUnitQuantities() );
876
+		foreach ($items as $item) {
877
+			$unit = $this->parseUnitItem($item);
878
+			$unitItems = array_merge($unitItems, $unit->getUnitItemIds());
879
+			$unitQuantities = array_merge($unitQuantities, $unit->getUnitQuantities());
880 880
 			$unitlessAllowed = $unitlessAllowed || $unit->getUnitlessAllowed();
881 881
 		}
882 882
 
883
-		if ( $unitQuantities === [] && !$unitlessAllowed ) {
883
+		if ($unitQuantities === [] && !$unitlessAllowed) {
884 884
 			throw new LogicException(
885 885
 				'The "units" parameter is required, and yet we seem to be missing any allowed unit'
886 886
 			);
887 887
 		}
888 888
 
889
-		return new UnitsParameter( $unitItems, $unitQuantities, $unitlessAllowed );
889
+		return new UnitsParameter($unitItems, $unitQuantities, $unitlessAllowed);
890 890
 	}
891 891
 
892 892
 	private function getEntityTypeMapping(): array {
893 893
 		return [
894
-			$this->config->get( 'WBQualityConstraintsWikibaseItemId' ) => 'item',
895
-			$this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) => 'property',
896
-			$this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) => 'lexeme',
897
-			$this->config->get( 'WBQualityConstraintsWikibaseFormId' ) => 'form',
898
-			$this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) => 'sense',
899
-			$this->config->get( 'WBQualityConstraintsWikibaseMediaInfoId' ) => 'mediainfo',
894
+			$this->config->get('WBQualityConstraintsWikibaseItemId') => 'item',
895
+			$this->config->get('WBQualityConstraintsWikibasePropertyId') => 'property',
896
+			$this->config->get('WBQualityConstraintsWikibaseLexemeId') => 'lexeme',
897
+			$this->config->get('WBQualityConstraintsWikibaseFormId') => 'form',
898
+			$this->config->get('WBQualityConstraintsWikibaseSenseId') => 'sense',
899
+			$this->config->get('WBQualityConstraintsWikibaseMediaInfoId') => 'mediainfo',
900 900
 		];
901 901
 	}
902 902
 
@@ -906,10 +906,10 @@  discard block
 block discarded – undo
906 906
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
907 907
 	 * @return EntityTypesParameter
908 908
 	 */
909
-	public function parseEntityTypesParameter( array $constraintParameters, string $constraintTypeItemId ): EntityTypesParameter {
909
+	public function parseEntityTypesParameter(array $constraintParameters, string $constraintTypeItemId): EntityTypesParameter {
910 910
 		$entityTypes = [];
911 911
 		$entityTypeItemIds = [];
912
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
912
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
913 913
 		$itemIds = $this->parseItemIdsParameter(
914 914
 			$constraintParameters,
915 915
 			$constraintTypeItemId,
@@ -918,22 +918,22 @@  discard block
 block discarded – undo
918 918
 		);
919 919
 
920 920
 		$mapping = $this->getEntityTypeMapping();
921
-		foreach ( $itemIds as $itemId ) {
922
-			$entityType = $this->mapItemId( $itemId, $mapping, $parameterId );
921
+		foreach ($itemIds as $itemId) {
922
+			$entityType = $this->mapItemId($itemId, $mapping, $parameterId);
923 923
 			$entityTypes[] = $entityType;
924 924
 			$entityTypeItemIds[] = $itemId;
925 925
 		}
926 926
 
927
-		if ( $entityTypes === [] ) {
927
+		if ($entityTypes === []) {
928 928
 			// @codeCoverageIgnoreStart
929 929
 			throw new LogicException(
930
-				'The "entity types" parameter is required, ' .
930
+				'The "entity types" parameter is required, '.
931 931
 				'and yet we seem to be missing any allowed entity type'
932 932
 			);
933 933
 			// @codeCoverageIgnoreEnd
934 934
 		}
935 935
 
936
-		return new EntityTypesParameter( $entityTypes, $entityTypeItemIds );
936
+		return new EntityTypesParameter($entityTypes, $entityTypeItemIds);
937 937
 	}
938 938
 
939 939
 	/**
@@ -941,18 +941,18 @@  discard block
 block discarded – undo
941 941
 	 * @throws ConstraintParameterException if the parameter is invalid
942 942
 	 * @return PropertyId[]
943 943
 	 */
944
-	public function parseSeparatorsParameter( array $constraintParameters ): array {
945
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
944
+	public function parseSeparatorsParameter(array $constraintParameters): array {
945
+		$separatorId = $this->config->get('WBQualityConstraintsSeparatorId');
946 946
 
947
-		if ( !array_key_exists( $separatorId, $constraintParameters ) ) {
947
+		if (!array_key_exists($separatorId, $constraintParameters)) {
948 948
 			return [];
949 949
 		}
950 950
 
951 951
 		$parameters = $constraintParameters[$separatorId];
952 952
 		$separators = [];
953 953
 
954
-		foreach ( $parameters as $parameter ) {
955
-			$separators[] = $this->parsePropertyIdParameter( $parameter, $separatorId );
954
+		foreach ($parameters as $parameter) {
955
+			$separators[] = $this->parsePropertyIdParameter($parameter, $separatorId);
956 956
 		}
957 957
 
958 958
 		return $separators;
@@ -960,17 +960,17 @@  discard block
 block discarded – undo
960 960
 
961 961
 	private function getConstraintScopeContextTypeMapping(): array {
962 962
 		return [
963
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' ) => Context::TYPE_STATEMENT,
964
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' ) => Context::TYPE_QUALIFIER,
965
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' ) => Context::TYPE_REFERENCE,
963
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId') => Context::TYPE_STATEMENT,
964
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId') => Context::TYPE_QUALIFIER,
965
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId') => Context::TYPE_REFERENCE,
966 966
 		];
967 967
 	}
968 968
 
969 969
 	private function getPropertyScopeContextTypeMapping(): array {
970 970
 		return [
971
-			$this->config->get( 'WBQualityConstraintsAsMainValueId' ) => Context::TYPE_STATEMENT,
972
-			$this->config->get( 'WBQualityConstraintsAsQualifiersId' ) => Context::TYPE_QUALIFIER,
973
-			$this->config->get( 'WBQualityConstraintsAsReferencesId' ) => Context::TYPE_REFERENCE,
971
+			$this->config->get('WBQualityConstraintsAsMainValueId') => Context::TYPE_STATEMENT,
972
+			$this->config->get('WBQualityConstraintsAsQualifiersId') => Context::TYPE_QUALIFIER,
973
+			$this->config->get('WBQualityConstraintsAsReferencesId') => Context::TYPE_REFERENCE,
974 974
 		];
975 975
 	}
976 976
 
@@ -980,9 +980,9 @@  discard block
 block discarded – undo
980 980
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
981 981
 	 * @return string[] list of Context::TYPE_* constants
982 982
 	 */
983
-	public function parsePropertyScopeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
983
+	public function parsePropertyScopeParameter(array $constraintParameters, string $constraintTypeItemId): array {
984 984
 		$contextTypes = [];
985
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
985
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
986 986
 		$itemIds = $this->parseItemIdsParameter(
987 987
 			$constraintParameters,
988 988
 			$constraintTypeItemId,
@@ -991,14 +991,14 @@  discard block
 block discarded – undo
991 991
 		);
992 992
 
993 993
 		$mapping = $this->getPropertyScopeContextTypeMapping();
994
-		foreach ( $itemIds as $itemId ) {
995
-			$contextTypes[] = $this->mapItemId( $itemId, $mapping, $parameterId );
994
+		foreach ($itemIds as $itemId) {
995
+			$contextTypes[] = $this->mapItemId($itemId, $mapping, $parameterId);
996 996
 		}
997 997
 
998
-		if ( $contextTypes === [] ) {
998
+		if ($contextTypes === []) {
999 999
 			// @codeCoverageIgnoreStart
1000 1000
 			throw new LogicException(
1001
-				'The "property scope" parameter is required, ' .
1001
+				'The "property scope" parameter is required, '.
1002 1002
 				'and yet we seem to be missing any allowed scope'
1003 1003
 			);
1004 1004
 			// @codeCoverageIgnoreEnd
Please login to merge, or discard this patch.