wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Helper/ConstraintParameterParser.php

Spacing +212 added lines, -212 removed lines

@@ -77,15 +77,15 @@ 
 	 * @param array $parameters
 	 * @throws ConstraintParameterException
 	 */
-	public function checkError( array $parameters ) {
-		if ( array_key_exists( '@error', $parameters ) ) {
+	public function checkError(array $parameters) {
+		if (array_key_exists('@error', $parameters)) {
 			$error = $parameters['@error'];
-			if ( array_key_exists( 'toolong', $error ) && $error['toolong'] ) {
+			if (array_key_exists('toolong', $error) && $error['toolong']) {
 				$msg = 'wbqc-violation-message-parameters-error-toolong';
 			} else {
 				$msg = 'wbqc-violation-message-parameters-error-unknown';
 			}
-			throw new ConstraintParameterException( wfMessage( $msg )->escaped() );
+			throw new ConstraintParameterException(wfMessage($msg)->escaped());
 		}
 	}
 
@@ -95,11 +95,11 @@ 
 	 * @param string $parameterId
 	 * @throws ConstraintParameterException
 	 */
-	private function requireSingleParameter( array $parameters, $parameterId ) {
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
+	private function requireSingleParameter(array $parameters, $parameterId) {
+		if (count($parameters[$parameterId]) !== 1) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-single' )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-single')
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
@@ -112,11 +112,11 @@ 
 	 * @return void
 	 * @throws ConstraintParameterException
 	 */
-	private function requireValueParameter( Snak $snak, $parameterId ) {
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
+	private function requireValueParameter(Snak $snak, $parameterId) {
+		if (!($snak instanceof PropertyValueSnak)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-value' )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-value')
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
@@ -129,18 +129,18 @@ 
 	 * @throws ConstraintParameterException
 	 * @return EntityId
 	 */
-	private function parseEntityIdParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseEntityIdParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			return $value->getEntityId();
 		} else {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-entity' )
+				wfMessage('wbqc-violation-message-parameter-entity')
 					->rawParams(
-						$this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-						$this->constraintParameterRenderer->formatDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+						$this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+						$this->constraintParameterRenderer->formatDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 					)
 					->escaped()
 			);
@@ -153,21 +153,21 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] class entity ID serializations
 	 */
-	public function parseClassParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
+	public function parseClassParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$classId = $this->config->get('WBQualityConstraintsClassId');
+		if (!array_key_exists($classId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-needed' )
-					->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $classId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-needed')
+					->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($classId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
 
 		$classes = [];
-		foreach ( $constraintParameters[$classId] as $class ) {
-			$classes[] = $this->parseEntityIdParameter( $class, $classId )->getSerialization();
+		foreach ($constraintParameters[$classId] as $class) {
+			$classes[] = $this->parseEntityIdParameter($class, $classId)->getSerialization();
 		}
 		return $classes;
 	}
@@ -178,24 +178,24 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
 	 */
-	public function parseRelationParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
+	public function parseRelationParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$relationId = $this->config->get('WBQualityConstraintsRelationId');
+		if (!array_key_exists($relationId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-needed' )
-					->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $relationId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-needed')
+					->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($relationId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $relationId );
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
-		$instanceId = $this->config->get( 'WBQualityConstraintsInstanceOfRelationId' );
-		$subclassId = $this->config->get( 'WBQualityConstraintsSubclassOfRelationId' );
-		$instanceOrSubclassId = $this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' );
-		switch ( $relationEntityId ) {
+		$this->requireSingleParameter($constraintParameters, $relationId);
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
+		$instanceId = $this->config->get('WBQualityConstraintsInstanceOfRelationId');
+		$subclassId = $this->config->get('WBQualityConstraintsSubclassOfRelationId');
+		$instanceOrSubclassId = $this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId');
+		switch ($relationEntityId) {
 			case $instanceId:
 				return 'instance';
 			case $subclassId:
@@ -204,13 +204,13 @@ 
 				return 'instanceOrSubclass';
 			default:
 				throw new ConstraintParameterException(
-					wfMessage( 'wbqc-violation-message-parameter-oneof' )
-						->rawParams( $this->constraintParameterRenderer->formatPropertyId( $relationId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
-						->numParams( 3 )
-						->rawParams( $this->constraintParameterRenderer->formatItemIdList(
-							[ $instanceId, $subclassId, $instanceOrSubclassId ],
+					wfMessage('wbqc-violation-message-parameter-oneof')
+						->rawParams($this->constraintParameterRenderer->formatPropertyId($relationId, Role::CONSTRAINT_PARAMETER_PROPERTY))
+						->numParams(3)
+						->rawParams($this->constraintParameterRenderer->formatItemIdList(
+							[$instanceId, $subclassId, $instanceOrSubclassId],
 							Role::CONSTRAINT_PARAMETER_VALUE
-						) )
+						))
 						->escaped()
 				);
 		}
@@ -223,21 +223,21 @@ 
 	 * @throws ConstraintParameterException
 	 * @return PropertyId
 	 */
-	private function parsePropertyIdParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parsePropertyIdParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			$id = $value->getEntityId();
-			if ( $id instanceof PropertyId ) {
+			if ($id instanceof PropertyId) {
 				return $id;
 			}
 		}
 		throw new ConstraintParameterException(
-			wfMessage( 'wbqc-violation-message-parameter-property' )
+			wfMessage('wbqc-violation-message-parameter-property')
 				->rawParams(
-					$this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-					$this->constraintParameterRenderer->formatDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+					$this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+					$this->constraintParameterRenderer->formatDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 				)
 				->escaped()
 		);
@@ -250,34 +250,34 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId
 	 */
-	public function parsePropertyParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertyParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-needed' )
-					->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $propertyId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-needed')
+					->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($propertyId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $propertyId );
-		return $this->parsePropertyIdParameter( $constraintParameters[$propertyId][0], $propertyId );
+		$this->requireSingleParameter($constraintParameters, $propertyId);
+		return $this->parsePropertyIdParameter($constraintParameters[$propertyId][0], $propertyId);
 	}
 
-	private function parseItemIdParameter( PropertyValueSnak $snak, $parameterId ) {
+	private function parseItemIdParameter(PropertyValueSnak $snak, $parameterId) {
 		$dataValue = $snak->getDataValue();
-		if ( $dataValue instanceof EntityIdValue &&
+		if ($dataValue instanceof EntityIdValue &&
 			$dataValue->getEntityId() instanceof ItemId
 		) {
-			return ItemIdSnakValue::fromItemId( $dataValue->getEntityId() );
+			return ItemIdSnakValue::fromItemId($dataValue->getEntityId());
 		} else {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-item' )
+				wfMessage('wbqc-violation-message-parameter-item')
 					->rawParams(
-						$this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-						$this->constraintParameterRenderer->formatDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+						$this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+						$this->constraintParameterRenderer->formatDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 					)
 					->escaped()
 			);
@@ -291,15 +291,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return ItemIdSnakValue[] array of values
 	 */
-	public function parseItemsParameter( array $constraintParameters, $constraintTypeItemId, $required ) {
-		$this->checkError( $constraintParameters );
-		$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
-		if ( !array_key_exists( $qualifierId, $constraintParameters ) ) {
-			if ( $required ) {
+	public function parseItemsParameter(array $constraintParameters, $constraintTypeItemId, $required) {
+		$this->checkError($constraintParameters);
+		$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
+		if (!array_key_exists($qualifierId, $constraintParameters)) {
+			if ($required) {
 				throw new ConstraintParameterException(
-					wfMessage( 'wbqc-violation-message-parameter-needed' )
-						->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
-						->rawParams( $this->constraintParameterRenderer->formatPropertyId( $qualifierId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+					wfMessage('wbqc-violation-message-parameter-needed')
+						->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
+						->rawParams($this->constraintParameterRenderer->formatPropertyId($qualifierId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 						->escaped()
 				);
 			} else {
@@ -308,11 +308,11 @@ 
 		}
 
 		$values = [];
-		foreach ( $constraintParameters[$qualifierId] as $parameter ) {
-			$snak = $this->snakDeserializer->deserialize( $parameter );
-			switch ( true ) {
+		foreach ($constraintParameters[$qualifierId] as $parameter) {
+			$snak = $this->snakDeserializer->deserialize($parameter);
+			switch (true) {
 				case $snak instanceof PropertyValueSnak:
-					$values[] = $this->parseItemIdParameter( $snak, $qualifierId );
+					$values[] = $this->parseItemIdParameter($snak, $qualifierId);
 					break;
 				case $snak instanceof PropertySomeValueSnak:
 					$values[] = ItemIdSnakValue::someValue();
@@ -331,28 +331,28 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId[]
 	 */
-	public function parsePropertiesParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertiesParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-needed' )
-					->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $propertyId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-needed')
+					->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($propertyId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
 
 		$parameters = $constraintParameters[$propertyId];
-		if ( count( $parameters ) === 1 &&
-			$this->snakDeserializer->deserialize( $parameters[0] ) instanceof PropertyNoValueSnak
+		if (count($parameters) === 1 &&
+			$this->snakDeserializer->deserialize($parameters[0]) instanceof PropertyNoValueSnak
 		) {
 			return [];
 		}
 
 		$properties = [];
-		foreach ( $parameters as $parameter ) {
-			$properties[] = $this->parsePropertyIdParameter( $parameter, $propertyId );
+		foreach ($parameters as $parameter) {
+			$properties[] = $this->parsePropertyIdParameter($parameter, $propertyId);
 		}
 		return $properties;
 	}
@@ -363,16 +363,16 @@ 
 	 * @throws ConstraintParameterException
 	 * @return DataValue|null
 	 */
-	private function parseValueOrNoValueParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		if ( $snak instanceof PropertyValueSnak ) {
+	private function parseValueOrNoValueParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		if ($snak instanceof PropertyValueSnak) {
 			return $snak->getDataValue();
-		} elseif ( $snak instanceof PropertyNoValueSnak ) {
+		} elseif ($snak instanceof PropertyNoValueSnak) {
 			return null;
 		} else {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-value-or-novalue' )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-value-or-novalue')
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
@@ -383,10 +383,10 @@ 
 	 * @param string $parameterId
 	 * @return DataValue|null
 	 */
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, $parameterId ) {
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, $parameterId) {
 		try {
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
-		} catch ( ConstraintParameterException $e ) {
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
+		} catch (ConstraintParameterException $e) {
 			// unknown value means “now”
 			return new NowValue();
 		}
@@ -399,14 +399,14 @@ 
 	 * @param string $unit
 	 * @return bool
 	 */
-	private function exactlyOneQuantityWithUnit( DataValue $min = null, DataValue $max = null, $unit ) {
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
-			!( $max instanceof UnboundedQuantityValue )
+	private function exactlyOneQuantityWithUnit(DataValue $min = null, DataValue $max = null, $unit) {
+		if (!($min instanceof UnboundedQuantityValue) ||
+			!($max instanceof UnboundedQuantityValue)
 		) {
 			return false;
 		}
 
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
 	}
 
 	/**
@@ -417,9 +417,9 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseRangeParameter( array $constraintParameters, $constraintTypeItemId, $type ) {
-		$this->checkError( $constraintParameters );
-		switch ( $type ) {
+	public function parseRangeParameter(array $constraintParameters, $constraintTypeItemId, $type) {
+		$this->checkError($constraintParameters);
+		switch ($type) {
 			case 'quantity':
 				$configKey = 'Quantity';
 				break;
@@ -428,58 +428,58 @@ 
 				break;
 			default:
 				throw new ConstraintParameterException(
-					wfMessage( 'wbqc-violation-message-value-needed-of-types-2' )
+					wfMessage('wbqc-violation-message-value-needed-of-types-2')
 						->rawParams(
-							$this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ),
-							wfMessage( 'datatypes-type-quantity' )->escaped(),
-							wfMessage( 'datatypes-type-time' )->escaped()
+							$this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM),
+							wfMessage('datatypes-type-quantity')->escaped(),
+							wfMessage('datatypes-type-time')->escaped()
 						)
 						->escaped()
 				);
 		}
-		$minimumId = $this->config->get( 'WBQualityConstraintsMinimum' . $configKey . 'Id' );
-		$maximumId = $this->config->get( 'WBQualityConstraintsMaximum' . $configKey . 'Id' );
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
-			!array_key_exists( $maximumId, $constraintParameters )
+		$minimumId = $this->config->get('WBQualityConstraintsMinimum'.$configKey.'Id');
+		$maximumId = $this->config->get('WBQualityConstraintsMaximum'.$configKey.'Id');
+		if (!array_key_exists($minimumId, $constraintParameters) ||
+			!array_key_exists($maximumId, $constraintParameters)
 		) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-range-parameters-needed' )
+				wfMessage('wbqc-violation-message-range-parameters-needed')
 					->rawParams(
-						wfMessage( 'datatypes-type-' . $type )->escaped(),
-						$this->constraintParameterRenderer->formatPropertyId( $minimumId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-						$this->constraintParameterRenderer->formatPropertyId( $maximumId, Role::CONSTRAINT_PARAMETER_PROPERTY )
+						wfMessage('datatypes-type-'.$type)->escaped(),
+						$this->constraintParameterRenderer->formatPropertyId($minimumId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+						$this->constraintParameterRenderer->formatPropertyId($maximumId, Role::CONSTRAINT_PARAMETER_PROPERTY)
 					)
-					->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
+					->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
 					->escaped()
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $minimumId );
-		$this->requireSingleParameter( $constraintParameters, $maximumId );
+		$this->requireSingleParameter($constraintParameters, $minimumId);
+		$this->requireSingleParameter($constraintParameters, $maximumId);
 		$parseFunction = $configKey === 'Date' ? 'parseValueOrNoValueOrNowParameter' : 'parseValueOrNoValueParameter';
-		$min = $this->$parseFunction( $constraintParameters[$minimumId][0], $minimumId );
-		$max = $this->$parseFunction( $constraintParameters[$maximumId][0], $maximumId );
+		$min = $this->$parseFunction($constraintParameters[$minimumId][0], $minimumId);
+		$max = $this->$parseFunction($constraintParameters[$maximumId][0], $maximumId);
 
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
-		if ( $this->exactlyOneQuantityWithUnit( $min, $max, $yearUnit ) ) {
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
+		if ($this->exactlyOneQuantityWithUnit($min, $max, $yearUnit)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-range-parameters-one-year' )
+				wfMessage('wbqc-violation-message-range-parameters-one-year')
 					->escaped()
 			);
 		}
-		if ( $min === null && $max === null ||
-			$min !== null && $max !== null && $min->equals( $max ) ) {
+		if ($min === null && $max === null ||
+			$min !== null && $max !== null && $min->equals($max)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-range-parameters-same' )
+				wfMessage('wbqc-violation-message-range-parameters-same')
 					->rawParams(
-						$this->constraintParameterRenderer->formatPropertyId( $minimumId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-						$this->constraintParameterRenderer->formatPropertyId( $maximumId, Role::CONSTRAINT_PARAMETER_PROPERTY )
+						$this->constraintParameterRenderer->formatPropertyId($minimumId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+						$this->constraintParameterRenderer->formatPropertyId($maximumId, Role::CONSTRAINT_PARAMETER_PROPERTY)
 					)
 					->escaped()
 			);
 		}
 
-		return [ $min, $max ];
+		return [$min, $max];
 	}
 
 	/**
@@ -489,18 +489,18 @@ 
 	 * @throws ConstraintParameterException
 	 * @return string
 	 */
-	private function parseStringParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseStringParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof StringValue ) {
+		if ($value instanceof StringValue) {
 			return $value->getValue();
 		} else {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-string' )
+				wfMessage('wbqc-violation-message-parameter-string')
 					->rawParams(
-						$this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-						$this->constraintParameterRenderer->formatDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+						$this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+						$this->constraintParameterRenderer->formatDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 					)
 					->escaped()
 			);
@@ -513,15 +513,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseNamespaceParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
+	public function parseNamespaceParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
 			return '';
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
 	}
 
 	/**
@@ -530,20 +530,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseFormatParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
+	public function parseFormatParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
+		if (!array_key_exists($formatId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-needed' )
-					->rawParams( $this->constraintParameterRenderer->formatItemId( $constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM ) )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $formatId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
+				wfMessage('wbqc-violation-message-parameter-needed')
+					->rawParams($this->constraintParameterRenderer->formatItemId($constraintTypeItemId, Role::CONSTRAINT_TYPE_ITEM))
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($formatId, Role::CONSTRAINT_PARAMETER_PROPERTY))
 					->escaped()
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $formatId );
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
+		$this->requireSingleParameter($constraintParameters, $formatId);
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
 	}
 
 	/**
@@ -551,16 +551,16 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return EntityId[]
 	 */
-	public function parseExceptionParameter( array $constraintParameters ) {
-		$this->checkError( $constraintParameters );
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
+	public function parseExceptionParameter(array $constraintParameters) {
+		$this->checkError($constraintParameters);
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
 			return [];
 		}
 
 		return array_map(
-			function( $snakSerialization ) use ( $exceptionId ) {
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
+			function($snakSerialization) use ($exceptionId) {
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
 			},
 			$constraintParameters[$exceptionId]
 		);
@@ -571,27 +571,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string|null 'mandatory' or null
 	 */
-	public function parseConstraintStatusParameter( array $constraintParameters ) {
-		$this->checkError( $constraintParameters );
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
+	public function parseConstraintStatusParameter(array $constraintParameters) {
+		$this->checkError($constraintParameters);
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
 			return null;
 		}
 
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
-		$this->requireValueParameter( $snak, $constraintStatusId );
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
+		$this->requireValueParameter($snak, $constraintStatusId);
 		$statusId = $snak->getDataValue()->getEntityId()->getSerialization();
 
-		if ( $statusId === $mandatoryId ) {
+		if ($statusId === $mandatoryId) {
 			return 'mandatory';
 		} else {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-oneof' )
-					->rawParams( $this->constraintParameterRenderer->formatPropertyId( $constraintStatusId, Role::CONSTRAINT_PARAMETER_PROPERTY ) )
-					->numParams( 1 )
-					->rawParams( $this->constraintParameterRenderer->formatItemIdList( [ $mandatoryId ], Role::CONSTRAINT_PARAMETER_VALUE ) )
+				wfMessage('wbqc-violation-message-parameter-oneof')
+					->rawParams($this->constraintParameterRenderer->formatPropertyId($constraintStatusId, Role::CONSTRAINT_PARAMETER_PROPERTY))
+					->numParams(1)
+					->rawParams($this->constraintParameterRenderer->formatItemIdList([$mandatoryId], Role::CONSTRAINT_PARAMETER_VALUE))
 					->escaped()
 			);
 		}
@@ -604,13 +604,13 @@ 
 	 * @return void
 	 * @throws ConstraintParameterException
 	 */
-	private function requireMonolingualTextParameter( DataValue $dataValue, $parameterId ) {
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
+	private function requireMonolingualTextParameter(DataValue $dataValue, $parameterId) {
+		if (!($dataValue instanceof MonolingualTextValue)) {
 			throw new ConstraintParameterException(
-				wfMessage( 'wbqc-violation-message-parameter-monolingualtext' )
+				wfMessage('wbqc-violation-message-parameter-monolingualtext')
 					->rawParams(
-						$this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY ),
-						$this->constraintParameterRenderer->formatDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+						$this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY),
+						$this->constraintParameterRenderer->formatDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 					)
 					->escaped()
 			);
@@ -625,26 +625,26 @@ 
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
 	 * @return MultilingualTextValue
 	 */
-	private function parseMultilingualTextParameter( array $snakSerializations, $parameterId ) {
+	private function parseMultilingualTextParameter(array $snakSerializations, $parameterId) {
 		$result = [];
 
-		foreach ( $snakSerializations as $snakSerialization ) {
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-			$this->requireValueParameter( $snak, $parameterId );
+		foreach ($snakSerializations as $snakSerialization) {
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
+			$this->requireValueParameter($snak, $parameterId);
 
 			$value = $snak->getDataValue();
-			$this->requireMonolingualTextParameter( $value, $parameterId );
+			$this->requireMonolingualTextParameter($value, $parameterId);
 			/** @var MonolingualTextValue $value */
 
 			$code = $value->getLanguageCode();
-			if ( array_key_exists( $code, $result ) ) {
+			if (array_key_exists($code, $result)) {
 				throw new ConstraintParameterException(
-					wfMessage( 'wbqc-violation-message-parameter-single-per-language' )
+					wfMessage('wbqc-violation-message-parameter-single-per-language')
 						->rawParams(
-							$this->constraintParameterRenderer->formatPropertyId( $parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY )
+							$this->constraintParameterRenderer->formatPropertyId($parameterId, Role::CONSTRAINT_PARAMETER_PROPERTY)
 						)
 						->plaintextParams(
-							Language::fetchLanguageName( $code ),
+							Language::fetchLanguageName($code),
 							$code
 						)
 						->escaped()
@@ -654,7 +654,7 @@ 
 			$result[$code] = $value;
 		}
 
-		return new MultilingualTextValue( $result );
+		return new MultilingualTextValue($result);
 	}
 
 	/**
@@ -662,11 +662,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseSyntaxClarificationParameter( array $constraintParameters ) {
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
+	public function parseSyntaxClarificationParameter(array $constraintParameters) {
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
 
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
-			return new MultilingualTextValue( [] );
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
+			return new MultilingualTextValue([]);
 		}
 
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -685,20 +685,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string[]|null Context::TYPE_* constants
 	 */
-	public function parseConstraintScopeParameter( array $constraintParameters, $constraintTypeItemId, array $validScopes = null ) {
-		$constraintScopeId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
-		$mainSnakId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' );
-		$qualifiersId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' );
-		$referencesId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' );
+	public function parseConstraintScopeParameter(array $constraintParameters, $constraintTypeItemId, array $validScopes = null) {
+		$constraintScopeId = $this->config->get('WBQualityConstraintsConstraintScopeId');
+		$mainSnakId = $this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId');
+		$qualifiersId = $this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId');
+		$referencesId = $this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId');
 
-		if ( !array_key_exists( $constraintScopeId, $constraintParameters ) ) {
+		if (!array_key_exists($constraintScopeId, $constraintParameters)) {
 			return null;
 		}
 
 		$contextTypes = [];
-		foreach ( $constraintParameters[$constraintScopeId] as $snakSerialization ) {
-			$scopeEntityId = $this->parseEntityIdParameter( $snakSerialization, $constraintScopeId );
-			switch ( $scopeEntityId->getSerialization() ) {
+		foreach ($constraintParameters[$constraintScopeId] as $snakSerialization) {
+			$scopeEntityId = $this->parseEntityIdParameter($snakSerialization, $constraintScopeId);
+			switch ($scopeEntityId->getSerialization()) {
 				case $mainSnakId:
 					$contextTypes[] = Context::TYPE_STATEMENT;
 					break;
@@ -710,14 +710,14 @@ 
 					break;
 				default:
 					throw new ConstraintParameterException(
-						wfMessage( 'wbqc-violation-message-parameter-oneof' )
+						wfMessage('wbqc-violation-message-parameter-oneof')
 							->rawParams(
 								$this->constraintParameterRenderer->formatPropertyId(
 									$constraintScopeId,
 									Role::CONSTRAINT_PARAMETER_PROPERTY
 								)
 							)
-							->numParams( 3 )
+							->numParams(3)
 							->rawParams(
 								$this->constraintParameterRenderer->formatItemIdList(
 									[
@@ -733,12 +733,12 @@ 
 			}
 		}
 
-		if ( $validScopes !== null ) {
-			$invalidScopes = array_diff( $contextTypes, $validScopes );
-			if ( $invalidScopes !== [] ) {
-				$invalidScope = array_pop( $invalidScopes );
+		if ($validScopes !== null) {
+			$invalidScopes = array_diff($contextTypes, $validScopes);
+			if ($invalidScopes !== []) {
+				$invalidScope = array_pop($invalidScopes);
 				throw new ConstraintParameterException(
-					wfMessage( 'wbqc-violation-message-invalid-scope' )
+					wfMessage('wbqc-violation-message-invalid-scope')
 						->rawParams(
 							$this->constraintParameterRenderer->formatConstraintScope(
 								$invalidScope,
@@ -749,7 +749,7 @@ 
 								Role::CONSTRAINT_TYPE_ITEM
 							)
 						)
-						->numParams( count( $validScopes ) )
+						->numParams(count($validScopes))
 						->rawParams(
 							$this->constraintParameterRenderer->formatConstraintScopeList(
 								$validScopes,

src/ConstraintCheck/Result/CheckResult.php

Spacing +5 added lines, -5 removed lines

@@ -149,11 +149,11 @@ 
 	public function getDataValue() {
 		$mainSnak = $this->context->getSnak();
 
-		if ( $mainSnak instanceof PropertyValueSnak ) {
+		if ($mainSnak instanceof PropertyValueSnak) {
 			return $mainSnak->getDataValue();
 		}
 
-		throw new LogicException( 'Cannot get DataValue, Snak is of type ' . $this->getSnakType() . '.' );
+		throw new LogicException('Cannot get DataValue, Snak is of type '.$this->getSnakType().'.');
 	}
 
 	/**
@@ -181,7 +181,7 @@ 
 	 * @param string $key
 	 * @param string $value
 	 */
-	public function addParameter( $key, $value ) {
+	public function addParameter($key, $value) {
 		$this->parameters[$key][] = $value;
 	}
 
@@ -195,7 +195,7 @@ 
 	/**
 	 * @param string $status
 	 */
-	public function setStatus( $status ) {
+	public function setStatus($status) {
 		$this->status = $status;
 	}
 
@@ -210,7 +210,7 @@ 
 	 * @param Metadata $metadata
 	 * @return self
 	 */
-	public function withMetadata( Metadata $metadata ) {
+	public function withMetadata(Metadata $metadata) {
 		$this->metadata = $metadata;
 		return $this;
 	}

src/ConstraintCheck/Helper/ConstraintParameterException.php

Spacing +2 added lines, -2 removed lines

@@ -16,8 +16,8 @@
 	/**
 	 * @param string $message HTML
 	 */
-	public function __construct( $message ) {
-		parent::__construct( $message );
+	public function __construct($message) {
+		parent::__construct($message);
 	}
 
 	/**

src/ConstraintCheck/Helper/TimeValueComparer.php

Spacing +9 added lines, -9 removed lines

@@ -16,27 +16,27 @@
 	 */
 	private $timeValueCalculator;
 
-	public function __construct( TimeValueCalculator $timeValueCalculator = null ) {
+	public function __construct(TimeValueCalculator $timeValueCalculator = null) {
 		$this->timeValueCalculator = $timeValueCalculator ?: new TimeValueCalculator();
 	}
 
-	public function getComparison( TimeValue $lhs, TimeValue $rhs ) {
-		$lhsTimestamp = $this->timeValueCalculator->getTimestamp( $lhs );
-		$rhsTimestamp = $this->timeValueCalculator->getTimestamp( $rhs );
+	public function getComparison(TimeValue $lhs, TimeValue $rhs) {
+		$lhsTimestamp = $this->timeValueCalculator->getTimestamp($lhs);
+		$rhsTimestamp = $this->timeValueCalculator->getTimestamp($rhs);
 
-		if ( $lhsTimestamp === $rhsTimestamp ) {
+		if ($lhsTimestamp === $rhsTimestamp) {
 			return 0;
 		}
 
 		return $lhsTimestamp < $rhsTimestamp ? -1 : 1;
 	}
 
-	public function getMinimum( TimeValue $timeValue1, TimeValue $timeValue2 ) {
-		return $this->getComparison( $timeValue1, $timeValue2 ) <= 0 ? $timeValue1 : $timeValue2;
+	public function getMinimum(TimeValue $timeValue1, TimeValue $timeValue2) {
+		return $this->getComparison($timeValue1, $timeValue2) <= 0 ? $timeValue1 : $timeValue2;
 	}
 
-	public function isFutureTime( TimeValue $timeValue ) {
-		return $this->getComparison( $timeValue, new NowValue() ) >= 0;
+	public function isFutureTime(TimeValue $timeValue) {
+		return $this->getComparison($timeValue, new NowValue()) >= 0;
 	}
 
 }

src/ConstraintCheck/Helper/NowValue.php

Spacing +4 added lines, -4 removed lines

@@ -28,7 +28,7 @@ 
 	 * @return string
 	 */
 	public function getTime() {
-		return gmdate( '+Y-m-d\TH:i:s\Z' );
+		return gmdate('+Y-m-d\TH:i:s\Z');
 	}
 
 	public function getTimezone() {
@@ -40,11 +40,11 @@ 
 	}
 
 	public function getArrayValue() {
-		throw new LogicException( 'NowValue should never be serialized' );
+		throw new LogicException('NowValue should never be serialized');
 	}
 
-	public function equals( $value ) {
-		return get_class( $value ) === self::class;
+	public function equals($value) {
+		return get_class($value) === self::class;
 	}
 
 }

src/ConstraintCheck/Helper/SparqlHelper.php

Spacing +137 added lines, -139 removed lines

@@ -108,18 +108,18 @@ 
 		$this->violationMessageDeserializer = $violationMessageDeserializer;
 		$this->dataFactory = $dataFactory;
 
-		$this->entityPrefix = $rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ENTITY );
+		$this->entityPrefix = $rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ENTITY);
 		$this->prefixes = <<<EOT
-PREFIX wd: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_ENTITY )}>
-PREFIX wds: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_STATEMENT )}>
-PREFIX wdt: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_DIRECT_CLAIM )}>
-PREFIX wdv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NS_VALUE )}>
-PREFIX p: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_CLAIM )}>
-PREFIX ps: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_CLAIM_STATEMENT )}>
-PREFIX pq: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_QUALIFIER )}>
-PREFIX pqv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_QUALIFIER_VALUE )}>
-PREFIX pr: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_REFERENCE )}>
-PREFIX prv: <{$rdfVocabulary->getNamespaceURI( RdfVocabulary::NSP_REFERENCE_VALUE )}>
+PREFIX wd: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_ENTITY)}>
+PREFIX wds: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_STATEMENT)}>
+PREFIX wdt: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_DIRECT_CLAIM)}>
+PREFIX wdv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NS_VALUE)}>
+PREFIX p: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_CLAIM)}>
+PREFIX ps: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_CLAIM_STATEMENT)}>
+PREFIX pq: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_QUALIFIER)}>
+PREFIX pqv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_QUALIFIER_VALUE)}>
+PREFIX pr: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_REFERENCE)}>
+PREFIX prv: <{$rdfVocabulary->getNamespaceURI(RdfVocabulary::NSP_REFERENCE_VALUE)}>
 PREFIX wikibase: <http://wikiba.se/ontology#>
 PREFIX wikibase-beta: <http://wikiba.se/ontology-beta#>
 EOT;
@@ -134,21 +134,21 @@ 
 	 * @return CachedBool
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function hasType( $id, array $classes, $withInstance ) {
-		$instanceOfId = $this->config->get( 'WBQualityConstraintsInstanceOfId' );
-		$subclassOfId = $this->config->get( 'WBQualityConstraintsSubclassOfId' );
+	public function hasType($id, array $classes, $withInstance) {
+		$instanceOfId = $this->config->get('WBQualityConstraintsInstanceOfId');
+		$subclassOfId = $this->config->get('WBQualityConstraintsSubclassOfId');
 
-		$path = ( $withInstance ? "wdt:$instanceOfId/" : "" ) . "wdt:$subclassOfId*";
+		$path = ($withInstance ? "wdt:$instanceOfId/" : "")."wdt:$subclassOfId*";
 
 		$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 {
@@ -159,19 +159,19 @@ 
 EOF;
 			// TODO hint:gearing is a workaround for T168973 and can hopefully be removed eventually
 
-			$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)
 		);
 	}
 
@@ -187,10 +187,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. }';
 			$deprecatedFilter .= 'MINUS { ?otherStatement wikibase-beta:rank wikibase-beta:DeprecatedRank. }';
 		}
@@ -210,9 +210,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -237,16 +237,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. }
   MINUS { ?otherStatement wikibase-beta:rank wikibase-beta:DeprecatedRank. }
@@ -267,9 +266,9 @@ 
 LIMIT 10
 EOF;
 
-		$result = $this->runQuery( $query );
+		$result = $this->runQuery($query);
 
-		return $this->getOtherEntities( $result );
+		return $this->getOtherEntities($result);
 	}
 
 	/**
@@ -279,8 +278,8 @@ 
 	 *
 	 * @return string
 	 */
-	private function stringLiteral( $text ) {
-		return '"' . strtr( $text, [ '"' => '\\"', '\\' => '\\\\' ] ) . '"';
+	private function stringLiteral($text) {
+		return '"'.strtr($text, ['"' => '\\"', '\\' => '\\\\']).'"';
 	}
 
 	/**
@@ -290,17 +289,17 @@ 
 	 *
 	 * @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'];
-				$entityPrefixLength = strlen( $this->entityPrefix );
-				if ( substr( $entityIRI, 0, $entityPrefixLength ) === $this->entityPrefix ) {
+				$entityPrefixLength = strlen($this->entityPrefix);
+				if (substr($entityIRI, 0, $entityPrefixLength) === $this->entityPrefix) {
 					try {
 						return $this->entityIdParser->parse(
-							substr( $entityIRI, $entityPrefixLength )
+							substr($entityIRI, $entityPrefixLength)
 						);
-					} catch ( EntityIdParsingException $e ) {
+					} catch (EntityIdParsingException $e) {
 						// fall through
 					}
 				}
@@ -308,7 +307,7 @@ 
 				return null;
 			},
 			$results->getArray()['results']['bindings']
-		), $results->getMetadata() );
+		), $results->getMetadata());
 	}
 
 	// @codingStandardsIgnoreStart cyclomatic complexity of this function is too high
@@ -321,47 +320,47 @@ 
 	 * @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 */
-				return [ 'wd:' . $dataValue->getEntityId()->getSerialization(), false ];
+				return ['wd:'.$dataValue->getEntityId()->getSerialization(), false];
 			case 'monolingualtext':
 				/** @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
@@ -374,44 +373,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();
 					}
@@ -435,36 +434,36 @@ 
 			]
 		);
 
-		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) {
 		$message = $cpe->getViolationMessage();
-		if ( $message instanceof ViolationMessage ) {
+		if ($message instanceof ViolationMessage) {
 			return [
 				'type' => ConstraintParameterException::class,
-				'violationMessage' => $this->violationMessageSerializer->serialize( $message ),
+				'violationMessage' => $this->violationMessageSerializer->serialize($message),
 			];
 		} else {
 			return [
@@ -474,15 +473,15 @@ 
 		}
 	}
 
-	private function deserializeConstraintParameterException( array $serialization ) {
-		if ( array_key_exists( 'violationMessage', $serialization ) ) {
+	private function deserializeConstraintParameterException(array $serialization) {
+		if (array_key_exists('violationMessage', $serialization)) {
 			$message = $this->violationMessageDeserializer->deserialize(
 				$serialization['violationMessage']
 			);
 		} else {
 			$message = $serialization['message'];
 		}
-		return new ConstraintParameterException( $message );
+		return new ConstraintParameterException($message);
 	}
 
 	/**
@@ -496,26 +495,26 @@ 
 	 * @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 );
+		$result = $this->runQuery($query);
 
 		$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(
-				wfMessage( 'wbqc-violation-message-parameter-regex' )
-					->rawParams( ConstraintParameterRenderer::formatByRole( Role::CONSTRAINT_PARAMETER_VALUE,
-						'<code><nowiki>' . htmlspecialchars( $regex ) . '</nowiki></code>' ) )
+				wfMessage('wbqc-violation-message-parameter-regex')
+					->rawParams(ConstraintParameterRenderer::formatByRole(Role::CONSTRAINT_PARAMETER_VALUE,
+						'<code><nowiki>'.htmlspecialchars($regex).'</nowiki></code>'))
 					->escaped()
 			);
 		}
@@ -528,14 +527,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);
 	}
 
 	/**
@@ -547,17 +546,17 @@ 
 	 * @return integer|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;
 			}
@@ -575,59 +574,58 @@ 
 	 *
 	 * @throws SparqlHelperException if the query times out or some other error occurs
 	 */
-	public function runQuery( $query ) {
+	public function runQuery($query) {
 
-		$endpoint = $this->config->get( 'WBQualityConstraintsSparqlEndpoint' );
-		$maxQueryTimeMillis = $this->config->get( 'WBQualityConstraintsSparqlMaxMillis' );
-		$url = $endpoint . '?' . http_build_query(
+		$endpoint = $this->config->get('WBQualityConstraintsSparqlEndpoint');
+		$maxQueryTimeMillis = $this->config->get('WBQualityConstraintsSparqlMaxMillis');
+		$url = $endpoint.'?'.http_build_query(
 			[
-				'query' => "#wbqc\n" . $this->prefixes . $query,
+				'query' => "#wbqc\n".$this->prefixes.$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',
 		];
-		$request = MWHttpRequest::factory( $url, $options );
-		$startTime = microtime( true );
+		$request = MWHttpRequest::factory($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
 		);
 
-		$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/ConstraintCheck/Cache/DependencyMetadata.php

Spacing +11 added lines, -11 removed lines

@@ -37,7 +37,7 @@ 
 	 * @param EntityId $entityId An entity ID from which the value was derived.
 	 * @return self Indication that a value was derived from the entity with the given ID.
 	 */
-	public static function ofEntityId( EntityId $entityId ) {
+	public static function ofEntityId(EntityId $entityId) {
 		$ret = new self;
 		$ret->entityIds[] = $entityId;
 		return $ret;
@@ -49,7 +49,7 @@ 
 	 * @return self Indication that a value will only remain valid
 	 * as long as the given time value is in the future, not in the past.
 	 */
-	public static function ofFutureTime( TimeValue $timeValue ) {
+	public static function ofFutureTime(TimeValue $timeValue) {
 		$ret = new self;
 		$ret->timeValue = $timeValue;
 		return $ret;
@@ -59,12 +59,12 @@ 
 	 * @param self[] $metadatas
 	 * @return self
 	 */
-	public static function merge( array $metadatas ) {
-		Assert::parameterElementType( self::class, $metadatas, '$metadatas' );
+	public static function merge(array $metadatas) {
+		Assert::parameterElementType(self::class, $metadatas, '$metadatas');
 		$ret = new self;
-		foreach ( $metadatas as $metadata ) {
-			$ret->entityIds = array_merge( $ret->entityIds, $metadata->entityIds );
-			$ret->timeValue = self::minTimeValue( $ret->timeValue, $metadata->timeValue );
+		foreach ($metadatas as $metadata) {
+			$ret->entityIds = array_merge($ret->entityIds, $metadata->entityIds);
+			$ret->timeValue = self::minTimeValue($ret->timeValue, $metadata->timeValue);
 		}
 		return $ret;
 	}
@@ -74,14 +74,14 @@ 
 	 * @param TimeValue|null $t2
 	 * @return TimeValue|null
 	 */
-	private static function minTimeValue( TimeValue $t1 = null, TimeValue $t2 = null ) {
-		if ( $t1 === null ) {
+	private static function minTimeValue(TimeValue $t1 = null, TimeValue $t2 = null) {
+		if ($t1 === null) {
 			return $t2;
 		}
-		if ( $t2 === null ) {
+		if ($t2 === null) {
 			return $t1;
 		}
-		return ( new TimeValueComparer() )->getMinimum( $t1, $t2 );
+		return (new TimeValueComparer())->getMinimum($t1, $t2);
 	}
 
 	/**

src/ConstraintCheck/Checker/RangeChecker.php

Spacing +32 added lines, -32 removed lines

@@ -91,9 +91,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 = [];
@@ -101,28 +101,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->constraintParameterParser->parseRangeParameter(
+		list($min, $max) = $this->constraintParameterParser->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(),
@@ -138,16 +138,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));
 	}
 
 	/**
@@ -158,7 +158,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
@@ -171,39 +171,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->constraintParameterParser->parseRangeParameter(
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId(),
 				$type
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/Api/CachingResultsBuilder.php

Spacing +60 added lines, -61 removed lines

@@ -142,11 +142,11 @@ 
 	) {
 		$results = [];
 		$metadatas = [];
-		if ( $this->canUseStoredResults( $entityIds, $claimIds, $constraintIds, $statuses ) ) {
+		if ($this->canUseStoredResults($entityIds, $claimIds, $constraintIds, $statuses)) {
 			$storedEntityIds = [];
-			foreach ( $entityIds as $entityId ) {
-				$storedResults = $this->getStoredResults( $entityId );
-				if ( $storedResults !== null ) {
+			foreach ($entityIds as $entityId) {
+				$storedResults = $this->getStoredResults($entityId);
+				if ($storedResults !== null) {
 					$this->dataFactory->increment(
 						'wikibase.quality.constraints.cache.entity.hit'
 					);
@@ -155,20 +155,20 @@ 
 					$storedEntityIds[] = $entityId;
 				}
 			}
-			$entityIds = array_values( array_diff( $entityIds, $storedEntityIds ) );
+			$entityIds = array_values(array_diff($entityIds, $storedEntityIds));
 		}
-		if ( $entityIds !== [] || $claimIds !== [] ) {
+		if ($entityIds !== [] || $claimIds !== []) {
 			$this->dataFactory->updateCount(
 				'wikibase.quality.constraints.cache.entity.miss',
-				count( $entityIds )
+				count($entityIds)
 			);
-			$response = $this->getAndStoreResults( $entityIds, $claimIds, $constraintIds, $statuses );
+			$response = $this->getAndStoreResults($entityIds, $claimIds, $constraintIds, $statuses);
 			$results += $response->getArray();
 			$metadatas[] = $response->getMetadata();
 		}
 		return new CachedCheckConstraintsResponse(
 			$results,
-			Metadata::merge( $metadatas )
+			Metadata::merge($metadatas)
 		);
 	}
 
@@ -197,13 +197,13 @@ 
 		array $constraintIds = null,
 		array $statuses
 	) {
-		if ( $claimIds !== [] ) {
+		if ($claimIds !== []) {
 			return false;
 		}
-		if ( $constraintIds !== null ) {
+		if ($constraintIds !== null) {
 			return false;
 		}
-		if ( $statuses != $this->cachedStatuses ) {
+		if ($statuses != $this->cachedStatuses) {
 			return false;
 		}
 		return true;
@@ -222,10 +222,10 @@ 
 		array $constraintIds = null,
 		array $statuses
 	) {
-		$results = $this->resultsBuilder->getResults( $entityIds, $claimIds, $constraintIds, $statuses );
+		$results = $this->resultsBuilder->getResults($entityIds, $claimIds, $constraintIds, $statuses);
 
-		if ( $this->canStoreResults( $entityIds, $claimIds, $constraintIds, $statuses ) ) {
-			foreach ( $entityIds as $entityId ) {
+		if ($this->canStoreResults($entityIds, $claimIds, $constraintIds, $statuses)) {
+			foreach ($entityIds as $entityId) {
 				$value = [
 					'results' => $results->getArray()[$entityId->getSerialization()],
 					'latestRevisionIds' => $this->getLatestRevisionIds(
@@ -233,10 +233,10 @@ 
 					),
 				];
 				$futureTime = $results->getMetadata()->getDependencyMetadata()->getFutureTime();
-				if ( $futureTime !== null ) {
+				if ($futureTime !== null) {
 					$value['futureTime'] = $futureTime->getArrayValue();
 				}
-				$this->cache->set( $entityId, $value, $this->ttlInSeconds );
+				$this->cache->set($entityId, $value, $this->ttlInSeconds);
 			}
 		}
 
@@ -268,10 +268,10 @@ 
 		array $constraintIds = null,
 		array $statuses
 	) {
-		if ( $constraintIds !== null ) {
+		if ($constraintIds !== null) {
 			return false;
 		}
-		if ( $statuses != $this->cachedStatuses ) {
+		if ($statuses != $this->cachedStatuses) {
 			return false;
 		}
 		return true;
@@ -284,45 +284,44 @@ 
 	public function getStoredResults(
 		EntityId $entityId
 	) {
-		$value = $this->cache->get( $entityId, $curTTL, [], $asOf );
-		$now = call_user_func( $this->microtime, true );
+		$value = $this->cache->get($entityId, $curTTL, [], $asOf);
+		$now = call_user_func($this->microtime, true);
 
-		if ( $value === false ) {
+		if ($value === false) {
 			return null;
 		}
 
-		$ageInSeconds = (int)ceil( $now - $asOf );
+		$ageInSeconds = (int) ceil($now - $asOf);
 
 		$dependedEntityIds = array_map(
-			[ $this->entityIdParser, "parse" ],
-			array_keys( $value['latestRevisionIds'] )
+			[$this->entityIdParser, "parse"],
+			array_keys($value['latestRevisionIds'])
 		);
 
-		if ( $value['latestRevisionIds'] !== $this->getLatestRevisionIds( $dependedEntityIds ) ) {
+		if ($value['latestRevisionIds'] !== $this->getLatestRevisionIds($dependedEntityIds)) {
 			return null;
 		}
 
-		if ( array_key_exists( 'futureTime', $value ) ) {
-			$futureTime = TimeValue::newFromArray( $value['futureTime'] );
-			if ( !$this->timeValueComparer->isFutureTime( $futureTime ) ) {
+		if (array_key_exists('futureTime', $value)) {
+			$futureTime = TimeValue::newFromArray($value['futureTime']);
+			if (!$this->timeValueComparer->isFutureTime($futureTime)) {
 				return null;
 			}
-			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime( $futureTime );
+			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime($futureTime);
 		} else {
 			$futureTimeDependencyMetadata = DependencyMetadata::blank();
 		}
 
 		$cachingMetadata = $ageInSeconds > 0 ?
-			CachingMetadata::ofMaximumAgeInSeconds( $ageInSeconds ) :
-			CachingMetadata::fresh();
+			CachingMetadata::ofMaximumAgeInSeconds($ageInSeconds) : CachingMetadata::fresh();
 
-		if ( is_array( $value['results'] ) ) {
-			array_walk( $value['results'], [ $this, 'updateCachingMetadata' ], $cachingMetadata );
+		if (is_array($value['results'])) {
+			array_walk($value['results'], [$this, 'updateCachingMetadata'], $cachingMetadata);
 		}
 
 		return new CachedCheckConstraintsResponse(
-			[ $entityId->getSerialization() => $value['results'] ],
-			$this->mergeStoredMetadata( $cachingMetadata, $dependedEntityIds, $futureTimeDependencyMetadata )
+			[$entityId->getSerialization() => $value['results']],
+			$this->mergeStoredMetadata($cachingMetadata, $dependedEntityIds, $futureTimeDependencyMetadata)
 		);
 	}
 
@@ -337,58 +336,58 @@ 
 		array $dependedEntityIds,
 		DependencyMetadata $futureTimeDependencyMetadata = null
 	) {
-		return Metadata::merge( [
-			Metadata::ofCachingMetadata( $cachingMetadata ),
-			Metadata::ofDependencyMetadata( array_reduce(
+		return Metadata::merge([
+			Metadata::ofCachingMetadata($cachingMetadata),
+			Metadata::ofDependencyMetadata(array_reduce(
 				$dependedEntityIds,
-				function( DependencyMetadata $metadata, EntityId $entityId ) {
-					return DependencyMetadata::merge( [
+				function(DependencyMetadata $metadata, EntityId $entityId) {
+					return DependencyMetadata::merge([
 						$metadata,
-						DependencyMetadata::ofEntityId( $entityId )
-					] );
+						DependencyMetadata::ofEntityId($entityId)
+					]);
 				},
 				$futureTimeDependencyMetadata
-			) )
-		] );
+			))
+		]);
 	}
 
 	/**
 	 * @param EntityId[] $entityIds
 	 * @return int[]
 	 */
-	private function getLatestRevisionIds( array $entityIds ) {
+	private function getLatestRevisionIds(array $entityIds) {
 		$revisionInformations = $this->wikiPageEntityMetaDataAccessor->loadRevisionInformation(
 			$entityIds,
 			EntityRevisionLookup::LATEST_FROM_REPLICA
 		);
 		$latestRevisionIds = [];
-		foreach ( $revisionInformations as $serialization => $revisionInformation ) {
+		foreach ($revisionInformations as $serialization => $revisionInformation) {
 			$latestRevisionIds[$serialization] = $revisionInformation->page_latest;
 		}
 		return $latestRevisionIds;
 	}
 
-	public function updateCachingMetadata( &$element, $key, CachingMetadata $cachingMetadata ) {
-		if ( $key === 'cached' ) {
-			$element = CachingMetadata::merge( [
+	public function updateCachingMetadata(&$element, $key, CachingMetadata $cachingMetadata) {
+		if ($key === 'cached') {
+			$element = CachingMetadata::merge([
 				$cachingMetadata,
-				CachingMetadata::ofArray( $element ),
-			] )->toArray();
+				CachingMetadata::ofArray($element),
+			])->toArray();
 		}
 		if (
-			is_array( $element ) &&
-			array_key_exists( 'constraint', $element ) &&
-			in_array( $element['constraint']['type'], $this->possiblyStaleConstraintTypes, true )
+			is_array($element) &&
+			array_key_exists('constraint', $element) &&
+			in_array($element['constraint']['type'], $this->possiblyStaleConstraintTypes, true)
 		) {
-			$element['cached'] = CachingMetadata::merge( [
+			$element['cached'] = CachingMetadata::merge([
 				$cachingMetadata,
 				CachingMetadata::ofArray(
-					array_key_exists( 'cached', $element ) ? $element['cached'] : null
+					array_key_exists('cached', $element) ? $element['cached'] : null
 				),
-			] )->toArray();
+			])->toArray();
 		}
-		if ( is_array( $element ) ) {
-			array_walk( $element, [ $this, __FUNCTION__ ], $cachingMetadata );
+		if (is_array($element)) {
+			array_walk($element, [$this, __FUNCTION__], $cachingMetadata);
 		}
 	}
 
@@ -397,7 +396,7 @@ 
 	 *
 	 * @param callable $microtime
 	 */
-	public function setMicrotimeFunction( callable $microtime ) {
+	public function setMicrotimeFunction(callable $microtime) {
 		$this->microtime = $microtime;
 	}