wikimedia / mediawiki-extensions-WikibaseQualityConstraints

src/ServiceWiring-ConstraintCheckers.php

Spacing +74 added lines, -74 removed lines

@@ -38,205 +38,205 @@
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\ValueTypeChecker;
 
 return [
-	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function(MediaWikiServices $services) {
 		return new ConflictsWithChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::ITEM_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::ITEM_CHECKER => static function(MediaWikiServices $services) {
 		return new ItemChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function(MediaWikiServices $services) {
 		return new TargetRequiredClaimChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function(MediaWikiServices $services) {
 		return new SymmetricChecker(
-			WikibaseServices::getEntityLookupWithoutCache( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			WikibaseServices::getEntityLookupWithoutCache($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::INVERSE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::INVERSE_CHECKER => static function(MediaWikiServices $services) {
 		return new InverseChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getConnectionCheckerHelper( $services )
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getConnectionCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::QUALIFIER_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::QUALIFIER_CHECKER => static function(MediaWikiServices $services) {
 		return new QualifierChecker();
 	},
 
-	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function(MediaWikiServices $services) {
 		return new QualifiersChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function(MediaWikiServices $services) {
 		return new MandatoryQualifiersChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::RANGE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::RANGE_CHECKER => static function(MediaWikiServices $services) {
 		return new RangeChecker(
-			WikibaseServices::getPropertyDataTypeLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services )
+			WikibaseServices::getPropertyDataTypeLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getRangeCheckerHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function(MediaWikiServices $services) {
 		return new DiffWithinRangeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getRangeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::TYPE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::TYPE_CHECKER => static function(MediaWikiServices $services) {
 		return new TypeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getTypeCheckerHelper( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getTypeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function(MediaWikiServices $services) {
 		return new ValueTypeChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			ConstraintsServices::getTypeCheckerHelper( $services ),
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
+			ConstraintsServices::getTypeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function(MediaWikiServices $services) {
 		return new SingleValueChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function(MediaWikiServices $services) {
 		return new MultiValueChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function(MediaWikiServices $services) {
 		// TODO return a different, dummy implementation if SPARQL is not available
 		return new UniqueValueChecker(
-			ConstraintsServices::getSparqlHelper( $services )
+			ConstraintsServices::getSparqlHelper($services)
 		);
 	},
 
-	ConstraintCheckerServices::FORMAT_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::FORMAT_CHECKER => static function(MediaWikiServices $services) {
 		// TODO return a different, dummy implementation if SPARQL is not available
 		return new FormatChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
 			$services->getMainConfig(),
-			ConstraintsServices::getSparqlHelper( $services ),
+			ConstraintsServices::getSparqlHelper($services),
 			$services->getShellboxClientFactory()
 		);
 	},
 
-	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function(MediaWikiServices $services) {
 		$pageNameNormalizer = new MediaWikiPageNameNormalizer();
 		return new CommonsLinkChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
+			ConstraintsServices::getConstraintParameterParser($services),
 			$pageNameNormalizer,
-			WikibaseRepo::getPropertyDataTypeLookup( $services )
+			WikibaseRepo::getPropertyDataTypeLookup($services)
 		);
 	},
 
-	ConstraintCheckerServices::ONE_OF_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::ONE_OF_CHECKER => static function(MediaWikiServices $services) {
 		return new OneOfChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function(MediaWikiServices $services) {
 		return new ValueOnlyChecker();
 	},
 
-	ConstraintCheckerServices::REFERENCE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::REFERENCE_CHECKER => static function(MediaWikiServices $services) {
 		return new ReferenceChecker();
 	},
 
-	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function(MediaWikiServices $services) {
 		return new NoBoundsChecker();
 	},
 
-	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function(MediaWikiServices $services) {
 		return new AllowedUnitsChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			WikibaseRepo::getUnitConverter( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			WikibaseRepo::getUnitConverter($services)
 		);
 	},
 
-	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function(MediaWikiServices $services) {
 		return new SingleBestValueChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function(MediaWikiServices $services) {
 		return new EntityTypeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::NONE_OF_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::NONE_OF_CHECKER => static function(MediaWikiServices $services) {
 		return new NoneOfChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::INTEGER_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::INTEGER_CHECKER => static function(MediaWikiServices $services) {
 		return new IntegerChecker();
 	},
 
-	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function(MediaWikiServices $services) {
 		return new CitationNeededChecker();
 	},
 
-	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function(MediaWikiServices $services) {
 		return new PropertyScopeChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 
-	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function(MediaWikiServices $services) {
 		return new ContemporaryChecker(
-			WikibaseServices::getEntityLookup( $services ),
-			ConstraintsServices::getRangeCheckerHelper( $services ),
+			WikibaseServices::getEntityLookup($services),
+			ConstraintsServices::getRangeCheckerHelper($services),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function(MediaWikiServices $services) {
 		return new LanguageChecker(
-			ConstraintsServices::getConstraintParameterParser( $services ),
-			WikibaseServices::getEntityLookup( $services )
+			ConstraintsServices::getConstraintParameterParser($services),
+			WikibaseServices::getEntityLookup($services)
 		);
 	},
 
-	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function ( MediaWikiServices $services ) {
+	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function(MediaWikiServices $services) {
 		return new LabelInLanguageChecker(
-			ConstraintsServices::getConstraintParameterParser( $services )
+			ConstraintsServices::getConstraintParameterParser($services)
 		);
 	},
 ];

src/ConstraintCheckerServices.php

Spacing +65 added lines, -65 removed lines

@@ -44,259 +44,259 @@
 	public const LEXEME_LANGUAGE_CHECKER = 'WBQC_Lexeme_LanguageChecker';
 	public const LABEL_IN_LANGUAGE_CHECKER = 'WBQC_LabelInLanguageChecker';
 
-	private static function getService( ?MediaWikiServices $services, $name ) {
-		if ( $services === null ) {
+	private static function getService(?MediaWikiServices $services, $name) {
+		if ($services === null) {
 			$services = MediaWikiServices::getInstance();
 		}
-		return $services->getService( $name );
+		return $services->getService($name);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getConflictsWithChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::CONFLICTS_WITH_CHECKER );
+	public static function getConflictsWithChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::CONFLICTS_WITH_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getItemChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::ITEM_CHECKER );
+	public static function getItemChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::ITEM_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getTargetRequiredClaimChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::TARGET_REQUIRED_CLAIM_CHECKER );
+	public static function getTargetRequiredClaimChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::TARGET_REQUIRED_CLAIM_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getSymmetricChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::SYMMETRIC_CHECKER );
+	public static function getSymmetricChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::SYMMETRIC_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getInverseChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::INVERSE_CHECKER );
+	public static function getInverseChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::INVERSE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getQualifierChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::QUALIFIER_CHECKER );
+	public static function getQualifierChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::QUALIFIER_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getQualifiersChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::QUALIFIERS_CHECKER );
+	public static function getQualifiersChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::QUALIFIERS_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getMandatoryQualifiersChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::MANDATORY_QUALIFIERS_CHECKER );
+	public static function getMandatoryQualifiersChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::MANDATORY_QUALIFIERS_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getRangeChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::RANGE_CHECKER );
+	public static function getRangeChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::RANGE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getDiffWithinRangeChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::DIFF_WITHIN_RANGE_CHECKER );
+	public static function getDiffWithinRangeChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::DIFF_WITHIN_RANGE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getTypeChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::TYPE_CHECKER );
+	public static function getTypeChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::TYPE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getValueTypeChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::VALUE_TYPE_CHECKER );
+	public static function getValueTypeChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::VALUE_TYPE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getSingleValueChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::SINGLE_VALUE_CHECKER );
+	public static function getSingleValueChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::SINGLE_VALUE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getMultiValueChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::MULTI_VALUE_CHECKER );
+	public static function getMultiValueChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::MULTI_VALUE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getUniqueValueChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::UNIQUE_VALUE_CHECKER );
+	public static function getUniqueValueChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::UNIQUE_VALUE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getFormatChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::FORMAT_CHECKER );
+	public static function getFormatChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::FORMAT_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getCommonsLinkChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::COMMONS_LINK_CHECKER );
+	public static function getCommonsLinkChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::COMMONS_LINK_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getOneOfChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::ONE_OF_CHECKER );
+	public static function getOneOfChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::ONE_OF_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getValueOnlyChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::VALUE_ONLY_CHECKER );
+	public static function getValueOnlyChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::VALUE_ONLY_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getReferenceChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::REFERENCE_CHECKER );
+	public static function getReferenceChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::REFERENCE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getNoBoundsChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::NO_BOUNDS_CHECKER );
+	public static function getNoBoundsChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::NO_BOUNDS_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getAllowedUnitsChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::ALLOWED_UNITS_CHECKER );
+	public static function getAllowedUnitsChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::ALLOWED_UNITS_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getSingleBestValueChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::SINGLE_BEST_VALUE_CHECKER );
+	public static function getSingleBestValueChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::SINGLE_BEST_VALUE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getEntityTypeChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::ENTITY_TYPE_CHECKER );
+	public static function getEntityTypeChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::ENTITY_TYPE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getNoneOfChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::NONE_OF_CHECKER );
+	public static function getNoneOfChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::NONE_OF_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getIntegerChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::INTEGER_CHECKER );
+	public static function getIntegerChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::INTEGER_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getCitationNeededChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::CITATION_NEEDED_CHECKER );
+	public static function getCitationNeededChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::CITATION_NEEDED_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getPropertyScopeChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::PROPERTY_SCOPE_CHECKER );
+	public static function getPropertyScopeChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::PROPERTY_SCOPE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return ConstraintChecker
 	 */
-	public static function getContemporaryChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::CONTEMPORARY_CHECKER );
+	public static function getContemporaryChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::CONTEMPORARY_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return LanguageChecker
 	 */
-	public static function getLexemeLanguageChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::LEXEME_LANGUAGE_CHECKER );
+	public static function getLexemeLanguageChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::LEXEME_LANGUAGE_CHECKER);
 	}
 
 	/**
 	 * @param MediaWikiServices|null $services
 	 * @return LabelInLanguageChecker
 	 */
-	public static function getLabelInLanguageChecker( MediaWikiServices $services = null ) {
-		return self::getService( $services, self::LABEL_IN_LANGUAGE_CHECKER );
+	public static function getLabelInLanguageChecker(MediaWikiServices $services = null) {
+		return self::getService($services, self::LABEL_IN_LANGUAGE_CHECKER);
 	}
 
 }

src/ServiceWiring.php

Spacing +136 added lines, -136 removed lines

@@ -28,46 +28,46 @@ 
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResultSerializer;
 
 return [
-	ConstraintsServices::EXPIRY_LOCK => static function ( MediaWikiServices $services ) {
-		return new ExpiryLock( ObjectCache::getInstance( CACHE_ANYTHING ) );
+	ConstraintsServices::EXPIRY_LOCK => static function(MediaWikiServices $services) {
+		return new ExpiryLock(ObjectCache::getInstance(CACHE_ANYTHING));
 	},
 
-	ConstraintsServices::LOGGING_HELPER => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::LOGGING_HELPER => static function(MediaWikiServices $services) {
 		return new LoggingHelper(
 			$services->getStatsdDataFactory(),
-			LoggerFactory::getInstance( 'WikibaseQualityConstraints' ),
+			LoggerFactory::getInstance('WikibaseQualityConstraints'),
 			$services->getMainConfig()
 		);
 	},
 
-	ConstraintsServices::CONSTRAINT_STORE => static function ( MediaWikiServices $services ) {
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
+	ConstraintsServices::CONSTRAINT_STORE => static function(MediaWikiServices $services) {
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
 		$dbName = $propertySource->getDatabaseName();
-		$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
+		$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
 
-		if ( $propertySource->getSourceName() !== $localEntitySourceName ) {
-			throw new \RuntimeException( 'Can\'t get a ConstraintStore for a non local entity source.' );
+		if ($propertySource->getSourceName() !== $localEntitySourceName) {
+			throw new \RuntimeException('Can\'t get a ConstraintStore for a non local entity source.');
 		}
 
 		return new ConstraintRepositoryStore(
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
 			$dbName
 		);
 	},
 
-	ConstraintsServices::CONSTRAINT_LOOKUP => static function ( MediaWikiServices $services ) {
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
+	ConstraintsServices::CONSTRAINT_LOOKUP => static function(MediaWikiServices $services) {
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
 		$dbName = $propertySource->getDatabaseName();
 		$rawLookup = new ConstraintRepositoryLookup(
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
 			$dbName
 		);
-		return new CachingConstraintLookup( $rawLookup );
+		return new CachingConstraintLookup($rawLookup);
 	},
 
-	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function(MediaWikiServices $services) {
 		return new CheckResultSerializer(
 			new ConstraintSerializer(
 				false // constraint parameters are not exposed
@@ -78,9 +78,9 @@ 
 		);
 	},
 
-	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function ( MediaWikiServices $services ) {
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
+	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function(MediaWikiServices $services) {
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
 
 		return new CheckResultDeserializer(
 			new ConstraintDeserializer(),
@@ -93,13 +93,13 @@ 
 		);
 	},
 
-	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function(MediaWikiServices $services) {
 		return new ViolationMessageSerializer();
 	},
 
-	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function ( MediaWikiServices $services ) {
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
+	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function(MediaWikiServices $services) {
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
 
 		return new ViolationMessageDeserializer(
 			$entityIdParser,
@@ -107,37 +107,37 @@ 
 		);
 	},
 
-	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function ( MediaWikiServices $services ) {
-		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory( $services );
-		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
+	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function(MediaWikiServices $services) {
+		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory($services);
+		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
 
 		return new ConstraintParameterParser(
 			$services->getMainConfig(),
 			$deserializerFactory,
-			$entitySourceDefinitions->getDatabaseSourceForEntityType( 'item' )->getConceptBaseUri()
+			$entitySourceDefinitions->getDatabaseSourceForEntityType('item')->getConceptBaseUri()
 		);
 	},
 
-	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function(MediaWikiServices $services) {
 		return new ConnectionCheckerHelper();
 	},
 
-	ConstraintsServices::RANGE_CHECKER_HELPER => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::RANGE_CHECKER_HELPER => static function(MediaWikiServices $services) {
 		return new RangeCheckerHelper(
 			$services->getMainConfig(),
-			WikibaseRepo::getUnitConverter( $services )
+			WikibaseRepo::getUnitConverter($services)
 		);
 	},
 
-	ConstraintsServices::SPARQL_HELPER => static function ( MediaWikiServices $services ) {
-		$endpoint = $services->getMainConfig()->get( 'WBQualityConstraintsSparqlEndpoint' );
-		if ( $endpoint === '' ) {
+	ConstraintsServices::SPARQL_HELPER => static function(MediaWikiServices $services) {
+		$endpoint = $services->getMainConfig()->get('WBQualityConstraintsSparqlEndpoint');
+		if ($endpoint === '') {
 			return new DummySparqlHelper();
 		}
 
-		$rdfVocabulary = WikibaseRepo::getRdfVocabulary( $services );
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
-		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup( $services );
+		$rdfVocabulary = WikibaseRepo::getRdfVocabulary($services);
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
+		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup($services);
 
 		return new SparqlHelper(
 			$services->getMainConfig(),
@@ -145,126 +145,126 @@ 
 			$entityIdParser,
 			$propertyDataTypeLookup,
 			$services->getMainWANObjectCache(),
-			ConstraintsServices::getViolationMessageSerializer( $services ),
-			ConstraintsServices::getViolationMessageDeserializer( $services ),
+			ConstraintsServices::getViolationMessageSerializer($services),
+			ConstraintsServices::getViolationMessageDeserializer($services),
 			$services->getStatsdDataFactory(),
-			ConstraintsServices::getExpiryLock( $services ),
-			ConstraintsServices::getLoggingHelper( $services ),
-			wfWikiID() . ' WikibaseQualityConstraints ' . Http::userAgent(),
+			ConstraintsServices::getExpiryLock($services),
+			ConstraintsServices::getLoggingHelper($services),
+			wfWikiID().' WikibaseQualityConstraints '.Http::userAgent(),
 			$services->getHttpRequestFactory()
 		);
 	},
 
-	ConstraintsServices::TYPE_CHECKER_HELPER => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::TYPE_CHECKER_HELPER => static function(MediaWikiServices $services) {
 		return new TypeCheckerHelper(
-			WikibaseServices::getEntityLookup( $services ),
+			WikibaseServices::getEntityLookup($services),
 			$services->getMainConfig(),
-			ConstraintsServices::getSparqlHelper( $services ),
+			ConstraintsServices::getSparqlHelper($services),
 			$services->getStatsdDataFactory()
 		);
 	},
 
-	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function ( MediaWikiServices $services ) {
-		$statementGuidParser = WikibaseRepo::getStatementGuidParser( $services );
+	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function(MediaWikiServices $services) {
+		$statementGuidParser = WikibaseRepo::getStatementGuidParser($services);
 
 		$config = $services->getMainConfig();
 		$checkerMap = [
-			$config->get( 'WBQualityConstraintsConflictsWithConstraintId' )
-				=> ConstraintCheckerServices::getConflictsWithChecker( $services ),
-			$config->get( 'WBQualityConstraintsItemRequiresClaimConstraintId' )
-				=> ConstraintCheckerServices::getItemChecker( $services ),
-			$config->get( 'WBQualityConstraintsValueRequiresClaimConstraintId' )
-				=> ConstraintCheckerServices::getTargetRequiredClaimChecker( $services ),
-			$config->get( 'WBQualityConstraintsSymmetricConstraintId' )
-				=> ConstraintCheckerServices::getSymmetricChecker( $services ),
-			$config->get( 'WBQualityConstraintsInverseConstraintId' )
-				=> ConstraintCheckerServices::getInverseChecker( $services ),
-			$config->get( 'WBQualityConstraintsUsedAsQualifierConstraintId' )
-				=> ConstraintCheckerServices::getQualifierChecker( $services ),
-			$config->get( 'WBQualityConstraintsAllowedQualifiersConstraintId' )
-				=> ConstraintCheckerServices::getQualifiersChecker( $services ),
-			$config->get( 'WBQualityConstraintsMandatoryQualifierConstraintId' )
-				=> ConstraintCheckerServices::getMandatoryQualifiersChecker( $services ),
-			$config->get( 'WBQualityConstraintsRangeConstraintId' )
-				=> ConstraintCheckerServices::getRangeChecker( $services ),
-			$config->get( 'WBQualityConstraintsDifferenceWithinRangeConstraintId' )
-				=> ConstraintCheckerServices::getDiffWithinRangeChecker( $services ),
-			$config->get( 'WBQualityConstraintsTypeConstraintId' )
-				=> ConstraintCheckerServices::getTypeChecker( $services ),
-			$config->get( 'WBQualityConstraintsValueTypeConstraintId' )
-				=> ConstraintCheckerServices::getValueTypeChecker( $services ),
-			$config->get( 'WBQualityConstraintsSingleValueConstraintId' )
-				=> ConstraintCheckerServices::getSingleValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsMultiValueConstraintId' )
-				=> ConstraintCheckerServices::getMultiValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' )
-				=> ConstraintCheckerServices::getUniqueValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsFormatConstraintId' )
-				=> ConstraintCheckerServices::getFormatChecker( $services ),
-			$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' )
-				=> ConstraintCheckerServices::getCommonsLinkChecker( $services ),
-			$config->get( 'WBQualityConstraintsOneOfConstraintId' )
-				=> ConstraintCheckerServices::getOneOfChecker( $services ),
-			$config->get( 'WBQualityConstraintsUsedForValuesOnlyConstraintId' )
-				=> ConstraintCheckerServices::getValueOnlyChecker( $services ),
-			$config->get( 'WBQualityConstraintsUsedAsReferenceConstraintId' )
-				=> ConstraintCheckerServices::getReferenceChecker( $services ),
-			$config->get( 'WBQualityConstraintsNoBoundsConstraintId' )
-				=> ConstraintCheckerServices::getNoBoundsChecker( $services ),
-			$config->get( 'WBQualityConstraintsAllowedUnitsConstraintId' )
-				=> ConstraintCheckerServices::getAllowedUnitsChecker( $services ),
-			$config->get( 'WBQualityConstraintsSingleBestValueConstraintId' )
-				=> ConstraintCheckerServices::getSingleBestValueChecker( $services ),
-			$config->get( 'WBQualityConstraintsAllowedEntityTypesConstraintId' )
-				=> ConstraintCheckerServices::getEntityTypeChecker( $services ),
-			$config->get( 'WBQualityConstraintsNoneOfConstraintId' )
-				=> ConstraintCheckerServices::getNoneOfChecker( $services ),
-			$config->get( 'WBQualityConstraintsIntegerConstraintId' )
-				=> ConstraintCheckerServices::getIntegerChecker( $services ),
-			$config->get( 'WBQualityConstraintsCitationNeededConstraintId' )
-				=> ConstraintCheckerServices::getCitationNeededChecker( $services ),
-			$config->get( 'WBQualityConstraintsPropertyScopeConstraintId' )
-				=> ConstraintCheckerServices::getPropertyScopeChecker( $services ),
-			$config->get( 'WBQualityConstraintsContemporaryConstraintId' )
-				=> ConstraintCheckerServices::getContemporaryChecker( $services ),
-			$config->get( 'WBQualityConstraintsLexemeLanguageConstraintId' )
-				=> ConstraintCheckerServices::getLexemeLanguageChecker( $services ),
-			$config->get( 'WBQualityConstraintsLabelInLanguageConstraintId' )
-				=> ConstraintCheckerServices::getLabelInLanguageChecker( $services ),
+			$config->get('WBQualityConstraintsConflictsWithConstraintId')
+				=> ConstraintCheckerServices::getConflictsWithChecker($services),
+			$config->get('WBQualityConstraintsItemRequiresClaimConstraintId')
+				=> ConstraintCheckerServices::getItemChecker($services),
+			$config->get('WBQualityConstraintsValueRequiresClaimConstraintId')
+				=> ConstraintCheckerServices::getTargetRequiredClaimChecker($services),
+			$config->get('WBQualityConstraintsSymmetricConstraintId')
+				=> ConstraintCheckerServices::getSymmetricChecker($services),
+			$config->get('WBQualityConstraintsInverseConstraintId')
+				=> ConstraintCheckerServices::getInverseChecker($services),
+			$config->get('WBQualityConstraintsUsedAsQualifierConstraintId')
+				=> ConstraintCheckerServices::getQualifierChecker($services),
+			$config->get('WBQualityConstraintsAllowedQualifiersConstraintId')
+				=> ConstraintCheckerServices::getQualifiersChecker($services),
+			$config->get('WBQualityConstraintsMandatoryQualifierConstraintId')
+				=> ConstraintCheckerServices::getMandatoryQualifiersChecker($services),
+			$config->get('WBQualityConstraintsRangeConstraintId')
+				=> ConstraintCheckerServices::getRangeChecker($services),
+			$config->get('WBQualityConstraintsDifferenceWithinRangeConstraintId')
+				=> ConstraintCheckerServices::getDiffWithinRangeChecker($services),
+			$config->get('WBQualityConstraintsTypeConstraintId')
+				=> ConstraintCheckerServices::getTypeChecker($services),
+			$config->get('WBQualityConstraintsValueTypeConstraintId')
+				=> ConstraintCheckerServices::getValueTypeChecker($services),
+			$config->get('WBQualityConstraintsSingleValueConstraintId')
+				=> ConstraintCheckerServices::getSingleValueChecker($services),
+			$config->get('WBQualityConstraintsMultiValueConstraintId')
+				=> ConstraintCheckerServices::getMultiValueChecker($services),
+			$config->get('WBQualityConstraintsDistinctValuesConstraintId')
+				=> ConstraintCheckerServices::getUniqueValueChecker($services),
+			$config->get('WBQualityConstraintsFormatConstraintId')
+				=> ConstraintCheckerServices::getFormatChecker($services),
+			$config->get('WBQualityConstraintsCommonsLinkConstraintId')
+				=> ConstraintCheckerServices::getCommonsLinkChecker($services),
+			$config->get('WBQualityConstraintsOneOfConstraintId')
+				=> ConstraintCheckerServices::getOneOfChecker($services),
+			$config->get('WBQualityConstraintsUsedForValuesOnlyConstraintId')
+				=> ConstraintCheckerServices::getValueOnlyChecker($services),
+			$config->get('WBQualityConstraintsUsedAsReferenceConstraintId')
+				=> ConstraintCheckerServices::getReferenceChecker($services),
+			$config->get('WBQualityConstraintsNoBoundsConstraintId')
+				=> ConstraintCheckerServices::getNoBoundsChecker($services),
+			$config->get('WBQualityConstraintsAllowedUnitsConstraintId')
+				=> ConstraintCheckerServices::getAllowedUnitsChecker($services),
+			$config->get('WBQualityConstraintsSingleBestValueConstraintId')
+				=> ConstraintCheckerServices::getSingleBestValueChecker($services),
+			$config->get('WBQualityConstraintsAllowedEntityTypesConstraintId')
+				=> ConstraintCheckerServices::getEntityTypeChecker($services),
+			$config->get('WBQualityConstraintsNoneOfConstraintId')
+				=> ConstraintCheckerServices::getNoneOfChecker($services),
+			$config->get('WBQualityConstraintsIntegerConstraintId')
+				=> ConstraintCheckerServices::getIntegerChecker($services),
+			$config->get('WBQualityConstraintsCitationNeededConstraintId')
+				=> ConstraintCheckerServices::getCitationNeededChecker($services),
+			$config->get('WBQualityConstraintsPropertyScopeConstraintId')
+				=> ConstraintCheckerServices::getPropertyScopeChecker($services),
+			$config->get('WBQualityConstraintsContemporaryConstraintId')
+				=> ConstraintCheckerServices::getContemporaryChecker($services),
+			$config->get('WBQualityConstraintsLexemeLanguageConstraintId')
+				=> ConstraintCheckerServices::getLexemeLanguageChecker($services),
+			$config->get('WBQualityConstraintsLabelInLanguageConstraintId')
+				=> ConstraintCheckerServices::getLabelInLanguageChecker($services),
 		];
 
 		return new DelegatingConstraintChecker(
-			WikibaseServices::getEntityLookup( $services ),
+			WikibaseServices::getEntityLookup($services),
 			$checkerMap,
-			ConstraintsServices::getConstraintLookup( $services ),
-			ConstraintsServices::getConstraintParameterParser( $services ),
+			ConstraintsServices::getConstraintLookup($services),
+			ConstraintsServices::getConstraintParameterParser($services),
 			$statementGuidParser,
-			ConstraintsServices::getLoggingHelper( $services ),
-			$config->get( 'WBQualityConstraintsCheckQualifiers' ),
-			$config->get( 'WBQualityConstraintsCheckReferences' ),
-			$config->get( 'WBQualityConstraintsPropertiesWithViolatingQualifiers' )
+			ConstraintsServices::getLoggingHelper($services),
+			$config->get('WBQualityConstraintsCheckQualifiers'),
+			$config->get('WBQualityConstraintsCheckReferences'),
+			$config->get('WBQualityConstraintsPropertiesWithViolatingQualifiers')
 		);
 	},
 
-	ConstraintsServices::RESULTS_SOURCE => static function ( MediaWikiServices $services ) {
+	ConstraintsServices::RESULTS_SOURCE => static function(MediaWikiServices $services) {
 		$config = $services->getMainConfig();
 		$resultsSource = new CheckingResultsSource(
-			ConstraintsServices::getDelegatingConstraintChecker( $services )
+			ConstraintsServices::getDelegatingConstraintChecker($services)
 		);
 
 		$cacheCheckConstraintsResults = false;
 
-		if ( $config->get( 'WBQualityConstraintsCacheCheckConstraintsResults' ) ) {
+		if ($config->get('WBQualityConstraintsCacheCheckConstraintsResults')) {
 			$cacheCheckConstraintsResults = true;
 			// check that we can use getLocalRepoWikiPageMetaDataAccessor()
 			// TODO we should always be able to cache constraint check results (T244726)
-			$entitySources = WikibaseRepo::getEntitySourceDefinitions( $services )->getSources();
-			$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
+			$entitySources = WikibaseRepo::getEntitySourceDefinitions($services)->getSources();
+			$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
 
-			foreach ( $entitySources as $entitySource ) {
-				if ( $entitySource->getSourceName() !== $localEntitySourceName ) {
-					LoggerFactory::getInstance( 'WikibaseQualityConstraints' )->warning(
-						'Cannot cache constraint check results for non-local source: ' .
+			foreach ($entitySources as $entitySource) {
+				if ($entitySource->getSourceName() !== $localEntitySourceName) {
+					LoggerFactory::getInstance('WikibaseQualityConstraints')->warning(
+						'Cannot cache constraint check results for non-local source: '.
 						$entitySource->getSourceName()
 					);
 					$cacheCheckConstraintsResults = false;
@@ -273,28 +273,28 @@ 
 			}
 		}
 
-		if ( $cacheCheckConstraintsResults ) {
+		if ($cacheCheckConstraintsResults) {
 			$possiblyStaleConstraintTypes = [
-				$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' ),
-				$config->get( 'WBQualityConstraintsTypeConstraintId' ),
-				$config->get( 'WBQualityConstraintsValueTypeConstraintId' ),
-				$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' ),
+				$config->get('WBQualityConstraintsCommonsLinkConstraintId'),
+				$config->get('WBQualityConstraintsTypeConstraintId'),
+				$config->get('WBQualityConstraintsValueTypeConstraintId'),
+				$config->get('WBQualityConstraintsDistinctValuesConstraintId'),
 			];
-			$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
+			$entityIdParser = WikibaseRepo::getEntityIdParser($services);
 			$wikiPageEntityMetaDataAccessor = WikibaseRepo::getLocalRepoWikiPageMetaDataAccessor(
 				$services );
 
 			$resultsSource = new CachingResultsSource(
 				$resultsSource,
 				ResultsCache::getDefaultInstance(),
-				ConstraintsServices::getCheckResultSerializer( $services ),
-				ConstraintsServices::getCheckResultDeserializer( $services ),
+				ConstraintsServices::getCheckResultSerializer($services),
+				ConstraintsServices::getCheckResultDeserializer($services),
 				$wikiPageEntityMetaDataAccessor,
 				$entityIdParser,
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsTTLSeconds' ),
+				$config->get('WBQualityConstraintsCacheCheckConstraintsTTLSeconds'),
 				$possiblyStaleConstraintTypes,
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds' ),
-				ConstraintsServices::getLoggingHelper( $services )
+				$config->get('WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds'),
+				ConstraintsServices::getLoggingHelper($services)
 			);
 		}
 

src/ConstraintCheck/Helper/ConstraintParameterParser.php

Spacing +287 added lines, -287 removed lines

@@ -77,15 +77,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));
 		}
 	}
 
@@ -95,11 +95,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)
 			);
 		}
 	}
@@ -111,11 +111,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)
 			);
 		}
 	}
@@ -127,17 +127,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)
 			);
 		}
 	}
@@ -148,20 +148,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;
 	}
@@ -172,31 +172,31 @@ 
 	 * @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 );
-		if ( !( $relationEntityId instanceof ItemId ) ) {
+		$this->requireSingleParameter($constraintParameters, $relationId);
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
+		if (!($relationEntityId instanceof ItemId)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
-					->withEntityId( new PropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withDataValue( new EntityIdValue( $relationEntityId ), Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
+					->withEntityId(new PropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withDataValue(new EntityIdValue($relationEntityId), Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
-		return $this->mapItemId( $relationEntityId, [
-			$this->config->get( 'WBQualityConstraintsInstanceOfRelationId' ) => 'instance',
-			$this->config->get( 'WBQualityConstraintsSubclassOfRelationId' ) => 'subclass',
-			$this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' ) => 'instanceOrSubclass',
-		], $relationId );
+		return $this->mapItemId($relationEntityId, [
+			$this->config->get('WBQualityConstraintsInstanceOfRelationId') => 'instance',
+			$this->config->get('WBQualityConstraintsSubclassOfRelationId') => 'subclass',
+			$this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId') => 'instanceOrSubclass',
+		], $relationId);
 	}
 
 	/**
@@ -206,20 +206,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)
 		);
 	}
 
@@ -230,33 +230,33 @@ 
 	 * @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) {
 			$entityId = $dataValue->getEntityId();
-			if ( $entityId instanceof ItemId ) {
-				return ItemIdSnakValue::fromItemId( $entityId );
+			if ($entityId instanceof ItemId) {
+				return ItemIdSnakValue::fromItemId($entityId);
 			}
 		}
 		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)
 		);
 	}
 
@@ -274,16 +274,16 @@ 
 		$required,
 		$parameterId = null
 	) {
-		$this->checkError( $constraintParameters );
-		if ( $parameterId === null ) {
-			$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+		$this->checkError($constraintParameters);
+		if ($parameterId === null) {
+			$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 		}
-		if ( !array_key_exists( $parameterId, $constraintParameters ) ) {
-			if ( $required ) {
+		if (!array_key_exists($parameterId, $constraintParameters)) {
+			if ($required) {
 				throw new ConstraintParameterException(
-					( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-						->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+						->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 				);
 			} else {
 				return [];
@@ -291,11 +291,11 @@ 
 		}
 
 		$values = [];
-		foreach ( $constraintParameters[$parameterId] as $parameter ) {
-			$snak = $this->snakDeserializer->deserialize( $parameter );
-			switch ( true ) {
+		foreach ($constraintParameters[$parameterId] as $parameter) {
+			$snak = $this->snakDeserializer->deserialize($parameter);
+			switch (true) {
 				case $snak instanceof PropertyValueSnak:
-					$values[] = $this->parseItemIdParameter( $snak, $parameterId );
+					$values[] = $this->parseItemIdParameter($snak, $parameterId);
 					break;
 				case $snak instanceof PropertySomeValueSnak:
 					$values[] = ItemIdSnakValue::someValue();
@@ -323,13 +323,13 @@ 
 		bool $required,
 		string $parameterId
 	): array {
-		return array_map( static function ( ItemIdSnakValue $value ) use ( $parameterId ): ItemId {
-			if ( $value->isValue() ) {
+		return array_map(static function(ItemIdSnakValue $value) use ($parameterId): ItemId {
+			if ($value->isValue()) {
 				return $value->getItemId();
 			} else {
 				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)
 				);
 			}
 		}, $this->parseItemsParameter(
@@ -337,7 +337,7 @@ 
 			$constraintTypeItemId,
 			$required,
 			$parameterId
-		) );
+		));
 	}
 
 	/**
@@ -345,18 +345,18 @@ 
 	 * @throws ConstraintParameterException
 	 * @return mixed elements of $mapping
 	 */
-	private function mapItemId( ItemId $itemId, array $mapping, string $parameterId ) {
+	private function mapItemId(ItemId $itemId, array $mapping, string $parameterId) {
 		$serialization = $itemId->getSerialization();
-		if ( array_key_exists( $serialization, $mapping ) ) {
+		if (array_key_exists($serialization, $mapping)) {
 			return $mapping[$serialization];
 		} else {
-			$allowed = array_map( static function ( $id ) {
-				return new ItemId( $id );
-			}, array_keys( $mapping ) );
+			$allowed = array_map(static function($id) {
+				return new ItemId($id);
+			}, array_keys($mapping));
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new PropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
-					->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new PropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
+					->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -367,27 +367,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;
 	}
@@ -398,16 +398,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)
 			);
 		}
 	}
@@ -417,10 +417,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();
 		}
@@ -433,14 +433,14 @@ 
 	 * @param string $unit
 	 * @return bool
 	 */
-	private function exactlyOneQuantityWithUnit( ?DataValue $min, ?DataValue $max, $unit ) {
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
-			!( $max instanceof UnboundedQuantityValue )
+	private function exactlyOneQuantityWithUnit(?DataValue $min, ?DataValue $max, $unit) {
+		if (!($min instanceof UnboundedQuantityValue) ||
+			!($max instanceof UnboundedQuantityValue)
 		) {
 			return false;
 		}
 
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
 	}
 
 	/**
@@ -453,42 +453,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];
 	}
 
 	/**
@@ -498,11 +498,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'
 		);
@@ -515,11 +515,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'
 		);
@@ -531,20 +531,20 @@ 
 	 * @throws ConstraintParameterException
 	 * @return string[]
 	 */
-	public function parseLanguageParameter( array $constraintParameters, $constraintTypeItemId ): array {
-		$this->checkError( $constraintParameters );
-		$languagePropertyId = $this->config->get( 'WBQualityConstraintsLanguagePropertyId' );
-		if ( !array_key_exists( $languagePropertyId, $constraintParameters ) ) {
+	public function parseLanguageParameter(array $constraintParameters, $constraintTypeItemId): array {
+		$this->checkError($constraintParameters);
+		$languagePropertyId = $this->config->get('WBQualityConstraintsLanguagePropertyId');
+		if (!array_key_exists($languagePropertyId, $constraintParameters)) {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withEntityId( new PropertyId( $languagePropertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withEntityId(new PropertyId($languagePropertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 			);
 		}
 
 		$languages = [];
-		foreach ( $constraintParameters[$languagePropertyId] as $snak ) {
-			$languages[] = $this->parseStringParameter( $snak, $languagePropertyId );
+		foreach ($constraintParameters[$languagePropertyId] as $snak) {
+			$languages[] = $this->parseStringParameter($snak, $languagePropertyId);
 		}
 		return $languages;
 	}
@@ -556,17 +556,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)
 			);
 		}
 	}
@@ -577,15 +577,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);
 	}
 
 	/**
@@ -594,19 +594,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);
 	}
 
 	/**
@@ -614,16 +614,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]
 		);
@@ -634,39 +634,39 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return string|null 'mandatory', 'suggestion' 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' );
-		$supportedStatuses = [ new ItemId( $mandatoryId ) ];
-		if ( $this->config->get( 'WBQualityConstraintsEnableSuggestionConstraintStatus' ) ) {
-			$suggestionId = $this->config->get( 'WBQualityConstraintsSuggestionConstraintId' );
-			$supportedStatuses[] = new ItemId( $suggestionId );
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
+		$supportedStatuses = [new ItemId($mandatoryId)];
+		if ($this->config->get('WBQualityConstraintsEnableSuggestionConstraintStatus')) {
+			$suggestionId = $this->config->get('WBQualityConstraintsSuggestionConstraintId');
+			$supportedStatuses[] = new ItemId($suggestionId);
 		} else {
 			$suggestionId = null;
 		}
 
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
-		$this->requireValueParameter( $snak, $constraintStatusId );
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
+		$this->requireValueParameter($snak, $constraintStatusId);
 		'@phan-var \Wikibase\DataModel\Snak\PropertyValueSnak $snak';
 		$dataValue = $snak->getDataValue();
 		'@phan-var EntityIdValue $dataValue';
 		$entityId = $dataValue->getEntityId();
 		$statusId = $entityId->getSerialization();
 
-		if ( $statusId === $mandatoryId ) {
+		if ($statusId === $mandatoryId) {
 			return 'mandatory';
-		} elseif ( $statusId === $suggestionId ) {
+		} elseif ($statusId === $suggestionId) {
 			return 'suggestion';
 		} else {
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
-					->withEntityId( new PropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
+					->withEntityId(new PropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
 					->withEntityIdList(
 						$supportedStatuses,
 						Role::CONSTRAINT_PARAMETER_VALUE
@@ -682,12 +682,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)
 			);
 		}
 	}
@@ -700,31 +700,31 @@ 
 	 * @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 */
 			'@phan-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);
 	}
 
 	/**
@@ -732,11 +732,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(
@@ -769,14 +769,14 @@ 
 		array $validContextTypes,
 		array $validEntityTypes
 	): array {
-		$contextTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
+		$contextTypeParameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
 		$contextTypeItemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
 			false,
 			$contextTypeParameterId
 		);
-		$entityTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintEntityTypesId' );
+		$entityTypeParameterId = $this->config->get('WBQualityConstraintsConstraintEntityTypesId');
 		$entityTypeItemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -792,26 +792,26 @@ 
 		$contextTypes = null;
 		$entityTypes = null;
 
-		if ( $contextTypeParameterId === $entityTypeParameterId ) {
+		if ($contextTypeParameterId === $entityTypeParameterId) {
 			$itemIds = $contextTypeItemIds;
 			$mapping = $contextTypeMapping + $entityTypeMapping;
-			foreach ( $itemIds as $itemId ) {
-				$mapped = $this->mapItemId( $itemId, $mapping, $contextTypeParameterId );
-				if ( in_array( $mapped, $contextTypeMapping, true ) ) {
+			foreach ($itemIds as $itemId) {
+				$mapped = $this->mapItemId($itemId, $mapping, $contextTypeParameterId);
+				if (in_array($mapped, $contextTypeMapping, true)) {
 					$contextTypes[] = $mapped;
 				} else {
 					$entityTypes[] = $mapped;
 				}
 			}
 		} else {
-			foreach ( $contextTypeItemIds as $contextTypeItemId ) {
+			foreach ($contextTypeItemIds as $contextTypeItemId) {
 				$contextTypes[] = $this->mapItemId(
 					$contextTypeItemId,
 					$contextTypeMapping,
 					$contextTypeParameterId
 				);
 			}
-			foreach ( $entityTypeItemIds as $entityTypeItemId ) {
+			foreach ($entityTypeItemIds as $entityTypeItemId) {
 				$entityTypes[] = $this->mapItemId(
 					$entityTypeItemId,
 					$entityTypeMapping,
@@ -820,21 +820,21 @@ 
 			}
 		}
 
-		$this->checkValidScope( $constraintTypeItemId, $contextTypes, $validContextTypes );
-		$this->checkValidScope( $constraintTypeItemId, $entityTypes, $validEntityTypes );
+		$this->checkValidScope($constraintTypeItemId, $contextTypes, $validContextTypes);
+		$this->checkValidScope($constraintTypeItemId, $entityTypes, $validEntityTypes);
 
-		return [ $contextTypes, $entityTypes ];
+		return [$contextTypes, $entityTypes];
 	}
 
-	private function checkValidScope( string $constraintTypeItemId, ?array $types, array $validTypes ): void {
-		$invalidTypes = array_diff( $types ?: [], $validTypes );
-		if ( $invalidTypes !== [] ) {
-			$invalidType = array_pop( $invalidTypes );
+	private function checkValidScope(string $constraintTypeItemId, ?array $types, array $validTypes): void {
+		$invalidTypes = array_diff($types ?: [], $validTypes);
+		if ($invalidTypes !== []) {
+			$invalidType = array_pop($invalidTypes);
 			throw new ConstraintParameterException(
-				( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
-					->withConstraintScope( $invalidType, Role::CONSTRAINT_PARAMETER_VALUE )
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
-					->withConstraintScopeList( $validTypes, Role::CONSTRAINT_PARAMETER_VALUE )
+				(new ViolationMessage('wbqc-violation-message-invalid-scope'))
+					->withConstraintScope($invalidType, Role::CONSTRAINT_PARAMETER_VALUE)
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
+					->withConstraintScopeList($validTypes, Role::CONSTRAINT_PARAMETER_VALUE)
 			);
 		}
 	}
@@ -845,8 +845,8 @@ 
 	 * @param ItemId $unitId
 	 * @return string unit
 	 */
-	private function parseUnitParameter( ItemId $unitId ) {
-		return $this->unitItemConceptBaseUri . $unitId->getSerialization();
+	private function parseUnitParameter(ItemId $unitId) {
+		return $this->unitItemConceptBaseUri.$unitId->getSerialization();
 	}
 
 	/**
@@ -856,23 +856,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);
 		}
 	}
 
@@ -882,36 +882,36 @@ 
 	 * @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);
 	}
 
 	private function getEntityTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsWikibaseItemId' ) => 'item',
-			$this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) => 'property',
-			$this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) => 'lexeme',
-			$this->config->get( 'WBQualityConstraintsWikibaseFormId' ) => 'form',
-			$this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) => 'sense',
-			$this->config->get( 'WBQualityConstraintsWikibaseMediaInfoId' ) => 'mediainfo',
+			$this->config->get('WBQualityConstraintsWikibaseItemId') => 'item',
+			$this->config->get('WBQualityConstraintsWikibasePropertyId') => 'property',
+			$this->config->get('WBQualityConstraintsWikibaseLexemeId') => 'lexeme',
+			$this->config->get('WBQualityConstraintsWikibaseFormId') => 'form',
+			$this->config->get('WBQualityConstraintsWikibaseSenseId') => 'sense',
+			$this->config->get('WBQualityConstraintsWikibaseMediaInfoId') => 'mediainfo',
 		];
 	}
 
@@ -921,10 +921,10 @@ 
 	 * @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 = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
 		$itemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -933,22 +933,22 @@ 
 		);
 
 		$mapping = $this->getEntityTypeMapping();
-		foreach ( $itemIds as $itemId ) {
-			$entityType = $this->mapItemId( $itemId, $mapping, $parameterId );
+		foreach ($itemIds as $itemId) {
+			$entityType = $this->mapItemId($itemId, $mapping, $parameterId);
 			$entityTypes[] = $entityType;
 			$entityTypeItemIds[] = $itemId;
 		}
 
-		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);
 	}
 
 	/**
@@ -956,18 +956,18 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid
 	 * @return PropertyId[]
 	 */
-	public function parseSeparatorsParameter( array $constraintParameters ) {
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
+	public function parseSeparatorsParameter(array $constraintParameters) {
+		$separatorId = $this->config->get('WBQualityConstraintsSeparatorId');
 
-		if ( !array_key_exists( $separatorId, $constraintParameters ) ) {
+		if (!array_key_exists($separatorId, $constraintParameters)) {
 			return [];
 		}
 
 		$parameters = $constraintParameters[$separatorId];
 		$separators = [];
 
-		foreach ( $parameters as $parameter ) {
-			$separators[] = $this->parsePropertyIdParameter( $parameter, $separatorId );
+		foreach ($parameters as $parameter) {
+			$separators[] = $this->parsePropertyIdParameter($parameter, $separatorId);
 		}
 
 		return $separators;
@@ -975,17 +975,17 @@ 
 
 	private function getConstraintScopeContextTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' ) => Context::TYPE_STATEMENT,
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' ) => Context::TYPE_QUALIFIER,
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' ) => Context::TYPE_REFERENCE,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId') => Context::TYPE_STATEMENT,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId') => Context::TYPE_QUALIFIER,
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId') => Context::TYPE_REFERENCE,
 		];
 	}
 
 	private function getPropertyScopeContextTypeMapping(): array {
 		return [
-			$this->config->get( 'WBQualityConstraintsAsMainValueId' ) => Context::TYPE_STATEMENT,
-			$this->config->get( 'WBQualityConstraintsAsQualifiersId' ) => Context::TYPE_QUALIFIER,
-			$this->config->get( 'WBQualityConstraintsAsReferencesId' ) => Context::TYPE_REFERENCE,
+			$this->config->get('WBQualityConstraintsAsMainValueId') => Context::TYPE_STATEMENT,
+			$this->config->get('WBQualityConstraintsAsQualifiersId') => Context::TYPE_QUALIFIER,
+			$this->config->get('WBQualityConstraintsAsReferencesId') => Context::TYPE_REFERENCE,
 		];
 	}
 
@@ -995,9 +995,9 @@ 
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
 	 * @return string[] list of Context::TYPE_* constants
 	 */
-	public function parsePropertyScopeParameter( array $constraintParameters, $constraintTypeItemId ) {
+	public function parsePropertyScopeParameter(array $constraintParameters, $constraintTypeItemId) {
 		$contextTypes = [];
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
 		$itemIds = $this->parseItemIdsParameter(
 			$constraintParameters,
 			$constraintTypeItemId,
@@ -1006,14 +1006,14 @@ 
 		);
 
 		$mapping = $this->getPropertyScopeContextTypeMapping();
-		foreach ( $itemIds as $itemId ) {
-			$contextTypes[] = $this->mapItemId( $itemId, $mapping, $parameterId );
+		foreach ($itemIds as $itemId) {
+			$contextTypes[] = $this->mapItemId($itemId, $mapping, $parameterId);
 		}
 
-		if ( empty( $contextTypes ) ) {
+		if (empty($contextTypes)) {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'The "property scope" parameter is required, ' .
+				'The "property scope" parameter is required, '.
 				'and yet we seem to be missing any allowed scope'
 			);
 			// @codeCoverageIgnoreEnd

src/ConstraintCheck/Message/ViolationMessageRenderer.php

Spacing +84 added lines, -84 removed lines

@@ -77,17 +77,17 @@ 
 	 * @param ViolationMessage $violationMessage
 	 * @return string
 	 */
-	public function render( ViolationMessage $violationMessage ) {
+	public function render(ViolationMessage $violationMessage) {
 		$messageKey = $violationMessage->getMessageKey();
-		$paramsLists = [ [] ];
-		foreach ( $violationMessage->getArguments() as $argument ) {
-			$params = $this->renderArgument( $argument );
+		$paramsLists = [[]];
+		foreach ($violationMessage->getArguments() as $argument) {
+			$params = $this->renderArgument($argument);
 			$paramsLists[] = $params;
 		}
-		$allParams = call_user_func_array( 'array_merge', $paramsLists );
+		$allParams = call_user_func_array('array_merge', $paramsLists);
 		return $this->messageLocalizer
-			->msg( $messageKey )
-			->params( $allParams )
+			->msg($messageKey)
+			->params($allParams)
 			->escaped();
 	}
 
@@ -96,13 +96,13 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return string HTML
 	 */
-	protected function addRole( $value, $role ) {
-		if ( $role === null ) {
+	protected function addRole($value, $role) {
+		if ($role === null) {
 			return $value;
 		}
 
-		return '<span class="wbqc-role wbqc-role-' . htmlspecialchars( $role ) . '">' .
-			$value .
+		return '<span class="wbqc-role wbqc-role-'.htmlspecialchars($role).'">'.
+			$value.
 			'</span>';
 	}
 
@@ -110,15 +110,15 @@ 
 	 * @param string $key message key
 	 * @return string HTML
 	 */
-	protected function msgEscaped( $key ) {
-		return $this->messageLocalizer->msg( $key )->escaped();
+	protected function msgEscaped($key) {
+		return $this->messageLocalizer->msg($key)->escaped();
 	}
 
 	/**
 	 * @param array $argument
 	 * @return array[] params (for Message::params)
 	 */
-	protected function renderArgument( array $argument ) {
+	protected function renderArgument(array $argument) {
 		$methods = [
 			ViolationMessage::TYPE_ENTITY_ID => 'renderEntityId',
 			ViolationMessage::TYPE_ENTITY_ID_LIST => 'renderEntityIdList',
@@ -139,12 +139,12 @@ 
 		$value = $argument['value'];
 		$role = $argument['role'];
 
-		if ( array_key_exists( $type, $methods ) ) {
+		if (array_key_exists($type, $methods)) {
 			$method = $methods[$type];
-			$params = $this->$method( $value, $role );
+			$params = $this->$method($value, $role);
 		} else {
 			throw new InvalidArgumentException(
-				'Unknown ViolationMessage argument type ' . $type . '!'
+				'Unknown ViolationMessage argument type '.$type.'!'
 			);
 		}
 
@@ -158,46 +158,46 @@ 
 	 * and return a single-element array with a raw message param (i. e. [ Message::rawParam( … ) ])
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderList( array $list, $role, callable $render ) {
-		if ( $list === [] ) {
+	private function renderList(array $list, $role, callable $render) {
+		if ($list === []) {
 			return [
-				Message::numParam( 0 ),
-				Message::rawParam( '<ul></ul>' ),
+				Message::numParam(0),
+				Message::rawParam('<ul></ul>'),
 			];
 		}
 
-		if ( count( $list ) > $this->maxListLength ) {
-			$list = array_slice( $list, 0, $this->maxListLength );
+		if (count($list) > $this->maxListLength) {
+			$list = array_slice($list, 0, $this->maxListLength);
 			$truncated = true;
 		}
 
 		$renderedParamsLists = array_map(
 			$render,
 			$list,
-			array_fill( 0, count( $list ), $role )
+			array_fill(0, count($list), $role)
 		);
 		$renderedParams = array_map(
-			static function ( $params ) {
+			static function($params) {
 				return $params[0];
 			},
 			$renderedParamsLists
 		);
 		$renderedElements = array_map(
-			static function ( $param ) {
+			static function($param) {
 				return $param['raw'];
 			},
 			$renderedParams
 		);
-		if ( isset( $truncated ) ) {
-			$renderedElements[] = $this->msgEscaped( 'ellipsis' );
+		if (isset($truncated)) {
+			$renderedElements[] = $this->msgEscaped('ellipsis');
 		}
 
 		return array_merge(
 			[
-				Message::numParam( count( $list ) ),
+				Message::numParam(count($list)),
 				Message::rawParam(
-					'<ul><li>' .
-					implode( '</li><li>', $renderedElements ) .
+					'<ul><li>'.
+					implode('</li><li>', $renderedElements).
 					'</li></ul>'
 				),
 			],
@@ -210,11 +210,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderEntityId( EntityId $entityId, $role ) {
-		return [ Message::rawParam( $this->addRole(
-			$this->entityIdFormatter->formatEntityId( $entityId ),
+	private function renderEntityId(EntityId $entityId, $role) {
+		return [Message::rawParam($this->addRole(
+			$this->entityIdFormatter->formatEntityId($entityId),
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -222,8 +222,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderEntityIdList( array $entityIdList, $role ) {
-		return $this->renderList( $entityIdList, $role, [ $this, 'renderEntityId' ] );
+	private function renderEntityIdList(array $entityIdList, $role) {
+		return $this->renderList($entityIdList, $role, [$this, 'renderEntityId']);
 	}
 
 	/**
@@ -231,24 +231,24 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderItemIdSnakValue( ItemIdSnakValue $value, $role ) {
-		switch ( true ) {
+	private function renderItemIdSnakValue(ItemIdSnakValue $value, $role) {
+		switch (true) {
 			case $value->isValue():
-				return $this->renderEntityId( $value->getItemId(), $role );
+				return $this->renderEntityId($value->getItemId(), $role);
 			case $value->isSomeValue():
-				return [ Message::rawParam( $this->addRole(
-					'<span class="wikibase-snakview-variation-somevaluesnak">' .
-						$this->msgEscaped( 'wikibase-snakview-snaktypeselector-somevalue' ) .
+				return [Message::rawParam($this->addRole(
+					'<span class="wikibase-snakview-variation-somevaluesnak">'.
+						$this->msgEscaped('wikibase-snakview-snaktypeselector-somevalue').
 						'</span>',
 					$role
-				) ) ];
+				))];
 			case $value->isNoValue():
-				return [ Message::rawParam( $this->addRole(
-					'<span class="wikibase-snakview-variation-novaluesnak">' .
-					$this->msgEscaped( 'wikibase-snakview-snaktypeselector-novalue' ) .
+				return [Message::rawParam($this->addRole(
+					'<span class="wikibase-snakview-variation-novaluesnak">'.
+					$this->msgEscaped('wikibase-snakview-snaktypeselector-novalue').
 						'</span>',
 					$role
-				) ) ];
+				))];
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
@@ -263,8 +263,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderItemIdSnakValueList( array $valueList, $role ) {
-		return $this->renderList( $valueList, $role, [ $this, 'renderItemIdSnakValue' ] );
+	private function renderItemIdSnakValueList(array $valueList, $role) {
+		return $this->renderList($valueList, $role, [$this, 'renderItemIdSnakValue']);
 	}
 
 	/**
@@ -272,11 +272,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderDataValue( DataValue $dataValue, $role ) {
-		return [ Message::rawParam( $this->addRole(
-			$this->dataValueFormatter->format( $dataValue ),
+	private function renderDataValue(DataValue $dataValue, $role) {
+		return [Message::rawParam($this->addRole(
+			$this->dataValueFormatter->format($dataValue),
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -284,7 +284,7 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderDataValueType( $dataValueType, $role ) {
+	private function renderDataValueType($dataValueType, $role) {
 		$messageKeys = [
 			'string' => 'datatypes-type-string',
 			'monolingualtext' => 'datatypes-type-monolingualtext',
@@ -293,15 +293,15 @@ 
 			'wikibase-entityid' => 'wbqc-dataValueType-wikibase-entityid',
 		];
 
-		if ( array_key_exists( $dataValueType, $messageKeys ) ) {
-			return [ Message::rawParam( $this->addRole(
-				$this->msgEscaped( $messageKeys[$dataValueType] ),
+		if (array_key_exists($dataValueType, $messageKeys)) {
+			return [Message::rawParam($this->addRole(
+				$this->msgEscaped($messageKeys[$dataValueType]),
 				$role
-			) ) ];
+			))];
 		} else {
 			// @codeCoverageIgnoreStart
 			throw new LogicException(
-				'Unknown data value type ' . $dataValueType
+				'Unknown data value type '.$dataValueType
 			);
 			// @codeCoverageIgnoreEnd
 		}
@@ -312,11 +312,11 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderInlineCode( $code, $role ) {
-		return [ Message::rawParam( $this->addRole(
-			'<code>' . htmlspecialchars( $code ) . '</code>',
+	private function renderInlineCode($code, $role) {
+		return [Message::rawParam($this->addRole(
+			'<code>'.htmlspecialchars($code).'</code>',
 			$role
-		) ) ];
+		))];
 	}
 
 	/**
@@ -324,8 +324,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderConstraintScope( $scope, $role ) {
-		switch ( $scope ) {
+	private function renderConstraintScope($scope, $role) {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
 				$itemId = $this->config->get(
 					'WBQualityConstraintsConstraintCheckedOnMainValueId'
@@ -345,10 +345,10 @@ 
 				// callers should never let this happen, but if it does happen,
 				// showing “unknown value” seems reasonable
 				// @codeCoverageIgnoreStart
-				return $this->renderItemIdSnakValue( ItemIdSnakValue::someValue(), $role );
+				return $this->renderItemIdSnakValue(ItemIdSnakValue::someValue(), $role);
 				// @codeCoverageIgnoreEnd
 		}
-		return $this->renderEntityId( new ItemId( $itemId ), $role );
+		return $this->renderEntityId(new ItemId($itemId), $role);
 	}
 
 	/**
@@ -356,8 +356,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderConstraintScopeList( array $scopeList, $role ) {
-		return $this->renderList( $scopeList, $role, [ $this, 'renderConstraintScope' ] );
+	private function renderConstraintScopeList(array $scopeList, $role) {
+		return $this->renderList($scopeList, $role, [$this, 'renderConstraintScope']);
 	}
 
 	/**
@@ -365,25 +365,25 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of a single raw message param (i. e. [ Message::rawParam( … ) ])
 	 */
-	private function renderPropertyScope( $scope, $role ) {
-		switch ( $scope ) {
+	private function renderPropertyScope($scope, $role) {
+		switch ($scope) {
 			case Context::TYPE_STATEMENT:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsMainValueId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsMainValueId');
 				break;
 			case Context::TYPE_QUALIFIER:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsQualifiersId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsQualifiersId');
 				break;
 			case Context::TYPE_REFERENCE:
-				$itemId = $this->config->get( 'WBQualityConstraintsAsReferencesId' );
+				$itemId = $this->config->get('WBQualityConstraintsAsReferencesId');
 				break;
 			default:
 				// callers should never let this happen, but if it does happen,
 				// showing “unknown value” seems reasonable
 				// @codeCoverageIgnoreStart
-				return $this->renderItemIdSnakValue( ItemIdSnakValue::someValue(), $role );
+				return $this->renderItemIdSnakValue(ItemIdSnakValue::someValue(), $role);
 				// @codeCoverageIgnoreEnd
 		}
-		return $this->renderEntityId( new ItemId( $itemId ), $role );
+		return $this->renderEntityId(new ItemId($itemId), $role);
 	}
 
 	/**
@@ -391,8 +391,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderPropertyScopeList( array $scopeList, $role ) {
-		return $this->renderList( $scopeList, $role, [ $this, 'renderPropertyScope' ] );
+	private function renderPropertyScopeList(array $scopeList, $role) {
+		return $this->renderList($scopeList, $role, [$this, 'renderPropertyScope']);
 	}
 
 	/**
@@ -400,12 +400,12 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderLanguage( $languageCode, $role ) {
+	private function renderLanguage($languageCode, $role) {
 		return [
 			// ::renderList (through ::renderLanguageList) requires 'raw' parameter
 			// so we effectively build Message::plaintextParam here
-			Message::rawParam( htmlspecialchars( Language::fetchLanguageName( $languageCode ) ) ),
-			Message::plaintextParam( $languageCode ),
+			Message::rawParam(htmlspecialchars(Language::fetchLanguageName($languageCode))),
+			Message::plaintextParam($languageCode),
 		];
 	}
 
@@ -414,8 +414,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return array[] list of parameters as accepted by Message::params()
 	 */
-	private function renderLanguageList( $languageCodes, $role ) {
-		return $this->renderList( $languageCodes, $role, [ $this, 'renderLanguage' ] );
+	private function renderLanguageList($languageCodes, $role) {
+		return $this->renderList($languageCodes, $role, [$this, 'renderLanguage']);
 	}
 
 }

src/ConstraintCheck/Message/ViolationMessage.php

Spacing +37 added lines, -37 removed lines

@@ -128,17 +128,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 = [];
 	}
 
@@ -147,7 +147,7 @@ 
 	 * @return string
 	 */
 	public function getMessageKey() {
-		return self::MESSAGE_KEY_PREFIX . $this->messageKeySuffix;
+		return self::MESSAGE_KEY_PREFIX.$this->messageKeySuffix;
 	}
 
 	/**
@@ -167,9 +167,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;
 	}
 
@@ -181,8 +181,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);
 	}
 
 	/**
@@ -199,8 +199,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);
 	}
 
 	/**
@@ -211,8 +211,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);
 	}
 
 	/**
@@ -229,8 +229,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);
 	}
 
 	/**
@@ -241,8 +241,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);
 	}
 
 	/**
@@ -257,8 +257,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);
 	}
 
 	/**
@@ -269,8 +269,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);
 	}
 
 	/**
@@ -281,8 +281,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);
 	}
 
 	/**
@@ -293,8 +293,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);
 	}
 
 	/**
@@ -305,8 +305,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withPropertyScope( $scope, $role = null ) {
-		return $this->withArgument( self::TYPE_PROPERTY_SCOPE, $role, $scope );
+	public function withPropertyScope($scope, $role = null) {
+		return $this->withArgument(self::TYPE_PROPERTY_SCOPE, $role, $scope);
 	}
 
 	/**
@@ -317,8 +317,8 @@ 
 	 * @param string|null $role one of the Role::* constants
 	 * @return ViolationMessage
 	 */
-	public function withPropertyScopeList( array $scopeList, $role = null ) {
-		return $this->withArgument( self::TYPE_PROPERTY_SCOPE_LIST, $role, $scopeList );
+	public function withPropertyScopeList(array $scopeList, $role = null) {
+		return $this->withArgument(self::TYPE_PROPERTY_SCOPE_LIST, $role, $scopeList);
 	}
 
 	/**
@@ -333,8 +333,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);
 	}
 
 	/**
@@ -349,8 +349,8 @@ 
 	 * @param string[] $languageCodes
 	 * @return ViolationMessage
 	 */
-	public function withLanguages( $languageCodes ) {
-		return $this->withArgument( self::TYPE_LANGUAGE_LIST, null, $languageCodes );
+	public function withLanguages($languageCodes) {
+		return $this->withArgument(self::TYPE_LANGUAGE_LIST, null, $languageCodes);
 	}
 
 	/**
@@ -365,8 +365,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/Message/ViolationMessageSerializer.php

Spacing +30 added lines, -30 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',
@@ -69,12 +69,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.'!'
 			);
 		}
 
@@ -91,8 +91,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;
 	}
 
@@ -100,8 +100,8 @@ 
 	 * @param string[] $strings
 	 * @return string[]
 	 */
-	private function serializeStringListByIdentity( $strings ) {
-		Assert::parameterElementType( 'string', $strings, '$strings' );
+	private function serializeStringListByIdentity($strings) {
+		Assert::parameterElementType('string', $strings, '$strings');
 		return $strings;
 	}
 
@@ -109,7 +109,7 @@ 
 	 * @param EntityId $entityId
 	 * @return string entity ID serialization
 	 */
-	private function serializeEntityId( EntityId $entityId ) {
+	private function serializeEntityId(EntityId $entityId) {
 		return $entityId->getSerialization();
 	}
 
@@ -117,8 +117,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);
 	}
 
 	/**
@@ -126,10 +126,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():
@@ -147,15 +147,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();
 	}
 
@@ -163,8 +163,8 @@ 
 	 * @param string $contextType one of the Context::TYPE_* constants
 	 * @return string the abbreviated context type
 	 */
-	private function serializeContextType( $contextType ) {
-		switch ( $contextType ) {
+	private function serializeContextType($contextType) {
+		switch ($contextType) {
 			case Context::TYPE_STATEMENT:
 				return 's';
 			case Context::TYPE_QUALIFIER:
@@ -174,7 +174,7 @@ 
 			default:
 				// @codeCoverageIgnoreStart
 				throw new LogicException(
-					'Unknown context type ' . $contextType
+					'Unknown context type '.$contextType
 				);
 				// @codeCoverageIgnoreEnd
 		}
@@ -184,15 +184,15 @@ 
 	 * @param string[] $contextTypeList Context::TYPE_* constants
 	 * @return string[] abbreviated context types
 	 */
-	private function serializeContextTypeList( array $contextTypeList ) {
-		return array_map( [ $this, 'serializeContextType' ], $contextTypeList );
+	private function serializeContextTypeList(array $contextTypeList) {
+		return array_map([$this, 'serializeContextType'], $contextTypeList);
 	}
 
 	/**
 	 * @param MultilingualTextValue $text
 	 * @return mixed {@see MultilingualTextValue::getArrayValue}
 	 */
-	private function serializeMultilingualText( MultilingualTextValue $text ) {
+	private function serializeMultilingualText(MultilingualTextValue $text) {
 		return $text->getArrayValue();
 	}
 

src/ConstraintCheck/Checker/LabelInLanguageChecker.php

Spacing +12 added lines, -12 removed lines

@@ -22,7 +22,7 @@ 
 	 */
 	private $constraintParameterParser;
 
-	public function __construct( ConstraintParameterParser $constraintParameterParser ) {
+	public function __construct(ConstraintParameterParser $constraintParameterParser) {
 		$this->constraintParameterParser = $constraintParameterParser;
 	}
 
@@ -68,9 +68,9 @@ 
 	 * @throws ConstraintParameterException
 	 * @return CheckResult
 	 */
-	public function checkConstraint( Context $context, Constraint $constraint ): CheckResult {
-		if ( $context->getSnakRank() === Statement::RANK_DEPRECATED ) {
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_DEPRECATED );
+	public function checkConstraint(Context $context, Constraint $constraint): CheckResult {
+		if ($context->getSnakRank() === Statement::RANK_DEPRECATED) {
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_DEPRECATED);
 		}
 
 		$parameters = [];
@@ -83,26 +83,26 @@ 
 		$parameters['language'] = $languages;
 
 		$status = CheckResult::STATUS_VIOLATION;
-		$message = ( new ViolationMessage( 'wbqc-violation-message-label-lacking' ) )
-			->withEntityId( $context->getSnak()->getPropertyId(), Role::PREDICATE )
-			->withLanguages( $languages );
+		$message = (new ViolationMessage('wbqc-violation-message-label-lacking'))
+			->withEntityId($context->getSnak()->getPropertyId(), Role::PREDICATE)
+			->withLanguages($languages);
 
 		/** @var LabelsProvider $entity */
 		$entity = $context->getEntity();
 		'@phan-var LabelsProvider $entity';
 
-		foreach ( $languages as $language ) {
-			if ( $entity->getLabels()->hasTermForLanguage( $language ) ) {
+		foreach ($languages as $language) {
+			if ($entity->getLabels()->hasTermForLanguage($language)) {
 				$message = null;
 				$status = CheckResult::STATUS_COMPLIANCE;
 				break;
 			}
 		}
 
-		return new CheckResult( $context, $constraint, $parameters, $status, $message );
+		return new CheckResult($context, $constraint, $parameters, $status, $message);
 	}
 
-	public function checkConstraintParameters( Constraint $constraint ): array {
+	public function checkConstraintParameters(Constraint $constraint): array {
 		$constraintParameters = $constraint->getConstraintParameters();
 		$exceptions = [];
 		try {
@@ -110,7 +110,7 @@ 
 				$constraintParameters,
 				$constraint->getConstraintTypeItemId()
 			);
-		} catch ( ConstraintParameterException $e ) {
+		} catch (ConstraintParameterException $e) {
 			$exceptions[] = $e;
 		}
 		return $exceptions;