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/Message/ViolationMessage.php

Spacing +31 added lines, -31 removed lines

@@ -110,17 +110,17 @@ 
 	public function __construct(
 		$messageKey
 	) {
-		if ( strpos( $messageKey, self::MESSAGE_KEY_PREFIX ) !== 0 ) {
+		if (strpos($messageKey, self::MESSAGE_KEY_PREFIX) !== 0) {
 			throw new InvalidArgumentException(
-				'ViolationMessage key ⧼' .
-				$messageKey .
-				'⧽ should start with "' .
-				self::MESSAGE_KEY_PREFIX .
+				'ViolationMessage key ⧼'.
+				$messageKey.
+				'⧽ should start with "'.
+				self::MESSAGE_KEY_PREFIX.
 				'".'
 			);
 		}
 
-		$this->messageKeySuffix = substr( $messageKey, strlen( self::MESSAGE_KEY_PREFIX ) );
+		$this->messageKeySuffix = substr($messageKey, strlen(self::MESSAGE_KEY_PREFIX));
 		$this->arguments = [];
 	}
 
@@ -129,7 +129,7 @@ 
 	 * @return string
 	 */
 	public function getMessageKey() {
-		return self::MESSAGE_KEY_PREFIX . $this->messageKeySuffix;
+		return self::MESSAGE_KEY_PREFIX.$this->messageKeySuffix;
 	}
 
 	/**
@@ -149,9 +149,9 @@ 
 	 * @param mixed $value the value, which should match the $type
 	 * @return ViolationMessage
 	 */
-	public function withArgument( $type, $role, $value ) {
+	public function withArgument($type, $role, $value) {
 		$ret = clone $this;
-		$ret->arguments[] = [ 'type' => $type, 'role' => $role, 'value' => $value ];
+		$ret->arguments[] = ['type' => $type, 'role' => $role, 'value' => $value];
 		return $ret;
 	}
 
@@ -163,8 +163,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withEntityId( EntityId $entityId, $role = null ) {
-		return $this->withArgument( self::TYPE_ENTITY_ID, $role, $entityId );
+	public function withEntityId(EntityId $entityId, $role = null) {
+		return $this->withArgument(self::TYPE_ENTITY_ID, $role, $entityId);
 	}
 
 	/**
@@ -181,8 +181,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withEntityIdList( array $entityIdList, $role = null ) {
-		return $this->withArgument( self::TYPE_ENTITY_ID_LIST, $role, $entityIdList );
+	public function withEntityIdList(array $entityIdList, $role = null) {
+		return $this->withArgument(self::TYPE_ENTITY_ID_LIST, $role, $entityIdList);
 	}
 
 	/**
@@ -193,8 +193,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withItemIdSnakValue( ItemIdSnakValue $value, $role = null ) {
-		return $this->withArgument( self::TYPE_ITEM_ID_SNAK_VALUE, $role, $value );
+	public function withItemIdSnakValue(ItemIdSnakValue $value, $role = null) {
+		return $this->withArgument(self::TYPE_ITEM_ID_SNAK_VALUE, $role, $value);
 	}
 
 	/**
@@ -211,8 +211,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withItemIdSnakValueList( array $valueList, $role = null ) {
-		return $this->withArgument( self::TYPE_ITEM_ID_SNAK_VALUE_LIST, $role, $valueList );
+	public function withItemIdSnakValueList(array $valueList, $role = null) {
+		return $this->withArgument(self::TYPE_ITEM_ID_SNAK_VALUE_LIST, $role, $valueList);
 	}
 
 	/**
@@ -223,8 +223,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withDataValue( DataValue $dataValue, $role = null ) {
-		return $this->withArgument( self::TYPE_DATA_VALUE, $role, $dataValue );
+	public function withDataValue(DataValue $dataValue, $role = null) {
+		return $this->withArgument(self::TYPE_DATA_VALUE, $role, $dataValue);
 	}
 
 	/**
@@ -239,8 +239,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withDataValueType( $dataValueType, $role = null ) {
-		return $this->withArgument( self::TYPE_DATA_VALUE_TYPE, $role, $dataValueType );
+	public function withDataValueType($dataValueType, $role = null) {
+		return $this->withArgument(self::TYPE_DATA_VALUE_TYPE, $role, $dataValueType);
 	}
 
 	/**
@@ -251,8 +251,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withInlineCode( $code, $role = null ) {
-		return $this->withArgument( self::TYPE_INLINE_CODE, $role, $code );
+	public function withInlineCode($code, $role = null) {
+		return $this->withArgument(self::TYPE_INLINE_CODE, $role, $code);
 	}
 
 	/**
@@ -263,8 +263,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withConstraintScope( $scope, $role = null ) {
-		return $this->withArgument( self::TYPE_CONSTRAINT_SCOPE, $role, $scope );
+	public function withConstraintScope($scope, $role = null) {
+		return $this->withArgument(self::TYPE_CONSTRAINT_SCOPE, $role, $scope);
 	}
 
 	/**
@@ -275,8 +275,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withConstraintScopeList( array $scopeList, $role = null ) {
-		return $this->withArgument( self::TYPE_CONSTRAINT_SCOPE_LIST, $role, $scopeList );
+	public function withConstraintScopeList(array $scopeList, $role = null) {
+		return $this->withArgument(self::TYPE_CONSTRAINT_SCOPE_LIST, $role, $scopeList);
 	}
 
 	/**
@@ -291,8 +291,8 @@ 
 	 * @param string $languageCode
 	 * @return ViolationMessage
 	 */
-	public function withLanguage( $languageCode ) {
-		return $this->withArgument( self::TYPE_LANGUAGE, null, $languageCode );
+	public function withLanguage($languageCode) {
+		return $this->withArgument(self::TYPE_LANGUAGE, null, $languageCode);
 	}
 
 	/**
@@ -307,8 +307,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withMultilingualText( MultilingualTextValue $text, $role = null ) {
-		return $this->withArgument( self::TYPE_MULTILINGUAL_TEXT, $role, $text );
+	public function withMultilingualText(MultilingualTextValue $text, $role = null) {
+		return $this->withArgument(self::TYPE_MULTILINGUAL_TEXT, $role, $text);
 	}
 
 }

src/ConstraintCheck/Checker/FormatChecker.php

Spacing +25 added lines, -25 removed lines

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

src/ConstraintCheck/Message/ViolationMessageDeserializer.php

Spacing +31 added lines, -31 removed lines

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

src/ConstraintCheck/Message/ViolationMessageSerializer.php

Spacing +28 added lines, -28 removed lines

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

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