wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintRepository.php

Spacing +42 added lines, -42 removed lines

@@ -21,23 +21,23 @@ 
 	 *
 	 * @return Constraint[]
 	 */
-	public function queryConstraintsForProperty( PropertyId $propertyId ) {
-		$db = wfGetDB( DB_REPLICA );
+	public function queryConstraintsForProperty(PropertyId $propertyId) {
+		$db = wfGetDB(DB_REPLICA);
 
 		$results = $db->select(
 			'wbqc_constraints',
 			'*',
-			[ 'pid' => $propertyId->getNumericId() ]
+			['pid' => $propertyId->getNumericId()]
 		);
 
-		return $this->convertToConstraints( $results );
+		return $this->convertToConstraints($results);
 	}
 
-	private function encodeConstraintParameters( array $constraintParameters ) {
-		$json = json_encode( $constraintParameters, JSON_FORCE_OBJECT );
+	private function encodeConstraintParameters(array $constraintParameters) {
+		$json = json_encode($constraintParameters, JSON_FORCE_OBJECT);
 
-		if ( strlen( $json ) > 50000 ) {
-			$json = json_encode( [ '@error' => [ 'toolong' => true ] ] );
+		if (strlen($json) > 50000) {
+			$json = json_encode(['@error' => ['toolong' => true]]);
 		}
 
 		return $json;
@@ -49,21 +49,21 @@ 
 	 * @throws DBUnexpectedError
 	 * @return bool
 	 */
-	public function insertBatch( array $constraints ) {
+	public function insertBatch(array $constraints) {
 		$accumulator = array_map(
-			function ( Constraint $constraint ) {
+			function(Constraint $constraint) {
 				return [
 					'constraint_guid' => $constraint->getConstraintId(),
 					'pid' => $constraint->getPropertyId()->getNumericId(),
 					'constraint_type_qid' => $constraint->getConstraintTypeItemId(),
-					'constraint_parameters' => $this->encodeConstraintParameters( $constraint->getConstraintParameters() )
+					'constraint_parameters' => $this->encodeConstraintParameters($constraint->getConstraintParameters())
 				];
 			},
 			$constraints
 		);
 
-		$db = wfGetDB( DB_MASTER );
-		return $db->insert( 'wbqc_constraints', $accumulator );
+		$db = wfGetDB(DB_MASTER);
+		return $db->insert('wbqc_constraints', $accumulator);
 	}
 
 	/**
@@ -71,13 +71,13 @@ 
 	 *
 	 * @return array
 	 */
-	private function uuidPattern( LikeMatch $any ) {
+	private function uuidPattern(LikeMatch $any) {
 		return array_merge(
-			array_fill( 0, 8, $any ), [ '-' ],
-			array_fill( 0, 4, $any ), [ '-' ],
-			array_fill( 0, 4, $any ), [ '-' ],
-			array_fill( 0, 4, $any ), [ '-' ],
-			array_fill( 0, 12, $any )
+			array_fill(0, 8, $any), ['-'],
+			array_fill(0, 4, $any), ['-'],
+			array_fill(0, 4, $any), ['-'],
+			array_fill(0, 4, $any), ['-'],
+			array_fill(0, 12, $any)
 		);
 	}
 
@@ -88,11 +88,11 @@ 
 	 * @throws DBUnexpectedError
 	 */
 	public function deleteWhereConstraintIdIsUuid() {
-		$db = wfGetDB( DB_MASTER );
+		$db = wfGetDB(DB_MASTER);
 		$db->delete(
 			'wbqc_constraints',
 			// WHERE constraint_guid LIKE ________-____-____-____-____________
-			'constraint_guid ' . $db->buildLike( $this->uuidPattern( $db->anyChar() ) )
+			'constraint_guid '.$db->buildLike($this->uuidPattern($db->anyChar()))
 		);
 	}
 
@@ -104,14 +104,14 @@ 
 	 *
 	 * @throws DBUnexpectedError
 	 */
-	public function deleteForPropertyWhereConstraintIdIsStatementId( PropertyId $propertyId ) {
-		$db = wfGetDB( DB_MASTER );
+	public function deleteForPropertyWhereConstraintIdIsStatementId(PropertyId $propertyId) {
+		$db = wfGetDB(DB_MASTER);
 		$db->delete(
 			'wbqc_constraints',
 			[
 				'pid' => $propertyId->getNumericId(),
 				// AND constraint_guid LIKE %$________-____-____-____-____________
-				'constraint_guid ' . $db->buildLike( array_merge( [ $db->anyString(), '$' ], $this->uuidPattern( $db->anyChar() ) ) )
+				'constraint_guid '.$db->buildLike(array_merge([$db->anyString(), '$'], $this->uuidPattern($db->anyChar())))
 			]
 		);
 	}
@@ -122,21 +122,21 @@ 
 	 * @throws InvalidArgumentException
 	 * @throws DBUnexpectedError
 	 */
-	public function deleteAll( $batchSize = 1000 ) {
-		if ( !is_int( $batchSize ) ) {
+	public function deleteAll($batchSize = 1000) {
+		if (!is_int($batchSize)) {
 			throw new InvalidArgumentException();
 		}
 		$lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
-		$db = $lbFactory->getMainLB()->getConnection( DB_MASTER );
-		if ( $db->getType() === 'sqlite' ) {
-			$db->delete( 'wbqc_constraints', '*' );
+		$db = $lbFactory->getMainLB()->getConnection(DB_MASTER);
+		if ($db->getType() === 'sqlite') {
+			$db->delete('wbqc_constraints', '*');
 		} else {
 			do {
-				$db->commit( __METHOD__, 'flush' );
+				$db->commit(__METHOD__, 'flush');
 				$lbFactory->waitForReplication();
-				$table = $db->tableName( 'wbqc_constraints' );
-				$db->query( sprintf( 'DELETE FROM %s LIMIT %d', $table, $batchSize ) );
-			} while ( $db->affectedRows() > 0 );
+				$table = $db->tableName('wbqc_constraints');
+				$db->query(sprintf('DELETE FROM %s LIMIT %d', $table, $batchSize));
+			} while ($db->affectedRows() > 0);
 		}
 	}
 
@@ -145,26 +145,26 @@ 
 	 *
 	 * @return Constraint[]
 	 */
-	private function convertToConstraints( IResultWrapper $results ) {
+	private function convertToConstraints(IResultWrapper $results) {
 		$constraints = [];
-		foreach ( $results as $result ) {
+		foreach ($results as $result) {
 			$constraintTypeItemId = $result->constraint_type_qid;
-			$constraintParameters = json_decode( $result->constraint_parameters, true );
+			$constraintParameters = json_decode($result->constraint_parameters, true);
 
-			if ( $constraintParameters === null ) {
+			if ($constraintParameters === null) {
 				// T171295
-				LoggerFactory::getInstance( 'WikibaseQualityConstraints' )
-					->warning( 'Constraint {constraintId} has invalid constraint parameters.', [
+				LoggerFactory::getInstance('WikibaseQualityConstraints')
+					->warning('Constraint {constraintId} has invalid constraint parameters.', [
 						'method' => __METHOD__,
 						'constraintId' => $result->constraint_guid,
 						'constraintParameters' => $result->constraint_parameters,
-					] );
-				$constraintParameters = [ '@error' => [ /* unknown */ ] ];
+					]);
+				$constraintParameters = ['@error' => [/* unknown */]];
 			}
 
 			$constraints[] = new Constraint(
 				$result->constraint_guid,
-				PropertyId::newFromNumber( $result->pid ),
+				PropertyId::newFromNumber($result->pid),
 				$constraintTypeItemId,
 				$constraintParameters
 			);

src/ConstraintCheck/Checker/CommonsLinkChecker.php

Spacing +42 added lines, -42 removed lines

@@ -80,22 +80,22 @@ 
 	 * @return array first element is the namespace number (default namespace for TitleParser),
 	 * second element is a string to prepend to the title before giving it to the TitleParser
 	 */
-	private function getCommonsNamespace( $namespace ) {
+	private function getCommonsNamespace($namespace) {
 		// for namespace numbers see mediawiki-config repo, wmf-config/InitialiseSettings.php,
 		// 'wgExtraNamespaces' key, 'commonswiki' subkey
-		switch ( $namespace ) {
+		switch ($namespace) {
 			case '':
-				return [ NS_MAIN, '' ];
+				return [NS_MAIN, ''];
 			case 'Creator':
-				return [ 100, '' ];
+				return [100, ''];
 			case 'TimedText':
-				return [ 102, '' ];
+				return [102, ''];
 			case 'Sequence':
-				return [ 104, '' ];
+				return [104, ''];
 			case 'Institution':
-				return [ 106, '' ];
+				return [106, ''];
 			default:
-				return [ NS_MAIN, $namespace . ':' ];
+				return [NS_MAIN, $namespace.':'];
 		}
 	}
 
@@ -108,17 +108,17 @@ 
 	 * @throws ConstraintParameterException
 	 * @return CheckResult
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint ) {
+	public function checkConstraint(Context $context, Constraint $constraint) {
 		$parameters = [];
 		$constraintParameters = $constraint->getConstraintParameters();
-		$namespace = $this->constraintParameterParser->parseNamespaceParameter( $constraintParameters, $constraint->getConstraintTypeItemId() );
-		$parameters['namespace'] = [ $namespace ];
+		$namespace = $this->constraintParameterParser->parseNamespaceParameter($constraintParameters, $constraint->getConstraintTypeItemId());
+		$parameters['namespace'] = [$namespace];
 
 		$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();
@@ -128,46 +128,46 @@ 
 		 *   type of $dataValue for properties with 'Commons link' constraint has to be 'string'
 		 *   parameter $namespace can be null, works for commons galleries
 		 */
-		if ( $dataValue->getType() !== 'string' ) {
-			$message = ( new ViolationMessage( 'wbqc-violation-message-value-needed-of-type' ) )
-				->withEntityId( new ItemId( $constraint->getConstraintTypeItemId() ), Role::CONSTRAINT_TYPE_ITEM )
-				->withDataValueType( 'string' );
-			return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_VIOLATION, $message );
+		if ($dataValue->getType() !== 'string') {
+			$message = (new ViolationMessage('wbqc-violation-message-value-needed-of-type'))
+				->withEntityId(new ItemId($constraint->getConstraintTypeItemId()), Role::CONSTRAINT_TYPE_ITEM)
+				->withDataValueType('string');
+			return new CheckResult($context, $constraint, $parameters, CheckResult::STATUS_VIOLATION, $message);
 		}
 
 		$commonsLink = $dataValue->getValue();
 
 		try {
-			if ( !$this->commonsLinkIsWellFormed( $commonsLink ) ) {
-				throw new MalformedTitleException( 'wbqc-violation-message-commons-link-not-well-formed', $commonsLink ); // caught below
+			if (!$this->commonsLinkIsWellFormed($commonsLink)) {
+				throw new MalformedTitleException('wbqc-violation-message-commons-link-not-well-formed', $commonsLink); // caught below
 			}
-			list( $defaultNamespace, $prefix ) = $this->getCommonsNamespace( $namespace );
-			$title = $this->titleParser->parseTitle( $prefix . $commonsLink, $defaultNamespace );
-			if ( $this->pageExists( $title ) ) {
+			list($defaultNamespace, $prefix) = $this->getCommonsNamespace($namespace);
+			$title = $this->titleParser->parseTitle($prefix.$commonsLink, $defaultNamespace);
+			if ($this->pageExists($title)) {
 				$message = null;
 				$status = CheckResult::STATUS_COMPLIANCE;
 			} else {
-				if ( $this->valueIncludesNamespace( $commonsLink, $namespace ) ) {
-					throw new MalformedTitleException( 'wbqc-violation-message-commons-link-not-well-formed', $commonsLink ); // caught below
+				if ($this->valueIncludesNamespace($commonsLink, $namespace)) {
+					throw new MalformedTitleException('wbqc-violation-message-commons-link-not-well-formed', $commonsLink); // caught below
 				} else {
-					$message = new ViolationMessage( 'wbqc-violation-message-commons-link-no-existent' );
+					$message = new ViolationMessage('wbqc-violation-message-commons-link-no-existent');
 					$status = CheckResult::STATUS_VIOLATION;
 				}
 			}
-		} catch ( MalformedTitleException $e ) {
-			$message = new ViolationMessage( 'wbqc-violation-message-commons-link-not-well-formed' );
+		} catch (MalformedTitleException $e) {
+			$message = new ViolationMessage('wbqc-violation-message-commons-link-not-well-formed');
 			$status = CheckResult::STATUS_VIOLATION;
 		}
 
-		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->parseNamespaceParameter( $constraintParameters, $constraint->getConstraintTypeItemId() );
-		} catch ( ConstraintParameterException $e ) {
+			$this->constraintParameterParser->parseNamespaceParameter($constraintParameters, $constraint->getConstraintTypeItemId());
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;
@@ -178,20 +178,20 @@ 
 	 *
 	 * @return bool
 	 */
-	private function pageExists( TitleValue $title ) {
+	private function pageExists(TitleValue $title) {
 		$commonsWikiId = 'commonswiki';
-		if ( defined( 'MW_PHPUNIT_TEST' ) ) {
+		if (defined('MW_PHPUNIT_TEST')) {
 			$commonsWikiId = false;
 		}
 
 		$lbFactory = MediaWikiServices::getInstance()->getDBLoadBalancerFactory();
-		$dbConnection = $lbFactory->getMainLB( $commonsWikiId )->getConnection(
+		$dbConnection = $lbFactory->getMainLB($commonsWikiId)->getConnection(
 			DB_REPLICA, false, $commonsWikiId
 		);
-		$row = $dbConnection->selectRow( 'page', '*', [
+		$row = $dbConnection->selectRow('page', '*', [
 			'page_title' => $title->getDBkey(),
 			'page_namespace' => $title->getNamespace()
-		] );
+		]);
 
 		return $row !== false;
 	}
@@ -201,9 +201,9 @@ 
 	 *
 	 * @return bool
 	 */
-	private function commonsLinkIsWellFormed( $commonsLink ) {
-		$toReplace = [ "_", "%20" ];
-		$compareString = trim( str_replace( $toReplace, '', $commonsLink ) );
+	private function commonsLinkIsWellFormed($commonsLink) {
+		$toReplace = ["_", "%20"];
+		$compareString = trim(str_replace($toReplace, '', $commonsLink));
 		return $commonsLink === $compareString;
 	}
 
@@ -216,9 +216,9 @@ 
 	 *
 	 * @return bool
 	 */
-	private function valueIncludesNamespace( $value, $namespace ) {
+	private function valueIncludesNamespace($value, $namespace) {
 		return $namespace !== '' &&
-			strncasecmp( $value, $namespace . ':', strlen( $namespace ) + 1 ) === 0;
+			strncasecmp($value, $namespace.':', strlen($namespace) + 1) === 0;
 	}
 
 }

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

Spacing +9 added lines, -9 removed lines

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

src/ConstraintCheck/Helper/NowValue.php

Spacing +4 added lines, -4 removed lines

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

src/ConstraintCheck/Helper/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);
 	}
 
 }

src/ConstraintSerializer.php

Spacing +3 added lines, -3 removed lines

@@ -16,7 +16,7 @@ 
 	/**
 	 * @param bool $serializeConstraintParameters Whether to serialize constraint parameters or not.
 	 */
-	public function __construct( $serializeConstraintParameters = true ) {
+	public function __construct($serializeConstraintParameters = true) {
 		$this->serializeConstraintParameters = $serializeConstraintParameters;
 	}
 
@@ -24,13 +24,13 @@ 
 	 * @param Constraint $constraint
 	 * @return array
 	 */
-	public function serialize( Constraint $constraint ) {
+	public function serialize(Constraint $constraint) {
 		$serialization = [
 			'id' => $constraint->getConstraintId(),
 			'pid' => $constraint->getPropertyId()->getSerialization(),
 			'qid' => $constraint->getConstraintTypeItemId(),
 		];
-		if ( $this->serializeConstraintParameters ) {
+		if ($this->serializeConstraintParameters) {
 			$serialization['params'] = $constraint->getConstraintParameters();
 		}
 		return $serialization;

src/ConstraintDeserializer.php

Spacing +4 added lines, -5 removed lines

@@ -10,14 +10,13 @@
  */
 class ConstraintDeserializer {
 
-	public function deserialize( array $serialization ) {
+	public function deserialize(array $serialization) {
 		return new Constraint(
 			$serialization['id'],
-			new PropertyId( $serialization['pid'] ),
+			new PropertyId($serialization['pid']),
 			$serialization['qid'],
-			array_key_exists( 'params', $serialization ) ?
-				$serialization['params'] :
-				[]
+			array_key_exists('params', $serialization) ?
+				$serialization['params'] : []
 		);
 	}
 

src/Api/CheckConstraintParameters.php

Spacing +53 added lines, -53 removed lines

@@ -74,20 +74,20 @@ 
 	 *
 	 * @return self
 	 */
-	public static function newFromGlobalState( ApiMain $main, $name, $prefix = '' ) {
+	public static function newFromGlobalState(ApiMain $main, $name, $prefix = '') {
 		$constraintReportFactory = ConstraintReportFactory::getDefaultInstance();
 		$repo = WikibaseRepo::getDefaultInstance();
-		$helperFactory = $repo->getApiHelperFactory( RequestContext::getMain() );
+		$helperFactory = $repo->getApiHelperFactory(RequestContext::getMain());
 		$language = $repo->getUserLanguage();
 
 		$languageFallbackLabelDescriptionLookupFactory = $repo->getLanguageFallbackLabelDescriptionLookupFactory();
-		$labelDescriptionLookup = $languageFallbackLabelDescriptionLookupFactory->newLabelDescriptionLookup( $language );
+		$labelDescriptionLookup = $languageFallbackLabelDescriptionLookupFactory->newLabelDescriptionLookup($language);
 		$entityIdHtmlLinkFormatterFactory = $repo->getEntityIdHtmlLinkFormatterFactory();
-		$entityIdHtmlLinkFormatter = $entityIdHtmlLinkFormatterFactory->getEntityIdFormatter( $labelDescriptionLookup );
+		$entityIdHtmlLinkFormatter = $entityIdHtmlLinkFormatterFactory->getEntityIdFormatter($labelDescriptionLookup);
 		$formatterOptions = new FormatterOptions();
-		$formatterOptions->setOption( SnakFormatter::OPT_LANG, $language->getCode() );
+		$formatterOptions->setOption(SnakFormatter::OPT_LANG, $language->getCode());
 		$valueFormatterFactory = $repo->getValueFormatterFactory();
-		$dataValueFormatter = $valueFormatterFactory->getValueFormatter( SnakFormatter::FORMAT_HTML, $formatterOptions );
+		$dataValueFormatter = $valueFormatterFactory->getValueFormatter(SnakFormatter::FORMAT_HTML, $formatterOptions);
 		$config = MediaWikiServices::getInstance()->getMainConfig();
 		$violationMessageRenderer = new MultilingualTextViolationMessageRenderer(
 			$entityIdHtmlLinkFormatter,
@@ -126,9 +126,9 @@ 
 		StatementGuidParser $statementGuidParser,
 		IBufferingStatsdDataFactory $dataFactory
 	) {
-		parent::__construct( $main, $name, $prefix );
+		parent::__construct($main, $name, $prefix);
 
-		$this->apiErrorReporter = $apiHelperFactory->getErrorReporter( $this );
+		$this->apiErrorReporter = $apiHelperFactory->getErrorReporter($this);
 		$this->delegatingConstraintChecker = $delegatingConstraintChecker;
 		$this->violationMessageRenderer = $violationMessageRenderer;
 		$this->statementGuidParser = $statementGuidParser;
@@ -143,39 +143,39 @@ 
 		$params = $this->extractRequestParams();
 		$result = $this->getResult();
 
-		$propertyIds = $this->parsePropertyIds( $params[self::PARAM_PROPERTY_ID] );
-		$constraintIds = $this->parseConstraintIds( $params[self::PARAM_CONSTRAINT_ID] );
+		$propertyIds = $this->parsePropertyIds($params[self::PARAM_PROPERTY_ID]);
+		$constraintIds = $this->parseConstraintIds($params[self::PARAM_CONSTRAINT_ID]);
 
-		$this->checkPropertyIds( $propertyIds, $result );
-		$this->checkConstraintIds( $constraintIds, $result );
+		$this->checkPropertyIds($propertyIds, $result);
+		$this->checkConstraintIds($constraintIds, $result);
 
-		$result->addValue( null, 'success', 1 );
+		$result->addValue(null, 'success', 1);
 	}
 
 	/**
 	 * @param array|null $propertyIdSerializations
 	 * @return PropertyId[]
 	 */
-	private function parsePropertyIds( $propertyIdSerializations ) {
-		if ( $propertyIdSerializations === null ) {
+	private function parsePropertyIds($propertyIdSerializations) {
+		if ($propertyIdSerializations === null) {
 			return [];
-		} elseif ( empty( $propertyIdSerializations ) ) {
+		} elseif (empty($propertyIdSerializations)) {
 			$this->apiErrorReporter->dieError(
-				'If ' . self::PARAM_PROPERTY_ID . ' is specified, it must be nonempty.',
+				'If '.self::PARAM_PROPERTY_ID.' is specified, it must be nonempty.',
 				'no-data'
 			);
 		}
 
 		return array_map(
-			function( $propertyIdSerialization ) {
+			function($propertyIdSerialization) {
 				try {
-					return new PropertyId( $propertyIdSerialization );
-				} catch ( InvalidArgumentException $e ) {
+					return new PropertyId($propertyIdSerialization);
+				} catch (InvalidArgumentException $e) {
 					$this->apiErrorReporter->dieError(
 						"Invalid id: $propertyIdSerialization",
 						'invalid-property-id',
 						0, // default argument
-						[ self::PARAM_PROPERTY_ID => $propertyIdSerialization ]
+						[self::PARAM_PROPERTY_ID => $propertyIdSerialization]
 					);
 				}
 			},
@@ -187,35 +187,35 @@ 
 	 * @param array|null $constraintIds
 	 * @return string[]
 	 */
-	private function parseConstraintIds( $constraintIds ) {
-		if ( $constraintIds === null ) {
+	private function parseConstraintIds($constraintIds) {
+		if ($constraintIds === null) {
 			return [];
-		} elseif ( empty( $constraintIds ) ) {
+		} elseif (empty($constraintIds)) {
 			$this->apiErrorReporter->dieError(
-				'If ' . self::PARAM_CONSTRAINT_ID . ' is specified, it must be nonempty.',
+				'If '.self::PARAM_CONSTRAINT_ID.' is specified, it must be nonempty.',
 				'no-data'
 			);
 		}
 
 		return array_map(
-			function( $constraintId ) {
+			function($constraintId) {
 				try {
-					$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
-					if ( !$propertyId instanceof PropertyId ) {
+					$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
+					if (!$propertyId instanceof PropertyId) {
 						$this->apiErrorReporter->dieError(
 							"Invalid property ID: {$propertyId->getSerialization()}",
 							'invalid-property-id',
 							0, // default argument
-							[ self::PARAM_CONSTRAINT_ID => $constraintId ]
+							[self::PARAM_CONSTRAINT_ID => $constraintId]
 						);
 					}
 					return $constraintId;
-				} catch ( StatementGuidParsingException $e ) {
+				} catch (StatementGuidParsingException $e) {
 					$this->apiErrorReporter->dieError(
 						"Invalid statement GUID: $constraintId",
 						'invalid-guid',
 						0, // default argument
-						[ self::PARAM_CONSTRAINT_ID => $constraintId ]
+						[self::PARAM_CONSTRAINT_ID => $constraintId]
 					);
 				}
 			},
@@ -227,12 +227,12 @@ 
 	 * @param PropertyId[] $propertyIds
 	 * @param ApiResult $result
 	 */
-	private function checkPropertyIds( array $propertyIds, ApiResult $result ) {
-		foreach ( $propertyIds as $propertyId ) {
-			$result->addArrayType( $this->getResultPathForPropertyId( $propertyId ), 'assoc' );
-			$allConstraintExceptions = $this->delegatingConstraintChecker->checkConstraintParametersOnPropertyId( $propertyId );
-			foreach ( $allConstraintExceptions as $constraintId => $constraintParameterExceptions ) {
-				$this->addConstraintParameterExceptionsToResult( $constraintId, $constraintParameterExceptions, $result );
+	private function checkPropertyIds(array $propertyIds, ApiResult $result) {
+		foreach ($propertyIds as $propertyId) {
+			$result->addArrayType($this->getResultPathForPropertyId($propertyId), 'assoc');
+			$allConstraintExceptions = $this->delegatingConstraintChecker->checkConstraintParametersOnPropertyId($propertyId);
+			foreach ($allConstraintExceptions as $constraintId => $constraintParameterExceptions) {
+				$this->addConstraintParameterExceptionsToResult($constraintId, $constraintParameterExceptions, $result);
 			}
 		}
 	}
@@ -241,14 +241,14 @@ 
 	 * @param string[] $constraintIds
 	 * @param ApiResult $result
 	 */
-	private function checkConstraintIds( array $constraintIds, ApiResult $result ) {
-		foreach ( $constraintIds as $constraintId ) {
-			if ( $result->getResultData( $this->getResultPathForConstraintId( $constraintId ) ) ) {
+	private function checkConstraintIds(array $constraintIds, ApiResult $result) {
+		foreach ($constraintIds as $constraintId) {
+			if ($result->getResultData($this->getResultPathForConstraintId($constraintId))) {
 				// already checked as part of checkPropertyIds()
 				continue;
 			}
-			$constraintParameterExceptions = $this->delegatingConstraintChecker->checkConstraintParametersOnConstraintId( $constraintId );
-			$this->addConstraintParameterExceptionsToResult( $constraintId, $constraintParameterExceptions, $result );
+			$constraintParameterExceptions = $this->delegatingConstraintChecker->checkConstraintParametersOnConstraintId($constraintId);
+			$this->addConstraintParameterExceptionsToResult($constraintId, $constraintParameterExceptions, $result);
 		}
 	}
 
@@ -256,17 +256,17 @@ 
 	 * @param PropertyId $propertyId
 	 * @return string[]
 	 */
-	private function getResultPathForPropertyId( PropertyId $propertyId ) {
-		return [ $this->getModuleName(), $propertyId->getSerialization() ];
+	private function getResultPathForPropertyId(PropertyId $propertyId) {
+		return [$this->getModuleName(), $propertyId->getSerialization()];
 	}
 
 	/**
 	 * @param string $constraintId
 	 * @return string[]
 	 */
-	private function getResultPathForConstraintId( $constraintId ) {
-		$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
-		return array_merge( $this->getResultPathForPropertyId( $propertyId ), [ $constraintId ] );
+	private function getResultPathForConstraintId($constraintId) {
+		$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
+		return array_merge($this->getResultPathForPropertyId($propertyId), [$constraintId]);
 	}
 
 	/**
@@ -276,9 +276,9 @@ 
 	 * @param ConstraintParameterException[]|null $constraintParameterExceptions
 	 * @param ApiResult $result
 	 */
-	private function addConstraintParameterExceptionsToResult( $constraintId, $constraintParameterExceptions, ApiResult $result ) {
-		$path = $this->getResultPathForConstraintId( $constraintId );
-		if ( $constraintParameterExceptions === null ) {
+	private function addConstraintParameterExceptionsToResult($constraintId, $constraintParameterExceptions, ApiResult $result) {
+		$path = $this->getResultPathForConstraintId($constraintId);
+		if ($constraintParameterExceptions === null) {
 			$result->addValue(
 				$path,
 				self::KEY_STATUS,
@@ -288,12 +288,12 @@ 
 			$result->addValue(
 				$path,
 				self::KEY_STATUS,
-				empty( $constraintParameterExceptions ) ? self::STATUS_OKAY : self::STATUS_NOT_OKAY
+				empty($constraintParameterExceptions) ? self::STATUS_OKAY : self::STATUS_NOT_OKAY
 			);
 			$result->addValue(
 				$path,
 				self::KEY_PROBLEMS,
-				array_map( [ $this, 'formatConstraintParameterException' ], $constraintParameterExceptions )
+				array_map([$this, 'formatConstraintParameterException'], $constraintParameterExceptions)
 			);
 		}
 	}
@@ -304,7 +304,7 @@ 
 	 * @param ConstraintParameterException $e
 	 * @return array
 	 */
-	private function formatConstraintParameterException( ConstraintParameterException $e ) {
+	private function formatConstraintParameterException(ConstraintParameterException $e) {
 		return [
 			self::KEY_MESSAGE_HTML => $this->violationMessageRenderer->render(
 				$e->getViolationMessage()