Completed
Push — master ( ad1496...5137f4 )
by
unknown
57s queued 16s
created
src/ConstraintCheck/Helper/TypeCheckerHelper.php 1 patch
Spacing   +54 added lines, -54 removed lines patch added patch discarded remove patch
@@ -81,26 +81,26 @@  discard block
 block discarded – undo
81 81
 	 * @return bool
82 82
 	 * @throws OverflowException if $entitiesChecked exceeds the configured limit
83 83
 	 */
84
-	private function isSubclassOf( EntityId $comparativeClass, array $classesToCheck, &$entitiesChecked = 0 ) {
85
-		$maxEntities = $this->config->get( 'WBQualityConstraintsTypeCheckMaxEntities' );
84
+	private function isSubclassOf(EntityId $comparativeClass, array $classesToCheck, &$entitiesChecked = 0) {
85
+		$maxEntities = $this->config->get('WBQualityConstraintsTypeCheckMaxEntities');
86 86
 		if ( ++$entitiesChecked > $maxEntities ) {
87
-			throw new OverflowException( 'Too many entities to check' );
87
+			throw new OverflowException('Too many entities to check');
88 88
 		}
89 89
 
90
-		$item = $this->entityLookup->getEntity( $comparativeClass );
91
-		if ( !( $item instanceof StatementListProvider ) ) {
90
+		$item = $this->entityLookup->getEntity($comparativeClass);
91
+		if (!($item instanceof StatementListProvider)) {
92 92
 			return false; // lookup failed, probably because item doesn't exist
93 93
 		}
94 94
 
95
-		$subclassId = $this->config->get( 'WBQualityConstraintsSubclassOfId' );
95
+		$subclassId = $this->config->get('WBQualityConstraintsSubclassOfId');
96 96
 		$statements = $item->getStatements()
97
-			->getByPropertyId( new NumericPropertyId( $subclassId ) )
97
+			->getByPropertyId(new NumericPropertyId($subclassId))
98 98
 			->getBestStatements();
99 99
 		/** @var Statement $statement */
100
-		foreach ( $statements as $statement ) {
100
+		foreach ($statements as $statement) {
101 101
 			$mainSnak = $statement->getMainSnak();
102 102
 
103
-			if ( !$this->hasCorrectType( $mainSnak ) ) {
103
+			if (!$this->hasCorrectType($mainSnak)) {
104 104
 				continue;
105 105
 			}
106 106
 			/** @var PropertyValueSnak $mainSnak */
@@ -110,11 +110,11 @@  discard block
 block discarded – undo
110 110
 			'@phan-var EntityIdValue $dataValue';
111 111
 			$comparativeClass = $dataValue->getEntityId();
112 112
 
113
-			if ( in_array( $comparativeClass->getSerialization(), $classesToCheck ) ) {
113
+			if (in_array($comparativeClass->getSerialization(), $classesToCheck)) {
114 114
 				return true;
115 115
 			}
116 116
 
117
-			if ( $this->isSubclassOf( $comparativeClass, $classesToCheck, $entitiesChecked ) ) {
117
+			if ($this->isSubclassOf($comparativeClass, $classesToCheck, $entitiesChecked)) {
118 118
 				return true;
119 119
 			}
120 120
 		}
@@ -135,40 +135,40 @@  discard block
 block discarded – undo
135 135
 	 * @return CachedBool
136 136
 	 * @throws SparqlHelperException if SPARQL is used and the query times out or some other error occurs
137 137
 	 */
138
-	public function isSubclassOfWithSparqlFallback( EntityId $comparativeClass, array $classesToCheck ) {
139
-		$timing = $this->statsFactory->getTiming( 'isSubclassOf_duration_seconds' )
140
-			->setLabel( 'result', 'success' )
141
-			->setLabel( 'TypeCheckerImplementation', 'php' )
142
-			->copyToStatsdAt( 'wikibase.quality.constraints.type.php.success.timing' );
138
+	public function isSubclassOfWithSparqlFallback(EntityId $comparativeClass, array $classesToCheck) {
139
+		$timing = $this->statsFactory->getTiming('isSubclassOf_duration_seconds')
140
+			->setLabel('result', 'success')
141
+			->setLabel('TypeCheckerImplementation', 'php')
142
+			->copyToStatsdAt('wikibase.quality.constraints.type.php.success.timing');
143 143
 		$timing->start();
144 144
 
145 145
 		try {
146 146
 			$entitiesChecked = 0;
147
-			$isSubclass = $this->isSubclassOf( $comparativeClass, $classesToCheck, $entitiesChecked );
147
+			$isSubclass = $this->isSubclassOf($comparativeClass, $classesToCheck, $entitiesChecked);
148 148
 			$timing->stop();
149 149
 
150 150
 			// not really a timing, but works like one (we want percentiles etc.)
151 151
 			// TODO: probably a good candidate for T348796
152
-			$this->statsFactory->getTiming( 'isSubclassOf_entities_total' )
153
-				->setLabel( 'TypeCheckerImplementation', 'php' )
154
-				->setLabel( 'result', 'success' )
155
-				->copyToStatsdAt( 'wikibase.quality.constraints.type.php.success.entities' )
156
-				->observe( $entitiesChecked );
157
-
158
-			return new CachedBool( $isSubclass, Metadata::blank() );
159
-		} catch ( OverflowException $e ) {
160
-			$timing->setLabel( 'result', 'overflow' )
161
-				->copyToStatsdAt( 'wikibase.quality.constraints.type.php.overflow.timing' )
152
+			$this->statsFactory->getTiming('isSubclassOf_entities_total')
153
+				->setLabel('TypeCheckerImplementation', 'php')
154
+				->setLabel('result', 'success')
155
+				->copyToStatsdAt('wikibase.quality.constraints.type.php.success.entities')
156
+				->observe($entitiesChecked);
157
+
158
+			return new CachedBool($isSubclass, Metadata::blank());
159
+		} catch (OverflowException $e) {
160
+			$timing->setLabel('result', 'overflow')
161
+				->copyToStatsdAt('wikibase.quality.constraints.type.php.overflow.timing')
162 162
 				->stop();
163 163
 
164
-			if ( !( $this->sparqlHelper instanceof DummySparqlHelper ) ) {
165
-				$this->statsFactory->getCounter( 'sparql_typeFallback_total' )
166
-					->copyToStatsdAt( 'wikibase.quality.constraints.sparql.typeFallback' )
164
+			if (!($this->sparqlHelper instanceof DummySparqlHelper)) {
165
+				$this->statsFactory->getCounter('sparql_typeFallback_total')
166
+					->copyToStatsdAt('wikibase.quality.constraints.sparql.typeFallback')
167 167
 					->increment();
168 168
 
169
-				$timing->setLabel( 'TypeCheckerImplementation', 'sparql' )
170
-					->setLabel( 'result', 'success' )
171
-					->copyToStatsdAt( 'wikibase.quality.constraints.type.sparql.success.timing' )
169
+				$timing->setLabel('TypeCheckerImplementation', 'sparql')
170
+					->setLabel('result', 'success')
171
+					->copyToStatsdAt('wikibase.quality.constraints.type.sparql.success.timing')
172 172
 					->start();
173 173
 
174 174
 				$hasType = $this->sparqlHelper->hasType(
@@ -180,7 +180,7 @@  discard block
 block discarded – undo
180 180
 
181 181
 				return $hasType;
182 182
 			} else {
183
-				return new CachedBool( false, Metadata::blank() );
183
+				return new CachedBool(false, Metadata::blank());
184 184
 			}
185 185
 		}
186 186
 	}
@@ -198,13 +198,13 @@  discard block
 block discarded – undo
198 198
 	 * @return CachedBool
199 199
 	 * @throws SparqlHelperException if SPARQL is used and the query times out or some other error occurs
200 200
 	 */
201
-	public function hasClassInRelation( StatementList $statements, array $relationIds, array $classesToCheck ) {
201
+	public function hasClassInRelation(StatementList $statements, array $relationIds, array $classesToCheck) {
202 202
 		$metadatas = [];
203 203
 
204
-		foreach ( $this->getBestStatementsByPropertyIds( $statements, $relationIds ) as $statement ) {
204
+		foreach ($this->getBestStatementsByPropertyIds($statements, $relationIds) as $statement) {
205 205
 			$mainSnak = $statement->getMainSnak();
206 206
 
207
-			if ( !$this->hasCorrectType( $mainSnak ) ) {
207
+			if (!$this->hasCorrectType($mainSnak)) {
208 208
 				continue;
209 209
 			}
210 210
 			/** @var PropertyValueSnak $mainSnak */
@@ -214,24 +214,24 @@  discard block
 block discarded – undo
214 214
 			'@phan-var EntityIdValue $dataValue';
215 215
 			$comparativeClass = $dataValue->getEntityId();
216 216
 
217
-			if ( in_array( $comparativeClass->getSerialization(), $classesToCheck ) ) {
217
+			if (in_array($comparativeClass->getSerialization(), $classesToCheck)) {
218 218
 				// discard $metadatas, we know this is fresh
219
-				return new CachedBool( true, Metadata::blank() );
219
+				return new CachedBool(true, Metadata::blank());
220 220
 			}
221 221
 
222
-			$result = $this->isSubclassOfWithSparqlFallback( $comparativeClass, $classesToCheck );
222
+			$result = $this->isSubclassOfWithSparqlFallback($comparativeClass, $classesToCheck);
223 223
 			$metadatas[] = $result->getMetadata();
224
-			if ( $result->getBool() ) {
224
+			if ($result->getBool()) {
225 225
 				return new CachedBool(
226 226
 					true,
227
-					Metadata::merge( $metadatas )
227
+					Metadata::merge($metadatas)
228 228
 				);
229 229
 			}
230 230
 		}
231 231
 
232 232
 		return new CachedBool(
233 233
 			false,
234
-			Metadata::merge( $metadatas )
234
+			Metadata::merge($metadatas)
235 235
 		);
236 236
 	}
237 237
 
@@ -240,7 +240,7 @@  discard block
 block discarded – undo
240 240
 	 * @return bool
241 241
 	 * @phan-assert PropertyValueSnak $mainSnak
242 242
 	 */
243
-	private function hasCorrectType( Snak $mainSnak ) {
243
+	private function hasCorrectType(Snak $mainSnak) {
244 244
 		return $mainSnak instanceof PropertyValueSnak
245 245
 			&& $mainSnak->getDataValue()->getType() === 'wikibase-entityid';
246 246
 	}
@@ -257,15 +257,15 @@  discard block
 block discarded – undo
257 257
 	) {
258 258
 		$statementArrays = [];
259 259
 
260
-		foreach ( $propertyIdSerializations as $propertyIdSerialization ) {
261
-			$propertyId = new NumericPropertyId( $propertyIdSerialization );
260
+		foreach ($propertyIdSerializations as $propertyIdSerialization) {
261
+			$propertyId = new NumericPropertyId($propertyIdSerialization);
262 262
 			$statementArrays[] = $statements
263
-				->getByPropertyId( $propertyId )
263
+				->getByPropertyId($propertyId)
264 264
 				->getBestStatements()
265 265
 				->toArray();
266 266
 		}
267 267
 
268
-		return call_user_func_array( 'array_merge', $statementArrays );
268
+		return call_user_func_array('array_merge', $statementArrays);
269 269
 	}
270 270
 
271 271
 	/**
@@ -285,8 +285,8 @@  discard block
 block discarded – undo
285 285
 		$relation
286 286
 	) {
287 287
 		$classes = array_map(
288
-			static function ( $itemIdSerialization ) {
289
-				return new ItemId( $itemIdSerialization );
288
+			static function($itemIdSerialization) {
289
+				return new ItemId($itemIdSerialization);
290 290
 			},
291 291
 			$classes
292 292
 		);
@@ -298,10 +298,10 @@  discard block
 block discarded – undo
298 298
 		// wbqc-violation-message-valueType-instance
299 299
 		// wbqc-violation-message-valueType-subclass
300 300
 		// wbqc-violation-message-valueType-instanceOrSubclass
301
-		return ( new ViolationMessage( 'wbqc-violation-message-' . $checker . '-' . $relation ) )
302
-			->withEntityId( $propertyId, Role::CONSTRAINT_PROPERTY )
303
-			->withEntityId( $entityId, Role::SUBJECT )
304
-			->withEntityIdList( $classes, Role::OBJECT );
301
+		return (new ViolationMessage('wbqc-violation-message-'.$checker.'-'.$relation))
302
+			->withEntityId($propertyId, Role::CONSTRAINT_PROPERTY)
303
+			->withEntityId($entityId, Role::SUBJECT)
304
+			->withEntityIdList($classes, Role::OBJECT);
305 305
 	}
306 306
 
307 307
 }
Please login to merge, or discard this patch.
src/ServiceWiring-Wikibase.php 1 patch
Spacing   +7 added lines, -7 removed lines patch added patch discarded remove patch
@@ -10,20 +10,20 @@
 block discarded – undo
10 10
 use Wikibase\Repo\WikibaseRepo;
11 11
 
12 12
 return [
13
-	WikibaseServices::ENTITY_LOOKUP => static function ( MediaWikiServices $services ): EntityLookup {
13
+	WikibaseServices::ENTITY_LOOKUP => static function(MediaWikiServices $services): EntityLookup {
14 14
 		return new ExceptionIgnoringEntityLookup(
15
-			WikibaseRepo::getEntityLookup( $services )
15
+			WikibaseRepo::getEntityLookup($services)
16 16
 		);
17 17
 	},
18 18
 
19
-	WikibaseServices::ENTITY_LOOKUP_WITHOUT_CACHE => static function ( MediaWikiServices $services ): EntityLookup {
19
+	WikibaseServices::ENTITY_LOOKUP_WITHOUT_CACHE => static function(MediaWikiServices $services): EntityLookup {
20 20
 		return new ExceptionIgnoringEntityLookup(
21
-			WikibaseRepo::getStore( $services )
22
-				->getEntityLookup( Store::LOOKUP_CACHING_RETRIEVE_ONLY )
21
+			WikibaseRepo::getStore($services)
22
+				->getEntityLookup(Store::LOOKUP_CACHING_RETRIEVE_ONLY)
23 23
 		);
24 24
 	},
25 25
 
26
-	WikibaseServices::PROPERTY_DATA_TYPE_LOOKUP => static function ( MediaWikiServices $services ): PropertyDataTypeLookup {
27
-		return WikibaseRepo::getPropertyDataTypeLookup( $services );
26
+	WikibaseServices::PROPERTY_DATA_TYPE_LOOKUP => static function(MediaWikiServices $services): PropertyDataTypeLookup {
27
+		return WikibaseRepo::getPropertyDataTypeLookup($services);
28 28
 	},
29 29
 ];
Please login to merge, or discard this patch.
src/ServiceWiring-ConstraintCheckers.php 1 patch
Spacing   +75 added lines, -75 removed lines patch added patch discarded remove patch
@@ -38,216 +38,216 @@
 block discarded – undo
38 38
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Checker\ValueTypeChecker;
39 39
 
40 40
 return [
41
-	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function ( MediaWikiServices $services ): ConflictsWithChecker {
41
+	ConstraintCheckerServices::CONFLICTS_WITH_CHECKER => static function(MediaWikiServices $services): ConflictsWithChecker {
42 42
 		return new ConflictsWithChecker(
43
-			ConstraintsServices::getConstraintParameterParser( $services ),
44
-			ConstraintsServices::getConnectionCheckerHelper( $services )
43
+			ConstraintsServices::getConstraintParameterParser($services),
44
+			ConstraintsServices::getConnectionCheckerHelper($services)
45 45
 		);
46 46
 	},
47 47
 
48
-	ConstraintCheckerServices::ITEM_CHECKER => static function ( MediaWikiServices $services ): ItemChecker {
48
+	ConstraintCheckerServices::ITEM_CHECKER => static function(MediaWikiServices $services): ItemChecker {
49 49
 		return new ItemChecker(
50
-			ConstraintsServices::getConstraintParameterParser( $services ),
51
-			ConstraintsServices::getConnectionCheckerHelper( $services )
50
+			ConstraintsServices::getConstraintParameterParser($services),
51
+			ConstraintsServices::getConnectionCheckerHelper($services)
52 52
 		);
53 53
 	},
54 54
 
55
-	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function (
55
+	ConstraintCheckerServices::TARGET_REQUIRED_CLAIM_CHECKER => static function(
56 56
 		MediaWikiServices $services
57 57
 	): TargetRequiredClaimChecker {
58 58
 		return new TargetRequiredClaimChecker(
59
-			WikibaseServices::getEntityLookup( $services ),
60
-			ConstraintsServices::getConstraintParameterParser( $services ),
61
-			ConstraintsServices::getConnectionCheckerHelper( $services )
59
+			WikibaseServices::getEntityLookup($services),
60
+			ConstraintsServices::getConstraintParameterParser($services),
61
+			ConstraintsServices::getConnectionCheckerHelper($services)
62 62
 		);
63 63
 	},
64 64
 
65
-	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function ( MediaWikiServices $services ): SymmetricChecker {
65
+	ConstraintCheckerServices::SYMMETRIC_CHECKER => static function(MediaWikiServices $services): SymmetricChecker {
66 66
 		return new SymmetricChecker(
67
-			WikibaseServices::getEntityLookupWithoutCache( $services ),
68
-			ConstraintsServices::getConnectionCheckerHelper( $services )
67
+			WikibaseServices::getEntityLookupWithoutCache($services),
68
+			ConstraintsServices::getConnectionCheckerHelper($services)
69 69
 		);
70 70
 	},
71 71
 
72
-	ConstraintCheckerServices::INVERSE_CHECKER => static function ( MediaWikiServices $services ): InverseChecker {
72
+	ConstraintCheckerServices::INVERSE_CHECKER => static function(MediaWikiServices $services): InverseChecker {
73 73
 		return new InverseChecker(
74
-			WikibaseServices::getEntityLookup( $services ),
75
-			ConstraintsServices::getConstraintParameterParser( $services ),
76
-			ConstraintsServices::getConnectionCheckerHelper( $services )
74
+			WikibaseServices::getEntityLookup($services),
75
+			ConstraintsServices::getConstraintParameterParser($services),
76
+			ConstraintsServices::getConnectionCheckerHelper($services)
77 77
 		);
78 78
 	},
79 79
 
80
-	ConstraintCheckerServices::QUALIFIER_CHECKER => static function ( MediaWikiServices $services ): QualifierChecker {
80
+	ConstraintCheckerServices::QUALIFIER_CHECKER => static function(MediaWikiServices $services): QualifierChecker {
81 81
 		return new QualifierChecker();
82 82
 	},
83 83
 
84
-	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function ( MediaWikiServices $services ): QualifiersChecker {
84
+	ConstraintCheckerServices::QUALIFIERS_CHECKER => static function(MediaWikiServices $services): QualifiersChecker {
85 85
 		return new QualifiersChecker(
86
-			ConstraintsServices::getConstraintParameterParser( $services )
86
+			ConstraintsServices::getConstraintParameterParser($services)
87 87
 		);
88 88
 	},
89 89
 
90
-	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function (
90
+	ConstraintCheckerServices::MANDATORY_QUALIFIERS_CHECKER => static function(
91 91
 		MediaWikiServices $services
92 92
 	): MandatoryQualifiersChecker {
93 93
 		return new MandatoryQualifiersChecker(
94
-			ConstraintsServices::getConstraintParameterParser( $services )
94
+			ConstraintsServices::getConstraintParameterParser($services)
95 95
 		);
96 96
 	},
97 97
 
98
-	ConstraintCheckerServices::RANGE_CHECKER => static function ( MediaWikiServices $services ): RangeChecker {
98
+	ConstraintCheckerServices::RANGE_CHECKER => static function(MediaWikiServices $services): RangeChecker {
99 99
 		return new RangeChecker(
100
-			WikibaseServices::getPropertyDataTypeLookup( $services ),
101
-			ConstraintsServices::getConstraintParameterParser( $services ),
102
-			ConstraintsServices::getRangeCheckerHelper( $services )
100
+			WikibaseServices::getPropertyDataTypeLookup($services),
101
+			ConstraintsServices::getConstraintParameterParser($services),
102
+			ConstraintsServices::getRangeCheckerHelper($services)
103 103
 		);
104 104
 	},
105 105
 
106
-	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function (
106
+	ConstraintCheckerServices::DIFF_WITHIN_RANGE_CHECKER => static function(
107 107
 		MediaWikiServices $services
108 108
 	): DiffWithinRangeChecker {
109 109
 		return new DiffWithinRangeChecker(
110
-			ConstraintsServices::getConstraintParameterParser( $services ),
111
-			ConstraintsServices::getRangeCheckerHelper( $services ),
110
+			ConstraintsServices::getConstraintParameterParser($services),
111
+			ConstraintsServices::getRangeCheckerHelper($services),
112 112
 			$services->getMainConfig()
113 113
 		);
114 114
 	},
115 115
 
116
-	ConstraintCheckerServices::TYPE_CHECKER => static function ( MediaWikiServices $services ): TypeChecker {
116
+	ConstraintCheckerServices::TYPE_CHECKER => static function(MediaWikiServices $services): TypeChecker {
117 117
 		return new TypeChecker(
118
-			ConstraintsServices::getConstraintParameterParser( $services ),
119
-			ConstraintsServices::getTypeCheckerHelper( $services ),
118
+			ConstraintsServices::getConstraintParameterParser($services),
119
+			ConstraintsServices::getTypeCheckerHelper($services),
120 120
 			$services->getMainConfig()
121 121
 		);
122 122
 	},
123 123
 
124
-	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function ( MediaWikiServices $services ): ValueTypeChecker {
124
+	ConstraintCheckerServices::VALUE_TYPE_CHECKER => static function(MediaWikiServices $services): ValueTypeChecker {
125 125
 		return new ValueTypeChecker(
126
-			WikibaseServices::getEntityLookup( $services ),
127
-			ConstraintsServices::getConstraintParameterParser( $services ),
128
-			ConstraintsServices::getTypeCheckerHelper( $services ),
126
+			WikibaseServices::getEntityLookup($services),
127
+			ConstraintsServices::getConstraintParameterParser($services),
128
+			ConstraintsServices::getTypeCheckerHelper($services),
129 129
 			$services->getMainConfig()
130 130
 		);
131 131
 	},
132 132
 
133
-	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function ( MediaWikiServices $services ): SingleValueChecker {
133
+	ConstraintCheckerServices::SINGLE_VALUE_CHECKER => static function(MediaWikiServices $services): SingleValueChecker {
134 134
 		return new SingleValueChecker(
135
-			ConstraintsServices::getConstraintParameterParser( $services )
135
+			ConstraintsServices::getConstraintParameterParser($services)
136 136
 		);
137 137
 	},
138 138
 
139
-	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function ( MediaWikiServices $services ): MultiValueChecker {
139
+	ConstraintCheckerServices::MULTI_VALUE_CHECKER => static function(MediaWikiServices $services): MultiValueChecker {
140 140
 		return new MultiValueChecker(
141
-			ConstraintsServices::getConstraintParameterParser( $services )
141
+			ConstraintsServices::getConstraintParameterParser($services)
142 142
 		);
143 143
 	},
144 144
 
145
-	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function ( MediaWikiServices $services ): UniqueValueChecker {
145
+	ConstraintCheckerServices::UNIQUE_VALUE_CHECKER => static function(MediaWikiServices $services): UniqueValueChecker {
146 146
 		// TODO return a different, dummy implementation if SPARQL is not available
147 147
 		return new UniqueValueChecker(
148
-			ConstraintsServices::getSparqlHelper( $services ),
149
-			ConstraintsServices::getConstraintParameterParser( $services )
148
+			ConstraintsServices::getSparqlHelper($services),
149
+			ConstraintsServices::getConstraintParameterParser($services)
150 150
 		);
151 151
 	},
152 152
 
153
-	ConstraintCheckerServices::FORMAT_CHECKER => static function ( MediaWikiServices $services ): FormatChecker {
153
+	ConstraintCheckerServices::FORMAT_CHECKER => static function(MediaWikiServices $services): FormatChecker {
154 154
 		// TODO return a different, dummy implementation if SPARQL is not available
155 155
 		return new FormatChecker(
156
-			ConstraintsServices::getConstraintParameterParser( $services ),
156
+			ConstraintsServices::getConstraintParameterParser($services),
157 157
 			$services->getMainConfig(),
158
-			ConstraintsServices::getSparqlHelper( $services ),
158
+			ConstraintsServices::getSparqlHelper($services),
159 159
 			$services->getShellboxClientFactory()
160 160
 		);
161 161
 	},
162 162
 
163
-	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function ( MediaWikiServices $services ): CommonsLinkChecker {
163
+	ConstraintCheckerServices::COMMONS_LINK_CHECKER => static function(MediaWikiServices $services): CommonsLinkChecker {
164 164
 		$pageNameNormalizer = new MediaWikiPageNameNormalizer();
165 165
 		return new CommonsLinkChecker(
166
-			ConstraintsServices::getConstraintParameterParser( $services ),
166
+			ConstraintsServices::getConstraintParameterParser($services),
167 167
 			$pageNameNormalizer,
168
-			WikibaseRepo::getPropertyDataTypeLookup( $services )
168
+			WikibaseRepo::getPropertyDataTypeLookup($services)
169 169
 		);
170 170
 	},
171 171
 
172
-	ConstraintCheckerServices::ONE_OF_CHECKER => static function ( MediaWikiServices $services ): OneOfChecker {
172
+	ConstraintCheckerServices::ONE_OF_CHECKER => static function(MediaWikiServices $services): OneOfChecker {
173 173
 		return new OneOfChecker(
174
-			ConstraintsServices::getConstraintParameterParser( $services )
174
+			ConstraintsServices::getConstraintParameterParser($services)
175 175
 		);
176 176
 	},
177 177
 
178
-	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function ( MediaWikiServices $services ): ValueOnlyChecker {
178
+	ConstraintCheckerServices::VALUE_ONLY_CHECKER => static function(MediaWikiServices $services): ValueOnlyChecker {
179 179
 		return new ValueOnlyChecker();
180 180
 	},
181 181
 
182
-	ConstraintCheckerServices::REFERENCE_CHECKER => static function ( MediaWikiServices $services ): ReferenceChecker {
182
+	ConstraintCheckerServices::REFERENCE_CHECKER => static function(MediaWikiServices $services): ReferenceChecker {
183 183
 		return new ReferenceChecker();
184 184
 	},
185 185
 
186
-	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function ( MediaWikiServices $services ): NoBoundsChecker {
186
+	ConstraintCheckerServices::NO_BOUNDS_CHECKER => static function(MediaWikiServices $services): NoBoundsChecker {
187 187
 		return new NoBoundsChecker();
188 188
 	},
189 189
 
190
-	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function ( MediaWikiServices $services ): AllowedUnitsChecker {
190
+	ConstraintCheckerServices::ALLOWED_UNITS_CHECKER => static function(MediaWikiServices $services): AllowedUnitsChecker {
191 191
 		return new AllowedUnitsChecker(
192
-			ConstraintsServices::getConstraintParameterParser( $services ),
193
-			WikibaseRepo::getUnitConverter( $services )
192
+			ConstraintsServices::getConstraintParameterParser($services),
193
+			WikibaseRepo::getUnitConverter($services)
194 194
 		);
195 195
 	},
196 196
 
197
-	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function (
197
+	ConstraintCheckerServices::SINGLE_BEST_VALUE_CHECKER => static function(
198 198
 		MediaWikiServices $services
199 199
 	): SingleBestValueChecker {
200 200
 		return new SingleBestValueChecker(
201
-			ConstraintsServices::getConstraintParameterParser( $services )
201
+			ConstraintsServices::getConstraintParameterParser($services)
202 202
 		);
203 203
 	},
204 204
 
205
-	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function ( MediaWikiServices $services ): EntityTypeChecker {
205
+	ConstraintCheckerServices::ENTITY_TYPE_CHECKER => static function(MediaWikiServices $services): EntityTypeChecker {
206 206
 		return new EntityTypeChecker(
207
-			ConstraintsServices::getConstraintParameterParser( $services )
207
+			ConstraintsServices::getConstraintParameterParser($services)
208 208
 		);
209 209
 	},
210 210
 
211
-	ConstraintCheckerServices::NONE_OF_CHECKER => static function ( MediaWikiServices $services ): NoneOfChecker {
211
+	ConstraintCheckerServices::NONE_OF_CHECKER => static function(MediaWikiServices $services): NoneOfChecker {
212 212
 		return new NoneOfChecker(
213
-			ConstraintsServices::getConstraintParameterParser( $services )
213
+			ConstraintsServices::getConstraintParameterParser($services)
214 214
 		);
215 215
 	},
216 216
 
217
-	ConstraintCheckerServices::INTEGER_CHECKER => static function ( MediaWikiServices $services ): IntegerChecker {
217
+	ConstraintCheckerServices::INTEGER_CHECKER => static function(MediaWikiServices $services): IntegerChecker {
218 218
 		return new IntegerChecker();
219 219
 	},
220 220
 
221
-	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function ( MediaWikiServices $services ): CitationNeededChecker {
221
+	ConstraintCheckerServices::CITATION_NEEDED_CHECKER => static function(MediaWikiServices $services): CitationNeededChecker {
222 222
 		return new CitationNeededChecker();
223 223
 	},
224 224
 
225
-	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function ( MediaWikiServices $services ): PropertyScopeChecker {
225
+	ConstraintCheckerServices::PROPERTY_SCOPE_CHECKER => static function(MediaWikiServices $services): PropertyScopeChecker {
226 226
 		return new PropertyScopeChecker(
227
-			ConstraintsServices::getConstraintParameterParser( $services )
227
+			ConstraintsServices::getConstraintParameterParser($services)
228 228
 		);
229 229
 	},
230 230
 
231
-	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function ( MediaWikiServices $services ): ContemporaryChecker {
231
+	ConstraintCheckerServices::CONTEMPORARY_CHECKER => static function(MediaWikiServices $services): ContemporaryChecker {
232 232
 		return new ContemporaryChecker(
233
-			WikibaseServices::getEntityLookup( $services ),
234
-			ConstraintsServices::getRangeCheckerHelper( $services ),
233
+			WikibaseServices::getEntityLookup($services),
234
+			ConstraintsServices::getRangeCheckerHelper($services),
235 235
 			$services->getMainConfig()
236 236
 		);
237 237
 	},
238 238
 
239
-	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function ( MediaWikiServices $services ): LanguageChecker {
239
+	ConstraintCheckerServices::LEXEME_LANGUAGE_CHECKER => static function(MediaWikiServices $services): LanguageChecker {
240 240
 		return new LanguageChecker(
241
-			ConstraintsServices::getConstraintParameterParser( $services ),
242
-			WikibaseServices::getEntityLookup( $services )
241
+			ConstraintsServices::getConstraintParameterParser($services),
242
+			WikibaseServices::getEntityLookup($services)
243 243
 		);
244 244
 	},
245 245
 
246
-	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function (
246
+	ConstraintCheckerServices::LABEL_IN_LANGUAGE_CHECKER => static function(
247 247
 		MediaWikiServices $services
248 248
 	): LabelInLanguageChecker {
249 249
 		return new LabelInLanguageChecker(
250
-			ConstraintsServices::getConstraintParameterParser( $services )
250
+			ConstraintsServices::getConstraintParameterParser($services)
251 251
 		);
252 252
 	},
253 253
 ];
Please login to merge, or discard this patch.
src/Api/ExpiryLock.php 1 patch
Spacing   +19 added lines, -19 removed lines patch added patch discarded remove patch
@@ -26,7 +26,7 @@  discard block
 block discarded – undo
26 26
 	/**
27 27
 	 * @param BagOStuff $cache
28 28
 	 */
29
-	public function __construct( BagOStuff $cache ) {
29
+	public function __construct(BagOStuff $cache) {
30 30
 		$this->cache = $cache;
31 31
 	}
32 32
 
@@ -37,17 +37,17 @@  discard block
 block discarded – undo
37 37
 	 *
38 38
 	 * @throws \Wikimedia\Assert\ParameterTypeException
39 39
 	 */
40
-	private function makeKey( $id ) {
41
-		if ( trim( $id ) === '' ) {
42
-			throw new ParameterTypeException( '$id', 'non-empty string' );
40
+	private function makeKey($id) {
41
+		if (trim($id) === '') {
42
+			throw new ParameterTypeException('$id', 'non-empty string');
43 43
 		}
44 44
 
45
-		Assert::parameterType( 'string', $id, '$id' );
45
+		Assert::parameterType('string', $id, '$id');
46 46
 
47 47
 		return $this->cache->makeKey(
48 48
 			'WikibaseQualityConstraints',
49 49
 			'ExpiryLock',
50
-			(string)$id
50
+			(string) $id
51 51
 		);
52 52
 	}
53 53
 
@@ -59,15 +59,15 @@  discard block
 block discarded – undo
59 59
 	 *
60 60
 	 * @throws \Wikimedia\Assert\ParameterTypeException
61 61
 	 */
62
-	public function lock( $id, ConvertibleTimestamp $expiryTimestamp ) {
62
+	public function lock($id, ConvertibleTimestamp $expiryTimestamp) {
63 63
 
64
-		$cacheId = $this->makeKey( $id );
64
+		$cacheId = $this->makeKey($id);
65 65
 
66
-		if ( !$this->isLockedInternal( $cacheId ) ) {
66
+		if (!$this->isLockedInternal($cacheId)) {
67 67
 			return $this->cache->set(
68 68
 				$cacheId,
69
-				$expiryTimestamp->getTimestamp( TS_UNIX ),
70
-				(int)$expiryTimestamp->getTimestamp( TS_UNIX )
69
+				$expiryTimestamp->getTimestamp(TS_UNIX),
70
+				(int) $expiryTimestamp->getTimestamp(TS_UNIX)
71 71
 			);
72 72
 		} else {
73 73
 			return false;
@@ -81,20 +81,20 @@  discard block
 block discarded – undo
81 81
 	 *
82 82
 	 * @throws \Wikimedia\Assert\ParameterTypeException
83 83
 	 */
84
-	private function isLockedInternal( $cacheId ) {
85
-		$expiryTime = $this->cache->get( $cacheId );
86
-		if ( !$expiryTime ) {
84
+	private function isLockedInternal($cacheId) {
85
+		$expiryTime = $this->cache->get($cacheId);
86
+		if (!$expiryTime) {
87 87
 			return false;
88 88
 		}
89 89
 
90 90
 		try {
91
-			$lockExpiryTimeStamp = new ConvertibleTimestamp( $expiryTime );
92
-		} catch ( TimestampException $exception ) {
91
+			$lockExpiryTimeStamp = new ConvertibleTimestamp($expiryTime);
92
+		} catch (TimestampException $exception) {
93 93
 			return false;
94 94
 		}
95 95
 
96 96
 		$now = new ConvertibleTimestamp();
97
-		if ( $now->timestamp < $lockExpiryTimeStamp->timestamp ) {
97
+		if ($now->timestamp < $lockExpiryTimeStamp->timestamp) {
98 98
 			return true;
99 99
 		} else {
100 100
 			return false;
@@ -108,8 +108,8 @@  discard block
 block discarded – undo
108 108
 	 *
109 109
 	 * @throws \Wikimedia\Assert\ParameterTypeException
110 110
 	 */
111
-	public function isLocked( $id ) {
112
-		return $this->isLockedInternal( $this->makeKey( $id ) );
111
+	public function isLocked($id) {
112
+		return $this->isLockedInternal($this->makeKey($id));
113 113
 	}
114 114
 
115 115
 }
Please login to merge, or discard this patch.
src/ConstraintCheck/Helper/ConstraintParameterParser.php 1 patch
Spacing   +291 added lines, -291 removed lines patch added patch discarded remove patch
@@ -1,6 +1,6 @@  discard block
 block discarded – undo
1 1
 <?php
2 2
 
3
-declare( strict_types = 1 );
3
+declare(strict_types=1);
4 4
 
5 5
 namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Helper;
6 6
 
@@ -68,15 +68,15 @@  discard block
 block discarded – undo
68 68
 	 * Check if any errors are recorded in the constraint parameters.
69 69
 	 * @throws ConstraintParameterException
70 70
 	 */
71
-	public function checkError( array $parameters ): void {
72
-		if ( array_key_exists( '@error', $parameters ) ) {
71
+	public function checkError(array $parameters): void {
72
+		if (array_key_exists('@error', $parameters)) {
73 73
 			$error = $parameters['@error'];
74
-			if ( array_key_exists( 'toolong', $error ) && $error['toolong'] ) {
74
+			if (array_key_exists('toolong', $error) && $error['toolong']) {
75 75
 				$msg = 'wbqc-violation-message-parameters-error-toolong';
76 76
 			} else {
77 77
 				$msg = 'wbqc-violation-message-parameters-error-unknown';
78 78
 			}
79
-			throw new ConstraintParameterException( new ViolationMessage( $msg ) );
79
+			throw new ConstraintParameterException(new ViolationMessage($msg));
80 80
 		}
81 81
 	}
82 82
 
@@ -84,11 +84,11 @@  discard block
 block discarded – undo
84 84
 	 * Require that $parameters contains exactly one $parameterId parameter.
85 85
 	 * @throws ConstraintParameterException
86 86
 	 */
87
-	private function requireSingleParameter( array $parameters, string $parameterId ): void {
88
-		if ( count( $parameters[$parameterId] ) !== 1 ) {
87
+	private function requireSingleParameter(array $parameters, string $parameterId): void {
88
+		if (count($parameters[$parameterId]) !== 1) {
89 89
 			throw new ConstraintParameterException(
90
-				( new ViolationMessage( 'wbqc-violation-message-parameter-single' ) )
91
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
90
+				(new ViolationMessage('wbqc-violation-message-parameter-single'))
91
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
92 92
 			);
93 93
 		}
94 94
 	}
@@ -97,11 +97,11 @@  discard block
 block discarded – undo
97 97
 	 * Require that $snak is a {@link PropertyValueSnak}.
98 98
 	 * @throws ConstraintParameterException
99 99
 	 */
100
-	private function requireValueParameter( Snak $snak, string $parameterId ): void {
101
-		if ( !( $snak instanceof PropertyValueSnak ) ) {
100
+	private function requireValueParameter(Snak $snak, string $parameterId): void {
101
+		if (!($snak instanceof PropertyValueSnak)) {
102 102
 			throw new ConstraintParameterException(
103
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
104
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
103
+				(new ViolationMessage('wbqc-violation-message-parameter-value'))
104
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
105 105
 			);
106 106
 		}
107 107
 	}
@@ -110,17 +110,17 @@  discard block
 block discarded – undo
110 110
 	 * Parse a single entity ID parameter.
111 111
 	 * @throws ConstraintParameterException
112 112
 	 */
113
-	private function parseEntityIdParameter( array $snakSerialization, string $parameterId ): EntityId {
114
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
115
-		$this->requireValueParameter( $snak, $parameterId );
113
+	private function parseEntityIdParameter(array $snakSerialization, string $parameterId): EntityId {
114
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
115
+		$this->requireValueParameter($snak, $parameterId);
116 116
 		$value = $snak->getDataValue();
117
-		if ( $value instanceof EntityIdValue ) {
117
+		if ($value instanceof EntityIdValue) {
118 118
 			return $value->getEntityId();
119 119
 		} else {
120 120
 			throw new ConstraintParameterException(
121
-				( new ViolationMessage( 'wbqc-violation-message-parameter-entity' ) )
122
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
123
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
121
+				(new ViolationMessage('wbqc-violation-message-parameter-entity'))
122
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
123
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
124 124
 			);
125 125
 		}
126 126
 	}
@@ -131,20 +131,20 @@  discard block
 block discarded – undo
131 131
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
132 132
 	 * @return string[] class entity ID serializations
133 133
 	 */
134
-	public function parseClassParameter( array $constraintParameters, string $constraintTypeItemId ): array {
135
-		$this->checkError( $constraintParameters );
136
-		$classId = $this->config->get( 'WBQualityConstraintsClassId' );
137
-		if ( !array_key_exists( $classId, $constraintParameters ) ) {
134
+	public function parseClassParameter(array $constraintParameters, string $constraintTypeItemId): array {
135
+		$this->checkError($constraintParameters);
136
+		$classId = $this->config->get('WBQualityConstraintsClassId');
137
+		if (!array_key_exists($classId, $constraintParameters)) {
138 138
 			throw new ConstraintParameterException(
139
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
140
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
141
-					->withEntityId( new NumericPropertyId( $classId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
139
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
140
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
141
+					->withEntityId(new NumericPropertyId($classId), Role::CONSTRAINT_PARAMETER_PROPERTY)
142 142
 			);
143 143
 		}
144 144
 
145 145
 		$classes = [];
146
-		foreach ( $constraintParameters[$classId] as $class ) {
147
-			$classes[] = $this->parseEntityIdParameter( $class, $classId )->getSerialization();
146
+		foreach ($constraintParameters[$classId] as $class) {
147
+			$classes[] = $this->parseEntityIdParameter($class, $classId)->getSerialization();
148 148
 		}
149 149
 		return $classes;
150 150
 	}
@@ -155,31 +155,31 @@  discard block
 block discarded – undo
155 155
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
156 156
 	 * @return string 'instance', 'subclass', or 'instanceOrSubclass'
157 157
 	 */
158
-	public function parseRelationParameter( array $constraintParameters, string $constraintTypeItemId ): string {
159
-		$this->checkError( $constraintParameters );
160
-		$relationId = $this->config->get( 'WBQualityConstraintsRelationId' );
161
-		if ( !array_key_exists( $relationId, $constraintParameters ) ) {
158
+	public function parseRelationParameter(array $constraintParameters, string $constraintTypeItemId): string {
159
+		$this->checkError($constraintParameters);
160
+		$relationId = $this->config->get('WBQualityConstraintsRelationId');
161
+		if (!array_key_exists($relationId, $constraintParameters)) {
162 162
 			throw new ConstraintParameterException(
163
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
164
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
165
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
163
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
164
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
165
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
166 166
 			);
167 167
 		}
168 168
 
169
-		$this->requireSingleParameter( $constraintParameters, $relationId );
170
-		$relationEntityId = $this->parseEntityIdParameter( $constraintParameters[$relationId][0], $relationId );
171
-		if ( !( $relationEntityId instanceof ItemId ) ) {
169
+		$this->requireSingleParameter($constraintParameters, $relationId);
170
+		$relationEntityId = $this->parseEntityIdParameter($constraintParameters[$relationId][0], $relationId);
171
+		if (!($relationEntityId instanceof ItemId)) {
172 172
 			throw new ConstraintParameterException(
173
-				( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
174
-					->withEntityId( new NumericPropertyId( $relationId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
175
-					->withDataValue( new EntityIdValue( $relationEntityId ), Role::CONSTRAINT_PARAMETER_VALUE )
173
+				(new ViolationMessage('wbqc-violation-message-parameter-item'))
174
+					->withEntityId(new NumericPropertyId($relationId), Role::CONSTRAINT_PARAMETER_PROPERTY)
175
+					->withDataValue(new EntityIdValue($relationEntityId), Role::CONSTRAINT_PARAMETER_VALUE)
176 176
 			);
177 177
 		}
178
-		return $this->mapItemId( $relationEntityId, [
179
-			$this->config->get( 'WBQualityConstraintsInstanceOfRelationId' ) => 'instance',
180
-			$this->config->get( 'WBQualityConstraintsSubclassOfRelationId' ) => 'subclass',
181
-			$this->config->get( 'WBQualityConstraintsInstanceOrSubclassOfRelationId' ) => 'instanceOrSubclass',
182
-		], $relationId );
178
+		return $this->mapItemId($relationEntityId, [
179
+			$this->config->get('WBQualityConstraintsInstanceOfRelationId') => 'instance',
180
+			$this->config->get('WBQualityConstraintsSubclassOfRelationId') => 'subclass',
181
+			$this->config->get('WBQualityConstraintsInstanceOrSubclassOfRelationId') => 'instanceOrSubclass',
182
+		], $relationId);
183 183
 	}
184 184
 
185 185
 	/**
@@ -189,20 +189,20 @@  discard block
 block discarded – undo
189 189
 	 * @throws ConstraintParameterException
190 190
 	 * @return PropertyId
191 191
 	 */
192
-	private function parsePropertyIdParameter( array $snakSerialization, string $parameterId ): PropertyId {
193
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
194
-		$this->requireValueParameter( $snak, $parameterId );
192
+	private function parsePropertyIdParameter(array $snakSerialization, string $parameterId): PropertyId {
193
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
194
+		$this->requireValueParameter($snak, $parameterId);
195 195
 		$value = $snak->getDataValue();
196
-		if ( $value instanceof EntityIdValue ) {
196
+		if ($value instanceof EntityIdValue) {
197 197
 			$id = $value->getEntityId();
198
-			if ( $id instanceof PropertyId ) {
198
+			if ($id instanceof PropertyId) {
199 199
 				return $id;
200 200
 			}
201 201
 		}
202 202
 		throw new ConstraintParameterException(
203
-			( new ViolationMessage( 'wbqc-violation-message-parameter-property' ) )
204
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
205
-				->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
203
+			(new ViolationMessage('wbqc-violation-message-parameter-property'))
204
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
205
+				->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
206 206
 		);
207 207
 	}
208 208
 
@@ -213,33 +213,33 @@  discard block
 block discarded – undo
213 213
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
214 214
 	 * @return PropertyId
215 215
 	 */
216
-	public function parsePropertyParameter( array $constraintParameters, string $constraintTypeItemId ): PropertyId {
217
-		$this->checkError( $constraintParameters );
218
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
219
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
216
+	public function parsePropertyParameter(array $constraintParameters, string $constraintTypeItemId): PropertyId {
217
+		$this->checkError($constraintParameters);
218
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
219
+		if (!array_key_exists($propertyId, $constraintParameters)) {
220 220
 			throw new ConstraintParameterException(
221
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
222
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
223
-					->withEntityId( new NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
221
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
222
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
223
+					->withEntityId(new NumericPropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
224 224
 			);
225 225
 		}
226 226
 
227
-		$this->requireSingleParameter( $constraintParameters, $propertyId );
228
-		return $this->parsePropertyIdParameter( $constraintParameters[$propertyId][0], $propertyId );
227
+		$this->requireSingleParameter($constraintParameters, $propertyId);
228
+		return $this->parsePropertyIdParameter($constraintParameters[$propertyId][0], $propertyId);
229 229
 	}
230 230
 
231
-	private function parseItemIdParameter( PropertyValueSnak $snak, string $parameterId ): ItemIdSnakValue {
231
+	private function parseItemIdParameter(PropertyValueSnak $snak, string $parameterId): ItemIdSnakValue {
232 232
 		$dataValue = $snak->getDataValue();
233
-		if ( $dataValue instanceof EntityIdValue ) {
233
+		if ($dataValue instanceof EntityIdValue) {
234 234
 			$entityId = $dataValue->getEntityId();
235
-			if ( $entityId instanceof ItemId ) {
236
-				return ItemIdSnakValue::fromItemId( $entityId );
235
+			if ($entityId instanceof ItemId) {
236
+				return ItemIdSnakValue::fromItemId($entityId);
237 237
 			}
238 238
 		}
239 239
 		throw new ConstraintParameterException(
240
-			( new ViolationMessage( 'wbqc-violation-message-parameter-item' ) )
241
-				->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
242
-				->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
240
+			(new ViolationMessage('wbqc-violation-message-parameter-item'))
241
+				->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
242
+				->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
243 243
 		);
244 244
 	}
245 245
 
@@ -257,16 +257,16 @@  discard block
 block discarded – undo
257 257
 		bool $required,
258 258
 		string $parameterId = null
259 259
 	): array {
260
-		$this->checkError( $constraintParameters );
261
-		if ( $parameterId === null ) {
262
-			$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
260
+		$this->checkError($constraintParameters);
261
+		if ($parameterId === null) {
262
+			$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
263 263
 		}
264
-		if ( !array_key_exists( $parameterId, $constraintParameters ) ) {
265
-			if ( $required ) {
264
+		if (!array_key_exists($parameterId, $constraintParameters)) {
265
+			if ($required) {
266 266
 				throw new ConstraintParameterException(
267
-					( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
268
-						->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
269
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
267
+					(new ViolationMessage('wbqc-violation-message-parameter-needed'))
268
+						->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
269
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
270 270
 				);
271 271
 			} else {
272 272
 				return [];
@@ -274,11 +274,11 @@  discard block
 block discarded – undo
274 274
 		}
275 275
 
276 276
 		$values = [];
277
-		foreach ( $constraintParameters[$parameterId] as $parameter ) {
278
-			$snak = $this->snakDeserializer->deserialize( $parameter );
279
-			switch ( true ) {
277
+		foreach ($constraintParameters[$parameterId] as $parameter) {
278
+			$snak = $this->snakDeserializer->deserialize($parameter);
279
+			switch (true) {
280 280
 				case $snak instanceof PropertyValueSnak:
281
-					$values[] = $this->parseItemIdParameter( $snak, $parameterId );
281
+					$values[] = $this->parseItemIdParameter($snak, $parameterId);
282 282
 					break;
283 283
 				case $snak instanceof PropertySomeValueSnak:
284 284
 					$values[] = ItemIdSnakValue::someValue();
@@ -306,13 +306,13 @@  discard block
 block discarded – undo
306 306
 		bool $required,
307 307
 		string $parameterId
308 308
 	): array {
309
-		return array_map( static function ( ItemIdSnakValue $value ) use ( $parameterId ): ItemId {
310
-			if ( $value->isValue() ) {
309
+		return array_map(static function(ItemIdSnakValue $value) use ($parameterId): ItemId {
310
+			if ($value->isValue()) {
311 311
 				return $value->getItemId();
312 312
 			} else {
313 313
 				throw new ConstraintParameterException(
314
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value' ) )
315
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
314
+					(new ViolationMessage('wbqc-violation-message-parameter-value'))
315
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
316 316
 				);
317 317
 			}
318 318
 		}, $this->parseItemsParameter(
@@ -320,7 +320,7 @@  discard block
 block discarded – undo
320 320
 			$constraintTypeItemId,
321 321
 			$required,
322 322
 			$parameterId
323
-		) );
323
+		));
324 324
 	}
325 325
 
326 326
 	/**
@@ -328,18 +328,18 @@  discard block
 block discarded – undo
328 328
 	 * @throws ConstraintParameterException
329 329
 	 * @return mixed elements of $mapping
330 330
 	 */
331
-	private function mapItemId( ItemId $itemId, array $mapping, string $parameterId ) {
331
+	private function mapItemId(ItemId $itemId, array $mapping, string $parameterId) {
332 332
 		$serialization = $itemId->getSerialization();
333
-		if ( array_key_exists( $serialization, $mapping ) ) {
333
+		if (array_key_exists($serialization, $mapping)) {
334 334
 			return $mapping[$serialization];
335 335
 		} else {
336
-			$allowed = array_map( static function ( $id ) {
337
-				return new ItemId( $id );
338
-			}, array_keys( $mapping ) );
336
+			$allowed = array_map(static function($id) {
337
+				return new ItemId($id);
338
+			}, array_keys($mapping));
339 339
 			throw new ConstraintParameterException(
340
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
341
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
342
-					->withEntityIdList( $allowed, Role::CONSTRAINT_PARAMETER_VALUE )
340
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
341
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
342
+					->withEntityIdList($allowed, Role::CONSTRAINT_PARAMETER_VALUE)
343 343
 			);
344 344
 		}
345 345
 	}
@@ -350,27 +350,27 @@  discard block
 block discarded – undo
350 350
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
351 351
 	 * @return PropertyId[]
352 352
 	 */
353
-	public function parsePropertiesParameter( array $constraintParameters, string $constraintTypeItemId ): array {
354
-		$this->checkError( $constraintParameters );
355
-		$propertyId = $this->config->get( 'WBQualityConstraintsPropertyId' );
356
-		if ( !array_key_exists( $propertyId, $constraintParameters ) ) {
353
+	public function parsePropertiesParameter(array $constraintParameters, string $constraintTypeItemId): array {
354
+		$this->checkError($constraintParameters);
355
+		$propertyId = $this->config->get('WBQualityConstraintsPropertyId');
356
+		if (!array_key_exists($propertyId, $constraintParameters)) {
357 357
 			throw new ConstraintParameterException(
358
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
359
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
360
-					->withEntityId( new NumericPropertyId( $propertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
358
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
359
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
360
+					->withEntityId(new NumericPropertyId($propertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
361 361
 			);
362 362
 		}
363 363
 
364 364
 		$parameters = $constraintParameters[$propertyId];
365
-		if ( count( $parameters ) === 1 &&
366
-			$this->snakDeserializer->deserialize( $parameters[0] ) instanceof PropertyNoValueSnak
365
+		if (count($parameters) === 1 &&
366
+			$this->snakDeserializer->deserialize($parameters[0]) instanceof PropertyNoValueSnak
367 367
 		) {
368 368
 			return [];
369 369
 		}
370 370
 
371 371
 		$properties = [];
372
-		foreach ( $parameters as $parameter ) {
373
-			$properties[] = $this->parsePropertyIdParameter( $parameter, $propertyId );
372
+		foreach ($parameters as $parameter) {
373
+			$properties[] = $this->parsePropertyIdParameter($parameter, $propertyId);
374 374
 		}
375 375
 		return $properties;
376 376
 	}
@@ -378,24 +378,24 @@  discard block
 block discarded – undo
378 378
 	/**
379 379
 	 * @throws ConstraintParameterException
380 380
 	 */
381
-	private function parseValueOrNoValueParameter( array $snakSerialization, string $parameterId ): ?DataValue {
382
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
383
-		if ( $snak instanceof PropertyValueSnak ) {
381
+	private function parseValueOrNoValueParameter(array $snakSerialization, string $parameterId): ?DataValue {
382
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
383
+		if ($snak instanceof PropertyValueSnak) {
384 384
 			return $snak->getDataValue();
385
-		} elseif ( $snak instanceof PropertyNoValueSnak ) {
385
+		} elseif ($snak instanceof PropertyNoValueSnak) {
386 386
 			return null;
387 387
 		} else {
388 388
 			throw new ConstraintParameterException(
389
-				( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
390
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
389
+				(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
390
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
391 391
 			);
392 392
 		}
393 393
 	}
394 394
 
395
-	private function parseValueOrNoValueOrNowParameter( array $snakSerialization, string $parameterId ): ?DataValue {
395
+	private function parseValueOrNoValueOrNowParameter(array $snakSerialization, string $parameterId): ?DataValue {
396 396
 		try {
397
-			return $this->parseValueOrNoValueParameter( $snakSerialization, $parameterId );
398
-		} catch ( ConstraintParameterException $e ) {
397
+			return $this->parseValueOrNoValueParameter($snakSerialization, $parameterId);
398
+		} catch (ConstraintParameterException $e) {
399 399
 			// unknown value means “now”
400 400
 			return new NowValue();
401 401
 		}
@@ -404,14 +404,14 @@  discard block
 block discarded – undo
404 404
 	/**
405 405
 	 * Checks whether there is exactly one non-null quantity with the given unit.
406 406
 	 */
407
-	private function exactlyOneQuantityWithUnit( ?DataValue $min, ?DataValue $max, string $unit ): bool {
408
-		if ( !( $min instanceof UnboundedQuantityValue ) ||
409
-			!( $max instanceof UnboundedQuantityValue )
407
+	private function exactlyOneQuantityWithUnit(?DataValue $min, ?DataValue $max, string $unit): bool {
408
+		if (!($min instanceof UnboundedQuantityValue) ||
409
+			!($max instanceof UnboundedQuantityValue)
410 410
 		) {
411 411
 			return false;
412 412
 		}
413 413
 
414
-		return ( $min->getUnit() === $unit ) !== ( $max->getUnit() === $unit );
414
+		return ($min->getUnit() === $unit) !== ($max->getUnit() === $unit);
415 415
 	}
416 416
 
417 417
 	/**
@@ -431,42 +431,42 @@  discard block
 block discarded – undo
431 431
 		string $constraintTypeItemId,
432 432
 		string $type
433 433
 	): array {
434
-		$this->checkError( $constraintParameters );
435
-		if ( !array_key_exists( $minimumId, $constraintParameters ) ||
436
-			!array_key_exists( $maximumId, $constraintParameters )
434
+		$this->checkError($constraintParameters);
435
+		if (!array_key_exists($minimumId, $constraintParameters) ||
436
+			!array_key_exists($maximumId, $constraintParameters)
437 437
 		) {
438 438
 			throw new ConstraintParameterException(
439
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-needed' ) )
440
-					->withDataValueType( $type )
441
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
442
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
443
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
439
+				(new ViolationMessage('wbqc-violation-message-range-parameters-needed'))
440
+					->withDataValueType($type)
441
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
442
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
443
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
444 444
 			);
445 445
 		}
446 446
 
447
-		$this->requireSingleParameter( $constraintParameters, $minimumId );
448
-		$this->requireSingleParameter( $constraintParameters, $maximumId );
447
+		$this->requireSingleParameter($constraintParameters, $minimumId);
448
+		$this->requireSingleParameter($constraintParameters, $maximumId);
449 449
 		$parseFunction = $type === 'time' ? 'parseValueOrNoValueOrNowParameter' : 'parseValueOrNoValueParameter';
450
-		$min = $this->$parseFunction( $constraintParameters[$minimumId][0], $minimumId );
451
-		$max = $this->$parseFunction( $constraintParameters[$maximumId][0], $maximumId );
450
+		$min = $this->$parseFunction($constraintParameters[$minimumId][0], $minimumId);
451
+		$max = $this->$parseFunction($constraintParameters[$maximumId][0], $maximumId);
452 452
 
453
-		$yearUnit = $this->config->get( 'WBQualityConstraintsYearUnit' );
454
-		if ( $this->exactlyOneQuantityWithUnit( $min, $max, $yearUnit ) ) {
453
+		$yearUnit = $this->config->get('WBQualityConstraintsYearUnit');
454
+		if ($this->exactlyOneQuantityWithUnit($min, $max, $yearUnit)) {
455 455
 			throw new ConstraintParameterException(
456
-				new ViolationMessage( 'wbqc-violation-message-range-parameters-one-year' )
456
+				new ViolationMessage('wbqc-violation-message-range-parameters-one-year')
457 457
 			);
458 458
 		}
459
-		if ( ( $min === null && $max === null ) ||
460
-			( $min !== null && $max !== null && $min->equals( $max ) )
459
+		if (($min === null && $max === null) ||
460
+			($min !== null && $max !== null && $min->equals($max))
461 461
 		) {
462 462
 			throw new ConstraintParameterException(
463
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-same' ) )
464
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
465
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
463
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
464
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
465
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
466 466
 			);
467 467
 		}
468 468
 
469
-		return [ $min, $max ];
469
+		return [$min, $max];
470 470
 	}
471 471
 
472 472
 	/**
@@ -476,11 +476,11 @@  discard block
 block discarded – undo
476 476
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
477 477
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
478 478
 	 */
479
-	public function parseQuantityRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
479
+	public function parseQuantityRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
480 480
 		return $this->parseRangeParameter(
481 481
 			$constraintParameters,
482
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
483
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
482
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
483
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
484 484
 			$constraintTypeItemId,
485 485
 			'quantity'
486 486
 		);
@@ -493,11 +493,11 @@  discard block
 block discarded – undo
493 493
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
494 494
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
495 495
 	 */
496
-	public function parseTimeRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
496
+	public function parseTimeRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
497 497
 		return $this->parseRangeParameter(
498 498
 			$constraintParameters,
499
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
500
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
499
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
500
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
501 501
 			$constraintTypeItemId,
502 502
 			'time'
503 503
 		);
@@ -510,20 +510,20 @@  discard block
 block discarded – undo
510 510
 	 * @throws ConstraintParameterException
511 511
 	 * @return string[]
512 512
 	 */
513
-	public function parseLanguageParameter( array $constraintParameters, string $constraintTypeItemId ): array {
514
-		$this->checkError( $constraintParameters );
515
-		$languagePropertyId = $this->config->get( 'WBQualityConstraintsLanguagePropertyId' );
516
-		if ( !array_key_exists( $languagePropertyId, $constraintParameters ) ) {
513
+	public function parseLanguageParameter(array $constraintParameters, string $constraintTypeItemId): array {
514
+		$this->checkError($constraintParameters);
515
+		$languagePropertyId = $this->config->get('WBQualityConstraintsLanguagePropertyId');
516
+		if (!array_key_exists($languagePropertyId, $constraintParameters)) {
517 517
 			throw new ConstraintParameterException(
518
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
519
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
520
-					->withEntityId( new NumericPropertyId( $languagePropertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
518
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
519
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
520
+					->withEntityId(new NumericPropertyId($languagePropertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
521 521
 			);
522 522
 		}
523 523
 
524 524
 		$languages = [];
525
-		foreach ( $constraintParameters[$languagePropertyId] as $snak ) {
526
-			$languages[] = $this->parseStringParameter( $snak, $languagePropertyId );
525
+		foreach ($constraintParameters[$languagePropertyId] as $snak) {
526
+			$languages[] = $this->parseStringParameter($snak, $languagePropertyId);
527 527
 		}
528 528
 		return $languages;
529 529
 	}
@@ -532,17 +532,17 @@  discard block
 block discarded – undo
532 532
 	 * Parse a single string parameter.
533 533
 	 * @throws ConstraintParameterException
534 534
 	 */
535
-	private function parseStringParameter( array $snakSerialization, string $parameterId ): string {
536
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
537
-		$this->requireValueParameter( $snak, $parameterId );
535
+	private function parseStringParameter(array $snakSerialization, string $parameterId): string {
536
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
537
+		$this->requireValueParameter($snak, $parameterId);
538 538
 		$value = $snak->getDataValue();
539
-		if ( $value instanceof StringValue ) {
539
+		if ($value instanceof StringValue) {
540 540
 			return $value->getValue();
541 541
 		} else {
542 542
 			throw new ConstraintParameterException(
543
-				( new ViolationMessage( 'wbqc-violation-message-parameter-string' ) )
544
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
545
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
543
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
544
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
545
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
546 546
 			);
547 547
 		}
548 548
 	}
@@ -553,15 +553,15 @@  discard block
 block discarded – undo
553 553
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
554 554
 	 * @return string
555 555
 	 */
556
-	public function parseNamespaceParameter( array $constraintParameters, string $constraintTypeItemId ): string {
557
-		$this->checkError( $constraintParameters );
558
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
559
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
556
+	public function parseNamespaceParameter(array $constraintParameters, string $constraintTypeItemId): string {
557
+		$this->checkError($constraintParameters);
558
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
559
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
560 560
 			return '';
561 561
 		}
562 562
 
563
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
564
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
563
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
564
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
565 565
 	}
566 566
 
567 567
 	/**
@@ -570,19 +570,19 @@  discard block
 block discarded – undo
570 570
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
571 571
 	 * @return string
572 572
 	 */
573
-	public function parseFormatParameter( array $constraintParameters, string $constraintTypeItemId ): string {
574
-		$this->checkError( $constraintParameters );
575
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
576
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
573
+	public function parseFormatParameter(array $constraintParameters, string $constraintTypeItemId): string {
574
+		$this->checkError($constraintParameters);
575
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
576
+		if (!array_key_exists($formatId, $constraintParameters)) {
577 577
 			throw new ConstraintParameterException(
578
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
579
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
580
-					->withEntityId( new NumericPropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
578
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
579
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
580
+					->withEntityId(new NumericPropertyId($formatId), Role::CONSTRAINT_PARAMETER_PROPERTY)
581 581
 			);
582 582
 		}
583 583
 
584
-		$this->requireSingleParameter( $constraintParameters, $formatId );
585
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
584
+		$this->requireSingleParameter($constraintParameters, $formatId);
585
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
586 586
 	}
587 587
 
588 588
 	/**
@@ -590,16 +590,16 @@  discard block
 block discarded – undo
590 590
 	 * @throws ConstraintParameterException if the parameter is invalid
591 591
 	 * @return EntityId[]
592 592
 	 */
593
-	public function parseExceptionParameter( array $constraintParameters ): array {
594
-		$this->checkError( $constraintParameters );
595
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
596
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
593
+	public function parseExceptionParameter(array $constraintParameters): array {
594
+		$this->checkError($constraintParameters);
595
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
596
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
597 597
 			return [];
598 598
 		}
599 599
 
600 600
 		return array_map(
601
-			function ( $snakSerialization ) use ( $exceptionId ) {
602
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
601
+			function($snakSerialization) use ($exceptionId) {
602
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
603 603
 			},
604 604
 			$constraintParameters[$exceptionId]
605 605
 		);
@@ -610,39 +610,39 @@  discard block
 block discarded – undo
610 610
 	 * @throws ConstraintParameterException if the parameter is invalid
611 611
 	 * @return string|null 'mandatory', 'suggestion' or null
612 612
 	 */
613
-	public function parseConstraintStatusParameter( array $constraintParameters ): ?string {
614
-		$this->checkError( $constraintParameters );
615
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
616
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
613
+	public function parseConstraintStatusParameter(array $constraintParameters): ?string {
614
+		$this->checkError($constraintParameters);
615
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
616
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
617 617
 			return null;
618 618
 		}
619 619
 
620
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
621
-		$supportedStatuses = [ new ItemId( $mandatoryId ) ];
622
-		if ( $this->config->get( 'WBQualityConstraintsEnableSuggestionConstraintStatus' ) ) {
623
-			$suggestionId = $this->config->get( 'WBQualityConstraintsSuggestionConstraintId' );
624
-			$supportedStatuses[] = new ItemId( $suggestionId );
620
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
621
+		$supportedStatuses = [new ItemId($mandatoryId)];
622
+		if ($this->config->get('WBQualityConstraintsEnableSuggestionConstraintStatus')) {
623
+			$suggestionId = $this->config->get('WBQualityConstraintsSuggestionConstraintId');
624
+			$supportedStatuses[] = new ItemId($suggestionId);
625 625
 		} else {
626 626
 			$suggestionId = null;
627 627
 		}
628 628
 
629
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
630
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
631
-		$this->requireValueParameter( $snak, $constraintStatusId );
629
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
630
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
631
+		$this->requireValueParameter($snak, $constraintStatusId);
632 632
 		'@phan-var \Wikibase\DataModel\Snak\PropertyValueSnak $snak';
633 633
 		$dataValue = $snak->getDataValue();
634 634
 		'@phan-var EntityIdValue $dataValue';
635 635
 		$entityId = $dataValue->getEntityId();
636 636
 		$statusId = $entityId->getSerialization();
637 637
 
638
-		if ( $statusId === $mandatoryId ) {
638
+		if ($statusId === $mandatoryId) {
639 639
 			return 'mandatory';
640
-		} elseif ( $statusId === $suggestionId ) {
640
+		} elseif ($statusId === $suggestionId) {
641 641
 			return 'suggestion';
642 642
 		} else {
643 643
 			throw new ConstraintParameterException(
644
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
645
-					->withEntityId( new NumericPropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
644
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
645
+					->withEntityId(new NumericPropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
646 646
 					->withEntityIdList(
647 647
 						$supportedStatuses,
648 648
 						Role::CONSTRAINT_PARAMETER_VALUE
@@ -655,12 +655,12 @@  discard block
 block discarded – undo
655 655
 	 * Require that $dataValue is a {@link MonolingualTextValue}.
656 656
 	 * @throws ConstraintParameterException
657 657
 	 */
658
-	private function requireMonolingualTextParameter( DataValue $dataValue, string $parameterId ): void {
659
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
658
+	private function requireMonolingualTextParameter(DataValue $dataValue, string $parameterId): void {
659
+		if (!($dataValue instanceof MonolingualTextValue)) {
660 660
 			throw new ConstraintParameterException(
661
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
662
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
663
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
661
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
662
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
663
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
664 664
 			);
665 665
 		}
666 666
 	}
@@ -670,31 +670,31 @@  discard block
 block discarded – undo
670 670
 	 *
671 671
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
672 672
 	 */
673
-	private function parseMultilingualTextParameter( array $snakSerializations, string $parameterId ): MultilingualTextValue {
673
+	private function parseMultilingualTextParameter(array $snakSerializations, string $parameterId): MultilingualTextValue {
674 674
 		$result = [];
675 675
 
676
-		foreach ( $snakSerializations as $snakSerialization ) {
677
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
678
-			$this->requireValueParameter( $snak, $parameterId );
676
+		foreach ($snakSerializations as $snakSerialization) {
677
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
678
+			$this->requireValueParameter($snak, $parameterId);
679 679
 
680 680
 			$value = $snak->getDataValue();
681
-			$this->requireMonolingualTextParameter( $value, $parameterId );
681
+			$this->requireMonolingualTextParameter($value, $parameterId);
682 682
 			/** @var MonolingualTextValue $value */
683 683
 			'@phan-var MonolingualTextValue $value';
684 684
 
685 685
 			$code = $value->getLanguageCode();
686
-			if ( array_key_exists( $code, $result ) ) {
686
+			if (array_key_exists($code, $result)) {
687 687
 				throw new ConstraintParameterException(
688
-					( new ViolationMessage( 'wbqc-violation-message-parameter-single-per-language' ) )
689
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
690
-						->withLanguage( $code )
688
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
689
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
690
+						->withLanguage($code)
691 691
 				);
692 692
 			}
693 693
 
694 694
 			$result[$code] = $value;
695 695
 		}
696 696
 
697
-		return new MultilingualTextValue( $result );
697
+		return new MultilingualTextValue($result);
698 698
 	}
699 699
 
700 700
 	/**
@@ -702,11 +702,11 @@  discard block
 block discarded – undo
702 702
 	 * @throws ConstraintParameterException if the parameter is invalid
703 703
 	 * @return MultilingualTextValue
704 704
 	 */
705
-	public function parseSyntaxClarificationParameter( array $constraintParameters ): MultilingualTextValue {
706
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
705
+	public function parseSyntaxClarificationParameter(array $constraintParameters): MultilingualTextValue {
706
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
707 707
 
708
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
709
-			return new MultilingualTextValue( [] );
708
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
709
+			return new MultilingualTextValue([]);
710 710
 		}
711 711
 
712 712
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -722,11 +722,11 @@  discard block
 block discarded – undo
722 722
 	 * @throws ConstraintParameterException if the parameter is invalid
723 723
 	 * @return MultilingualTextValue
724 724
 	 */
725
-	public function parseConstraintClarificationParameter( array $constraintParameters ): MultilingualTextValue {
726
-		$constraintClarificationId = $this->config->get( 'WBQualityConstraintsConstraintClarificationId' );
725
+	public function parseConstraintClarificationParameter(array $constraintParameters): MultilingualTextValue {
726
+		$constraintClarificationId = $this->config->get('WBQualityConstraintsConstraintClarificationId');
727 727
 
728
-		if ( !array_key_exists( $constraintClarificationId, $constraintParameters ) ) {
729
-			return new MultilingualTextValue( [] );
728
+		if (!array_key_exists($constraintClarificationId, $constraintParameters)) {
729
+			return new MultilingualTextValue([]);
730 730
 		}
731 731
 
732 732
 		$constraintClarifications = $this->parseMultilingualTextParameter(
@@ -759,14 +759,14 @@  discard block
 block discarded – undo
759 759
 		array $validContextTypes,
760 760
 		array $validEntityTypes
761 761
 	): array {
762
-		$contextTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
762
+		$contextTypeParameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
763 763
 		$contextTypeItemIds = $this->parseItemIdsParameter(
764 764
 			$constraintParameters,
765 765
 			$constraintTypeItemId,
766 766
 			false,
767 767
 			$contextTypeParameterId
768 768
 		);
769
-		$entityTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintEntityTypesId' );
769
+		$entityTypeParameterId = $this->config->get('WBQualityConstraintsConstraintEntityTypesId');
770 770
 		$entityTypeItemIds = $this->parseItemIdsParameter(
771 771
 			$constraintParameters,
772 772
 			$constraintTypeItemId,
@@ -782,26 +782,26 @@  discard block
 block discarded – undo
782 782
 		$contextTypes = null;
783 783
 		$entityTypes = null;
784 784
 
785
-		if ( $contextTypeParameterId === $entityTypeParameterId ) {
785
+		if ($contextTypeParameterId === $entityTypeParameterId) {
786 786
 			$itemIds = $contextTypeItemIds;
787 787
 			$mapping = $contextTypeMapping + $entityTypeMapping;
788
-			foreach ( $itemIds as $itemId ) {
789
-				$mapped = $this->mapItemId( $itemId, $mapping, $contextTypeParameterId );
790
-				if ( in_array( $mapped, $contextTypeMapping, true ) ) {
788
+			foreach ($itemIds as $itemId) {
789
+				$mapped = $this->mapItemId($itemId, $mapping, $contextTypeParameterId);
790
+				if (in_array($mapped, $contextTypeMapping, true)) {
791 791
 					$contextTypes[] = $mapped;
792 792
 				} else {
793 793
 					$entityTypes[] = $mapped;
794 794
 				}
795 795
 			}
796 796
 		} else {
797
-			foreach ( $contextTypeItemIds as $contextTypeItemId ) {
797
+			foreach ($contextTypeItemIds as $contextTypeItemId) {
798 798
 				$contextTypes[] = $this->mapItemId(
799 799
 					$contextTypeItemId,
800 800
 					$contextTypeMapping,
801 801
 					$contextTypeParameterId
802 802
 				);
803 803
 			}
804
-			foreach ( $entityTypeItemIds as $entityTypeItemId ) {
804
+			foreach ($entityTypeItemIds as $entityTypeItemId) {
805 805
 				$entityTypes[] = $this->mapItemId(
806 806
 					$entityTypeItemId,
807 807
 					$entityTypeMapping,
@@ -810,21 +810,21 @@  discard block
 block discarded – undo
810 810
 			}
811 811
 		}
812 812
 
813
-		$this->checkValidScope( $constraintTypeItemId, $contextTypes, $validContextTypes );
814
-		$this->checkValidScope( $constraintTypeItemId, $entityTypes, $validEntityTypes );
813
+		$this->checkValidScope($constraintTypeItemId, $contextTypes, $validContextTypes);
814
+		$this->checkValidScope($constraintTypeItemId, $entityTypes, $validEntityTypes);
815 815
 
816
-		return [ $contextTypes, $entityTypes ];
816
+		return [$contextTypes, $entityTypes];
817 817
 	}
818 818
 
819
-	private function checkValidScope( string $constraintTypeItemId, ?array $types, array $validTypes ): void {
820
-		$invalidTypes = array_diff( $types ?: [], $validTypes );
821
-		if ( $invalidTypes !== [] ) {
822
-			$invalidType = array_pop( $invalidTypes );
819
+	private function checkValidScope(string $constraintTypeItemId, ?array $types, array $validTypes): void {
820
+		$invalidTypes = array_diff($types ?: [], $validTypes);
821
+		if ($invalidTypes !== []) {
822
+			$invalidType = array_pop($invalidTypes);
823 823
 			throw new ConstraintParameterException(
824
-				( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
825
-					->withConstraintScope( $invalidType, Role::CONSTRAINT_PARAMETER_VALUE )
826
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
827
-					->withConstraintScopeList( $validTypes, Role::CONSTRAINT_PARAMETER_VALUE )
824
+				(new ViolationMessage('wbqc-violation-message-invalid-scope'))
825
+					->withConstraintScope($invalidType, Role::CONSTRAINT_PARAMETER_VALUE)
826
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
827
+					->withConstraintScopeList($validTypes, Role::CONSTRAINT_PARAMETER_VALUE)
828 828
 			);
829 829
 		}
830 830
 	}
@@ -832,8 +832,8 @@  discard block
 block discarded – undo
832 832
 	/**
833 833
 	 * Turn an item ID into a full unit string (using the concept URI).
834 834
 	 */
835
-	private function parseUnitParameter( ItemId $unitId ): string {
836
-		return $this->unitItemConceptBaseUri . $unitId->getSerialization();
835
+	private function parseUnitParameter(ItemId $unitId): string {
836
+		return $this->unitItemConceptBaseUri.$unitId->getSerialization();
837 837
 	}
838 838
 
839 839
 	/**
@@ -841,23 +841,23 @@  discard block
 block discarded – undo
841 841
 	 *
842 842
 	 * @throws ConstraintParameterException
843 843
 	 */
844
-	private function parseUnitItem( ItemIdSnakValue $item ): UnitsParameter {
845
-		switch ( true ) {
844
+	private function parseUnitItem(ItemIdSnakValue $item): UnitsParameter {
845
+		switch (true) {
846 846
 			case $item->isValue():
847
-				$unit = $this->parseUnitParameter( $item->getItemId() );
847
+				$unit = $this->parseUnitParameter($item->getItemId());
848 848
 				return new UnitsParameter(
849
-					[ $item->getItemId() ],
850
-					[ UnboundedQuantityValue::newFromNumber( 1, $unit ) ],
849
+					[$item->getItemId()],
850
+					[UnboundedQuantityValue::newFromNumber(1, $unit)],
851 851
 					false
852 852
 				);
853 853
 			case $item->isSomeValue():
854
-				$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
854
+				$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
855 855
 				throw new ConstraintParameterException(
856
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
857
-						->withEntityId( new NumericPropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
856
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
857
+						->withEntityId(new NumericPropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
858 858
 				);
859 859
 			case $item->isNoValue():
860
-				return new UnitsParameter( [], [], true );
860
+				return new UnitsParameter([], [], true);
861 861
 		}
862 862
 	}
863 863
 
@@ -867,36 +867,36 @@  discard block
 block discarded – undo
867 867
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
868 868
 	 * @return UnitsParameter
869 869
 	 */
870
-	public function parseUnitsParameter( array $constraintParameters, string $constraintTypeItemId ): UnitsParameter {
871
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
870
+	public function parseUnitsParameter(array $constraintParameters, string $constraintTypeItemId): UnitsParameter {
871
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
872 872
 		$unitItems = [];
873 873
 		$unitQuantities = [];
874 874
 		$unitlessAllowed = false;
875 875
 
876
-		foreach ( $items as $item ) {
877
-			$unit = $this->parseUnitItem( $item );
878
-			$unitItems = array_merge( $unitItems, $unit->getUnitItemIds() );
879
-			$unitQuantities = array_merge( $unitQuantities, $unit->getUnitQuantities() );
876
+		foreach ($items as $item) {
877
+			$unit = $this->parseUnitItem($item);
878
+			$unitItems = array_merge($unitItems, $unit->getUnitItemIds());
879
+			$unitQuantities = array_merge($unitQuantities, $unit->getUnitQuantities());
880 880
 			$unitlessAllowed = $unitlessAllowed || $unit->getUnitlessAllowed();
881 881
 		}
882 882
 
883
-		if ( $unitQuantities === [] && !$unitlessAllowed ) {
883
+		if ($unitQuantities === [] && !$unitlessAllowed) {
884 884
 			throw new LogicException(
885 885
 				'The "units" parameter is required, and yet we seem to be missing any allowed unit'
886 886
 			);
887 887
 		}
888 888
 
889
-		return new UnitsParameter( $unitItems, $unitQuantities, $unitlessAllowed );
889
+		return new UnitsParameter($unitItems, $unitQuantities, $unitlessAllowed);
890 890
 	}
891 891
 
892 892
 	private function getEntityTypeMapping(): array {
893 893
 		return [
894
-			$this->config->get( 'WBQualityConstraintsWikibaseItemId' ) => 'item',
895
-			$this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) => 'property',
896
-			$this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) => 'lexeme',
897
-			$this->config->get( 'WBQualityConstraintsWikibaseFormId' ) => 'form',
898
-			$this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) => 'sense',
899
-			$this->config->get( 'WBQualityConstraintsWikibaseMediaInfoId' ) => 'mediainfo',
894
+			$this->config->get('WBQualityConstraintsWikibaseItemId') => 'item',
895
+			$this->config->get('WBQualityConstraintsWikibasePropertyId') => 'property',
896
+			$this->config->get('WBQualityConstraintsWikibaseLexemeId') => 'lexeme',
897
+			$this->config->get('WBQualityConstraintsWikibaseFormId') => 'form',
898
+			$this->config->get('WBQualityConstraintsWikibaseSenseId') => 'sense',
899
+			$this->config->get('WBQualityConstraintsWikibaseMediaInfoId') => 'mediainfo',
900 900
 		];
901 901
 	}
902 902
 
@@ -906,10 +906,10 @@  discard block
 block discarded – undo
906 906
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
907 907
 	 * @return EntityTypesParameter
908 908
 	 */
909
-	public function parseEntityTypesParameter( array $constraintParameters, string $constraintTypeItemId ): EntityTypesParameter {
909
+	public function parseEntityTypesParameter(array $constraintParameters, string $constraintTypeItemId): EntityTypesParameter {
910 910
 		$entityTypes = [];
911 911
 		$entityTypeItemIds = [];
912
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
912
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
913 913
 		$itemIds = $this->parseItemIdsParameter(
914 914
 			$constraintParameters,
915 915
 			$constraintTypeItemId,
@@ -918,22 +918,22 @@  discard block
 block discarded – undo
918 918
 		);
919 919
 
920 920
 		$mapping = $this->getEntityTypeMapping();
921
-		foreach ( $itemIds as $itemId ) {
922
-			$entityType = $this->mapItemId( $itemId, $mapping, $parameterId );
921
+		foreach ($itemIds as $itemId) {
922
+			$entityType = $this->mapItemId($itemId, $mapping, $parameterId);
923 923
 			$entityTypes[] = $entityType;
924 924
 			$entityTypeItemIds[] = $itemId;
925 925
 		}
926 926
 
927
-		if ( $entityTypes === [] ) {
927
+		if ($entityTypes === []) {
928 928
 			// @codeCoverageIgnoreStart
929 929
 			throw new LogicException(
930
-				'The "entity types" parameter is required, ' .
930
+				'The "entity types" parameter is required, '.
931 931
 				'and yet we seem to be missing any allowed entity type'
932 932
 			);
933 933
 			// @codeCoverageIgnoreEnd
934 934
 		}
935 935
 
936
-		return new EntityTypesParameter( $entityTypes, $entityTypeItemIds );
936
+		return new EntityTypesParameter($entityTypes, $entityTypeItemIds);
937 937
 	}
938 938
 
939 939
 	/**
@@ -941,18 +941,18 @@  discard block
 block discarded – undo
941 941
 	 * @throws ConstraintParameterException if the parameter is invalid
942 942
 	 * @return PropertyId[]
943 943
 	 */
944
-	public function parseSeparatorsParameter( array $constraintParameters ): array {
945
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
944
+	public function parseSeparatorsParameter(array $constraintParameters): array {
945
+		$separatorId = $this->config->get('WBQualityConstraintsSeparatorId');
946 946
 
947
-		if ( !array_key_exists( $separatorId, $constraintParameters ) ) {
947
+		if (!array_key_exists($separatorId, $constraintParameters)) {
948 948
 			return [];
949 949
 		}
950 950
 
951 951
 		$parameters = $constraintParameters[$separatorId];
952 952
 		$separators = [];
953 953
 
954
-		foreach ( $parameters as $parameter ) {
955
-			$separators[] = $this->parsePropertyIdParameter( $parameter, $separatorId );
954
+		foreach ($parameters as $parameter) {
955
+			$separators[] = $this->parsePropertyIdParameter($parameter, $separatorId);
956 956
 		}
957 957
 
958 958
 		return $separators;
@@ -960,17 +960,17 @@  discard block
 block discarded – undo
960 960
 
961 961
 	private function getConstraintScopeContextTypeMapping(): array {
962 962
 		return [
963
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' ) => Context::TYPE_STATEMENT,
964
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' ) => Context::TYPE_QUALIFIER,
965
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' ) => Context::TYPE_REFERENCE,
963
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId') => Context::TYPE_STATEMENT,
964
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId') => Context::TYPE_QUALIFIER,
965
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId') => Context::TYPE_REFERENCE,
966 966
 		];
967 967
 	}
968 968
 
969 969
 	private function getPropertyScopeContextTypeMapping(): array {
970 970
 		return [
971
-			$this->config->get( 'WBQualityConstraintsAsMainValueId' ) => Context::TYPE_STATEMENT,
972
-			$this->config->get( 'WBQualityConstraintsAsQualifiersId' ) => Context::TYPE_QUALIFIER,
973
-			$this->config->get( 'WBQualityConstraintsAsReferencesId' ) => Context::TYPE_REFERENCE,
971
+			$this->config->get('WBQualityConstraintsAsMainValueId') => Context::TYPE_STATEMENT,
972
+			$this->config->get('WBQualityConstraintsAsQualifiersId') => Context::TYPE_QUALIFIER,
973
+			$this->config->get('WBQualityConstraintsAsReferencesId') => Context::TYPE_REFERENCE,
974 974
 		];
975 975
 	}
976 976
 
@@ -980,9 +980,9 @@  discard block
 block discarded – undo
980 980
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
981 981
 	 * @return string[] list of Context::TYPE_* constants
982 982
 	 */
983
-	public function parsePropertyScopeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
983
+	public function parsePropertyScopeParameter(array $constraintParameters, string $constraintTypeItemId): array {
984 984
 		$contextTypes = [];
985
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
985
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
986 986
 		$itemIds = $this->parseItemIdsParameter(
987 987
 			$constraintParameters,
988 988
 			$constraintTypeItemId,
@@ -991,14 +991,14 @@  discard block
 block discarded – undo
991 991
 		);
992 992
 
993 993
 		$mapping = $this->getPropertyScopeContextTypeMapping();
994
-		foreach ( $itemIds as $itemId ) {
995
-			$contextTypes[] = $this->mapItemId( $itemId, $mapping, $parameterId );
994
+		foreach ($itemIds as $itemId) {
995
+			$contextTypes[] = $this->mapItemId($itemId, $mapping, $parameterId);
996 996
 		}
997 997
 
998
-		if ( $contextTypes === [] ) {
998
+		if ($contextTypes === []) {
999 999
 			// @codeCoverageIgnoreStart
1000 1000
 			throw new LogicException(
1001
-				'The "property scope" parameter is required, ' .
1001
+				'The "property scope" parameter is required, '.
1002 1002
 				'and yet we seem to be missing any allowed scope'
1003 1003
 			);
1004 1004
 			// @codeCoverageIgnoreEnd
Please login to merge, or discard this patch.
src/ConstraintCheck/Helper/LoggingHelper.php 1 patch
Spacing   +32 added lines, -32 removed lines patch added patch discarded remove patch
@@ -53,12 +53,12 @@  discard block
 block discarded – undo
53 53
 		$this->dataFactory = $dataFactory;
54 54
 		$this->logger = $logger;
55 55
 		$this->constraintCheckDurationLimits = [
56
-			'info' => $config->get( 'WBQualityConstraintsCheckDurationInfoSeconds' ),
57
-			'warning' => $config->get( 'WBQualityConstraintsCheckDurationWarningSeconds' ),
56
+			'info' => $config->get('WBQualityConstraintsCheckDurationInfoSeconds'),
57
+			'warning' => $config->get('WBQualityConstraintsCheckDurationWarningSeconds'),
58 58
 		];
59 59
 		$this->constraintCheckOnEntityDurationLimits = [
60
-			'info' => $config->get( 'WBQualityConstraintsCheckOnEntityDurationInfoSeconds' ),
61
-			'warning' => $config->get( 'WBQualityConstraintsCheckOnEntityDurationWarningSeconds' ),
60
+			'info' => $config->get('WBQualityConstraintsCheckOnEntityDurationInfoSeconds'),
61
+			'warning' => $config->get('WBQualityConstraintsCheckOnEntityDurationWarningSeconds'),
62 62
 		];
63 63
 	}
64 64
 
@@ -69,23 +69,23 @@  discard block
 block discarded – undo
69 69
 	 * @param float $durationSeconds
70 70
 	 * @return array [ $limitSeconds, $logLevel ]
71 71
 	 */
72
-	private function findLimit( $limits, $durationSeconds ) {
72
+	private function findLimit($limits, $durationSeconds) {
73 73
 		$limitSeconds = null;
74 74
 		$logLevel = null;
75 75
 
76
-		foreach ( $limits as $level => $limit ) {
76
+		foreach ($limits as $level => $limit) {
77 77
 			if (
78 78
 				// duration exceeds this limit
79 79
 				$limit !== null && $durationSeconds > $limit &&
80 80
 				// this limit is longer than previous longest limit
81
-				( $limitSeconds === null || $limit > $limitSeconds )
81
+				($limitSeconds === null || $limit > $limitSeconds)
82 82
 			) {
83 83
 				$limitSeconds = $limit;
84 84
 				$logLevel = $level;
85 85
 			}
86 86
 		}
87 87
 
88
-		return [ $limitSeconds, $logLevel ];
88
+		return [$limitSeconds, $logLevel];
89 89
 	}
90 90
 
91 91
 	/**
@@ -110,31 +110,31 @@  discard block
 block discarded – undo
110 110
 		$durationSeconds,
111 111
 		$method
112 112
 	) {
113
-		$constraintCheckerClassShortName = substr( strrchr( $constraintCheckerClass, '\\' ), 1 );
113
+		$constraintCheckerClassShortName = substr(strrchr($constraintCheckerClass, '\\'), 1);
114 114
 		$constraintTypeItemId = $constraint->getConstraintTypeItemId();
115 115
 
116 116
 		$this->dataFactory->timing(
117
-			'wikibase.quality.constraints.check.timing.' .
118
-				$constraintTypeItemId . '-' .
117
+			'wikibase.quality.constraints.check.timing.'.
118
+				$constraintTypeItemId.'-'.
119 119
 				$constraintCheckerClassShortName,
120 120
 			$durationSeconds * 1000
121 121
 		);
122 122
 
123 123
 		// find the longest limit (and associated log level) that the duration exceeds
124
-		[ $limitSeconds, $logLevel ] = $this->findLimit(
124
+		[$limitSeconds, $logLevel] = $this->findLimit(
125 125
 			$this->constraintCheckDurationLimits,
126 126
 			$durationSeconds
127 127
 		);
128
-		if ( $limitSeconds === null ) {
128
+		if ($limitSeconds === null) {
129 129
 			return;
130 130
 		}
131
-		if ( $context->getType() !== Context::TYPE_STATEMENT ) {
131
+		if ($context->getType() !== Context::TYPE_STATEMENT) {
132 132
 			// TODO log less details but still log something
133 133
 			return;
134 134
 		}
135 135
 
136 136
 		$resultMessage = $result->getMessage();
137
-		if ( $resultMessage !== null ) {
137
+		if ($resultMessage !== null) {
138 138
 			$resultMessageKey = $resultMessage->getMessageKey();
139 139
 		} else {
140 140
 			$resultMessageKey = null;
@@ -142,8 +142,8 @@  discard block
 block discarded – undo
142 142
 
143 143
 		$this->logger->log(
144 144
 			$logLevel,
145
-			'Constraint check with {constraintCheckerClassShortName} ' .
146
-			'took longer than {limitSeconds} second(s) ' .
145
+			'Constraint check with {constraintCheckerClassShortName} '.
146
+			'took longer than {limitSeconds} second(s) '.
147 147
 			'(duration: {durationSeconds} seconds).',
148 148
 			[
149 149
 				'method' => $method,
@@ -153,7 +153,7 @@  discard block
 block discarded – undo
153 153
 				'constraintId' => $constraint->getConstraintId(),
154 154
 				'constraintPropertyId' => $constraint->getPropertyId()->getSerialization(),
155 155
 				'constraintTypeItemId' => $constraintTypeItemId,
156
-				'constraintParameters' => json_encode( $constraint->getConstraintParameters() ),
156
+				'constraintParameters' => json_encode($constraint->getConstraintParameters()),
157 157
 				'constraintCheckerClass' => $constraintCheckerClass,
158 158
 				'constraintCheckerClassShortName' => $constraintCheckerClassShortName,
159 159
 				'entityId' => $context->getEntity()->getId()->getSerialization(),
@@ -188,18 +188,18 @@  discard block
 block discarded – undo
188 188
 		);
189 189
 
190 190
 		// find the longest limit (and associated log level) that the duration exceeds
191
-		[ $limitSeconds, $logLevel ] = $this->findLimit(
191
+		[$limitSeconds, $logLevel] = $this->findLimit(
192 192
 			$this->constraintCheckOnEntityDurationLimits,
193 193
 			$durationSeconds
194 194
 		);
195
-		if ( $limitSeconds === null ) {
195
+		if ($limitSeconds === null) {
196 196
 			return;
197 197
 		}
198 198
 
199 199
 		$this->logger->log(
200 200
 			$logLevel,
201
-			'Full constraint check on {entityId} ' .
202
-			'took longer than {limitSeconds} second(s) ' .
201
+			'Full constraint check on {entityId} '.
202
+			'took longer than {limitSeconds} second(s) '.
203 203
 			'(duration: {durationSeconds} seconds).',
204 204
 			[
205 205
 				'method' => $method,
@@ -217,7 +217,7 @@  discard block
 block discarded – undo
217 217
 	 *
218 218
 	 * @param EntityId $entityId
219 219
 	 */
220
-	public function logCheckConstraintsCacheHit( EntityId $entityId ) {
220
+	public function logCheckConstraintsCacheHit(EntityId $entityId) {
221 221
 		$this->dataFactory->increment(
222 222
 			'wikibase.quality.constraints.cache.entity.hit'
223 223
 		);
@@ -228,10 +228,10 @@  discard block
 block discarded – undo
228 228
 	 *
229 229
 	 * @param EntityId[] $entityIds
230 230
 	 */
231
-	public function logCheckConstraintsCacheMisses( array $entityIds ) {
231
+	public function logCheckConstraintsCacheMisses(array $entityIds) {
232 232
 		$this->dataFactory->updateCount(
233 233
 			'wikibase.quality.constraints.cache.entity.miss',
234
-			count( $entityIds )
234
+			count($entityIds)
235 235
 		);
236 236
 	}
237 237
 
@@ -258,17 +258,17 @@  discard block
 block discarded – undo
258 258
 	 * @param EntityId[] $entityIds
259 259
 	 * @param int $maxRevisionIds
260 260
 	 */
261
-	public function logHugeDependencyMetadata( array $entityIds, $maxRevisionIds ) {
261
+	public function logHugeDependencyMetadata(array $entityIds, $maxRevisionIds) {
262 262
 		$this->logger->log(
263 263
 			'warning',
264
-			'Dependency metadata for constraint check result has huge set of entity IDs ' .
265
-			'(count ' . count( $entityIds ) . ', limit ' . $maxRevisionIds . '); ' .
264
+			'Dependency metadata for constraint check result has huge set of entity IDs '.
265
+			'(count '.count($entityIds).', limit '.$maxRevisionIds.'); '.
266 266
 			'caching disabled for this check result.',
267 267
 			[
268 268
 				'loggingMethod' => __METHOD__,
269 269
 				'entityIds' => json_encode(
270 270
 					array_map(
271
-						static function ( EntityId $entityId ) {
271
+						static function(EntityId $entityId) {
272 272
 							return $entityId->getSerialization();
273 273
 						},
274 274
 						$entityIds
@@ -287,17 +287,17 @@  discard block
 block discarded – undo
287 287
 			'Sparql API replied with status 429 and a retry-after header. Requesting to retry after {retryAfterTime}',
288 288
 			[
289 289
 				'retryAfterTime' => $retryAfterTime,
290
-				'responseHeaders' => json_encode( $request->getResponseHeaders() ),
290
+				'responseHeaders' => json_encode($request->getResponseHeaders()),
291 291
 				'responseContent' => $request->getContent(),
292 292
 			]
293 293
 		);
294 294
 	}
295 295
 
296
-	public function logSparqlHelperTooManyRequestsRetryAfterInvalid( MWHttpRequest $request ) {
296
+	public function logSparqlHelperTooManyRequestsRetryAfterInvalid(MWHttpRequest $request) {
297 297
 		$this->logger->warning(
298 298
 			'Sparql API replied with status 429 and no valid retry-after header.',
299 299
 			[
300
-				'responseHeaders' => json_encode( $request->getResponseHeaders() ),
300
+				'responseHeaders' => json_encode($request->getResponseHeaders()),
301 301
 				'responseContent' => $request->getContent(),
302 302
 			]
303 303
 		);
Please login to merge, or discard this patch.
src/ConstraintStore.php 1 patch
Spacing   +2 added lines, -2 removed lines patch added patch discarded remove patch
@@ -15,7 +15,7 @@  discard block
 block discarded – undo
15 15
 	 *
16 16
 	 * @throws DBUnexpectedError
17 17
 	 */
18
-	public function insertBatch( array $constraints );
18
+	public function insertBatch(array $constraints);
19 19
 
20 20
 	/**
21 21
 	 * Delete all constraints for the property ID.
@@ -24,6 +24,6 @@  discard block
 block discarded – undo
24 24
 	 *
25 25
 	 * @throws DBUnexpectedError
26 26
 	 */
27
-	public function deleteForProperty( NumericPropertyId $propertyId );
27
+	public function deleteForProperty(NumericPropertyId $propertyId);
28 28
 
29 29
 }
Please login to merge, or discard this patch.
src/ConstraintRepositoryStore.php 1 patch
Spacing   +19 added lines, -19 removed lines patch added patch discarded remove patch
@@ -24,16 +24,16 @@  discard block
 block discarded – undo
24 24
 	 * then using the main DBLoadBalancer service may be incorrect.
25 25
 	 * @param string|false $dbName Database name ($domain for ILoadBalancer methods).
26 26
 	 */
27
-	public function __construct( ILoadBalancer $lb, $dbName ) {
27
+	public function __construct(ILoadBalancer $lb, $dbName) {
28 28
 		$this->lb = $lb;
29 29
 		$this->dbName = $dbName;
30 30
 	}
31 31
 
32
-	private function encodeConstraintParameters( array $constraintParameters ) {
33
-		$json = json_encode( $constraintParameters, JSON_FORCE_OBJECT );
32
+	private function encodeConstraintParameters(array $constraintParameters) {
33
+		$json = json_encode($constraintParameters, JSON_FORCE_OBJECT);
34 34
 
35
-		if ( strlen( $json ) > 50000 ) {
36
-			$json = json_encode( [ '@error' => [ 'toolong' => true ] ] );
35
+		if (strlen($json) > 50000) {
36
+			$json = json_encode(['@error' => ['toolong' => true]]);
37 37
 		}
38 38
 
39 39
 		return $json;
@@ -44,28 +44,28 @@  discard block
 block discarded – undo
44 44
 	 *
45 45
 	 * @throws DBUnexpectedError
46 46
 	 */
47
-	public function insertBatch( array $constraints ) {
48
-		if ( !$constraints ) {
47
+	public function insertBatch(array $constraints) {
48
+		if (!$constraints) {
49 49
 			return;
50 50
 		}
51 51
 
52 52
 		$accumulator = array_map(
53
-			function ( Constraint $constraint ) {
53
+			function(Constraint $constraint) {
54 54
 				return [
55 55
 					'constraint_guid' => $constraint->getConstraintId(),
56 56
 					'pid' => $constraint->getPropertyId()->getNumericId(),
57 57
 					'constraint_type_qid' => $constraint->getConstraintTypeItemId(),
58
-					'constraint_parameters' => $this->encodeConstraintParameters( $constraint->getConstraintParameters() ),
58
+					'constraint_parameters' => $this->encodeConstraintParameters($constraint->getConstraintParameters()),
59 59
 				];
60 60
 			},
61 61
 			$constraints
62 62
 		);
63 63
 
64
-		$dbw = $this->lb->getConnection( ILoadBalancer::DB_PRIMARY, [], $this->dbName );
64
+		$dbw = $this->lb->getConnection(ILoadBalancer::DB_PRIMARY, [], $this->dbName);
65 65
 		$dbw->newInsertQueryBuilder()
66
-			->insertInto( 'wbqc_constraints' )
67
-			->rows( $accumulator )
68
-			->caller( __METHOD__ )
66
+			->insertInto('wbqc_constraints')
67
+			->rows($accumulator)
68
+			->caller(__METHOD__)
69 69
 			->execute();
70 70
 	}
71 71
 
@@ -76,14 +76,14 @@  discard block
 block discarded – undo
76 76
 	 *
77 77
 	 * @throws DBUnexpectedError
78 78
 	 */
79
-	public function deleteForProperty( NumericPropertyId $propertyId ) {
80
-		$dbw = $this->lb->getConnection( ILoadBalancer::DB_PRIMARY, [], $this->dbName );
79
+	public function deleteForProperty(NumericPropertyId $propertyId) {
80
+		$dbw = $this->lb->getConnection(ILoadBalancer::DB_PRIMARY, [], $this->dbName);
81 81
 		$dbw->newDeleteQueryBuilder()
82
-			->deleteFrom( 'wbqc_constraints' )
83
-			->where( [
82
+			->deleteFrom('wbqc_constraints')
83
+			->where([
84 84
 				'pid' => $propertyId->getNumericId(),
85
-			] )
86
-			->caller( __METHOD__ )
85
+			])
86
+			->caller(__METHOD__)
87 87
 			->execute();
88 88
 	}
89 89
 
Please login to merge, or discard this patch.
src/ServiceWiring.php 1 patch
Spacing   +144 added lines, -144 removed lines patch added patch discarded remove patch
@@ -30,53 +30,53 @@  discard block
 block discarded – undo
30 30
 use WikibaseQuality\ConstraintReport\ConstraintCheck\Result\CheckResultSerializer;
31 31
 
32 32
 return [
33
-	ConstraintsServices::EXPIRY_LOCK => static function ( MediaWikiServices $services ): ExpiryLock {
34
-		return new ExpiryLock( $services->getObjectCacheFactory()->getInstance( CACHE_ANYTHING ) );
33
+	ConstraintsServices::EXPIRY_LOCK => static function(MediaWikiServices $services): ExpiryLock {
34
+		return new ExpiryLock($services->getObjectCacheFactory()->getInstance(CACHE_ANYTHING));
35 35
 	},
36 36
 
37
-	ConstraintsServices::LOGGING_HELPER => static function ( MediaWikiServices $services ): LoggingHelper {
37
+	ConstraintsServices::LOGGING_HELPER => static function(MediaWikiServices $services): LoggingHelper {
38 38
 		return new LoggingHelper(
39 39
 			$services->getStatsdDataFactory(),
40
-			LoggerFactory::getInstance( 'WikibaseQualityConstraints' ),
40
+			LoggerFactory::getInstance('WikibaseQualityConstraints'),
41 41
 			$services->getMainConfig()
42 42
 		);
43 43
 	},
44 44
 
45
-	ConstraintsServices::CONSTRAINT_STORE => static function ( MediaWikiServices $services ): ConstraintRepositoryStore {
46
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
47
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
48
-		if ( $propertySource === null ) {
49
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for properties not stored in a database.' );
45
+	ConstraintsServices::CONSTRAINT_STORE => static function(MediaWikiServices $services): ConstraintRepositoryStore {
46
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
47
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
48
+		if ($propertySource === null) {
49
+			throw new RuntimeException('Can\'t get a ConstraintStore for properties not stored in a database.');
50 50
 		}
51 51
 
52
-		$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
53
-		if ( $propertySource->getSourceName() !== $localEntitySourceName ) {
54
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for a non local entity source.' );
52
+		$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
53
+		if ($propertySource->getSourceName() !== $localEntitySourceName) {
54
+			throw new RuntimeException('Can\'t get a ConstraintStore for a non local entity source.');
55 55
 		}
56 56
 
57 57
 		$dbName = $propertySource->getDatabaseName();
58 58
 		return new ConstraintRepositoryStore(
59
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
59
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
60 60
 			$dbName
61 61
 		);
62 62
 	},
63 63
 
64
-	ConstraintsServices::CONSTRAINT_LOOKUP => static function ( MediaWikiServices $services ): ConstraintLookup {
65
-		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
66
-		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType( Property::ENTITY_TYPE );
67
-		if ( $propertySource === null ) {
68
-			throw new RuntimeException( 'Can\'t get a ConstraintStore for properties not stored in a database.' );
64
+	ConstraintsServices::CONSTRAINT_LOOKUP => static function(MediaWikiServices $services): ConstraintLookup {
65
+		$sourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
66
+		$propertySource = $sourceDefinitions->getDatabaseSourceForEntityType(Property::ENTITY_TYPE);
67
+		if ($propertySource === null) {
68
+			throw new RuntimeException('Can\'t get a ConstraintStore for properties not stored in a database.');
69 69
 		}
70 70
 
71 71
 		$dbName = $propertySource->getDatabaseName();
72 72
 		$rawLookup = new ConstraintRepositoryLookup(
73
-			$services->getDBLoadBalancerFactory()->getMainLB( $dbName ),
73
+			$services->getDBLoadBalancerFactory()->getMainLB($dbName),
74 74
 			$dbName
75 75
 		);
76
-		return new CachingConstraintLookup( $rawLookup );
76
+		return new CachingConstraintLookup($rawLookup);
77 77
 	},
78 78
 
79
-	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function ( MediaWikiServices $services ): CheckResultSerializer {
79
+	ConstraintsServices::CHECK_RESULT_SERIALIZER => static function(MediaWikiServices $services): CheckResultSerializer {
80 80
 		return new CheckResultSerializer(
81 81
 			new ConstraintSerializer(
82 82
 				false // constraint parameters are not exposed
@@ -87,9 +87,9 @@  discard block
 block discarded – undo
87 87
 		);
88 88
 	},
89 89
 
90
-	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function ( MediaWikiServices $services ): CheckResultDeserializer {
91
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
92
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
90
+	ConstraintsServices::CHECK_RESULT_DESERIALIZER => static function(MediaWikiServices $services): CheckResultDeserializer {
91
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
92
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
93 93
 
94 94
 		return new CheckResultDeserializer(
95 95
 			new ConstraintDeserializer(),
@@ -102,17 +102,17 @@  discard block
 block discarded – undo
102 102
 		);
103 103
 	},
104 104
 
105
-	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function (
105
+	ConstraintsServices::VIOLATION_MESSAGE_SERIALIZER => static function(
106 106
 		MediaWikiServices $services
107 107
 	): ViolationMessageSerializer {
108 108
 		return new ViolationMessageSerializer();
109 109
 	},
110 110
 
111
-	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function (
111
+	ConstraintsServices::VIOLATION_MESSAGE_DESERIALIZER => static function(
112 112
 		MediaWikiServices $services
113 113
 	): ViolationMessageDeserializer {
114
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
115
-		$dataValueFactory = WikibaseRepo::getDataValueFactory( $services );
114
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
115
+		$dataValueFactory = WikibaseRepo::getDataValueFactory($services);
116 116
 
117 117
 		return new ViolationMessageDeserializer(
118 118
 			$entityIdParser,
@@ -120,39 +120,39 @@  discard block
 block discarded – undo
120 120
 		);
121 121
 	},
122 122
 
123
-	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function (
123
+	ConstraintsServices::CONSTRAINT_PARAMETER_PARSER => static function(
124 124
 		MediaWikiServices $services
125 125
 	): ConstraintParameterParser {
126
-		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory( $services );
127
-		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions( $services );
126
+		$deserializerFactory = WikibaseRepo::getBaseDataModelDeserializerFactory($services);
127
+		$entitySourceDefinitions = WikibaseRepo::getEntitySourceDefinitions($services);
128 128
 
129 129
 		return new ConstraintParameterParser(
130 130
 			$services->getMainConfig(),
131 131
 			$deserializerFactory,
132
-			$entitySourceDefinitions->getDatabaseSourceForEntityType( 'item' )->getConceptBaseUri()
132
+			$entitySourceDefinitions->getDatabaseSourceForEntityType('item')->getConceptBaseUri()
133 133
 		);
134 134
 	},
135 135
 
136
-	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function ( MediaWikiServices $services ): ConnectionCheckerHelper {
136
+	ConstraintsServices::CONNECTION_CHECKER_HELPER => static function(MediaWikiServices $services): ConnectionCheckerHelper {
137 137
 		return new ConnectionCheckerHelper();
138 138
 	},
139 139
 
140
-	ConstraintsServices::RANGE_CHECKER_HELPER => static function ( MediaWikiServices $services ): RangeCheckerHelper {
140
+	ConstraintsServices::RANGE_CHECKER_HELPER => static function(MediaWikiServices $services): RangeCheckerHelper {
141 141
 		return new RangeCheckerHelper(
142 142
 			$services->getMainConfig(),
143
-			WikibaseRepo::getUnitConverter( $services )
143
+			WikibaseRepo::getUnitConverter($services)
144 144
 		);
145 145
 	},
146 146
 
147
-	ConstraintsServices::SPARQL_HELPER => static function ( MediaWikiServices $services ): SparqlHelper {
148
-		$endpoint = $services->getMainConfig()->get( 'WBQualityConstraintsSparqlEndpoint' );
149
-		if ( $endpoint === '' ) {
147
+	ConstraintsServices::SPARQL_HELPER => static function(MediaWikiServices $services): SparqlHelper {
148
+		$endpoint = $services->getMainConfig()->get('WBQualityConstraintsSparqlEndpoint');
149
+		if ($endpoint === '') {
150 150
 			return new DummySparqlHelper();
151 151
 		}
152 152
 
153
-		$rdfVocabulary = WikibaseRepo::getRdfVocabulary( $services );
154
-		$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
155
-		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup( $services );
153
+		$rdfVocabulary = WikibaseRepo::getRdfVocabulary($services);
154
+		$entityIdParser = WikibaseRepo::getEntityIdParser($services);
155
+		$propertyDataTypeLookup = WikibaseRepo::getPropertyDataTypeLookup($services);
156 156
 
157 157
 		return new SparqlHelper(
158 158
 			$services->getMainConfig(),
@@ -160,128 +160,128 @@  discard block
 block discarded – undo
160 160
 			$entityIdParser,
161 161
 			$propertyDataTypeLookup,
162 162
 			$services->getMainWANObjectCache(),
163
-			ConstraintsServices::getViolationMessageSerializer( $services ),
164
-			ConstraintsServices::getViolationMessageDeserializer( $services ),
163
+			ConstraintsServices::getViolationMessageSerializer($services),
164
+			ConstraintsServices::getViolationMessageDeserializer($services),
165 165
 			$services->getStatsdDataFactory(),
166
-			ConstraintsServices::getExpiryLock( $services ),
167
-			ConstraintsServices::getLoggingHelper( $services ),
168
-			WikiMap::getCurrentWikiId() . ' WikibaseQualityConstraints ' . $services->getHttpRequestFactory()->getUserAgent(),
166
+			ConstraintsServices::getExpiryLock($services),
167
+			ConstraintsServices::getLoggingHelper($services),
168
+			WikiMap::getCurrentWikiId().' WikibaseQualityConstraints '.$services->getHttpRequestFactory()->getUserAgent(),
169 169
 			$services->getHttpRequestFactory()
170 170
 		);
171 171
 	},
172 172
 
173
-	ConstraintsServices::TYPE_CHECKER_HELPER => static function ( MediaWikiServices $services ): TypeCheckerHelper {
173
+	ConstraintsServices::TYPE_CHECKER_HELPER => static function(MediaWikiServices $services): TypeCheckerHelper {
174 174
 		return new TypeCheckerHelper(
175
-			WikibaseServices::getEntityLookup( $services ),
175
+			WikibaseServices::getEntityLookup($services),
176 176
 			$services->getMainConfig(),
177
-			ConstraintsServices::getSparqlHelper( $services ),
178
-			$services->getStatsFactory()->withComponent( 'WikibaseQualityConstraints' )
177
+			ConstraintsServices::getSparqlHelper($services),
178
+			$services->getStatsFactory()->withComponent('WikibaseQualityConstraints')
179 179
 		);
180 180
 	},
181 181
 
182
-	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function (
182
+	ConstraintsServices::DELEGATING_CONSTRAINT_CHECKER => static function(
183 183
 		MediaWikiServices $services
184 184
 	): DelegatingConstraintChecker {
185
-		$statementGuidParser = WikibaseRepo::getStatementGuidParser( $services );
185
+		$statementGuidParser = WikibaseRepo::getStatementGuidParser($services);
186 186
 
187 187
 		$config = $services->getMainConfig();
188 188
 		$checkerMap = [
189
-			$config->get( 'WBQualityConstraintsConflictsWithConstraintId' )
190
-				=> ConstraintCheckerServices::getConflictsWithChecker( $services ),
191
-			$config->get( 'WBQualityConstraintsItemRequiresClaimConstraintId' )
192
-				=> ConstraintCheckerServices::getItemChecker( $services ),
193
-			$config->get( 'WBQualityConstraintsValueRequiresClaimConstraintId' )
194
-				=> ConstraintCheckerServices::getTargetRequiredClaimChecker( $services ),
195
-			$config->get( 'WBQualityConstraintsSymmetricConstraintId' )
196
-				=> ConstraintCheckerServices::getSymmetricChecker( $services ),
197
-			$config->get( 'WBQualityConstraintsInverseConstraintId' )
198
-				=> ConstraintCheckerServices::getInverseChecker( $services ),
199
-			$config->get( 'WBQualityConstraintsUsedAsQualifierConstraintId' )
200
-				=> ConstraintCheckerServices::getQualifierChecker( $services ),
201
-			$config->get( 'WBQualityConstraintsAllowedQualifiersConstraintId' )
202
-				=> ConstraintCheckerServices::getQualifiersChecker( $services ),
203
-			$config->get( 'WBQualityConstraintsMandatoryQualifierConstraintId' )
204
-				=> ConstraintCheckerServices::getMandatoryQualifiersChecker( $services ),
205
-			$config->get( 'WBQualityConstraintsRangeConstraintId' )
206
-				=> ConstraintCheckerServices::getRangeChecker( $services ),
207
-			$config->get( 'WBQualityConstraintsDifferenceWithinRangeConstraintId' )
208
-				=> ConstraintCheckerServices::getDiffWithinRangeChecker( $services ),
209
-			$config->get( 'WBQualityConstraintsTypeConstraintId' )
210
-				=> ConstraintCheckerServices::getTypeChecker( $services ),
211
-			$config->get( 'WBQualityConstraintsValueTypeConstraintId' )
212
-				=> ConstraintCheckerServices::getValueTypeChecker( $services ),
213
-			$config->get( 'WBQualityConstraintsSingleValueConstraintId' )
214
-				=> ConstraintCheckerServices::getSingleValueChecker( $services ),
215
-			$config->get( 'WBQualityConstraintsMultiValueConstraintId' )
216
-				=> ConstraintCheckerServices::getMultiValueChecker( $services ),
217
-			$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' )
218
-				=> ConstraintCheckerServices::getUniqueValueChecker( $services ),
219
-			$config->get( 'WBQualityConstraintsFormatConstraintId' )
220
-				=> ConstraintCheckerServices::getFormatChecker( $services ),
221
-			$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' )
222
-				=> ConstraintCheckerServices::getCommonsLinkChecker( $services ),
223
-			$config->get( 'WBQualityConstraintsOneOfConstraintId' )
224
-				=> ConstraintCheckerServices::getOneOfChecker( $services ),
225
-			$config->get( 'WBQualityConstraintsUsedForValuesOnlyConstraintId' )
226
-				=> ConstraintCheckerServices::getValueOnlyChecker( $services ),
227
-			$config->get( 'WBQualityConstraintsUsedAsReferenceConstraintId' )
228
-				=> ConstraintCheckerServices::getReferenceChecker( $services ),
229
-			$config->get( 'WBQualityConstraintsNoBoundsConstraintId' )
230
-				=> ConstraintCheckerServices::getNoBoundsChecker( $services ),
231
-			$config->get( 'WBQualityConstraintsAllowedUnitsConstraintId' )
232
-				=> ConstraintCheckerServices::getAllowedUnitsChecker( $services ),
233
-			$config->get( 'WBQualityConstraintsSingleBestValueConstraintId' )
234
-				=> ConstraintCheckerServices::getSingleBestValueChecker( $services ),
235
-			$config->get( 'WBQualityConstraintsAllowedEntityTypesConstraintId' )
236
-				=> ConstraintCheckerServices::getEntityTypeChecker( $services ),
237
-			$config->get( 'WBQualityConstraintsNoneOfConstraintId' )
238
-				=> ConstraintCheckerServices::getNoneOfChecker( $services ),
239
-			$config->get( 'WBQualityConstraintsIntegerConstraintId' )
240
-				=> ConstraintCheckerServices::getIntegerChecker( $services ),
241
-			$config->get( 'WBQualityConstraintsCitationNeededConstraintId' )
242
-				=> ConstraintCheckerServices::getCitationNeededChecker( $services ),
243
-			$config->get( 'WBQualityConstraintsPropertyScopeConstraintId' )
244
-				=> ConstraintCheckerServices::getPropertyScopeChecker( $services ),
245
-			$config->get( 'WBQualityConstraintsContemporaryConstraintId' )
246
-				=> ConstraintCheckerServices::getContemporaryChecker( $services ),
247
-			$config->get( 'WBQualityConstraintsLexemeLanguageConstraintId' )
248
-				=> ConstraintCheckerServices::getLexemeLanguageChecker( $services ),
249
-			$config->get( 'WBQualityConstraintsLabelInLanguageConstraintId' )
250
-				=> ConstraintCheckerServices::getLabelInLanguageChecker( $services ),
189
+			$config->get('WBQualityConstraintsConflictsWithConstraintId')
190
+				=> ConstraintCheckerServices::getConflictsWithChecker($services),
191
+			$config->get('WBQualityConstraintsItemRequiresClaimConstraintId')
192
+				=> ConstraintCheckerServices::getItemChecker($services),
193
+			$config->get('WBQualityConstraintsValueRequiresClaimConstraintId')
194
+				=> ConstraintCheckerServices::getTargetRequiredClaimChecker($services),
195
+			$config->get('WBQualityConstraintsSymmetricConstraintId')
196
+				=> ConstraintCheckerServices::getSymmetricChecker($services),
197
+			$config->get('WBQualityConstraintsInverseConstraintId')
198
+				=> ConstraintCheckerServices::getInverseChecker($services),
199
+			$config->get('WBQualityConstraintsUsedAsQualifierConstraintId')
200
+				=> ConstraintCheckerServices::getQualifierChecker($services),
201
+			$config->get('WBQualityConstraintsAllowedQualifiersConstraintId')
202
+				=> ConstraintCheckerServices::getQualifiersChecker($services),
203
+			$config->get('WBQualityConstraintsMandatoryQualifierConstraintId')
204
+				=> ConstraintCheckerServices::getMandatoryQualifiersChecker($services),
205
+			$config->get('WBQualityConstraintsRangeConstraintId')
206
+				=> ConstraintCheckerServices::getRangeChecker($services),
207
+			$config->get('WBQualityConstraintsDifferenceWithinRangeConstraintId')
208
+				=> ConstraintCheckerServices::getDiffWithinRangeChecker($services),
209
+			$config->get('WBQualityConstraintsTypeConstraintId')
210
+				=> ConstraintCheckerServices::getTypeChecker($services),
211
+			$config->get('WBQualityConstraintsValueTypeConstraintId')
212
+				=> ConstraintCheckerServices::getValueTypeChecker($services),
213
+			$config->get('WBQualityConstraintsSingleValueConstraintId')
214
+				=> ConstraintCheckerServices::getSingleValueChecker($services),
215
+			$config->get('WBQualityConstraintsMultiValueConstraintId')
216
+				=> ConstraintCheckerServices::getMultiValueChecker($services),
217
+			$config->get('WBQualityConstraintsDistinctValuesConstraintId')
218
+				=> ConstraintCheckerServices::getUniqueValueChecker($services),
219
+			$config->get('WBQualityConstraintsFormatConstraintId')
220
+				=> ConstraintCheckerServices::getFormatChecker($services),
221
+			$config->get('WBQualityConstraintsCommonsLinkConstraintId')
222
+				=> ConstraintCheckerServices::getCommonsLinkChecker($services),
223
+			$config->get('WBQualityConstraintsOneOfConstraintId')
224
+				=> ConstraintCheckerServices::getOneOfChecker($services),
225
+			$config->get('WBQualityConstraintsUsedForValuesOnlyConstraintId')
226
+				=> ConstraintCheckerServices::getValueOnlyChecker($services),
227
+			$config->get('WBQualityConstraintsUsedAsReferenceConstraintId')
228
+				=> ConstraintCheckerServices::getReferenceChecker($services),
229
+			$config->get('WBQualityConstraintsNoBoundsConstraintId')
230
+				=> ConstraintCheckerServices::getNoBoundsChecker($services),
231
+			$config->get('WBQualityConstraintsAllowedUnitsConstraintId')
232
+				=> ConstraintCheckerServices::getAllowedUnitsChecker($services),
233
+			$config->get('WBQualityConstraintsSingleBestValueConstraintId')
234
+				=> ConstraintCheckerServices::getSingleBestValueChecker($services),
235
+			$config->get('WBQualityConstraintsAllowedEntityTypesConstraintId')
236
+				=> ConstraintCheckerServices::getEntityTypeChecker($services),
237
+			$config->get('WBQualityConstraintsNoneOfConstraintId')
238
+				=> ConstraintCheckerServices::getNoneOfChecker($services),
239
+			$config->get('WBQualityConstraintsIntegerConstraintId')
240
+				=> ConstraintCheckerServices::getIntegerChecker($services),
241
+			$config->get('WBQualityConstraintsCitationNeededConstraintId')
242
+				=> ConstraintCheckerServices::getCitationNeededChecker($services),
243
+			$config->get('WBQualityConstraintsPropertyScopeConstraintId')
244
+				=> ConstraintCheckerServices::getPropertyScopeChecker($services),
245
+			$config->get('WBQualityConstraintsContemporaryConstraintId')
246
+				=> ConstraintCheckerServices::getContemporaryChecker($services),
247
+			$config->get('WBQualityConstraintsLexemeLanguageConstraintId')
248
+				=> ConstraintCheckerServices::getLexemeLanguageChecker($services),
249
+			$config->get('WBQualityConstraintsLabelInLanguageConstraintId')
250
+				=> ConstraintCheckerServices::getLabelInLanguageChecker($services),
251 251
 		];
252 252
 
253 253
 		return new DelegatingConstraintChecker(
254
-			WikibaseServices::getEntityLookup( $services ),
254
+			WikibaseServices::getEntityLookup($services),
255 255
 			$checkerMap,
256
-			ConstraintsServices::getConstraintLookup( $services ),
257
-			ConstraintsServices::getConstraintParameterParser( $services ),
256
+			ConstraintsServices::getConstraintLookup($services),
257
+			ConstraintsServices::getConstraintParameterParser($services),
258 258
 			$statementGuidParser,
259
-			ConstraintsServices::getLoggingHelper( $services ),
260
-			$config->get( 'WBQualityConstraintsCheckQualifiers' ),
261
-			$config->get( 'WBQualityConstraintsCheckReferences' ),
262
-			$config->get( 'WBQualityConstraintsPropertiesWithViolatingQualifiers' )
259
+			ConstraintsServices::getLoggingHelper($services),
260
+			$config->get('WBQualityConstraintsCheckQualifiers'),
261
+			$config->get('WBQualityConstraintsCheckReferences'),
262
+			$config->get('WBQualityConstraintsPropertiesWithViolatingQualifiers')
263 263
 		);
264 264
 	},
265 265
 
266
-	ConstraintsServices::RESULTS_SOURCE => static function ( MediaWikiServices $services ): ResultsSource {
266
+	ConstraintsServices::RESULTS_SOURCE => static function(MediaWikiServices $services): ResultsSource {
267 267
 		$config = $services->getMainConfig();
268 268
 		$resultsSource = new CheckingResultsSource(
269
-			ConstraintsServices::getDelegatingConstraintChecker( $services )
269
+			ConstraintsServices::getDelegatingConstraintChecker($services)
270 270
 		);
271 271
 
272 272
 		$cacheCheckConstraintsResults = false;
273 273
 
274
-		if ( $config->get( 'WBQualityConstraintsCacheCheckConstraintsResults' ) ) {
274
+		if ($config->get('WBQualityConstraintsCacheCheckConstraintsResults')) {
275 275
 			$cacheCheckConstraintsResults = true;
276 276
 			// check that we can use getLocalRepoWikiPageMetaDataAccessor()
277 277
 			// TODO we should always be able to cache constraint check results (T244726)
278
-			$entitySources = WikibaseRepo::getEntitySourceDefinitions( $services )->getSources();
279
-			$localEntitySourceName = WikibaseRepo::getLocalEntitySource( $services )->getSourceName();
278
+			$entitySources = WikibaseRepo::getEntitySourceDefinitions($services)->getSources();
279
+			$localEntitySourceName = WikibaseRepo::getLocalEntitySource($services)->getSourceName();
280 280
 
281
-			foreach ( $entitySources as $entitySource ) {
282
-				if ( $entitySource->getSourceName() !== $localEntitySourceName ) {
283
-					LoggerFactory::getInstance( 'WikibaseQualityConstraints' )->warning(
284
-						'Cannot cache constraint check results for non-local source: ' .
281
+			foreach ($entitySources as $entitySource) {
282
+				if ($entitySource->getSourceName() !== $localEntitySourceName) {
283
+					LoggerFactory::getInstance('WikibaseQualityConstraints')->warning(
284
+						'Cannot cache constraint check results for non-local source: '.
285 285
 						$entitySource->getSourceName()
286 286
 					);
287 287
 					$cacheCheckConstraintsResults = false;
@@ -290,42 +290,42 @@  discard block
 block discarded – undo
290 290
 			}
291 291
 		}
292 292
 
293
-		if ( $cacheCheckConstraintsResults ) {
293
+		if ($cacheCheckConstraintsResults) {
294 294
 			$possiblyStaleConstraintTypes = [
295
-				$config->get( 'WBQualityConstraintsCommonsLinkConstraintId' ),
296
-				$config->get( 'WBQualityConstraintsTypeConstraintId' ),
297
-				$config->get( 'WBQualityConstraintsValueTypeConstraintId' ),
298
-				$config->get( 'WBQualityConstraintsDistinctValuesConstraintId' ),
295
+				$config->get('WBQualityConstraintsCommonsLinkConstraintId'),
296
+				$config->get('WBQualityConstraintsTypeConstraintId'),
297
+				$config->get('WBQualityConstraintsValueTypeConstraintId'),
298
+				$config->get('WBQualityConstraintsDistinctValuesConstraintId'),
299 299
 			];
300
-			$entityIdParser = WikibaseRepo::getEntityIdParser( $services );
300
+			$entityIdParser = WikibaseRepo::getEntityIdParser($services);
301 301
 			$wikiPageEntityMetaDataAccessor = WikibaseRepo::getLocalRepoWikiPageMetaDataAccessor(
302 302
 				$services );
303 303
 
304 304
 			$resultsSource = new CachingResultsSource(
305 305
 				$resultsSource,
306 306
 				ResultsCache::getDefaultInstance(),
307
-				ConstraintsServices::getCheckResultSerializer( $services ),
308
-				ConstraintsServices::getCheckResultDeserializer( $services ),
307
+				ConstraintsServices::getCheckResultSerializer($services),
308
+				ConstraintsServices::getCheckResultDeserializer($services),
309 309
 				$wikiPageEntityMetaDataAccessor,
310 310
 				$entityIdParser,
311
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsTTLSeconds' ),
311
+				$config->get('WBQualityConstraintsCacheCheckConstraintsTTLSeconds'),
312 312
 				$possiblyStaleConstraintTypes,
313
-				$config->get( 'WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds' ),
314
-				ConstraintsServices::getLoggingHelper( $services )
313
+				$config->get('WBQualityConstraintsCacheCheckConstraintsMaximumRevisionIds'),
314
+				ConstraintsServices::getLoggingHelper($services)
315 315
 			);
316 316
 		}
317 317
 
318 318
 		return $resultsSource;
319 319
 	},
320 320
 
321
-	ConstraintsServices::VIOLATION_MESSAGE_RENDERER_FACTORY => static function (
321
+	ConstraintsServices::VIOLATION_MESSAGE_RENDERER_FACTORY => static function(
322 322
 		MediaWikiServices $services
323 323
 	): ViolationMessageRendererFactory {
324 324
 		return new ViolationMessageRendererFactory(
325 325
 			$services->getMainConfig(),
326 326
 			$services->getLanguageNameUtils(),
327
-			WikibaseRepo::getEntityIdHtmlLinkFormatterFactory( $services ),
328
-			WikibaseRepo::getValueFormatterFactory( $services )
327
+			WikibaseRepo::getEntityIdHtmlLinkFormatterFactory($services),
328
+			WikibaseRepo::getValueFormatterFactory($services)
329 329
 		);
330 330
 	},
331 331
 ];
Please login to merge, or discard this patch.