@@ -200,73 +200,73 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | } |
@@ -80,7 +80,7 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | } |
@@ -81,26 +81,26 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | } |
@@ -31,53 +31,53 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | ]; |
@@ -10,20 +10,20 @@ |
||
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 | ]; |
@@ -38,216 +38,216 @@ |
||
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 | ]; |
@@ -26,7 +26,7 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | } |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
320 | 320 | $constraintTypeItemId, |
321 | 321 | $required, |
322 | 322 | $parameterId |
323 | - ) ); |
|
323 | + )); |
|
324 | 324 | } |
325 | 325 | |
326 | 326 | /** |
@@ -328,18 +328,18 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
@@ -53,12 +53,12 @@ discard block |
||
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 |
||
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 | 79 | $limit !== null && $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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | ); |