wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Checker/FormatChecker.php

Spacing +25 added lines, -25 removed lines

@@ -93,12 +93,12 @@ 
 	 * @throws ConstraintParameterException
 	 * @return CheckResult
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint ) {
+	public function checkConstraint(Context $context, Constraint $constraint) {
 		$parameters = [];
 		$constraintParameters = $constraint->getConstraintParameters();
 
-		$format = $this->constraintParameterParser->parseFormatParameter( $constraintParameters, $constraint->getConstraintTypeItemId() );
-		$parameters['pattern'] = [ $format ];
+		$format = $this->constraintParameterParser->parseFormatParameter($constraintParameters, $constraint->getConstraintTypeItemId());
+		$parameters['pattern'] = [$format];
 
 		$syntaxClarifications = $this->constraintParameterParser->parseSyntaxClarificationParameter(
 			$constraintParameters
@@ -106,9 +106,9 @@ 
 
 		$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();
@@ -117,7 +117,7 @@ 
 		 * error handling:
 		 *   type of $dataValue for properties with 'Format' constraint has to be 'string' or 'monolingualtext'
 		 */
-		switch ( $dataValue->getType() ) {
+		switch ($dataValue->getType()) {
 			case 'string':
 				$text = $dataValue->getValue();
 				break;
@@ -126,46 +126,46 @@ 
 				$text = $dataValue->getText();
 				break;
 			default:
-				$message = ( new ViolationMessage( 'wbqc-violation-message-value-needed-of-types-2' ) )
-					->withEntityId( new ItemId( $constraint->getConstraintTypeItemId() ), Role::CONSTRAINT_TYPE_ITEM )
-					->withDataValueType( 'string' )
-					->withDataValueType( 'monolingualtext' );
-				return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_VIOLATION, $message );
+				$message = (new ViolationMessage('wbqc-violation-message-value-needed-of-types-2'))
+					->withEntityId(new ItemId($constraint->getConstraintTypeItemId()), Role::CONSTRAINT_TYPE_ITEM)
+					->withDataValueType('string')
+					->withDataValueType('monolingualtext');
+				return new CheckResult($context, $constraint, $parameters, CheckResult::STATUS_VIOLATION, $message);
 		}
 
-		if ( $this->sparqlHelper !== null && $this->config->get( 'WBQualityConstraintsCheckFormatConstraint' ) ) {
-			if ( $this->sparqlHelper->matchesRegularExpression( $text, $format ) ) {
+		if ($this->sparqlHelper !== null && $this->config->get('WBQualityConstraintsCheckFormatConstraint')) {
+			if ($this->sparqlHelper->matchesRegularExpression($text, $format)) {
 				$message = null;
 				$status = CheckResult::STATUS_COMPLIANCE;
 			} else {
-				$message = ( new ViolationMessage( 'wbqc-violation-message-format-clarification' ) )
-					->withEntityId( $context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY )
-					->withDataValue( new StringValue( $text ), Role::OBJECT )
-					->withInlineCode( $format, Role::CONSTRAINT_PARAMETER_VALUE )
-					->withMultilingualText( $syntaxClarifications, Role::CONSTRAINT_PARAMETER_VALUE );
+				$message = (new ViolationMessage('wbqc-violation-message-format-clarification'))
+					->withEntityId($context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY)
+					->withDataValue(new StringValue($text), Role::OBJECT)
+					->withInlineCode($format, Role::CONSTRAINT_PARAMETER_VALUE)
+					->withMultilingualText($syntaxClarifications, Role::CONSTRAINT_PARAMETER_VALUE);
 				$status = CheckResult::STATUS_VIOLATION;
 			}
 		} else {
-			$message = ( new ViolationMessage( 'wbqc-violation-message-security-reason' ) )
-				->withEntityId( new ItemId( $constraint->getConstraintTypeItemId() ), Role::CONSTRAINT_TYPE_ITEM );
+			$message = (new ViolationMessage('wbqc-violation-message-security-reason'))
+				->withEntityId(new ItemId($constraint->getConstraintTypeItemId()), Role::CONSTRAINT_TYPE_ITEM);
 			$status = CheckResult::STATUS_TODO;
 		}
-		return new CheckResult( $context, $constraint, $parameters, $status, $message );
+		return new CheckResult($context, $constraint, $parameters, $status, $message);
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ) {
+	public function checkConstraintParameters(Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$exceptions = [];
 		try {
-			$this->constraintParameterParser->parseFormatParameter( $constraintParameters, $constraint->getConstraintTypeItemId() );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseFormatParameter($constraintParameters, $constraint->getConstraintTypeItemId());
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		try {
 			$this->constraintParameterParser->parseSyntaxClarificationParameter(
 				$constraintParameters
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/ConstraintCheck/Message/ViolationMessageDeserializer.php

Spacing +31 added lines, -31 removed lines

@@ -39,23 +39,23 @@ 
 		$this->dataValueFactory = $dataValueFactory;
 	}
 
-	public function unabbreviateViolationMessageKey( $messageKeySuffix ) {
-		return ViolationMessage::MESSAGE_KEY_PREFIX . $messageKeySuffix;
+	public function unabbreviateViolationMessageKey($messageKeySuffix) {
+		return ViolationMessage::MESSAGE_KEY_PREFIX.$messageKeySuffix;
 	}
 
 	/**
 	 * @param array $serialization
 	 * @return ViolationMessage
 	 */
-	public function deserialize( $serialization ) {
-		Assert::parameterType( 'array', $serialization, '$serialization' );
+	public function deserialize($serialization) {
+		Assert::parameterType('array', $serialization, '$serialization');
 
 		$message = new ViolationMessage(
-			$this->unabbreviateViolationMessageKey( $serialization['k'] )
+			$this->unabbreviateViolationMessageKey($serialization['k'])
 		);
 
-		foreach ( $serialization['a'] as $serializedArgument ) {
-			$message = $this->deserializeArgument( $message, $serializedArgument );
+		foreach ($serialization['a'] as $serializedArgument) {
+			$message = $this->deserializeArgument($message, $serializedArgument);
 		}
 
 		return $message;
@@ -66,7 +66,7 @@ 
 	 * @param array $serializedArgument [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
 	 * @return ViolationMessage $message with the deserialized argument appended
 	 */
-	private function deserializeArgument( ViolationMessage $message, array $serializedArgument ) {
+	private function deserializeArgument(ViolationMessage $message, array $serializedArgument) {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'deserializeEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'deserializeEntityIdList',
@@ -85,23 +85,23 @@ 
 		$serializedValue = $serializedArgument['v'];
 		$role = $serializedArgument['r'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$value = $this->$method( $serializedValue );
+			$value = $this->$method($serializedValue);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
-		return $message->withArgument( $type, $role, $value );
+		return $message->withArgument($type, $role, $value);
 	}
 
 	/**
 	 * @param string $string any value that shall simply be deserialized into itself
 	 * @return string that same value, unchanged
 	 */
-	private function deserializeStringByIdentity( $string ) {
+	private function deserializeStringByIdentity($string) {
 		return $string;
 	}
 
@@ -109,30 +109,30 @@ 
 	 * @param string $entityIdSerialization entity ID serialization
 	 * @return EntityId
 	 */
-	private function deserializeEntityId( $entityIdSerialization ) {
-		return $this->entityIdParser->parse( $entityIdSerialization );
+	private function deserializeEntityId($entityIdSerialization) {
+		return $this->entityIdParser->parse($entityIdSerialization);
 	}
 
 	/**
 	 * @param string[] $entityIdSerializations entity ID serializations
 	 * @return EntityId[]
 	 */
-	private function deserializeEntityIdList( array $entityIdSerializations ) {
-		return array_map( [ $this, 'deserializeEntityId' ], $entityIdSerializations );
+	private function deserializeEntityIdList(array $entityIdSerializations) {
+		return array_map([$this, 'deserializeEntityId'], $entityIdSerializations);
 	}
 
 	/**
 	 * @param string $valueSerialization entity ID serialization, '::somevalue' or '::novalue'
 	 * @return ItemIdSnakValue
 	 */
-	private function deserializeItemIdSnakValue( $valueSerialization ) {
-		switch ( $valueSerialization ) {
+	private function deserializeItemIdSnakValue($valueSerialization) {
+		switch ($valueSerialization) {
 			case '::somevalue':
 				return ItemIdSnakValue::someValue();
 			case '::novalue':
 				return ItemIdSnakValue::noValue();
 			default:
-				return ItemIdSnakValue::fromItemId( $this->deserializeEntityId( $valueSerialization ) );
+				return ItemIdSnakValue::fromItemId($this->deserializeEntityId($valueSerialization));
 		}
 	}
 
@@ -140,24 +140,24 @@ 
 	 * @param string[] $valueSerializations entity ID serializations, '::somevalue's or '::novalue's
 	 * @return ItemIdSnakValue[]
 	 */
-	private function deserializeItemIdSnakValueList( $valueSerializations ) {
-		return array_map( [ $this, 'deserializeItemIdSnakValue' ], $valueSerializations );
+	private function deserializeItemIdSnakValueList($valueSerializations) {
+		return array_map([$this, 'deserializeItemIdSnakValue'], $valueSerializations);
 	}
 
 	/**
 	 * @param array $dataValueSerialization the data value in array form
 	 * @return DataValue
 	 */
-	private function deserializeDataValue( array $dataValueSerialization ) {
-		return $this->dataValueFactory->newFromArray( $dataValueSerialization );
+	private function deserializeDataValue(array $dataValueSerialization) {
+		return $this->dataValueFactory->newFromArray($dataValueSerialization);
 	}
 
 	/**
 	 * @param string $scopeAbbreviation
 	 * @return string one of the Context::TYPE_* constants
 	 */
-	private function deserializeConstraintScope( $scopeAbbreviation ) {
-		switch ( $scopeAbbreviation ) {
+	private function deserializeConstraintScope($scopeAbbreviation) {
+		switch ($scopeAbbreviation) {
 			case 's':
 				return Context::TYPE_STATEMENT;
 			case 'q':
@@ -167,7 +167,7 @@ 
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					'Unknown constraint scope abbreviation ' . $scopeAbbreviation
+					'Unknown constraint scope abbreviation '.$scopeAbbreviation
 				);
 				// @codeCoverageIgnoreEnd
 		}
@@ -177,16 +177,16 @@ 
 	 * @param string[] $scopeAbbreviations
 	 * @return string[] Context::TYPE_* constants
 	 */
-	private function deserializeConstraintScopeList( array $scopeAbbreviations ) {
-		return array_map( [ $this, 'deserializeConstraintScope' ], $scopeAbbreviations );
+	private function deserializeConstraintScopeList(array $scopeAbbreviations) {
+		return array_map([$this, 'deserializeConstraintScope'], $scopeAbbreviations);
 	}
 
 	/**
 	 * @param mixed $textSerialization {@see MultilingualTextValue::getArrayValue}
 	 * @return MultilingualTextValue
 	 */
-	private function deserializeMultilingualText( $textSerialization ) {
-		return MultilingualTextValue::newFromArray( $textSerialization );
+	private function deserializeMultilingualText($textSerialization) {
+		return MultilingualTextValue::newFromArray($textSerialization);
 	}
 
 }

src/ConstraintCheck/Message/ViolationMessageSerializer.php

Spacing +28 added lines, -28 removed lines

@@ -19,26 +19,26 @@ 
  */
 class ViolationMessageSerializer implements Serializer {
 
-	private function abbreviateViolationMessageKey( $fullMessageKey ) {
-		return substr( $fullMessageKey, strlen( ViolationMessage::MESSAGE_KEY_PREFIX ) );
+	private function abbreviateViolationMessageKey($fullMessageKey) {
+		return substr($fullMessageKey, strlen(ViolationMessage::MESSAGE_KEY_PREFIX));
 	}
 
 	/**
 	 * @param ViolationMessage $object
 	 * @return array
 	 */
-	public function serialize( $object ) {
+	public function serialize($object) {
 		/** @var ViolationMessage $object */
-		Assert::parameterType( ViolationMessage::class, $object, '$object' );
+		Assert::parameterType(ViolationMessage::class, $object, '$object');
 
 		$arguments = $object->getArguments();
 		$serializedArguments = [];
-		foreach ( $arguments as $argument ) {
-			$serializedArguments[] = $this->serializeArgument( $argument );
+		foreach ($arguments as $argument) {
+			$serializedArguments[] = $this->serializeArgument($argument);
 		}
 
 		return [
-			'k' => $this->abbreviateViolationMessageKey( $object->getMessageKey() ),
+			'k' => $this->abbreviateViolationMessageKey($object->getMessageKey()),
 			'a' => $serializedArguments,
 		];
 	}
@@ -47,7 +47,7 @@ 
 	 * @param array $argument element of ViolationMessage::getArguments()
 	 * @return array [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
 	 */
-	private function serializeArgument( array $argument ) {
+	private function serializeArgument(array $argument) {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'serializeEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'serializeEntityIdList',
@@ -66,12 +66,12 @@ 
 		$value = $argument['value'];
 		$role = $argument['role'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$serializedValue = $this->$method( $value );
+			$serializedValue = $this->$method($value);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
@@ -88,8 +88,8 @@ 
 	 * @param string $string any value that shall simply be serialized to itself
 	 * @return string that same value, unchanged
 	 */
-	private function serializeStringByIdentity( $string ) {
-		Assert::parameterType( 'string', $string, '$string' );
+	private function serializeStringByIdentity($string) {
+		Assert::parameterType('string', $string, '$string');
 		return $string;
 	}
 
@@ -97,7 +97,7 @@ 
 	 * @param EntityId $entityId
 	 * @return string entity ID serialization
 	 */
-	private function serializeEntityId( EntityId $entityId ) {
+	private function serializeEntityId(EntityId $entityId) {
 		return $entityId->getSerialization();
 	}
 
@@ -105,8 +105,8 @@ 
 	 * @param EntityId[] $entityIdList
 	 * @return string[] entity ID serializations
 	 */
-	private function serializeEntityIdList( array $entityIdList ) {
-		return array_map( [ $this, 'serializeEntityId' ], $entityIdList );
+	private function serializeEntityIdList(array $entityIdList) {
+		return array_map([$this, 'serializeEntityId'], $entityIdList);
 	}
 
 	/**
@@ -114,10 +114,10 @@ 
 	 * @return string entity ID serialization, '::somevalue', or '::novalue'
 	 * (according to EntityId::PATTERN, entity ID serializations can never begin with two colons)
 	 */
-	private function serializeItemIdSnakValue( ItemIdSnakValue $value ) {
-		switch ( true ) {
+	private function serializeItemIdSnakValue(ItemIdSnakValue $value) {
+		switch (true) {
 			case $value->isValue():
-				return $this->serializeEntityId( $value->getItemId() );
+				return $this->serializeEntityId($value->getItemId());
 			case $value->isSomeValue():
 				return '::somevalue';
 			case $value->isNoValue():
@@ -135,15 +135,15 @@ 
 	 * @param ItemIdSnakValue[] $valueList
 	 * @return string[] array of entity ID serializations, '::somevalue's or '::novalue's
 	 */
-	private function serializeItemIdSnakValueList( array $valueList ) {
-		return array_map( [ $this, 'serializeItemIdSnakValue' ], $valueList );
+	private function serializeItemIdSnakValueList(array $valueList) {
+		return array_map([$this, 'serializeItemIdSnakValue'], $valueList);
 	}
 
 	/**
 	 * @param DataValue $dataValue
 	 * @return array the data value in array form
 	 */
-	private function serializeDataValue( DataValue $dataValue ) {
+	private function serializeDataValue(DataValue $dataValue) {
 		return $dataValue->toArray();
 	}
 
@@ -151,8 +151,8 @@ 
 	 * @param string $scope one of the Context::TYPE_* constants
 	 * @return string the abbreviated scope
 	 */
-	private function serializeConstraintScope( $scope ) {
-		switch ( $scope ) {
+	private function serializeConstraintScope($scope) {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
 				return 's';
 			case Context::TYPE_QUALIFIER:
@@ -162,7 +162,7 @@ 
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					'Unknown constraint scope ' . $scope
+					'Unknown constraint scope '.$scope
 				);
 				// @codeCoverageIgnoreEnd
 		}
@@ -172,15 +172,15 @@ 
 	 * @param string[] $scopeList Context::TYPE_* constants
 	 * @return string[] abbreviated scopes
 	 */
-	private function serializeConstraintScopeList( array $scopeList ) {
-		return array_map( [ $this, 'serializeConstraintScope' ], $scopeList );
+	private function serializeConstraintScopeList(array $scopeList) {
+		return array_map([$this, 'serializeConstraintScope'], $scopeList);
 	}
 
 	/**
 	 * @param MultilingualTextValue $text
 	 * @return mixed {@see MultilingualTextValue::getArrayValue}
 	 */
-	private function serializeMultilingualText( MultilingualTextValue $text ) {
+	private function serializeMultilingualText(MultilingualTextValue $text) {
 		return $text->getArrayValue();
 	}
 

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/DelegatingConstraintChecker.php

Spacing +133 added lines, -133 removed lines

@@ -137,14 +137,14 @@ 
 		callable $defaultResults = null
 	) {
 
-		$entity = $this->entityLookup->getEntity( $entityId );
-		if ( $entity instanceof StatementListProvider ) {
+		$entity = $this->entityLookup->getEntity($entityId);
+		if ($entity instanceof StatementListProvider) {
 			$result = $this->checkEveryStatement(
-				$this->entityLookup->getEntity( $entityId ),
+				$this->entityLookup->getEntity($entityId),
 				$constraintIds,
 				$defaultResults
 			);
-			$output = $this->sortResult( $result );
+			$output = $this->sortResult($result);
 			return $output;
 		}
 
@@ -170,19 +170,19 @@ 
 		callable $defaultResults = null
 	) {
 
-		$parsedGuid = $this->statementGuidParser->parse( $guid );
+		$parsedGuid = $this->statementGuidParser->parse($guid);
 		$entityId = $parsedGuid->getEntityId();
-		$entity = $this->entityLookup->getEntity( $entityId );
-		if ( $entity instanceof StatementListProvider ) {
-			$statement = $entity->getStatements()->getFirstStatementWithGuid( $guid );
-			if ( $statement ) {
+		$entity = $this->entityLookup->getEntity($entityId);
+		if ($entity instanceof StatementListProvider) {
+			$statement = $entity->getStatements()->getFirstStatementWithGuid($guid);
+			if ($statement) {
 				$result = $this->checkStatement(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResults
 				);
-				$output = $this->sortResult( $result );
+				$output = $this->sortResult($result);
 				return $output;
 			}
 		}
@@ -190,8 +190,8 @@ 
 		return [];
 	}
 
-	private function getAllowedContextTypes( Constraint $constraint ) {
-		if ( !array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+	private function getAllowedContextTypes(Constraint $constraint) {
+		if (!array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 			return [
 				Context::TYPE_STATEMENT,
 				Context::TYPE_QUALIFIER,
@@ -199,12 +199,12 @@ 
 			];
 		}
 
-		return array_keys( array_filter(
+		return array_keys(array_filter(
 			$this->checkerMap[$constraint->getConstraintTypeItemId()]->getSupportedContextTypes(),
-			function ( $resultStatus ) {
+			function($resultStatus) {
 				return $resultStatus !== CheckResult::STATUS_NOT_IN_SCOPE;
 			}
-		) );
+		));
 	}
 
 	/**
@@ -215,32 +215,32 @@ 
 	 *
 	 * @return ConstraintParameterException[]
 	 */
-	private function checkCommonConstraintParameters( Constraint $constraint ) {
+	private function checkCommonConstraintParameters(Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		try {
-			$this->constraintParameterParser->checkError( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
-			return [ $e ];
+			$this->constraintParameterParser->checkError($constraintParameters);
+		} catch (ConstraintParameterException $e) {
+			return [$e];
 		}
 
 		$problems = [];
 		try {
-			$this->constraintParameterParser->parseExceptionParameter( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseExceptionParameter($constraintParameters);
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		try {
-			$this->constraintParameterParser->parseConstraintStatusParameter( $constraintParameters );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseConstraintStatusParameter($constraintParameters);
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		try {
 			$this->constraintParameterParser->parseConstraintScopeParameter(
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId(),
-				$this->getAllowedContextTypes( $constraint )
+				$this->getAllowedContextTypes($constraint)
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$problems[] = $e;
 		}
 		return $problems;
@@ -253,16 +253,16 @@ 
 	 * @return ConstraintParameterException[][] first level indexed by constraint ID,
 	 * second level like checkConstraintParametersOnConstraintId (but without possibility of null)
 	 */
-	public function checkConstraintParametersOnPropertyId( PropertyId $propertyId ) {
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
+	public function checkConstraintParametersOnPropertyId(PropertyId $propertyId) {
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
 		$result = [];
 
-		foreach ( $constraints as $constraint ) {
-			$problems = $this->checkCommonConstraintParameters( $constraint );
+		foreach ($constraints as $constraint) {
+			$problems = $this->checkCommonConstraintParameters($constraint);
 
-			if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+			if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 				$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
-				$problems = array_merge( $problems, $checker->checkConstraintParameters( $constraint ) );
+				$problems = array_merge($problems, $checker->checkConstraintParameters($constraint));
 			}
 
 			$result[$constraint->getConstraintId()] = $problems;
@@ -279,17 +279,17 @@ 
 	 * @return ConstraintParameterException[]|null list of constraint parameter exceptions
 	 * (empty means all parameters okay), or null if constraint is not found
 	 */
-	public function checkConstraintParametersOnConstraintId( $constraintId ) {
-		$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
+	public function checkConstraintParametersOnConstraintId($constraintId) {
+		$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
 
-		foreach ( $constraints as $constraint ) {
-			if ( $constraint->getConstraintId() === $constraintId ) {
-				$problems = $this->checkCommonConstraintParameters( $constraint );
+		foreach ($constraints as $constraint) {
+			if ($constraint->getConstraintId() === $constraintId) {
+				$problems = $this->checkCommonConstraintParameters($constraint);
 
-				if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+				if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 					$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
-					$problems = array_merge( $problems, $checker->checkConstraintParameters( $constraint ) );
+					$problems = array_merge($problems, $checker->checkConstraintParameters($constraint));
 				}
 
 				return $problems;
@@ -314,14 +314,14 @@ 
 		$result = [];
 
 		/** @var Statement $statement */
-		foreach ( $entity->getStatements() as $statement ) {
-			$result = array_merge( $result,
+		foreach ($entity->getStatements() as $statement) {
+			$result = array_merge($result,
 				$this->checkStatement(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResults
-				) );
+				));
 		}
 
 		return $result;
@@ -343,32 +343,32 @@ 
 	) {
 		$result = [];
 
-		$result = array_merge( $result,
+		$result = array_merge($result,
 			$this->checkConstraintsForMainSnak(
 				$entity,
 				$statement,
 				$constraintIds,
 				$defaultResults
-			) );
+			));
 
-		if ( $this->checkQualifiers ) {
-			$result = array_merge( $result,
+		if ($this->checkQualifiers) {
+			$result = array_merge($result,
 				$this->checkConstraintsForQualifiers(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResults
-				) );
+				));
 		}
 
-		if ( $this->checkReferences ) {
-			$result = array_merge( $result,
+		if ($this->checkReferences) {
+			$result = array_merge($result,
 				$this->checkConstraintsForReferences(
 					$entity,
 					$statement,
 					$constraintIds,
 					$defaultResults
-				) );
+				));
 		}
 
 		return $result;
@@ -383,12 +383,12 @@ 
 	 * @param string[]|null $constraintIds
 	 * @return Constraint[]
 	 */
-	private function getConstraintsToUse( PropertyId $propertyId, array $constraintIds = null ) {
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
-		if ( $constraintIds !== null ) {
+	private function getConstraintsToUse(PropertyId $propertyId, array $constraintIds = null) {
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
+		if ($constraintIds !== null) {
 			$constraintsToUse = [];
-			foreach ( $constraints as $constraint ) {
-				if ( in_array( $constraint->getConstraintId(), $constraintIds ) ) {
+			foreach ($constraints as $constraint) {
+				if (in_array($constraint->getConstraintId(), $constraintIds)) {
 					$constraintsToUse[] = $constraint;
 				}
 			}
@@ -412,29 +412,29 @@ 
 		array $constraintIds = null,
 		callable $defaultResults = null
 	) {
-		$context = new MainSnakContext( $entity, $statement );
+		$context = new MainSnakContext($entity, $statement);
 		$constraints = $this->getConstraintsToUse(
 			$statement->getPropertyId(),
 			$constraintIds
 		);
-		$result = $defaultResults !== null ? $defaultResults( $context ) : [];
+		$result = $defaultResults !== null ? $defaultResults($context) : [];
 
-		foreach ( $constraints as $constraint ) {
+		foreach ($constraints as $constraint) {
 			$parameters = $constraint->getConstraintParameters();
 			try {
-				$exceptions = $this->constraintParameterParser->parseExceptionParameter( $parameters );
-			} catch ( ConstraintParameterException $e ) {
-				$result[] = new CheckResult( $context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage() );
+				$exceptions = $this->constraintParameterParser->parseExceptionParameter($parameters);
+			} catch (ConstraintParameterException $e) {
+				$result[] = new CheckResult($context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage());
 				continue;
 			}
 
-			if ( in_array( $entity->getId(), $exceptions ) ) {
-				$message = wfMessage( 'wbqc-exception-message' )->escaped();
-				$result[] = new CheckResult( $context, $constraint, [], CheckResult::STATUS_EXCEPTION, $message );
+			if (in_array($entity->getId(), $exceptions)) {
+				$message = wfMessage('wbqc-exception-message')->escaped();
+				$result[] = new CheckResult($context, $constraint, [], CheckResult::STATUS_EXCEPTION, $message);
 				continue;
 			}
 
-			$result[] = $this->getCheckResultFor( $context, $constraint );
+			$result[] = $this->getCheckResultFor($context, $constraint);
 		}
 
 		return $result;
@@ -456,24 +456,24 @@ 
 	) {
 		$result = [];
 
-		if ( in_array(
+		if (in_array(
 			$statement->getPropertyId()->getSerialization(),
 			$this->propertiesWithViolatingQualifiers
-		) ) {
+		)) {
 			return $result;
 		}
 
-		foreach ( $statement->getQualifiers() as $qualifier ) {
-			$qualifierContext = new QualifierContext( $entity, $statement, $qualifier );
-			if ( $defaultResults !== null ) {
-				$result = array_merge( $result, $defaultResults( $qualifierContext ) );
+		foreach ($statement->getQualifiers() as $qualifier) {
+			$qualifierContext = new QualifierContext($entity, $statement, $qualifier);
+			if ($defaultResults !== null) {
+				$result = array_merge($result, $defaultResults($qualifierContext));
 			}
 			$qualifierConstraints = $this->getConstraintsToUse(
 				$qualifierContext->getSnak()->getPropertyId(),
 				$constraintIds
 			);
-			foreach ( $qualifierConstraints as $qualifierConstraint ) {
-				$result[] = $this->getCheckResultFor( $qualifierContext, $qualifierConstraint );
+			foreach ($qualifierConstraints as $qualifierConstraint) {
+				$result[] = $this->getCheckResultFor($qualifierContext, $qualifierConstraint);
 			}
 		}
 
@@ -497,19 +497,19 @@ 
 		$result = [];
 
 		/** @var Reference $reference */
-		foreach ( $statement->getReferences() as $reference ) {
-			foreach ( $reference->getSnaks() as $snak ) {
+		foreach ($statement->getReferences() as $reference) {
+			foreach ($reference->getSnaks() as $snak) {
 				$referenceContext = new ReferenceContext(
 					$entity, $statement, $reference, $snak
 				);
-				if ( $defaultResults !== null ) {
-					$result = array_merge( $result, $defaultResults( $referenceContext ) );
+				if ($defaultResults !== null) {
+					$result = array_merge($result, $defaultResults($referenceContext));
 				}
 				$referenceConstraints = $this->getConstraintsToUse(
 					$referenceContext->getSnak()->getPropertyId(),
 					$constraintIds
 				);
-				foreach ( $referenceConstraints as $referenceConstraint ) {
+				foreach ($referenceConstraints as $referenceConstraint) {
 					$result[] = $this->getCheckResultFor(
 						$referenceContext,
 						$referenceConstraint
@@ -528,65 +528,65 @@ 
 	 * @throws InvalidArgumentException
 	 * @return CheckResult
 	 */
-	private function getCheckResultFor( Context $context, Constraint $constraint ) {
-		if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
+	private function getCheckResultFor(Context $context, Constraint $constraint) {
+		if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
 			$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
-			$result = $this->handleScope( $checker, $context, $constraint );
+			$result = $this->handleScope($checker, $context, $constraint);
 
-			if ( $result !== null ) {
-				$this->addMetadata( $result );
+			if ($result !== null) {
+				$this->addMetadata($result);
 				return $result;
 			}
 
-			$startTime = microtime( true );
+			$startTime = microtime(true);
 			try {
-				$result = $checker->checkConstraint( $context, $constraint );
-			} catch ( ConstraintParameterException $e ) {
-				$result = new CheckResult( $context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage() );
-			} catch ( SparqlHelperException $e ) {
-				$message = new ViolationMessage( 'wbqc-violation-message-sparql-error' );
-				$result = new CheckResult( $context, $constraint, [], CheckResult::STATUS_VIOLATION, $message );
+				$result = $checker->checkConstraint($context, $constraint);
+			} catch (ConstraintParameterException $e) {
+				$result = new CheckResult($context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage());
+			} catch (SparqlHelperException $e) {
+				$message = new ViolationMessage('wbqc-violation-message-sparql-error');
+				$result = new CheckResult($context, $constraint, [], CheckResult::STATUS_VIOLATION, $message);
 			}
-			$endTime = microtime( true );
+			$endTime = microtime(true);
 
-			$this->addMetadata( $result );
+			$this->addMetadata($result);
 
 			try {
 				$constraintStatus = $this->constraintParameterParser
-					->parseConstraintStatusParameter( $constraint->getConstraintParameters() );
-			} catch ( ConstraintParameterException $e ) {
-				$result = new CheckResult( $context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage() );
+					->parseConstraintStatusParameter($constraint->getConstraintParameters());
+			} catch (ConstraintParameterException $e) {
+				$result = new CheckResult($context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage());
 				$constraintStatus = null;
 			}
-			if ( $constraintStatus === null ) {
+			if ($constraintStatus === null) {
 				// downgrade violation to warning
-				if ( $result->getStatus() === CheckResult::STATUS_VIOLATION ) {
-					$result->setStatus( CheckResult::STATUS_WARNING );
+				if ($result->getStatus() === CheckResult::STATUS_VIOLATION) {
+					$result->setStatus(CheckResult::STATUS_WARNING);
 				}
 			} else {
-				if ( $constraintStatus !== 'mandatory' ) {
+				if ($constraintStatus !== 'mandatory') {
 					// @codeCoverageIgnoreStart
 					throw new LogicException(
-						"Unknown constraint status '$constraintStatus', " .
+						"Unknown constraint status '$constraintStatus', ".
 						"only known status is 'mandatory'"
 					);
 					// @codeCoverageIgnoreEnd
 				}
-				$result->addParameter( 'constraint_status', $constraintStatus );
+				$result->addParameter('constraint_status', $constraintStatus);
 			}
 
 			$this->loggingHelper->logConstraintCheck(
 				$context,
 				$constraint,
 				$result,
-				get_class( $checker ),
+				get_class($checker),
 				$endTime - $startTime,
 				__METHOD__
 			);
 
 			return $result;
 		} else {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_TODO, null );
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_TODO, null);
 		}
 	}
 
@@ -600,29 +600,29 @@ 
 				$constraint->getConstraintParameters(),
 				$constraint->getConstraintTypeItemId()
 			);
-		} catch ( ConstraintParameterException $e ) {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage() );
+		} catch (ConstraintParameterException $e) {
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage());
 		}
-		if ( $checkedContextTypes === null ) {
+		if ($checkedContextTypes === null) {
 			$checkedContextTypes = $checker->getDefaultContextTypes();
 		}
-		if ( !in_array( $context->getType(), $checkedContextTypes ) ) {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_NOT_IN_SCOPE, null );
+		if (!in_array($context->getType(), $checkedContextTypes)) {
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_NOT_IN_SCOPE, null);
 		}
-		if ( $checker->getSupportedContextTypes()[$context->getType()] === CheckResult::STATUS_TODO ) {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_TODO, null );
+		if ($checker->getSupportedContextTypes()[$context->getType()] === CheckResult::STATUS_TODO) {
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_TODO, null);
 		}
 		return null;
 	}
 
-	private function addMetadata( CheckResult $result ) {
-		$result->withMetadata( Metadata::merge( [
+	private function addMetadata(CheckResult $result) {
+		$result->withMetadata(Metadata::merge([
 			$result->getMetadata(),
-			Metadata::ofDependencyMetadata( DependencyMetadata::merge( [
-				DependencyMetadata::ofEntityId( $result->getEntityId() ),
-				DependencyMetadata::ofEntityId( $result->getConstraint()->getPropertyId() ),
-			] ) ),
-		] ) );
+			Metadata::ofDependencyMetadata(DependencyMetadata::merge([
+				DependencyMetadata::ofEntityId($result->getEntityId()),
+				DependencyMetadata::ofEntityId($result->getConstraint()->getPropertyId()),
+			])),
+		]));
 	}
 
 	/**
@@ -630,12 +630,12 @@ 
 	 *
 	 * @return CheckResult[]
 	 */
-	private function sortResult( array $result ) {
-		if ( count( $result ) < 2 ) {
+	private function sortResult(array $result) {
+		if (count($result) < 2) {
 			return $result;
 		}
 
-		$sortFunction = function ( CheckResult $a, CheckResult $b ) {
+		$sortFunction = function(CheckResult $a, CheckResult $b) {
 			$orderNum = 0;
 			$order = [
 				CheckResult::STATUS_BAD_PARAMETERS => $orderNum++,
@@ -651,45 +651,45 @@ 
 			$statusA = $a->getStatus();
 			$statusB = $b->getStatus();
 
-			$orderA = array_key_exists( $statusA, $order ) ? $order[ $statusA ] : $order[ 'other' ];
-			$orderB = array_key_exists( $statusB, $order ) ? $order[ $statusB ] : $order[ 'other' ];
+			$orderA = array_key_exists($statusA, $order) ? $order[$statusA] : $order['other'];
+			$orderB = array_key_exists($statusB, $order) ? $order[$statusB] : $order['other'];
 
-			if ( $orderA === $orderB ) {
+			if ($orderA === $orderB) {
 				$pidA = $a->getContext()->getSnak()->getPropertyId()->getSerialization();
 				$pidB = $b->getContext()->getSnak()->getPropertyId()->getSerialization();
 
-				if ( $pidA === $pidB ) {
+				if ($pidA === $pidB) {
 					$hashA = $a->getContext()->getSnak()->getHash();
 					$hashB = $b->getContext()->getSnak()->getHash();
 
-					if ( $hashA === $hashB ) {
-						if ( $a instanceof NullResult ) {
+					if ($hashA === $hashB) {
+						if ($a instanceof NullResult) {
 							return $b instanceof NullResult ? 0 : -1;
 						}
-						if ( $b instanceof NullResult ) {
+						if ($b instanceof NullResult) {
 							return $a instanceof NullResult ? 0 : 1;
 						}
 
 						$typeA = $a->getConstraint()->getConstraintTypeItemId();
 						$typeB = $b->getConstraint()->getConstraintTypeItemId();
 
-						if ( $typeA == $typeB ) {
+						if ($typeA == $typeB) {
 							return 0;
 						} else {
-							return ( $typeA > $typeB ) ? 1 : -1;
+							return ($typeA > $typeB) ? 1 : -1;
 						}
 					} else {
-						return ( $hashA > $hashB ) ? 1 : -1;
+						return ($hashA > $hashB) ? 1 : -1;
 					}
 				} else {
-					return ( $pidA > $pidB ) ? 1 : -1;
+					return ($pidA > $pidB) ? 1 : -1;
 				}
 			} else {
-				return ( $orderA > $orderB ) ? 1 : -1;
+				return ($orderA > $orderB) ? 1 : -1;
 			}
 		};
 
-		uasort( $result, $sortFunction );
+		uasort($result, $sortFunction);
 
 		return $result;
 	}

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/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/Helper/RangeCheckerHelper.php

Spacing +43 added lines, -43 removed lines

@@ -51,7 +51,7 @@ 
 		UnitConverter $unitConverter = null
 	) {
 		$this->config = $config;
-		$this->timeParser = ( new TimeParserFactory() )->getTimeParser();
+		$this->timeParser = (new TimeParserFactory())->getTimeParser();
 		$this->timeCalculator = new TimeValueCalculator();
 		$this->timeValueComparer = new TimeValueComparer();
 		$this->unitConverter = $unitConverter;
@@ -61,10 +61,10 @@ 
 	 * @param UnboundedQuantityValue $value
 	 * @return UnboundedQuantityValue $value converted to standard units if possible, otherwise unchanged $value.
 	 */
-	private function standardize( UnboundedQuantityValue $value ) {
-		if ( $this->unitConverter !== null ) {
-			$standard = $this->unitConverter->toStandardUnits( $value );
-			if ( $standard !== null ) {
+	private function standardize(UnboundedQuantityValue $value) {
+		if ($this->unitConverter !== null) {
+			$standard = $this->unitConverter->toStandardUnits($value);
+			if ($standard !== null) {
 				return $standard;
 			} else {
 				return $value;
@@ -86,29 +86,29 @@ 
 	 *                 when $lhs is respectively less than, equal to, or greater than $rhs.
 	 *                 (In other words, just like the “spaceship” operator <=>.)
 	 */
-	public function getComparison( DataValue $lhs = null, DataValue $rhs = null ) {
-		if ( $lhs === null || $rhs === null ) {
+	public function getComparison(DataValue $lhs = null, DataValue $rhs = null) {
+		if ($lhs === null || $rhs === null) {
 			return 0;
 		}
 
-		if ( $lhs->getType() !== $rhs->getType() ) {
-			throw new InvalidArgumentException( 'Different data value types' );
+		if ($lhs->getType() !== $rhs->getType()) {
+			throw new InvalidArgumentException('Different data value types');
 		}
 
-		switch ( $lhs->getType() ) {
+		switch ($lhs->getType()) {
 			case 'time':
 				/** @var TimeValue $lhs */
 				/** @var TimeValue $rhs */
-				return $this->timeValueComparer->getComparison( $lhs, $rhs );
+				return $this->timeValueComparer->getComparison($lhs, $rhs);
 			case 'quantity':
 				/** @var QuantityValue|UnboundedQuantityValue $lhs */
 				/** @var QuantityValue|UnboundedQuantityValue $rhs */
-				$lhsStandard = $this->standardize( $lhs );
-				$rhsStandard = $this->standardize( $rhs );
-				return $lhsStandard->getAmount()->compare( $rhsStandard->getAmount() );
+				$lhsStandard = $this->standardize($lhs);
+				$rhsStandard = $this->standardize($rhs);
+				return $lhsStandard->getAmount()->compare($rhsStandard->getAmount());
 		}
 
-		throw new InvalidArgumentException( 'Unsupported data value type' );
+		throw new InvalidArgumentException('Unsupported data value type');
 	}
 
 	/**
@@ -123,71 +123,71 @@ 
 	 * @throws InvalidArgumentException if the values do not both have the same, supported data value type
 	 * @return UnboundedQuantityValue
 	 */
-	public function getDifference( DataValue $minuend, DataValue $subtrahend ) {
-		if ( $minuend->getType() === 'time' && $subtrahend->getType() === 'time' ) {
-			$minuendSeconds = $this->timeCalculator->getTimestamp( $minuend );
-			$subtrahendSeconds = $this->timeCalculator->getTimestamp( $subtrahend );
+	public function getDifference(DataValue $minuend, DataValue $subtrahend) {
+		if ($minuend->getType() === 'time' && $subtrahend->getType() === 'time') {
+			$minuendSeconds = $this->timeCalculator->getTimestamp($minuend);
+			$subtrahendSeconds = $this->timeCalculator->getTimestamp($subtrahend);
 			return UnboundedQuantityValue::newFromNumber(
 				$minuendSeconds - $subtrahendSeconds,
-				$this->config->get( 'WBQualityConstraintsSecondUnit' )
+				$this->config->get('WBQualityConstraintsSecondUnit')
 			);
 		}
-		if ( $minuend->getType() === 'quantity' && $subtrahend->getType() === 'quantity' ) {
-			$minuendStandard = $this->standardize( $minuend );
-			$subtrahendStandard = $this->standardize( $subtrahend );
+		if ($minuend->getType() === 'quantity' && $subtrahend->getType() === 'quantity') {
+			$minuendStandard = $this->standardize($minuend);
+			$subtrahendStandard = $this->standardize($subtrahend);
 			$minuendValue = $minuendStandard->getAmount()->getValueFloat();
 			$subtrahendValue = $subtrahendStandard->getAmount()->getValueFloat();
 			$diff = $minuendValue - $subtrahendValue;
 			// we don’t check whether both quantities have the same standard unit –
 			// that’s the job of a different constraint type, Units (T164372)
-			return UnboundedQuantityValue::newFromNumber( $diff, $minuendStandard->getUnit() );
+			return UnboundedQuantityValue::newFromNumber($diff, $minuendStandard->getUnit());
 		}
 
-		throw new InvalidArgumentException( 'Unsupported or different data value types' );
+		throw new InvalidArgumentException('Unsupported or different data value types');
 	}
 
-	public function getDifferenceInYears( TimeValue $minuend, TimeValue $subtrahend ) {
-		if ( !preg_match( '/^([-+]\d{1,16})-(.*)$/', $minuend->getTime(), $minuendMatches ) ||
-			!preg_match( '/^([-+]\d{1,16})-(.*)$/', $subtrahend->getTime(), $subtrahendMatches )
+	public function getDifferenceInYears(TimeValue $minuend, TimeValue $subtrahend) {
+		if (!preg_match('/^([-+]\d{1,16})-(.*)$/', $minuend->getTime(), $minuendMatches) ||
+			!preg_match('/^([-+]\d{1,16})-(.*)$/', $subtrahend->getTime(), $subtrahendMatches)
 		) {
-			throw new InvalidArgumentException( 'TimeValue::getTime() did not match expected format' );
+			throw new InvalidArgumentException('TimeValue::getTime() did not match expected format');
 		}
-		$minuendYear = (float)$minuendMatches[1];
-		$subtrahendYear = (float)$subtrahendMatches[1];
+		$minuendYear = (float) $minuendMatches[1];
+		$subtrahendYear = (float) $subtrahendMatches[1];
 		$minuendRest = $minuendMatches[2];
 		$subtrahendRest = $subtrahendMatches[2];
 
 		// calculate difference of years
 		$diff = $minuendYear - $subtrahendYear;
-		if ( $minuendYear > 0.0 && $subtrahendYear < 0.0 ) {
+		if ($minuendYear > 0.0 && $subtrahendYear < 0.0) {
 			$diff -= 1.0; // there is no year 0, remove it from difference
-		} elseif ( $minuendYear < 0.0 && $subtrahendYear > 0.0 ) {
+		} elseif ($minuendYear < 0.0 && $subtrahendYear > 0.0) {
 			$diff -= -1.0; // there is no year 0, remove it from negative difference
 		}
 
 		// adjust for date within year by parsing the month-day part within the same year
-		$minuendDateValue = $this->timeParser->parse( '+0000000000001970-' . $minuendRest );
-		$subtrahendDateValue = $this->timeParser->parse( '+0000000000001970-' . $subtrahendRest );
-		$minuendDateSeconds = $this->timeCalculator->getTimestamp( $minuendDateValue );
-		$subtrahendDateSeconds = $this->timeCalculator->getTimestamp( $subtrahendDateValue );
-		if ( $minuendDateSeconds < $subtrahendDateSeconds ) {
+		$minuendDateValue = $this->timeParser->parse('+0000000000001970-'.$minuendRest);
+		$subtrahendDateValue = $this->timeParser->parse('+0000000000001970-'.$subtrahendRest);
+		$minuendDateSeconds = $this->timeCalculator->getTimestamp($minuendDateValue);
+		$subtrahendDateSeconds = $this->timeCalculator->getTimestamp($subtrahendDateValue);
+		if ($minuendDateSeconds < $subtrahendDateSeconds) {
 			// difference in the last year is actually less than one full year
 			// e. g. 1975-03-01 - 1974-09-01 is just six months
 			// (we don’t need sub-year precision in the difference, adjusting by 0.5 is enough)
 			$diff -= 0.5;
-		} elseif ( $minuendDateSeconds > $subtrahendDateSeconds ) {
+		} elseif ($minuendDateSeconds > $subtrahendDateSeconds) {
 			// difference in the last year is actually more than one full year
 			// e. g. 1975-09-01 - 1974-03-01 is 18 months
 			// (we don’t need sub-year precision in the difference, adjusting by 0.5 is enough)
 			$diff += 0.5;
 		}
 
-		$unit = $this->config->get( 'WBQualityConstraintsYearUnit' );
-		return UnboundedQuantityValue::newFromNumber( $diff, $unit );
+		$unit = $this->config->get('WBQualityConstraintsYearUnit');
+		return UnboundedQuantityValue::newFromNumber($diff, $unit);
 	}
 
-	public function isFutureTime( TimeValue $timeValue ) {
-		return $this->timeValueComparer->isFutureTime( $timeValue );
+	public function isFutureTime(TimeValue $timeValue) {
+		return $this->timeValueComparer->isFutureTime($timeValue);
 	}
 
 }