wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Checker/RangeChecker.php

Spacing +38 added lines, -38 removed lines

@@ -84,9 +84,9 @@ 
 	 * @throws ConstraintParameterException
 	 * @return CheckResult
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint ) {
-		if ( $context->getSnakRank() === Statement::RANK_DEPRECATED ) {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_DEPRECATED );
+	public function checkConstraint(Context $context, Constraint $constraint) {
+		if ($context->getSnakRank() === Statement::RANK_DEPRECATED) {
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_DEPRECATED);
 		}
 
 		$parameters = [];
@@ -94,28 +94,28 @@ 
 
 		$snak = $context->getSnak();
 
-		if ( !$snak instanceof PropertyValueSnak ) {
+		if (!$snak instanceof PropertyValueSnak) {
 			// nothing to check
-			return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE );
+			return new CheckResult($context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE);
 		}
 
 		$dataValue = $snak->getDataValue();
 
-		list( $min, $max ) = $this->parseRangeParameter(
+		list($min, $max) = $this->parseRangeParameter(
 			$constraintParameters,
 			$constraint->getConstraintTypeItemId(),
 			$dataValue->getType()
 		);
 		$parameterKey = $dataValue->getType() === 'quantity' ? 'quantity' : 'date';
-		if ( $min !== null ) {
-			$parameters['minimum_' . $parameterKey] = [ $min ];
+		if ($min !== null) {
+			$parameters['minimum_'.$parameterKey] = [$min];
 		}
-		if ( $max !== null ) {
-			$parameters['maximum_' . $parameterKey] = [ $max ];
+		if ($max !== null) {
+			$parameters['maximum_'.$parameterKey] = [$max];
 		}
 
-		if ( $this->rangeCheckerHelper->getComparison( $min, $dataValue ) > 0 ||
-			 $this->rangeCheckerHelper->getComparison( $dataValue, $max ) > 0
+		if ($this->rangeCheckerHelper->getComparison($min, $dataValue) > 0 ||
+			 $this->rangeCheckerHelper->getComparison($dataValue, $max) > 0
 		) {
 			$message = $this->getViolationMessage(
 				$context->getSnak()->getPropertyId(),
@@ -131,16 +131,16 @@ 
 
 		if (
 			$dataValue instanceof TimeValue &&
-			( $min instanceof NowValue || $max instanceof NowValue ) &&
-			$this->rangeCheckerHelper->isFutureTime( $dataValue )
+			($min instanceof NowValue || $max instanceof NowValue) &&
+			$this->rangeCheckerHelper->isFutureTime($dataValue)
 		) {
-			$dependencyMetadata = DependencyMetadata::ofFutureTime( $dataValue );
+			$dependencyMetadata = DependencyMetadata::ofFutureTime($dataValue);
 		} else {
 			$dependencyMetadata = DependencyMetadata::blank();
 		}
 
-		return ( new CheckResult( $context, $constraint, $parameters, $status, $message ) )
-			->withMetadata( Metadata::ofDependencyMetadata( $dependencyMetadata ) );
+		return (new CheckResult($context, $constraint, $parameters, $status, $message))
+			->withMetadata(Metadata::ofDependencyMetadata($dependencyMetadata));
 	}
 
 	/**
@@ -151,8 +151,8 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	private function parseRangeParameter( array $constraintParameters, $constraintTypeItemId, $type ) {
-		switch ( $type ) {
+	private function parseRangeParameter(array $constraintParameters, $constraintTypeItemId, $type) {
+		switch ($type) {
 			case 'quantity':
 				return $this->constraintParameterParser->parseQuantityRangeParameter(
 					$constraintParameters,
@@ -166,10 +166,10 @@ 
 		}
 
 		throw new ConstraintParameterException(
-			( new ViolationMessage( 'wbqc-violation-message-value-needed-of-types-2' ) )
-				->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-				->withDataValueType( 'quantity' )
-				->withDataValueType( 'time' )
+			(new ViolationMessage('wbqc-violation-message-value-needed-of-types-2'))
+				->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+				->withDataValueType('quantity')
+				->withDataValueType('time')
 		);
 	}
 
@@ -181,7 +181,7 @@ 
 	 *
 	 * @return ViolationMessage
 	 */
-	private function getViolationMessage( PropertyId $predicate, DataValue $value, $min, $max ) {
+	private function getViolationMessage(PropertyId $predicate, DataValue $value, $min, $max) {
 		// possible message keys:
 		// wbqc-violation-message-range-quantity-closed
 		// wbqc-violation-message-range-quantity-leftopen
@@ -194,39 +194,39 @@ 
 		// wbqc-violation-message-range-time-rightopen
 		// wbqc-violation-message-range-time-rightopen-leftnow
 		$messageKey = 'wbqc-violation-message-range';
-		$messageKey .= '-' . $value->getType();
+		$messageKey .= '-'.$value->getType();
 		// at least one of $min, $max is set, otherwise there could be no violation
-		$messageKey .= '-' . ( $min !== null ? ( $max !== null ? 'closed' : 'rightopen' ) : 'leftopen' );
-		if ( $min instanceof NowValue ) {
+		$messageKey .= '-'.($min !== null ? ($max !== null ? 'closed' : 'rightopen') : 'leftopen');
+		if ($min instanceof NowValue) {
 			$messageKey .= '-leftnow';
-		} elseif ( $max instanceof NowValue ) {
+		} elseif ($max instanceof NowValue) {
 			$messageKey .= '-rightnow';
 		}
-		$message = ( new ViolationMessage( $messageKey ) )
-			->withEntityId( $predicate, Role::PREDICATE )
-			->withDataValue( $value, Role::OBJECT );
-		if ( $min !== null && !( $min instanceof NowValue ) ) {
-			$message = $message->withDataValue( $min, Role::OBJECT );
+		$message = (new ViolationMessage($messageKey))
+			->withEntityId($predicate, Role::PREDICATE)
+			->withDataValue($value, Role::OBJECT);
+		if ($min !== null && !($min instanceof NowValue)) {
+			$message = $message->withDataValue($min, Role::OBJECT);
 		}
-		if ( $max !== null && !( $max instanceof NowValue ) ) {
-			$message = $message->withDataValue( $max, Role::OBJECT );
+		if ($max !== null && !($max instanceof NowValue)) {
+			$message = $message->withDataValue($max, Role::OBJECT);
 		}
 		return $message;
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ) {
+	public function checkConstraintParameters(Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$exceptions = [];
 		try {
 			// we don’t have a data value here, so get the type from the property instead
 			// (the distinction between data type and data value type is irrelevant for 'quantity' and 'time')
-			$type = $this->propertyDataTypeLookup->getDataTypeIdForProperty( $constraint->getPropertyId() );
+			$type = $this->propertyDataTypeLookup->getDataTypeIdForProperty($constraint->getPropertyId());
 			$this->parseRangeParameter(
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId(),
 				$type
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/ConstraintCheck/ItemIdSnakValue.php

Spacing +12 added lines, -12 removed lines

@@ -44,7 +44,7 @@ 
 	 * @param ItemId $itemId
 	 * @return self
 	 */
-	public static function fromItemId( ItemId $itemId ) {
+	public static function fromItemId(ItemId $itemId) {
 		$ret = new self;
 		$ret->itemId = $itemId;
 		return $ret;
@@ -80,15 +80,15 @@ 
 	 * @throws InvalidArgumentException
 	 * @return self
 	 */
-	public static function fromSnak( Snak $snak ) {
-		switch ( true ) {
+	public static function fromSnak(Snak $snak) {
+		switch (true) {
 			case $snak instanceof PropertyValueSnak:
 				// @phan-suppress-next-line PhanUndeclaredMethod Fixed by https://github.com/phan/phan/issues/3315
 				$dataValue = $snak->getDataValue();
-				if ( $dataValue instanceof EntityIdValue ) {
+				if ($dataValue instanceof EntityIdValue) {
 					$itemId = $dataValue->getEntityId();
-					if ( $itemId instanceof ItemId ) {
-						return self::fromItemId( $itemId );
+					if ($itemId instanceof ItemId) {
+						return self::fromItemId($itemId);
 					}
 				}
 				break;
@@ -98,7 +98,7 @@ 
 				return self::noValue();
 		}
 
-		throw new InvalidArgumentException( 'Snak must contain item ID value or be a somevalue / novalue snak' );
+		throw new InvalidArgumentException('Snak must contain item ID value or be a somevalue / novalue snak');
 	}
 
 	/**
@@ -136,8 +136,8 @@ 
 	 * @return ItemId
 	 */
 	public function getItemId() {
-		if ( !$this->isValue() ) {
-			throw new DomainException( 'This value does not contain an item ID.' );
+		if (!$this->isValue()) {
+			throw new DomainException('This value does not contain an item ID.');
 		}
 		return $this->itemId;
 	}
@@ -149,15 +149,15 @@ 
 	 * @param Snak $snak
 	 * @return bool
 	 */
-	public function matchesSnak( Snak $snak ) {
-		switch ( true ) {
+	public function matchesSnak(Snak $snak) {
+		switch (true) {
 			case $snak instanceof PropertyValueSnak:
 				// @phan-suppress-next-line PhanUndeclaredMethod Fixed by https://github.com/phan/phan/issues/3315
 				$dataValue = $snak->getDataValue();
 				return $this->isValue() &&
 					$dataValue instanceof EntityIdValue &&
 					$dataValue->getEntityId() instanceof ItemId &&
-					$dataValue->getEntityId()->equals( $this->getItemId() );
+					$dataValue->getEntityId()->equals($this->getItemId());
 			case $snak instanceof PropertySomeValueSnak:
 				return $this->isSomeValue();
 			case $snak instanceof PropertyNoValueSnak:

src/ConstraintCheck/Helper/SparqlHelper.php

Spacing +172 added lines, -175 removed lines

@@ -162,58 +162,58 @@ 
 		$this->defaultUserAgent = $defaultUserAgent;
 		$this->requestFactory = $requestFactory;
 		$this->entityPrefixes = [];
-		foreach ( $rdfVocabulary->entityNamespaceNames as $namespaceName ) {
-			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI( $namespaceName );
+		foreach ($rdfVocabulary->entityNamespaceNames as $namespaceName) {
+			$this->entityPrefixes[] = $rdfVocabulary->getNamespaceURI($namespaceName);
 		}
 
-		$this->prefixes = $this->getQueryPrefixes( $rdfVocabulary );
+		$this->prefixes = $this->getQueryPrefixes($rdfVocabulary);
 	}
 
-	private function getQueryPrefixes( RdfVocabulary $rdfVocabulary ) {
+	private function getQueryPrefixes(RdfVocabulary $rdfVocabulary) {
 		// TODO: it would probably be smarter that RdfVocubulary exposed these prefixes somehow
 		$prefixes = '';
-		foreach ( $rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName ) {
+		foreach ($rdfVocabulary->entityNamespaceNames as $sourceName => $namespaceName) {
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 		$prefixes .= <<<END
-PREFIX wds: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_STATEMENT )}>
-PREFIX wdv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_VALUE )}>\n
+PREFIX wds: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_STATEMENT)}>
+PREFIX wdv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_VALUE)}>\n
 END;
 
-		foreach ( $rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces ) {
+		foreach ($rdfVocabulary->propertyNamespaceNames as $sourceName => $sourceNamespaces) {
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_DIRECT_CLAIM];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_CLAIM_STATEMENT];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_QUALIFIER_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 			$namespaceName = $sourceNamespaces[RdfVocabulary::NSP_REFERENCE_VALUE];
 			$prefixes .= <<<END
-PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI( $namespaceName )}>\n
+PREFIX {$namespaceName}: <{$rdfVocabulary->getNamespaceURI($namespaceName)}>\n
 END;
 		}
 		$prefixes .= <<<END
-PREFIX wikibase: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ONTOLOGY )}>\n
+PREFIX wikibase: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ONTOLOGY)}>\n
 END;
 		return $prefixes;
 	}
@@ -225,22 +225,21 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function hasType( $id, array $classes ) {
-		$subclassOfId = $this->config->get( 'WBQualityConstraintsSubclassOfId' );
+	public function hasType($id, array $classes) {
+		$subclassOfId = $this->config->get('WBQualityConstraintsSubclassOfId');
 		// TODO hint:gearing is a workaround for T168973 and can hopefully be removed eventually
-		$gearingHint = $this->config->get( 'WBQualityConstraintsSparqlHasWikibaseSupport' ) ?
-			' hint:Prior hint:gearing "forward".' :
-			'';
+		$gearingHint = $this->config->get('WBQualityConstraintsSparqlHasWikibaseSupport') ?
+			' hint:Prior hint:gearing "forward".' : '';
 
 		$metadatas = [];
 
-		foreach ( array_chunk( $classes, 20 ) as $classesChunk ) {
-			$classesValues = implode( ' ', array_map(
-				function( $class ) {
-					return 'wd:' . $class;
+		foreach (array_chunk($classes, 20) as $classesChunk) {
+			$classesValues = implode(' ', array_map(
+				function($class) {
+					return 'wd:'.$class;
 				},
 				$classesChunk
-			) );
+			));
 
 			$query = <<<EOF
 ASK {
@@ -250,19 +249,19 @@ 
 }
 EOF;
 
-			$result = $this->runQuery( $query );
+			$result = $this->runQuery($query);
 			$metadatas[] = $result->getMetadata();
-			if ( $result->getArray()['boolean'] ) {
+			if ($result->getArray()['boolean']) {
 				return new CachedBool(
 					true,
-					Metadata::merge( $metadatas )
+					Metadata::merge($metadatas)
 				);
 			}
 		}
 
 		return new CachedBool(
 			false,
-			Metadata::merge( $metadatas )
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -278,10 +277,10 @@ 
 		$ignoreDeprecatedStatements
 	) {
 		$pid = $statement->getPropertyId()->serialize();
-		$guid = str_replace( '$', '-', $statement->getGuid() );
+		$guid = str_replace('$', '-', $statement->getGuid());
 
 		$deprecatedFilter = '';
-		if ( $ignoreDeprecatedStatements ) {
+		if ($ignoreDeprecatedStatements) {
 			$deprecatedFilter = 'MINUS { ?otherStatement wikibase:rank wikibase:DeprecatedRank. }';
 		}
 
@@ -300,9 +299,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -327,16 +326,15 @@ 
 		$dataType = $this->propertyDataTypeLookup->getDataTypeIdForProperty(
 			$snak->getPropertyId()
 		);
-		list( $value, $isFullValue ) = $this->getRdfLiteral( $dataType, $dataValue );
-		if ( $isFullValue ) {
+		list($value, $isFullValue) = $this->getRdfLiteral($dataType, $dataValue);
+		if ($isFullValue) {
 			$prefix .= 'v';
 		}
 		$path = $type === Context::TYPE_QUALIFIER ?
-			"$prefix:$pid" :
-			"prov:wasDerivedFrom/$prefix:$pid";
+			"$prefix:$pid" : "prov:wasDerivedFrom/$prefix:$pid";
 
 		$deprecatedFilter = '';
-		if ( $ignoreDeprecatedStatements ) {
+		if ($ignoreDeprecatedStatements) {
 			$deprecatedFilter = <<< EOF
   MINUS { ?otherStatement wikibase:rank wikibase:DeprecatedRank. }
 EOF;
@@ -356,9 +354,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -368,8 +366,8 @@ 
 	 *
 	 * @return string
 	 */
-	private function stringLiteral( $text ) {
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
+	private function stringLiteral($text) {
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
 	}
 
 	/**
@@ -379,18 +377,18 @@ 
 	 *
 	 * @return CachedEntityIds
 	 */
-	private function getOtherEntities( CachedQueryResults $results ) {
-		return new CachedEntityIds( array_map(
-			function ( $resultBindings ) {
+	private function getOtherEntities(CachedQueryResults $results) {
+		return new CachedEntityIds(array_map(
+			function($resultBindings) {
 				$entityIRI = $resultBindings['otherEntity']['value'];
-				foreach ( $this->entityPrefixes as $entityPrefix ) {
-					$entityPrefixLength = strlen( $entityPrefix );
-					if ( substr( $entityIRI, 0, $entityPrefixLength ) === $entityPrefix ) {
+				foreach ($this->entityPrefixes as $entityPrefix) {
+					$entityPrefixLength = strlen($entityPrefix);
+					if (substr($entityIRI, 0, $entityPrefixLength) === $entityPrefix) {
 						try {
 							return $this->entityIdParser->parse(
-								substr( $entityIRI, $entityPrefixLength )
+								substr($entityIRI, $entityPrefixLength)
 							);
-						} catch ( EntityIdParsingException $e ) {
+						} catch (EntityIdParsingException $e) {
 							// fall through
 						}
 					}
@@ -401,7 +399,7 @@ 
 				return null;
 			},
 			$results->getArray()['results']['bindings']
-		), $results->getMetadata() );
+		), $results->getMetadata());
 	}
 
 	// @codingStandardsIgnoreStart cyclomatic complexity of this function is too high
@@ -414,49 +412,49 @@ 
 	 * @return array the literal or IRI as a string in SPARQL syntax,
 	 * and a boolean indicating whether it refers to a full value node or not
 	 */
-	private function getRdfLiteral( $dataType, DataValue $dataValue ) {
-		switch ( $dataType ) {
+	private function getRdfLiteral($dataType, DataValue $dataValue) {
+		switch ($dataType) {
 			case 'string':
 			case 'external-id':
-				return [ $this->stringLiteral( $dataValue->getValue() ), false ];
+				return [$this->stringLiteral($dataValue->getValue()), false];
 			case 'commonsMedia':
-				$url = $this->rdfVocabulary->getMediaFileURI( $dataValue->getValue() );
-				return [ '<' . $url . '>', false ];
+				$url = $this->rdfVocabulary->getMediaFileURI($dataValue->getValue());
+				return ['<'.$url.'>', false];
 			case 'geo-shape':
-				$url = $this->rdfVocabulary->getGeoShapeURI( $dataValue->getValue() );
-				return [ '<' . $url . '>', false ];
+				$url = $this->rdfVocabulary->getGeoShapeURI($dataValue->getValue());
+				return ['<'.$url.'>', false];
 			case 'tabular-data':
-				$url = $this->rdfVocabulary->getTabularDataURI( $dataValue->getValue() );
-				return [ '<' . $url . '>', false ];
+				$url = $this->rdfVocabulary->getTabularDataURI($dataValue->getValue());
+				return ['<'.$url.'>', false];
 			case 'url':
 				$url = $dataValue->getValue();
-				if ( !preg_match( '/^[^<>"{}\\\\|^`\\x00-\\x20]*$/D', $url ) ) {
+				if (!preg_match('/^[^<>"{}\\\\|^`\\x00-\\x20]*$/D', $url)) {
 					// not a valid URL for SPARQL (see SPARQL spec, production 139 IRIREF)
 					// such an URL should never reach us, so just throw
-					throw new InvalidArgumentException( 'invalid URL: ' . $url );
+					throw new InvalidArgumentException('invalid URL: '.$url);
 				}
-				return [ '<' . $url . '>', false ];
+				return ['<'.$url.'>', false];
 			case 'wikibase-item':
 			case 'wikibase-property':
 				/** @var EntityIdValue $dataValue */
 				'@phan-var EntityIdValue $dataValue';
-				return [ 'wd:' . $dataValue->getEntityId()->getSerialization(), false ];
+				return ['wd:'.$dataValue->getEntityId()->getSerialization(), false];
 			case 'monolingualtext':
 				/** @var MonolingualTextValue $dataValue */
 				'@phan-var MonolingualTextValue $dataValue';
 				$lang = $dataValue->getLanguageCode();
-				if ( !preg_match( '/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/D', $lang ) ) {
+				if (!preg_match('/^[a-zA-Z]+(-[a-zA-Z0-9]+)*$/D', $lang)) {
 					// not a valid language tag for SPARQL (see SPARQL spec, production 145 LANGTAG)
 					// such a language tag should never reach us, so just throw
-					throw new InvalidArgumentException( 'invalid language tag: ' . $lang );
+					throw new InvalidArgumentException('invalid language tag: '.$lang);
 				}
-				return [ $this->stringLiteral( $dataValue->getText() ) . '@' . $lang, false ];
+				return [$this->stringLiteral($dataValue->getText()).'@'.$lang, false];
 			case 'globe-coordinate':
 			case 'quantity':
 			case 'time':
-				return [ 'wdv:' . $dataValue->getHash(), true ];
+				return ['wdv:'.$dataValue->getHash(), true];
 			default:
-				throw new InvalidArgumentException( 'unknown data type: ' . $dataType );
+				throw new InvalidArgumentException('unknown data type: '.$dataType);
 		}
 	}
 	// @codingStandardsIgnoreEnd
@@ -469,44 +467,44 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpression( $text, $regex ) {
+	public function matchesRegularExpression($text, $regex) {
 		// caching wrapper around matchesRegularExpressionWithSparql
 
-		$textHash = hash( 'sha256', $text );
+		$textHash = hash('sha256', $text);
 		$cacheKey = $this->cache->makeKey(
 			'WikibaseQualityConstraints', // extension
 			'regex', // action
 			'WDQS-Java', // regex flavor
-			hash( 'sha256', $regex )
+			hash('sha256', $regex)
 		);
-		$cacheMapSize = $this->config->get( 'WBQualityConstraintsFormatCacheMapSize' );
+		$cacheMapSize = $this->config->get('WBQualityConstraintsFormatCacheMapSize');
 
 		$cacheMapArray = $this->cache->getWithSetCallback(
 			$cacheKey,
 			WANObjectCache::TTL_DAY,
-			function( $cacheMapArray ) use ( $text, $regex, $textHash, $cacheMapSize ) {
+			function($cacheMapArray) use ($text, $regex, $textHash, $cacheMapSize) {
 				// Initialize the cache map if not set
-				if ( $cacheMapArray === false ) {
+				if ($cacheMapArray === false) {
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.init';
-					$this->dataFactory->increment( $key );
+					$this->dataFactory->increment($key);
 					return [];
 				}
 
 				$key = 'wikibase.quality.constraints.regex.cache.refresh';
-				$this->dataFactory->increment( $key );
-				$cacheMap = MapCacheLRU::newFromArray( $cacheMapArray, $cacheMapSize );
-				if ( $cacheMap->has( $textHash ) ) {
+				$this->dataFactory->increment($key);
+				$cacheMap = MapCacheLRU::newFromArray($cacheMapArray, $cacheMapSize);
+				if ($cacheMap->has($textHash)) {
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.hit';
-					$this->dataFactory->increment( $key );
-					$cacheMap->get( $textHash ); // ping cache
+					$this->dataFactory->increment($key);
+					$cacheMap->get($textHash); // ping cache
 				} else {
 					$key = 'wikibase.quality.constraints.regex.cache.refresh.miss';
-					$this->dataFactory->increment( $key );
+					$this->dataFactory->increment($key);
 					try {
-						$matches = $this->matchesRegularExpressionWithSparql( $text, $regex );
-					} catch ( ConstraintParameterException $e ) {
-						$matches = $this->serializeConstraintParameterException( $e );
-					} catch ( SparqlHelperException $e ) {
+						$matches = $this->matchesRegularExpressionWithSparql($text, $regex);
+					} catch (ConstraintParameterException $e) {
+						$matches = $this->serializeConstraintParameterException($e);
+					} catch (SparqlHelperException $e) {
 						// don’t cache this
 						return $cacheMap->toArray();
 					}
@@ -530,42 +528,42 @@ 
 			]
 		);
 
-		if ( isset( $cacheMapArray[$textHash] ) ) {
+		if (isset($cacheMapArray[$textHash])) {
 			$key = 'wikibase.quality.constraints.regex.cache.hit';
-			$this->dataFactory->increment( $key );
+			$this->dataFactory->increment($key);
 			$matches = $cacheMapArray[$textHash];
-			if ( is_bool( $matches ) ) {
+			if (is_bool($matches)) {
 				return $matches;
-			} elseif ( is_array( $matches ) &&
-				$matches['type'] == ConstraintParameterException::class ) {
-				throw $this->deserializeConstraintParameterException( $matches );
+			} elseif (is_array($matches) &&
+				$matches['type'] == ConstraintParameterException::class) {
+				throw $this->deserializeConstraintParameterException($matches);
 			} else {
 				throw new MWException(
-					'Value of unknown type in object cache (' .
-					'cache key: ' . $cacheKey . ', ' .
-					'cache map key: ' . $textHash . ', ' .
-					'value type: ' . gettype( $matches ) . ')'
+					'Value of unknown type in object cache ('.
+					'cache key: '.$cacheKey.', '.
+					'cache map key: '.$textHash.', '.
+					'value type: '.gettype($matches).')'
 				);
 			}
 		} else {
 			$key = 'wikibase.quality.constraints.regex.cache.miss';
-			$this->dataFactory->increment( $key );
-			return $this->matchesRegularExpressionWithSparql( $text, $regex );
+			$this->dataFactory->increment($key);
+			return $this->matchesRegularExpressionWithSparql($text, $regex);
 		}
 	}
 
-	private function serializeConstraintParameterException( ConstraintParameterException $cpe ) {
+	private function serializeConstraintParameterException(ConstraintParameterException $cpe) {
 		return [
 			'type' => ConstraintParameterException::class,
-			'violationMessage' => $this->violationMessageSerializer->serialize( $cpe->getViolationMessage() ),
+			'violationMessage' => $this->violationMessageSerializer->serialize($cpe->getViolationMessage()),
 		];
 	}
 
-	private function deserializeConstraintParameterException( array $serialization ) {
+	private function deserializeConstraintParameterException(array $serialization) {
 		$message = $this->violationMessageDeserializer->deserialize(
 			$serialization['violationMessage']
 		);
-		return new ConstraintParameterException( $message );
+		return new ConstraintParameterException($message);
 	}
 
 	/**
@@ -579,25 +577,25 @@ 
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 * @throws ConstraintParameterException if the $regex is invalid
 	 */
-	public function matchesRegularExpressionWithSparql( $text, $regex ) {
-		$textStringLiteral = $this->stringLiteral( $text );
-		$regexStringLiteral = $this->stringLiteral( '^(?:' . $regex . ')$' );
+	public function matchesRegularExpressionWithSparql($text, $regex) {
+		$textStringLiteral = $this->stringLiteral($text);
+		$regexStringLiteral = $this->stringLiteral('^(?:'.$regex.')$');
 
 		$query = <<<EOF
 SELECT (REGEX($textStringLiteral, $regexStringLiteral) AS ?matches) {}
 EOF;
 
-		$result = $this->runQuery( $query, false );
+		$result = $this->runQuery($query, false);
 
 		$vars = $result->getArray()['results']['bindings'][0];
-		if ( array_key_exists( 'matches', $vars ) ) {
+		if (array_key_exists('matches', $vars)) {
 			// true or false ⇒ regex okay, text matches or not
 			return $vars['matches']['value'] === 'true';
 		} else {
 			// empty result: regex broken
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-regex' ) )
-					->withInlineCode( $regex, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-regex'))
+					->withInlineCode($regex, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -609,14 +607,14 @@ 
 	 *
 	 * @return boolean
 	 */
-	public function isTimeout( $responseContent ) {
-		$timeoutRegex = implode( '|', array_map(
-			function ( $fqn ) {
-				return preg_quote( $fqn, '/' );
+	public function isTimeout($responseContent) {
+		$timeoutRegex = implode('|', array_map(
+			function($fqn) {
+				return preg_quote($fqn, '/');
 			},
-			$this->config->get( 'WBQualityConstraintsSparqlTimeoutExceptionClasses' )
-		) );
-		return (bool)preg_match( '/' . $timeoutRegex . '/', $responseContent );
+			$this->config->get('WBQualityConstraintsSparqlTimeoutExceptionClasses')
+		));
+		return (bool) preg_match('/'.$timeoutRegex.'/', $responseContent);
 	}
 
 	/**
@@ -628,17 +626,17 @@ 
 	 * @return int|boolean the max-age (in seconds)
 	 * or a plain boolean if no max-age can be determined
 	 */
-	public function getCacheMaxAge( $responseHeaders ) {
+	public function getCacheMaxAge($responseHeaders) {
 		if (
-			array_key_exists( 'x-cache-status', $responseHeaders ) &&
-			preg_match( '/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0] )
+			array_key_exists('x-cache-status', $responseHeaders) &&
+			preg_match('/^hit(?:-.*)?$/', $responseHeaders['x-cache-status'][0])
 		) {
 			$maxage = [];
 			if (
-				array_key_exists( 'cache-control', $responseHeaders ) &&
-				preg_match( '/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage )
+				array_key_exists('cache-control', $responseHeaders) &&
+				preg_match('/\bmax-age=(\d+)\b/', $responseHeaders['cache-control'][0], $maxage)
 			) {
-				return intval( $maxage[1] );
+				return intval($maxage[1]);
 			} else {
 				return true;
 			}
@@ -659,34 +657,34 @@ 
 	 * or SparlHelper::EMPTY_RETRY_AFTER if there is an empty Retry-After
 	 * or SparlHelper::INVALID_RETRY_AFTER if there is something wrong with the format
 	 */
-	public function getThrottling( MWHttpRequest $request ) {
-		$retryAfterValue = $request->getResponseHeader( 'Retry-After' );
-		if ( $retryAfterValue === null ) {
+	public function getThrottling(MWHttpRequest $request) {
+		$retryAfterValue = $request->getResponseHeader('Retry-After');
+		if ($retryAfterValue === null) {
 			return self::NO_RETRY_AFTER;
 		}
 
-		$trimmedRetryAfterValue = trim( $retryAfterValue );
-		if ( empty( $trimmedRetryAfterValue ) ) {
+		$trimmedRetryAfterValue = trim($retryAfterValue);
+		if (empty($trimmedRetryAfterValue)) {
 			return self::EMPTY_RETRY_AFTER;
 		}
 
-		if ( is_numeric( $trimmedRetryAfterValue ) ) {
-			$delaySeconds = (int)$trimmedRetryAfterValue;
-			if ( $delaySeconds >= 0 ) {
-				return $this->getTimestampInFuture( new DateInterval( 'PT' . $delaySeconds . 'S' ) );
+		if (is_numeric($trimmedRetryAfterValue)) {
+			$delaySeconds = (int) $trimmedRetryAfterValue;
+			if ($delaySeconds >= 0) {
+				return $this->getTimestampInFuture(new DateInterval('PT'.$delaySeconds.'S'));
 			}
 		} else {
-			$return = strtotime( $trimmedRetryAfterValue );
-			if ( !empty( $return ) ) {
-				return new ConvertibleTimestamp( $return );
+			$return = strtotime($trimmedRetryAfterValue);
+			if (!empty($return)) {
+				return new ConvertibleTimestamp($return);
 			}
 		}
 		return self::INVALID_RETRY_AFTER;
 	}
 
-	private function getTimestampInFuture( DateInterval $delta ) {
+	private function getTimestampInFuture(DateInterval $delta) {
 		$now = new ConvertibleTimestamp();
-		return new ConvertibleTimestamp( $now->timestamp->add( $delta ) );
+		return new ConvertibleTimestamp($now->timestamp->add($delta));
 	}
 
 	/**
@@ -700,97 +698,96 @@ 
 	 *
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function runQuery( $query, $needsPrefixes = true ) {
+	public function runQuery($query, $needsPrefixes = true) {
 
-		if ( $this->throttlingLock->isLocked( self::EXPIRY_LOCK_ID ) ) {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
+		if ($this->throttlingLock->isLocked(self::EXPIRY_LOCK_ID)) {
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.throttling');
 			throw new TooManySparqlRequestsException();
 		}
 
-		$endpoint = $this->config->get( 'WBQualityConstraintsSparqlEndpoint' );
-		$maxQueryTimeMillis = $this->config->get( 'WBQualityConstraintsSparqlMaxMillis' );
-		$fallbackBlockDuration = (int)$this->config->get( 'WBQualityConstraintsSparqlThrottlingFallbackDuration' );
+		$endpoint = $this->config->get('WBQualityConstraintsSparqlEndpoint');
+		$maxQueryTimeMillis = $this->config->get('WBQualityConstraintsSparqlMaxMillis');
+		$fallbackBlockDuration = (int) $this->config->get('WBQualityConstraintsSparqlThrottlingFallbackDuration');
 
-		if ( $fallbackBlockDuration < 0 ) {
-			throw new InvalidArgumentException( 'Fallback duration must be positive int but is: ' .
-				$fallbackBlockDuration );
+		if ($fallbackBlockDuration < 0) {
+			throw new InvalidArgumentException('Fallback duration must be positive int but is: '.
+				$fallbackBlockDuration);
 		}
 
-		if ( $this->config->get( 'WBQualityConstraintsSparqlHasWikibaseSupport' ) ) {
+		if ($this->config->get('WBQualityConstraintsSparqlHasWikibaseSupport')) {
 			$needsPrefixes = false;
 		}
 
-		if ( $needsPrefixes ) {
-			$query = $this->prefixes . $query;
+		if ($needsPrefixes) {
+			$query = $this->prefixes.$query;
 		}
-		$query = "#wbqc\n" . $query;
+		$query = "#wbqc\n".$query;
 
-		$url = $endpoint . '?' . http_build_query(
+		$url = $endpoint.'?'.http_build_query(
 			[
 				'query' => $query,
 				'format' => 'json',
 				'maxQueryTimeMillis' => $maxQueryTimeMillis,
 			],
-			null, ini_get( 'arg_separator.output' ),
+			null, ini_get('arg_separator.output'),
 			// encode spaces with %20, not +
 			PHP_QUERY_RFC3986
 		);
 
 		$options = [
 			'method' => 'GET',
-			'timeout' => (int)round( ( $maxQueryTimeMillis + 1000 ) / 1000 ),
+			'timeout' => (int) round(($maxQueryTimeMillis + 1000) / 1000),
 			'connectTimeout' => 'default',
 			'userAgent' => $this->defaultUserAgent,
 		];
-		$request = $this->requestFactory->create( $url, $options );
-		$startTime = microtime( true );
+		$request = $this->requestFactory->create($url, $options);
+		$startTime = microtime(true);
 		$status = $request->execute();
-		$endTime = microtime( true );
+		$endTime = microtime(true);
 		$this->dataFactory->timing(
 			'wikibase.quality.constraints.sparql.timing',
-			( $endTime - $startTime ) * 1000
+			($endTime - $startTime) * 1000
 		);
 
-		if ( $request->getStatus() === self::HTTP_TOO_MANY_REQUESTS ) {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.throttling' );
-			$throttlingUntil = $this->getThrottling( $request );
-			if ( !( $throttlingUntil instanceof ConvertibleTimestamp ) ) {
-				$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid( $request );
+		if ($request->getStatus() === self::HTTP_TOO_MANY_REQUESTS) {
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.throttling');
+			$throttlingUntil = $this->getThrottling($request);
+			if (!($throttlingUntil instanceof ConvertibleTimestamp)) {
+				$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterInvalid($request);
 				$this->throttlingLock->lock(
 					self::EXPIRY_LOCK_ID,
-					$this->getTimestampInFuture( new DateInterval( 'PT' . $fallbackBlockDuration . 'S' ) )
+					$this->getTimestampInFuture(new DateInterval('PT'.$fallbackBlockDuration.'S'))
 				);
 			} else {
-				$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent( $throttlingUntil, $request );
-				$this->throttlingLock->lock( self::EXPIRY_LOCK_ID, $throttlingUntil );
+				$this->loggingHelper->logSparqlHelperTooManyRequestsRetryAfterPresent($throttlingUntil, $request);
+				$this->throttlingLock->lock(self::EXPIRY_LOCK_ID, $throttlingUntil);
 			}
 			throw new TooManySparqlRequestsException();
 		}
 
-		$maxAge = $this->getCacheMaxAge( $request->getResponseHeaders() );
-		if ( $maxAge ) {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.cached' );
+		$maxAge = $this->getCacheMaxAge($request->getResponseHeaders());
+		if ($maxAge) {
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.cached');
 		}
 
-		if ( $status->isOK() ) {
+		if ($status->isOK()) {
 			$json = $request->getContent();
-			$arr = json_decode( $json, true );
+			$arr = json_decode($json, true);
 			return new CachedQueryResults(
 				$arr,
 				Metadata::ofCachingMetadata(
 					$maxAge ?
-						CachingMetadata::ofMaximumAgeInSeconds( $maxAge ) :
-						CachingMetadata::fresh()
+						CachingMetadata::ofMaximumAgeInSeconds($maxAge) : CachingMetadata::fresh()
 				)
 			);
 		} else {
-			$this->dataFactory->increment( 'wikibase.quality.constraints.sparql.error' );
+			$this->dataFactory->increment('wikibase.quality.constraints.sparql.error');
 
 			$this->dataFactory->increment(
 				"wikibase.quality.constraints.sparql.error.http.{$request->getStatus()}"
 			);
 
-			if ( $this->isTimeout( $request->getContent() ) ) {
+			if ($this->isTimeout($request->getContent())) {
 				$this->dataFactory->increment(
 					'wikibase.quality.constraints.sparql.error.timeout'
 				);

src/CachingConstraintLookup.php

Spacing +4 added lines, -4 removed lines

@@ -26,7 +26,7 @@ 
 	/**
 	 * @param ConstraintLookup $lookup The lookup to which all queries are delegated.
 	 */
-	public function __construct( ConstraintLookup $lookup ) {
+	public function __construct(ConstraintLookup $lookup) {
 		$this->lookup = $lookup;
 	}
 
@@ -35,10 +35,10 @@ 
 	 *
 	 * @return Constraint[]
 	 */
-	public function queryConstraintsForProperty( PropertyId $propertyId ) {
+	public function queryConstraintsForProperty(PropertyId $propertyId) {
 		$id = $propertyId->getSerialization();
-		if ( !array_key_exists( $id, $this->cache ) ) {
-			$this->cache[$id] = $this->lookup->queryConstraintsForProperty( $propertyId );
+		if (!array_key_exists($id, $this->cache)) {
+			$this->cache[$id] = $this->lookup->queryConstraintsForProperty($propertyId);
 		}
 		return $this->cache[$id];
 	}