wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ConstraintReportFactory.php

Spacing +49 added lines, -49 removed lines

@@ -154,7 +154,7 @@ 
 	public static function getDefaultInstance() {
 		static $instance = null;
 
-		if ( $instance === null ) {
+		if ($instance === null) {
 			$wikibaseRepo = WikibaseRepo::getDefaultInstance();
 			$entityIdFormatter = $wikibaseRepo->getEntityIdHtmlLinkFormatterFactory()->getEntityIdFormatter(
 				$wikibaseRepo->getLanguageFallbackLabelDescriptionLookupFactory()->newLabelDescriptionLookup(
@@ -235,21 +235,21 @@ 
 	 * @return DelegatingConstraintChecker
 	 */
 	public function getConstraintChecker() {
-		if ( $this->delegatingConstraintChecker === null ) {
+		if ($this->delegatingConstraintChecker === null) {
 			$this->delegatingConstraintChecker = new DelegatingConstraintChecker(
 				$this->lookup,
 				$this->getConstraintCheckerMap(),
-				new CachingConstraintLookup( $this->getConstraintRepository() ),
+				new CachingConstraintLookup($this->getConstraintRepository()),
 				$this->constraintParameterParser,
 				$this->statementGuidParser,
 				new LoggingHelper(
 					$this->dataFactory,
-					LoggerFactory::getInstance( 'WikibaseQualityConstraints' ),
+					LoggerFactory::getInstance('WikibaseQualityConstraints'),
 					$this->config
 				),
-				$this->config->get( 'WBQualityConstraintsCheckQualifiers' ),
-				$this->config->get( 'WBQualityConstraintsCheckReferences' ),
-				$this->config->get( 'WBQualityConstraintsPropertiesWithViolatingQualifiers' )
+				$this->config->get('WBQualityConstraintsCheckQualifiers'),
+				$this->config->get('WBQualityConstraintsCheckReferences'),
+				$this->config->get('WBQualityConstraintsPropertiesWithViolatingQualifiers')
 			);
 		}
 
@@ -260,10 +260,10 @@ 
 	 * @return ConstraintChecker[]
 	 */
 	private function getConstraintCheckerMap() {
-		if ( $this->constraintCheckerMap === null ) {
+		if ($this->constraintCheckerMap === null) {
 			$connectionCheckerHelper = new ConnectionCheckerHelper();
-			$rangeCheckerHelper = new RangeCheckerHelper( $this->config, $this->unitConverter );
-			if ( $this->config->get( 'WBQualityConstraintsSparqlEndpoint' ) !== '' ) {
+			$rangeCheckerHelper = new RangeCheckerHelper($this->config, $this->unitConverter);
+			if ($this->config->get('WBQualityConstraintsSparqlEndpoint') !== '') {
 				$sparqlHelper = new SparqlHelper(
 					$this->config,
 					$this->rdfVocabulary,
@@ -286,74 +286,74 @@ 
 			);
 
 			$this->constraintCheckerMap = [
-				$this->config->get( 'WBQualityConstraintsConflictsWithConstraintId' )
+				$this->config->get('WBQualityConstraintsConflictsWithConstraintId')
 					=> new ConflictsWithChecker(
 						$this->lookup,
 						$this->constraintParameterParser,
 						$connectionCheckerHelper,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsItemRequiresClaimConstraintId' )
+				$this->config->get('WBQualityConstraintsItemRequiresClaimConstraintId')
 					=> new ItemChecker(
 						$this->lookup,
 						$this->constraintParameterParser,
 						$connectionCheckerHelper,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsValueRequiresClaimConstraintId' )
+				$this->config->get('WBQualityConstraintsValueRequiresClaimConstraintId')
 					=> new TargetRequiredClaimChecker(
 						$this->lookup,
 						$this->constraintParameterParser,
 						$connectionCheckerHelper,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsSymmetricConstraintId' )
+				$this->config->get('WBQualityConstraintsSymmetricConstraintId')
 					=> new SymmetricChecker(
 						$this->lookup,
 						$connectionCheckerHelper,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsInverseConstraintId' )
+				$this->config->get('WBQualityConstraintsInverseConstraintId')
 					=> new InverseChecker(
 						$this->lookup,
 						$this->constraintParameterParser,
 						$connectionCheckerHelper,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsUsedAsQualifierConstraintId' )
+				$this->config->get('WBQualityConstraintsUsedAsQualifierConstraintId')
 					=> new QualifierChecker(),
-				$this->config->get( 'WBQualityConstraintsAllowedQualifiersConstraintId' )
+				$this->config->get('WBQualityConstraintsAllowedQualifiersConstraintId')
 					=> new QualifiersChecker(
 						$this->constraintParameterParser,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsMandatoryQualifierConstraintId' )
+				$this->config->get('WBQualityConstraintsMandatoryQualifierConstraintId')
 					=> new MandatoryQualifiersChecker(
 						$this->constraintParameterParser,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsRangeConstraintId' )
+				$this->config->get('WBQualityConstraintsRangeConstraintId')
 					=> new RangeChecker(
 						$this->propertyDataTypeLookup,
 						$this->constraintParameterParser,
 						$rangeCheckerHelper,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsDifferenceWithinRangeConstraintId' )
+				$this->config->get('WBQualityConstraintsDifferenceWithinRangeConstraintId')
 					=> new DiffWithinRangeChecker(
 						$this->constraintParameterParser,
 						$rangeCheckerHelper,
 						$this->constraintParameterRenderer,
 						$this->config
 					),
-				$this->config->get( 'WBQualityConstraintsTypeConstraintId' )
+				$this->config->get('WBQualityConstraintsTypeConstraintId')
 					=> new TypeChecker(
 						$this->lookup,
 						$this->constraintParameterParser,
 						$typeCheckerHelper,
 						$this->config
 					),
-				$this->config->get( 'WBQualityConstraintsValueTypeConstraintId' )
+				$this->config->get('WBQualityConstraintsValueTypeConstraintId')
 					=> new ValueTypeChecker(
 						$this->lookup,
 						$this->constraintParameterParser,
@@ -361,47 +361,47 @@ 
 						$typeCheckerHelper,
 						$this->config
 					),
-				$this->config->get( 'WBQualityConstraintsSingleValueConstraintId' )
+				$this->config->get('WBQualityConstraintsSingleValueConstraintId')
 					=> new SingleValueChecker(),
-				$this->config->get( 'WBQualityConstraintsMultiValueConstraintId' )
+				$this->config->get('WBQualityConstraintsMultiValueConstraintId')
 					=> new MultiValueChecker(),
-				$this->config->get( 'WBQualityConstraintsDistinctValuesConstraintId' )
+				$this->config->get('WBQualityConstraintsDistinctValuesConstraintId')
 					=> new UniqueValueChecker(
 						$this->constraintParameterRenderer,
 						$sparqlHelper
 					),
-				$this->config->get( 'WBQualityConstraintsFormatConstraintId' )
+				$this->config->get('WBQualityConstraintsFormatConstraintId')
 					=> new FormatChecker(
 						$this->constraintParameterParser,
 						$this->constraintParameterRenderer,
 						$this->config,
 						$sparqlHelper
 					),
-				$this->config->get( 'WBQualityConstraintsCommonsLinkConstraintId' )
+				$this->config->get('WBQualityConstraintsCommonsLinkConstraintId')
 					=> new CommonsLinkChecker(
 						$this->constraintParameterParser,
 						$this->constraintParameterRenderer,
 						$this->titleParser
 					),
-				$this->config->get( 'WBQualityConstraintsOneOfConstraintId' )
+				$this->config->get('WBQualityConstraintsOneOfConstraintId')
 					=> new OneOfChecker(
 						$this->constraintParameterParser,
 						$this->constraintParameterRenderer
 					),
-				$this->config->get( 'WBQualityConstraintsUsedForValuesOnlyConstraintId' )
+				$this->config->get('WBQualityConstraintsUsedForValuesOnlyConstraintId')
 					=> new ValueOnlyChecker(),
-				$this->config->get( 'WBQualityConstraintsUsedAsReferenceConstraintId' )
+				$this->config->get('WBQualityConstraintsUsedAsReferenceConstraintId')
 					=> new ReferenceChecker(),
-				$this->config->get( 'WBQualityConstraintsNoBoundsConstraintId' )
+				$this->config->get('WBQualityConstraintsNoBoundsConstraintId')
 					=> new NoBoundsChecker(),
-				$this->config->get( 'WBQualityConstraintsAllowedUnitsConstraintId' )
+				$this->config->get('WBQualityConstraintsAllowedUnitsConstraintId')
 					=> new AllowedUnitsChecker(
 						$this->constraintParameterParser,
 						$this->unitConverter
 					),
-				$this->config->get( 'WBQualityConstraintsSingleBestValueConstraintId' )
+				$this->config->get('WBQualityConstraintsSingleBestValueConstraintId')
 					=> new SingleBestValueChecker(),
-				$this->config->get( 'WBQualityConstraintsAllowedEntityTypesConstraintId' )
+				$this->config->get('WBQualityConstraintsAllowedEntityTypesConstraintId')
 					=> new EntityTypeChecker(
 						$this->constraintParameterParser,
 						$this->constraintParameterRenderer
@@ -416,26 +416,26 @@ 
 	 * @return array[]
 	 */
 	public function getConstraintParameterMap() {
-		if ( $this->constraintParameterMap === null ) {
+		if ($this->constraintParameterMap === null) {
 			$this->constraintParameterMap = [
-				'Commons link' => [ 'namespace' ],
-				'Conflicts with' => [ 'property', 'item' ],
-				'Diff within range' => [ 'property', 'minimum_quantity', 'maximum_quantity' ],
-				'Format' => [ 'pattern' ],
-				'Inverse' => [ 'property' ],
-				'Item' => [ 'property', 'item' ],
-				'Mandatory qualifiers' => [ 'property' ],
+				'Commons link' => ['namespace'],
+				'Conflicts with' => ['property', 'item'],
+				'Diff within range' => ['property', 'minimum_quantity', 'maximum_quantity'],
+				'Format' => ['pattern'],
+				'Inverse' => ['property'],
+				'Item' => ['property', 'item'],
+				'Mandatory qualifiers' => ['property'],
 				'Multi value' => [],
-				'One of' => [ 'item' ],
+				'One of' => ['item'],
 				'Qualifier' => [],
-				'Qualifiers' => [ 'property' ],
-				'Range' => [ 'minimum_quantity', 'maximum_quantity', 'minimum_date', 'maximum_date' ],
+				'Qualifiers' => ['property'],
+				'Range' => ['minimum_quantity', 'maximum_quantity', 'minimum_date', 'maximum_date'],
 				'Single value' => [],
 				'Symmetric' => [],
-				'Target required claim' => [ 'property', 'item' ],
-				'Type' => [ 'class', 'relation' ],
+				'Target required claim' => ['property', 'item'],
+				'Type' => ['class', 'relation'],
 				'Unique value' => [],
-				'Value type' => [ 'class', 'relation' ]
+				'Value type' => ['class', 'relation']
 			];
 		}
 
@@ -446,7 +446,7 @@ 
 	 * @return ConstraintRepository
 	 */
 	public function getConstraintRepository() {
-		if ( $this->constraintRepository === null ) {
+		if ($this->constraintRepository === null) {
 			$this->constraintRepository = new ConstraintRepository();
 		}
 

src/ConstraintCheck/Helper/ConstraintParameterParser.php

Spacing +258 added lines, -258 removed lines

@@ -88,15 +88,15 @@ 
 	 * @param array $parameters
 	 * @throws ConstraintParameterException
 	 */
-	public function checkError( array $parameters ) {
-		if ( array_key_exists( '@error', $parameters ) ) {
+	public function checkError(array $parameters) {
+		if (array_key_exists('@error', $parameters)) {
 			$error = $parameters['@error'];
-			if ( array_key_exists( 'toolong', $error ) && $error['toolong'] ) {
+			if (array_key_exists('toolong', $error) && $error['toolong']) {
 				$msg = 'wbqc-violation-message-parameters-error-toolong';
 			} else {
 				$msg = 'wbqc-violation-message-parameters-error-unknown';
 			}
-			throw new ConstraintParameterException( new ViolationMessage( $msg ) );
+			throw new ConstraintParameterException(new ViolationMessage($msg));
 		}
 	}
 
@@ -106,11 +106,11 @@ 
 	 * @param string $parameterId
 	 * @throws ConstraintParameterException
 	 */
-	private function requireSingleParameter( array $parameters, $parameterId ) {
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
+	private function requireSingleParameter(array $parameters, $parameterId) {
+		if (count($parameters[$parameterId]) !== 1) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-single' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-single'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -122,11 +122,11 @@ 
 	 * @return void
 	 * @throws ConstraintParameterException
 	 */
-	private function requireValueParameter( Snak $snak, $parameterId ) {
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
+	private function requireValueParameter(Snak $snak, $parameterId) {
+		if (!($snak instanceof PropertyValueSnak)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -138,17 +138,17 @@ 
 	 * @throws ConstraintParameterException
 	 * @return EntityId
 	 */
-	private function parseEntityIdParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseEntityIdParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			return $value->getEntityId();
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-entity' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-entity'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -159,20 +159,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] class entity ID serializations
 	 */
-	public function parseClassParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
+	public function parseClassParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$classId = $this->config->get('WBQualityConstraintsClassId');
+		if (!array_key_exists($classId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $classId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($classId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$classes = [];
-		foreach ( $constraintParameters[$classId] as $class ) {
-			$classes[] = $this->parseEntityIdParameter( $class, $classId )->getSerialization();
+		foreach ($constraintParameters[$classId] as $class) {
+			$classes[] = $this->parseEntityIdParameter($class, $classId)->getSerialization();
 		}
 		return $classes;
 	}
@@ -183,23 +183,23 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
 	 */
-	public function parseRelationParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
+	public function parseRelationParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$relationId = $this->config->get('WBQualityConstraintsRelationId');
+		if (!array_key_exists($relationId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $relationId );
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
-		$instanceId = $this->config->get( 'WBQualityConstraintsInstanceOfRelationId' );
-		$subclassId = $this->config->get( 'WBQualityConstraintsSubclassOfRelationId' );
-		$instanceOrSubclassId = $this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' );
-		switch ( $relationEntityId ) {
+		$this->requireSingleParameter($constraintParameters, $relationId);
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
+		$instanceId = $this->config->get('WBQualityConstraintsInstanceOfRelationId');
+		$subclassId = $this->config->get('WBQualityConstraintsSubclassOfRelationId');
+		$instanceOrSubclassId = $this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId');
+		switch ($relationEntityId) {
 			case $instanceId:
 				return 'instance';
 			case $subclassId:
@@ -208,13 +208,13 @@ 
 				return 'instanceOrSubclass';
 			default:
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-						->withEntityId( new PropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+						->withEntityId(new PropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 						->withEntityIdList(
 							[
-								new ItemId( $instanceId ),
-								new ItemId( $subclassId ),
-								new ItemId( $instanceOrSubclassId ),
+								new ItemId($instanceId),
+								new ItemId($subclassId),
+								new ItemId($instanceOrSubclassId),
 							],
 							Role::CONSTRAINT_PARAMETER_VALUE
 						)
@@ -229,20 +229,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return PropertyId
 	 */
-	private function parsePropertyIdParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parsePropertyIdParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof EntityIdValue ) {
+		if ($value instanceof EntityIdValue) {
 			$id = $value->getEntityId();
-			if ( $id instanceof PropertyId ) {
+			if ($id instanceof PropertyId) {
 				return $id;
 			}
 		}
 		throw new ConstraintParameterException(
-			( new ViolationMessage( 'wbqc-violation-message-parameter-property' ) )
-				->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-				->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+			(new ViolationMessage('wbqc-violation-message-parameter-property'))
+				->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+				->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 		);
 	}
 
@@ -253,32 +253,32 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId
 	 */
-	public function parsePropertyParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertyParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $propertyId );
-		return $this->parsePropertyIdParameter( $constraintParameters[$propertyId][0], $propertyId );
+		$this->requireSingleParameter($constraintParameters, $propertyId);
+		return $this->parsePropertyIdParameter($constraintParameters[$propertyId][0], $propertyId);
 	}
 
-	private function parseItemIdParameter( PropertyValueSnak $snak, $parameterId ) {
+	private function parseItemIdParameter(PropertyValueSnak $snak, $parameterId) {
 		$dataValue = $snak->getDataValue();
-		if ( $dataValue instanceof EntityIdValue &&
+		if ($dataValue instanceof EntityIdValue &&
 			$dataValue->getEntityId() instanceof ItemId
 		) {
-			return ItemIdSnakValue::fromItemId( $dataValue->getEntityId() );
+			return ItemIdSnakValue::fromItemId($dataValue->getEntityId());
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -290,15 +290,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return ItemIdSnakValue[] array of values
 	 */
-	public function parseItemsParameter( array $constraintParameters, $constraintTypeItemId, $required ) {
-		$this->checkError( $constraintParameters );
-		$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
-		if ( !array_key_exists( $qualifierId, $constraintParameters ) ) {
-			if ( $required ) {
+	public function parseItemsParameter(array $constraintParameters, $constraintTypeItemId, $required) {
+		$this->checkError($constraintParameters);
+		$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
+		if (!array_key_exists($qualifierId, $constraintParameters)) {
+			if ($required) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-						->withEntityId( new PropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withEntityId(new PropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			} else {
 				return [];
@@ -306,11 +306,11 @@ 
 		}
 
 		$values = [];
-		foreach ( $constraintParameters[$qualifierId] as $parameter ) {
-			$snak = $this->snakDeserializer->deserialize( $parameter );
-			switch ( true ) {
+		foreach ($constraintParameters[$qualifierId] as $parameter) {
+			$snak = $this->snakDeserializer->deserialize($parameter);
+			switch (true) {
 				case $snak instanceof PropertyValueSnak:
-					$values[] = $this->parseItemIdParameter( $snak, $qualifierId );
+					$values[] = $this->parseItemIdParameter($snak, $qualifierId);
 					break;
 				case $snak instanceof PropertySomeValueSnak:
 					$values[] = ItemIdSnakValue::someValue();
@@ -329,27 +329,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return PropertyId[]
 	 */
-	public function parsePropertiesParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
+	public function parsePropertiesParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
+		if (!array_key_exists($propertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$parameters = $constraintParameters[$propertyId];
-		if ( count( $parameters ) === 1 &&
-			$this->snakDeserializer->deserialize( $parameters[0] ) instanceof PropertyNoValueSnak
+		if (count($parameters) === 1 &&
+			$this->snakDeserializer->deserialize($parameters[0]) instanceof PropertyNoValueSnak
 		) {
 			return [];
 		}
 
 		$properties = [];
-		foreach ( $parameters as $parameter ) {
-			$properties[] = $this->parsePropertyIdParameter( $parameter, $propertyId );
+		foreach ($parameters as $parameter) {
+			$properties[] = $this->parsePropertyIdParameter($parameter, $propertyId);
 		}
 		return $properties;
 	}
@@ -360,16 +360,16 @@ 
 	 * @throws ConstraintParameterException
 	 * @return DataValue|null
 	 */
-	private function parseValueOrNoValueParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		if ( $snak instanceof PropertyValueSnak ) {
+	private function parseValueOrNoValueParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		if ($snak instanceof PropertyValueSnak) {
 			return $snak->getDataValue();
-		} elseif ( $snak instanceof PropertyNoValueSnak ) {
+		} elseif ($snak instanceof PropertyNoValueSnak) {
 			return null;
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 	}
@@ -379,10 +379,10 @@ 
 	 * @param string $parameterId
 	 * @return DataValue|null
 	 */
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, $parameterId ) {
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, $parameterId) {
 		try {
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
-		} catch ( ConstraintParameterException $e ) {
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
+		} catch (ConstraintParameterException $e) {
 			// unknown value means “now”
 			return new NowValue();
 		}
@@ -395,14 +395,14 @@ 
 	 * @param string $unit
 	 * @return bool
 	 */
-	private function exactlyOneQuantityWithUnit( DataValue $min = null, DataValue $max = null, $unit ) {
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
-			!( $max instanceof UnboundedQuantityValue )
+	private function exactlyOneQuantityWithUnit(DataValue $min = null, DataValue $max = null, $unit) {
+		if (!($min instanceof UnboundedQuantityValue) ||
+			!($max instanceof UnboundedQuantityValue)
 		) {
 			return false;
 		}
 
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
 	}
 
 	/**
@@ -415,42 +415,42 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] if the parameter is invalid or missing
 	 */
-	private function parseRangeParameter( array $constraintParameters, $minimumId, $maximumId, $constraintTypeItemId, $type ) {
-		$this->checkError( $constraintParameters );
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
-			!array_key_exists( $maximumId, $constraintParameters )
+	private function parseRangeParameter(array $constraintParameters, $minimumId, $maximumId, $constraintTypeItemId, $type) {
+		$this->checkError($constraintParameters);
+		if (!array_key_exists($minimumId, $constraintParameters) ||
+			!array_key_exists($maximumId, $constraintParameters)
 		) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-needed' ) )
-					->withDataValueType( $type )
-					->withEntityId( new PropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new PropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-needed'))
+					->withDataValueType($type)
+					->withEntityId(new PropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new PropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $minimumId );
-		$this->requireSingleParameter( $constraintParameters, $maximumId );
+		$this->requireSingleParameter($constraintParameters, $minimumId);
+		$this->requireSingleParameter($constraintParameters, $maximumId);
 		$parseFunction = $type === 'time' ? 'parseValueOrNoValueOrNowParameter' : 'parseValueOrNoValueParameter';
-		$min = $this->$parseFunction( $constraintParameters[$minimumId][0], $minimumId );
-		$max = $this->$parseFunction( $constraintParameters[$maximumId][0], $maximumId );
+		$min = $this->$parseFunction($constraintParameters[$minimumId][0], $minimumId);
+		$max = $this->$parseFunction($constraintParameters[$maximumId][0], $maximumId);
 
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
-		if ( $this->exactlyOneQuantityWithUnit( $min, $max, $yearUnit ) ) {
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
+		if ($this->exactlyOneQuantityWithUnit($min, $max, $yearUnit)) {
 			throw new ConstraintParameterException(
-				new ViolationMessage( 'wbqc-violation-message-range-parameters-one-year' )
+				new ViolationMessage('wbqc-violation-message-range-parameters-one-year')
 			);
 		}
-		if ( $min === null && $max === null ||
-			$min !== null && $max !== null && $min->equals( $max ) ) {
+		if ($min === null && $max === null ||
+			$min !== null && $max !== null && $min->equals($max)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-same' ) )
-					->withEntityId( new PropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityId( new PropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
+					->withEntityId(new PropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityId(new PropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		return [ $min, $max ];
+		return [$min, $max];
 	}
 
 	/**
@@ -460,11 +460,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseQuantityRangeParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parseQuantityRangeParameter(array $constraintParameters, $constraintTypeItemId) {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
 			$constraintTypeItemId,
 			'quantity'
 		);
@@ -477,11 +477,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
 	 */
-	public function parseTimeRangeParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parseTimeRangeParameter(array $constraintParameters, $constraintTypeItemId) {
 		return $this->parseRangeParameter(
 			$constraintParameters,
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
 			$constraintTypeItemId,
 			'time'
 		);
@@ -494,17 +494,17 @@ 
 	 * @throws ConstraintParameterException
 	 * @return string
 	 */
-	private function parseStringParameter( array $snakSerialization, $parameterId ) {
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-		$this->requireValueParameter( $snak, $parameterId );
+	private function parseStringParameter(array $snakSerialization, $parameterId) {
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
+		$this->requireValueParameter($snak, $parameterId);
 		$value = $snak->getDataValue();
-		if ( $value instanceof StringValue ) {
+		if ($value instanceof StringValue) {
 			return $value->getValue();
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-string' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -515,15 +515,15 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseNamespaceParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
+	public function parseNamespaceParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
 			return '';
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
 	}
 
 	/**
@@ -532,19 +532,19 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string
 	 */
-	public function parseFormatParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$this->checkError( $constraintParameters );
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
+	public function parseFormatParameter(array $constraintParameters, $constraintTypeItemId) {
+		$this->checkError($constraintParameters);
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
+		if (!array_key_exists($formatId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($formatId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $formatId );
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
+		$this->requireSingleParameter($constraintParameters, $formatId);
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
 	}
 
 	/**
@@ -552,16 +552,16 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return EntityId[]
 	 */
-	public function parseExceptionParameter( array $constraintParameters ) {
-		$this->checkError( $constraintParameters );
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
+	public function parseExceptionParameter(array $constraintParameters) {
+		$this->checkError($constraintParameters);
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
 			return [];
 		}
 
 		return array_map(
-			function( $snakSerialization ) use ( $exceptionId ) {
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
+			function($snakSerialization) use ($exceptionId) {
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
 			},
 			$constraintParameters[$exceptionId]
 		);
@@ -572,26 +572,26 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string|null 'mandatory' or null
 	 */
-	public function parseConstraintStatusParameter( array $constraintParameters ) {
-		$this->checkError( $constraintParameters );
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
+	public function parseConstraintStatusParameter(array $constraintParameters) {
+		$this->checkError($constraintParameters);
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
 			return null;
 		}
 
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
-		$this->requireValueParameter( $snak, $constraintStatusId );
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
+		$this->requireValueParameter($snak, $constraintStatusId);
 		$statusId = $snak->getDataValue()->getEntityId()->getSerialization();
 
-		if ( $statusId === $mandatoryId ) {
+		if ($statusId === $mandatoryId) {
 			return 'mandatory';
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new PropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityIdList( [ new ItemId( $mandatoryId ) ], Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new PropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityIdList([new ItemId($mandatoryId)], Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -603,12 +603,12 @@ 
 	 * @return void
 	 * @throws ConstraintParameterException
 	 */
-	private function requireMonolingualTextParameter( DataValue $dataValue, $parameterId ) {
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
+	private function requireMonolingualTextParameter(DataValue $dataValue, $parameterId) {
+		if (!($dataValue instanceof MonolingualTextValue)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -621,30 +621,30 @@ 
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
 	 * @return MultilingualTextValue
 	 */
-	private function parseMultilingualTextParameter( array $snakSerializations, $parameterId ) {
+	private function parseMultilingualTextParameter(array $snakSerializations, $parameterId) {
 		$result = [];
 
-		foreach ( $snakSerializations as $snakSerialization ) {
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
-			$this->requireValueParameter( $snak, $parameterId );
+		foreach ($snakSerializations as $snakSerialization) {
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
+			$this->requireValueParameter($snak, $parameterId);
 
 			$value = $snak->getDataValue();
-			$this->requireMonolingualTextParameter( $value, $parameterId );
+			$this->requireMonolingualTextParameter($value, $parameterId);
 			/** @var MonolingualTextValue $value */
 
 			$code = $value->getLanguageCode();
-			if ( array_key_exists( $code, $result ) ) {
+			if (array_key_exists($code, $result)) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-single-per-language' ) )
-						->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-						->withLanguage( $code )
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
+						->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+						->withLanguage($code)
 				);
 			}
 
 			$result[$code] = $value;
 		}
 
-		return new MultilingualTextValue( $result );
+		return new MultilingualTextValue($result);
 	}
 
 	/**
@@ -652,11 +652,11 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return MultilingualTextValue
 	 */
-	public function parseSyntaxClarificationParameter( array $constraintParameters ) {
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
+	public function parseSyntaxClarificationParameter(array $constraintParameters) {
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
 
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
-			return new MultilingualTextValue( [] );
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
+			return new MultilingualTextValue([]);
 		}
 
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -675,20 +675,20 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string[]|null Context::TYPE_* constants
 	 */
-	public function parseConstraintScopeParameter( array $constraintParameters, $constraintTypeItemId, array $validScopes = null ) {
-		$constraintScopeId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
-		$mainSnakId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' );
-		$qualifiersId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' );
-		$referencesId = $this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' );
+	public function parseConstraintScopeParameter(array $constraintParameters, $constraintTypeItemId, array $validScopes = null) {
+		$constraintScopeId = $this->config->get('WBQualityConstraintsConstraintScopeId');
+		$mainSnakId = $this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId');
+		$qualifiersId = $this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId');
+		$referencesId = $this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId');
 
-		if ( !array_key_exists( $constraintScopeId, $constraintParameters ) ) {
+		if (!array_key_exists($constraintScopeId, $constraintParameters)) {
 			return null;
 		}
 
 		$contextTypes = [];
-		foreach ( $constraintParameters[$constraintScopeId] as $snakSerialization ) {
-			$scopeEntityId = $this->parseEntityIdParameter( $snakSerialization, $constraintScopeId );
-			switch ( $scopeEntityId->getSerialization() ) {
+		foreach ($constraintParameters[$constraintScopeId] as $snakSerialization) {
+			$scopeEntityId = $this->parseEntityIdParameter($snakSerialization, $constraintScopeId);
+			switch ($scopeEntityId->getSerialization()) {
 				case $mainSnakId:
 					$contextTypes[] = Context::TYPE_STATEMENT;
 					break;
@@ -700,13 +700,13 @@ 
 					break;
 				default:
 					throw new ConstraintParameterException(
-						( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-							->withEntityId( new PropertyId( $constraintScopeId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+						(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+							->withEntityId(new PropertyId($constraintScopeId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 							->withEntityIdList(
 								[
-									new ItemId( $mainSnakId ),
-									new ItemId( $qualifiersId ),
-									new ItemId( $referencesId ),
+									new ItemId($mainSnakId),
+									new ItemId($qualifiersId),
+									new ItemId($referencesId),
 								],
 								Role::CONSTRAINT_PARAMETER_VALUE
 							)
@@ -714,15 +714,15 @@ 
 			}
 		}
 
-		if ( $validScopes !== null ) {
-			$invalidScopes = array_diff( $contextTypes, $validScopes );
-			if ( $invalidScopes !== [] ) {
-				$invalidScope = array_pop( $invalidScopes );
+		if ($validScopes !== null) {
+			$invalidScopes = array_diff($contextTypes, $validScopes);
+			if ($invalidScopes !== []) {
+				$invalidScope = array_pop($invalidScopes);
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
-						->withConstraintScope( $invalidScope, Role::CONSTRAINT_PARAMETER_VALUE )
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-						->withConstraintScopeList( $validScopes, Role::CONSTRAINT_PARAMETER_VALUE )
+					(new ViolationMessage('wbqc-violation-message-invalid-scope'))
+						->withConstraintScope($invalidScope, Role::CONSTRAINT_PARAMETER_VALUE)
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withConstraintScopeList($validScopes, Role::CONSTRAINT_PARAMETER_VALUE)
 				);
 			}
 		}
@@ -736,15 +736,15 @@ 
 	 * @param ItemId $unitId
 	 * @return string unit
 	 */
-	private function parseUnitParameter( ItemId $unitId ) {
+	private function parseUnitParameter(ItemId $unitId) {
 		$unitRepositoryName = $unitId->getRepositoryName();
-		if ( !array_key_exists( $unitRepositoryName, $this->conceptBaseUris ) ) {
+		if (!array_key_exists($unitRepositoryName, $this->conceptBaseUris)) {
 			throw new LogicException(
-				'No base URI for concept URI for repository: ' . $unitRepositoryName
+				'No base URI for concept URI for repository: '.$unitRepositoryName
 			);
 		}
 		$baseUri = $this->conceptBaseUris[$unitRepositoryName];
-		return $baseUri . $unitId->getSerialization();
+		return $baseUri.$unitId->getSerialization();
 	}
 
 	/**
@@ -754,23 +754,23 @@ 
 	 * @return UnitsParameter
 	 * @throws ConstraintParameterException
 	 */
-	private function parseUnitItem( ItemIdSnakValue $item ) {
-		switch ( true ) {
+	private function parseUnitItem(ItemIdSnakValue $item) {
+		switch (true) {
 			case $item->isValue():
-				$unit = $this->parseUnitParameter( $item->getItemId() );
+				$unit = $this->parseUnitParameter($item->getItemId());
 				return new UnitsParameter(
-					[ $item->getItemId() ],
-					[ UnboundedQuantityValue::newFromNumber( 1, $unit ) ],
+					[$item->getItemId()],
+					[UnboundedQuantityValue::newFromNumber(1, $unit)],
 					false
 				);
 			case $item->isSomeValue():
-				$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+				$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
-						->withEntityId( new PropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
+						->withEntityId(new PropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			case $item->isNoValue():
-				return new UnitsParameter( [], [], true );
+				return new UnitsParameter([], [], true);
 		}
 	}
 
@@ -780,26 +780,26 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return UnitsParameter
 	 */
-	public function parseUnitsParameter( array $constraintParameters, $constraintTypeItemId ) {
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
+	public function parseUnitsParameter(array $constraintParameters, $constraintTypeItemId) {
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
 		$unitItems = [];
 		$unitQuantities = [];
 		$unitlessAllowed = false;
 
-		foreach ( $items as $item ) {
-			$unit = $this->parseUnitItem( $item );
-			$unitItems = array_merge( $unitItems, $unit->getUnitItemIds() );
-			$unitQuantities = array_merge( $unitQuantities, $unit->getUnitQuantities() );
+		foreach ($items as $item) {
+			$unit = $this->parseUnitItem($item);
+			$unitItems = array_merge($unitItems, $unit->getUnitItemIds());
+			$unitQuantities = array_merge($unitQuantities, $unit->getUnitQuantities());
 			$unitlessAllowed = $unitlessAllowed || $unit->getUnitlessAllowed();
 		}
 
-		if ( $unitQuantities === [] && !$unitlessAllowed ) {
+		if ($unitQuantities === [] && !$unitlessAllowed) {
 			throw new LogicException(
 				'The "units" parameter is required, and yet we seem to be missing any allowed unit'
 			);
 		}
 
-		return new UnitsParameter( $unitItems, $unitQuantities, $unitlessAllowed );
+		return new UnitsParameter($unitItems, $unitQuantities, $unitlessAllowed);
 	}
 
 	/**
@@ -809,33 +809,33 @@ 
 	 * @return EntityTypesParameter
 	 * @throws ConstraintParameterException
 	 */
-	private function parseEntityTypeItem( ItemIdSnakValue $item ) {
-		$entityTypeMapping = $this->config->get( 'WBQualityConstraintsEntityTypeMapping' );
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+	private function parseEntityTypeItem(ItemIdSnakValue $item) {
+		$entityTypeMapping = $this->config->get('WBQualityConstraintsEntityTypeMapping');
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 
-		if ( !$item->isValue() ) {
+		if (!$item->isValue()) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$itemId = $item->getItemId()->getSerialization();
-		if ( !array_key_exists( $itemId, $entityTypeMapping ) ) {
+		if (!array_key_exists($itemId, $entityTypeMapping)) {
 			$entityTypeItemIds = array_map(
-				function ( $itemId ) {
-					return new ItemId( $itemId );
+				function($itemId) {
+					return new ItemId($itemId);
 				},
-				array_keys( $entityTypeMapping )
+				array_keys($entityTypeMapping)
 			);
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityIdList( $entityTypeItemIds, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityIdList($entityTypeItemIds, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 
-		return new EntityTypesParameter( [ $entityTypeMapping[$itemId] ], [ $item->getItemId() ] );
+		return new EntityTypesParameter([$entityTypeMapping[$itemId]], [$item->getItemId()]);
 	}
 
 	/**
@@ -844,27 +844,27 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return EntityTypesParameter
 	 */
-	public function parseEntityTypesParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parseEntityTypesParameter(array $constraintParameters, $constraintTypeItemId) {
 		$entityTypes = [];
 		$entityTypeItemIds = [];
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
 
-		foreach ( $items as $item ) {
-			$entityType = $this->parseEntityTypeItem( $item );
-			$entityTypes = array_merge( $entityTypes, $entityType->getEntityTypes() );
-			$entityTypeItemIds = array_merge( $entityTypeItemIds, $entityType->getEntityTypeItemIds() );
+		foreach ($items as $item) {
+			$entityType = $this->parseEntityTypeItem($item);
+			$entityTypes = array_merge($entityTypes, $entityType->getEntityTypes());
+			$entityTypeItemIds = array_merge($entityTypeItemIds, $entityType->getEntityTypeItemIds());
 		}
 
-		if ( empty( $entityTypes ) ) {
+		if (empty($entityTypes)) {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'The "entity types" parameter is required, ' .
+				'The "entity types" parameter is required, '.
 				'and yet we seem to be missing any allowed entity type'
 			);
 			// @codeCoverageIgnoreEnd
 		}
 
-		return new EntityTypesParameter( $entityTypes, $entityTypeItemIds );
+		return new EntityTypesParameter($entityTypes, $entityTypeItemIds);
 	}
 
 }

src/ConstraintCheck/Checker/EntityTypeChecker.php

Spacing +10 added lines, -10 removed lines

@@ -59,9 +59,9 @@ 
 		];
 	}
 
-	public function checkConstraint( Context $context, Constraint $constraint ) {
-		if ( $context->getSnakRank() === Statement::RANK_DEPRECATED ) {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_DEPRECATED );
+	public function checkConstraint(Context $context, Constraint $constraint) {
+		if ($context->getSnakRank() === Statement::RANK_DEPRECATED) {
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_DEPRECATED);
 		}
 
 		$constraintParameters = $constraint->getConstraintParameters();
@@ -71,10 +71,10 @@ 
 		);
 		$parameters['item'] = $entityTypes->getEntityTypes();
 
-		if ( !in_array( $context->getEntity()->getType(), $entityTypes->getEntityTypes() ) ) {
-			$message = ( new ViolationMessage( 'wbqc-violation-message-entityType' ) )
-				->withEntityId( $context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY )
-				->withEntityIdList( $entityTypes->getEntityTypeItemIds(), Role::CONSTRAINT_PARAMETER_VALUE );
+		if (!in_array($context->getEntity()->getType(), $entityTypes->getEntityTypes())) {
+			$message = (new ViolationMessage('wbqc-violation-message-entityType'))
+				->withEntityId($context->getSnak()->getPropertyId(), Role::CONSTRAINT_PROPERTY)
+				->withEntityIdList($entityTypes->getEntityTypeItemIds(), Role::CONSTRAINT_PARAMETER_VALUE);
 
 			return new CheckResult(
 				$context,
@@ -85,10 +85,10 @@ 
 			);
 		}
 
-		return new CheckResult( $context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE );
+		return new CheckResult($context, $constraint, $parameters, CheckResult::STATUS_COMPLIANCE);
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ) {
+	public function checkConstraintParameters(Constraint $constraint) {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$exceptions = [];
 		try {
@@ -96,7 +96,7 @@ 
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId()
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;