wikimedia / mediawiki-extensions-WikibaseQualityConstraints

WikibaseQualityConstraints.alias.php

Spacing +1 added lines, -1 removed lines

@@ -10,5 +10,5 @@
 
 /** English (English) */
 $specialPageAliases['en'] = [
-	'ConstraintReport' => [ 'ConstraintReport', 'Constraint Report' ],
+	'ConstraintReport' => ['ConstraintReport', 'Constraint Report'],
 ];

src/ConstraintCheck/Helper/RangeCheckerHelper.php

Doc Comments +2 added lines, -2 removed lines

@@ -119,8 +119,8 @@
 	 * for quantity values, the difference is the numerical difference between the quantities,
 	 * after attempting normalization of each side.
 	 *
-	 * @param TimeValue|QuantityValue|UnboundedQuantityValue $minuend
-	 * @param TimeValue|QuantityValue|UnboundedQuantityValue $subtrahend
+	 * @param DataValue $minuend
+	 * @param DataValue $subtrahend
 	 *
 	 * @throws InvalidArgumentException if the values do not both have the same, supported data value type
 	 * @return UnboundedQuantityValue

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);
 	}
 
 }

src/ConstraintLookup.php

Spacing +1 added lines, -1 removed lines

@@ -14,6 +14,6 @@
 	 *
 	 * @return Constraint[]
 	 */
-	public function queryConstraintsForProperty( PropertyId $propertyId );
+	public function queryConstraintsForProperty(PropertyId $propertyId);
 
 }

src/CachingConstraintLookup.php

Spacing +4 added lines, -4 removed lines

@@ -26,7 +26,7 @@ 
 	/**
 	 * @var 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/Role.php

Spacing +1 added lines, -1 removed lines

@@ -72,7 +72,7 @@
 	 * @codeCoverageIgnore
 	 */
 	private function __construct() {
-		throw new LogicException( 'This class should never be instantiated.' );
+		throw new LogicException('This class should never be instantiated.');
 	}
 
 }

src/ConstraintCheck/ConstraintChecker.php

Spacing +2 added lines, -2 removed lines

@@ -22,7 +22,7 @@ 
 	 * @throws ConstraintParameterException if the constraint parameters are invalid
 	 * @throws SparqlHelperException if the checker uses SPARQL and the query times out or some other error occurs
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint );
+	public function checkConstraint(Context $context, Constraint $constraint);
 
 	/**
 	 * Check if the constraint parameters of $constraint are valid.
@@ -33,6 +33,6 @@ 
 	 *
 	 * @return ConstraintParameterException[]
 	 */
-	public function checkConstraintParameters( Constraint $constraint );
+	public function checkConstraintParameters(Constraint $constraint);
 
 }

src/ConstraintCheck/Cache/CachedArray.php

Spacing +1 added lines, -1 removed lines

@@ -20,7 +20,7 @@
 	 */
 	private $metadata;
 
-	public function __construct( array $array, Metadata $metadata ) {
+	public function __construct(array $array, Metadata $metadata) {
 		$this->array = $array;
 		$this->metadata = $metadata;
 	}

src/ConstraintCheck/Cache/CachedBool.php

Spacing +1 added lines, -1 removed lines

@@ -24,7 +24,7 @@
 	 * @param bool $bool
 	 * @param Metadata $metadata
 	 */
-	public function __construct( $bool, Metadata $metadata ) {
+	public function __construct($bool, Metadata $metadata) {
 		$this->bool = $bool;
 		$this->metadata = $metadata;
 	}

src/ConstraintCheck/Cache/Metadata.php

Spacing +7 added lines, -7 removed lines

@@ -32,14 +32,14 @@ 
 		return $ret;
 	}
 
-	public static function ofCachingMetadata( CachingMetadata $cachingMetadata ) {
+	public static function ofCachingMetadata(CachingMetadata $cachingMetadata) {
 		$ret = new self;
 		$ret->cachingMetadata = $cachingMetadata;
 		$ret->dependencyMetadata = DependencyMetadata::blank();
 		return $ret;
 	}
 
-	public static function ofDependencyMetadata( DependencyMetadata $dependencyMetadata ) {
+	public static function ofDependencyMetadata(DependencyMetadata $dependencyMetadata) {
 		$ret = new self;
 		$ret->cachingMetadata = CachingMetadata::fresh();
 		$ret->dependencyMetadata = $dependencyMetadata;
@@ -50,17 +50,17 @@ 
 	 * @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');
 		$cachingMetadatas = [];
 		$dependencyMetadatas = [];
-		foreach ( $metadatas as $metadata ) {
+		foreach ($metadatas as $metadata) {
 			$cachingMetadatas[] = $metadata->cachingMetadata;
 			$dependencyMetadatas[] = $metadata->dependencyMetadata;
 		}
 		$ret = new self;
-		$ret->cachingMetadata = CachingMetadata::merge( $cachingMetadatas );
-		$ret->dependencyMetadata = DependencyMetadata::merge( $dependencyMetadatas );
+		$ret->cachingMetadata = CachingMetadata::merge($cachingMetadatas);
+		$ret->dependencyMetadata = DependencyMetadata::merge($dependencyMetadatas);
 		return $ret;
 	}