wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintCheck/Context/AbstractContext.php

Spacing +1 added lines, -1 removed lines

@@ -23,7 +23,7 @@
 	 */
 	protected $snak;
 
-	public function __construct( StatementListProvidingEntity $entity, Snak $snak ) {
+	public function __construct(StatementListProvidingEntity $entity, Snak $snak) {
 		$this->entity = $entity;
 		$this->snak = $snak;
 	}

src/ConstraintCheck/Checker/ConflictsWithChecker.php

Spacing +20 added lines, -20 removed lines

@@ -71,9 +71,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 = [];
@@ -84,7 +84,7 @@ 
 			$constraintParameters,
 			$constraintTypeItemId
 		);
-		$parameters['property'] = [ $propertyId ];
+		$parameters['property'] = [$propertyId];
 
 		$items = $this->constraintParameterParser->parseItemsParameter(
 			$constraintParameters,
@@ -95,22 +95,22 @@ 
 
 		$statementList = $context->getEntity()
 			->getStatements()
-			->getByRank( [ Statement::RANK_PREFERRED, Statement::RANK_NORMAL ] );
+			->getByRank([Statement::RANK_PREFERRED, Statement::RANK_NORMAL]);
 
 		/*
 		 * 'Conflicts with' can be defined with
 		 *   a) a property only
 		 *   b) a property and a number of items (each combination of property and item forming an individual claim)
 		 */
-		if ( $items === [] ) {
+		if ($items === []) {
 			$offendingStatement = $this->connectionCheckerHelper->findStatementWithProperty(
 				$statementList,
 				$propertyId
 			);
-			if ( $offendingStatement !== null ) {
-				$message = ( new ViolationMessage( 'wbqc-violation-message-conflicts-with-property' ) )
-					->withEntityId( $context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY )
-					->withEntityId( $propertyId, Role::PREDICATE );
+			if ($offendingStatement !== null) {
+				$message = (new ViolationMessage('wbqc-violation-message-conflicts-with-property'))
+					->withEntityId($context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY)
+					->withEntityId($propertyId, Role::PREDICATE);
 				$status = CheckResult::STATUS_VIOLATION;
 			} else {
 				$message = null;
@@ -122,12 +122,12 @@ 
 				$propertyId,
 				$items
 			);
-			if ( $offendingStatement !== null ) {
-				$offendingValue = ItemIdSnakValue::fromSnak( $offendingStatement->getMainSnak() );
-				$message = ( new ViolationMessage( 'wbqc-violation-message-conflicts-with-claim' ) )
-					->withEntityId( $context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY )
-					->withEntityId( $propertyId, Role::PREDICATE )
-					->withItemIdSnakValue( $offendingValue, Role::OBJECT );
+			if ($offendingStatement !== null) {
+				$offendingValue = ItemIdSnakValue::fromSnak($offendingStatement->getMainSnak());
+				$message = (new ViolationMessage('wbqc-violation-message-conflicts-with-claim'))
+					->withEntityId($context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY)
+					->withEntityId($propertyId, Role::PREDICATE)
+					->withItemIdSnakValue($offendingValue, Role::OBJECT);
 				$status = CheckResult::STATUS_VIOLATION;
 			} else {
 				$message = null;
@@ -135,10 +135,10 @@ 
 			}
 		}
 
-		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();
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
 		$exceptions = [];
@@ -147,7 +147,7 @@ 
 				$constraintParameters,
 				$constraintTypeItemId
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		try {
@@ -156,7 +156,7 @@ 
 				$constraintTypeItemId,
 				false
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/ConstraintCheck/Message/ViolationMessageDeserializer.php

Spacing +32 added lines, -32 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',
@@ -87,23 +87,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;
 	}
 
@@ -111,32 +111,32 @@ 
 	 * @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:
-				$itemId = $this->deserializeEntityId( $valueSerialization );
+				$itemId = $this->deserializeEntityId($valueSerialization);
 				'@phan-var \Wikibase\DataModel\Entity\ItemId $itemId';
-				return ItemIdSnakValue::fromItemId( $itemId );
+				return ItemIdSnakValue::fromItemId($itemId);
 		}
 	}
 
@@ -144,24 +144,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 $contextTypeAbbreviation
 	 * @return string one of the Context::TYPE_* constants
 	 */
-	private function deserializeContextType( $contextTypeAbbreviation ) {
-		switch ( $contextTypeAbbreviation ) {
+	private function deserializeContextType($contextTypeAbbreviation) {
+		switch ($contextTypeAbbreviation) {
 			case 's':
 				return Context::TYPE_STATEMENT;
 			case 'q':
@@ -171,7 +171,7 @@ 
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					'Unknown context type abbreviation ' . $contextTypeAbbreviation
+					'Unknown context type abbreviation '.$contextTypeAbbreviation
 				);
 				// @codeCoverageIgnoreEnd
 		}
@@ -181,16 +181,16 @@ 
 	 * @param string[] $contextTypeAbbreviations
 	 * @return string[] Context::TYPE_* constants
 	 */
-	private function deserializeContextTypeList( array $contextTypeAbbreviations ) {
-		return array_map( [ $this, 'deserializeContextType' ], $contextTypeAbbreviations );
+	private function deserializeContextTypeList(array $contextTypeAbbreviations) {
+		return array_map([$this, 'deserializeContextType'], $contextTypeAbbreviations);
 	}
 
 	/**
 	 * @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/Checker/DiffWithinRangeChecker.php

Spacing +41 added lines, -42 removed lines

@@ -76,8 +76,8 @@ 
 	 * @throws ConstraintParameterException
 	 * @return array [ DataValue|null $min, DataValue|null $max, PropertyId $property, array $parameters ]
 	 */
-	private function parseConstraintParameters( Constraint $constraint ) {
-		list( $min, $max ) = $this->constraintParameterParser->parseQuantityRangeParameter(
+	private function parseConstraintParameters(Constraint $constraint) {
+		list($min, $max) = $this->constraintParameterParser->parseQuantityRangeParameter(
 			$constraint->getConstraintParameters(),
 			$constraint->getConstraintTypeItemId()
 		);
@@ -87,15 +87,15 @@ 
 		);
 
 		$parameters = [];
-		if ( $min !== null ) {
-			$parameters['minimum_quantity'] = [ $min ];
+		if ($min !== null) {
+			$parameters['minimum_quantity'] = [$min];
 		}
-		if ( $max !== null ) {
-			$parameters['maximum_quantity'] = [ $max ];
+		if ($max !== null) {
+			$parameters['maximum_quantity'] = [$max];
 		}
-		$parameters['property'] = [ $property ];
+		$parameters['property'] = [$property];
 
-		return [ $min, $max, $property, $parameters ];
+		return [$min, $max, $property, $parameters];
 	}
 
 	/**
@@ -105,13 +105,13 @@ 
 	 *
 	 * @return bool
 	 */
-	private function rangeInYears( $min, $max ) {
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
+	private function rangeInYears($min, $max) {
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
 
-		if ( $min !== null && $min->getUnit() === $yearUnit ) {
+		if ($min !== null && $min->getUnit() === $yearUnit) {
 			return true;
 		}
-		if ( $max !== null && $max->getUnit() === $yearUnit ) {
+		if ($max !== null && $max->getUnit() === $yearUnit) {
 			return true;
 		}
 
@@ -127,30 +127,30 @@ 
 	 * @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 = [];
 
 		$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);
 		}
 
 		$minuend = $snak->getDataValue();
 		'@phan-var \DataValues\TimeValue|\DataValues\QuantityValue|\DataValues\UnboundedQuantityValue $minuend';
 
 		/** @var PropertyId $property */
-		list( $min, $max, $property, $parameters ) = $this->parseConstraintParameters( $constraint );
+		list($min, $max, $property, $parameters) = $this->parseConstraintParameters($constraint);
 
 		// checks only the first occurrence of the referenced property
-		foreach ( $context->getSnakGroup( Context::GROUP_NON_DEPRECATED ) as $otherSnak ) {
+		foreach ($context->getSnakGroup(Context::GROUP_NON_DEPRECATED) as $otherSnak) {
 			if (
-				!$property->equals( $otherSnak->getPropertyId() ) ||
+				!$property->equals($otherSnak->getPropertyId()) ||
 				!$otherSnak instanceof PropertyValueSnak
 			) {
 				continue;
@@ -158,30 +158,29 @@ 
 
 			$subtrahend = $otherSnak->getDataValue();
 			'@phan-var \DataValues\TimeValue|\DataValues\QuantityValue|\DataValues\UnboundedQuantityValue $subtrahend';
-			if ( $subtrahend->getType() === $minuend->getType() ) {
-				$diff = $this->rangeInYears( $min, $max ) && $minuend->getType() === 'time' ?
-					$this->rangeCheckerHelper->getDifferenceInYears( $minuend, $subtrahend ) :
-					$this->rangeCheckerHelper->getDifference( $minuend, $subtrahend );
+			if ($subtrahend->getType() === $minuend->getType()) {
+				$diff = $this->rangeInYears($min, $max) && $minuend->getType() === 'time' ?
+					$this->rangeCheckerHelper->getDifferenceInYears($minuend, $subtrahend) : $this->rangeCheckerHelper->getDifference($minuend, $subtrahend);
 
-				if ( $this->rangeCheckerHelper->getComparison( $min, $diff ) > 0 ||
-					$this->rangeCheckerHelper->getComparison( $diff, $max ) > 0
+				if ($this->rangeCheckerHelper->getComparison($min, $diff) > 0 ||
+					$this->rangeCheckerHelper->getComparison($diff, $max) > 0
 				) {
 					// at least one of $min, $max is set at this point, otherwise there could be no violation
-					$openness = $min !== null ? ( $max !== null ? '' : '-rightopen' ) : '-leftopen';
+					$openness = $min !== null ? ($max !== null ? '' : '-rightopen') : '-leftopen';
 					// possible message keys:
 					// wbqc-violation-message-diff-within-range
 					// wbqc-violation-message-diff-within-range-leftopen
 					// wbqc-violation-message-diff-within-range-rightopen
-					$message = ( new ViolationMessage( "wbqc-violation-message-diff-within-range$openness" ) )
-						->withEntityId( $context->getSnak()->getPropertyId(), Role::PREDICATE )
-						->withDataValue( $minuend, Role::OBJECT )
-						->withEntityId( $otherSnak->getPropertyId(), Role::PREDICATE )
-						->withDataValue( $subtrahend, Role::OBJECT );
-					if ( $min !== null ) {
-						$message = $message->withDataValue( $min, Role::OBJECT );
+					$message = (new ViolationMessage("wbqc-violation-message-diff-within-range$openness"))
+						->withEntityId($context->getSnak()->getPropertyId(), Role::PREDICATE)
+						->withDataValue($minuend, Role::OBJECT)
+						->withEntityId($otherSnak->getPropertyId(), Role::PREDICATE)
+						->withDataValue($subtrahend, Role::OBJECT);
+					if ($min !== null) {
+						$message = $message->withDataValue($min, Role::OBJECT);
 					}
-					if ( $max !== null ) {
-						$message = $message->withDataValue( $max, Role::OBJECT );
+					if ($max !== null) {
+						$message = $message->withDataValue($max, Role::OBJECT);
 					}
 					$status = CheckResult::STATUS_VIOLATION;
 				} else {
@@ -189,17 +188,17 @@ 
 					$status = CheckResult::STATUS_COMPLIANCE;
 				}
 			} else {
-				$message = new ViolationMessage( 'wbqc-violation-message-diff-within-range-must-have-equal-types' );
+				$message = new ViolationMessage('wbqc-violation-message-diff-within-range-must-have-equal-types');
 				$status = CheckResult::STATUS_VIOLATION;
 			}
 
-			return new CheckResult( $context, $constraint, $parameters, $status, $message );
+			return new CheckResult($context, $constraint, $parameters, $status, $message);
 		}
 
-		return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE );
+		return new CheckResult($context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE);
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ) {
+	public function checkConstraintParameters(Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
 		$exceptions = [];
@@ -208,7 +207,7 @@ 
 				$constraintParameters,
 				$constraintTypeItemId
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		try {
@@ -216,7 +215,7 @@ 
 				$constraintParameters,
 				$constraintTypeItemId
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;

src/ConstraintCheck/Helper/RangeCheckerHelper.php

Spacing +43 added lines, -43 removed lines

@@ -53,7 +53,7 @@ 
 		$this->config = $config;
 		$this->timeParser = new IsoTimestampParser();
 		$this->timeCalculator = new TimeValueCalculator();
-		$this->timeValueComparer = new TimeValueComparer( $this->timeCalculator );
+		$this->timeValueComparer = new TimeValueComparer($this->timeCalculator);
 		$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,33 +86,33 @@ 
 	 *                 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 */
 				'@phan-var TimeValue $lhs';
 				'@phan-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 */
 				'@phan-var QuantityValue|UnboundedQuantityValue $lhs';
 				'@phan-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');
 	}
 
 	/**
@@ -127,71 +127,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);
 	}
 
 }

src/ConstraintCheck/Context/ContextCursorSerializer.php

Spacing +4 added lines, -4 removed lines

@@ -13,8 +13,8 @@ 
 	 * @param ContextCursor $cursor
 	 * @return array
 	 */
-	public function serialize( ContextCursor $cursor ) {
-		if ( $cursor instanceof EntityContextCursor ) {
+	public function serialize(ContextCursor $cursor) {
+		if ($cursor instanceof EntityContextCursor) {
 			return [
 				't' => '\entity',
 				'i' => $cursor->getEntityId(),
@@ -30,9 +30,9 @@ 
 			'h' => $cursor->getSnakHash(),
 		];
 
-		if ( $type === Context::TYPE_QUALIFIER || $type === Context::TYPE_REFERENCE ) {
+		if ($type === Context::TYPE_QUALIFIER || $type === Context::TYPE_REFERENCE) {
 			$serialization['P'] = $cursor->getSnakPropertyId();
-			if ( $type === Context::TYPE_REFERENCE ) {
+			if ($type === Context::TYPE_REFERENCE) {
 				/** @var ReferenceContextCursor $cursor */
 				'@phan-var ReferenceContextCursor $cursor';
 				$serialization['r'] = $cursor->getReferenceHash();

src/ConstraintCheck/Checker/RangeChecker.php

Spacing +38 added lines, -38 removed lines

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

src/CachingConstraintLookup.php

Spacing +4 added lines, -4 removed lines

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

src/ConstraintCheck/Context/ContextCursor.php

Spacing +1 added lines, -1 removed lines

@@ -65,6 +65,6 @@
 	 * @param ?array $result
 	 * @param array[] &$container
 	 */
-	public function storeCheckResultInArray( ?array $result, array &$container );
+	public function storeCheckResultInArray(?array $result, array &$container);
 
 }