Completed
Push — master ( fea290...e373fa )
by
unknown
48s queued 12s
created
src/Api/CheckResultsRenderer.php 1 patch
Spacing   +20 added lines, -20 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\Api;
6 6
 
@@ -41,11 +41,11 @@  discard block
 block discarded – undo
41 41
 		$this->violationMessageRenderer = $violationMessageRenderer;
42 42
 	}
43 43
 
44
-	public function render( CachedCheckResults $checkResults ): CachedCheckConstraintsResponse {
44
+	public function render(CachedCheckResults $checkResults): CachedCheckConstraintsResponse {
45 45
 		$response = [];
46
-		foreach ( $checkResults->getArray() as $checkResult ) {
47
-			$resultArray = $this->checkResultToArray( $checkResult );
48
-			$checkResult->getContextCursor()->storeCheckResultInArray( $resultArray, $response );
46
+		foreach ($checkResults->getArray() as $checkResult) {
47
+			$resultArray = $this->checkResultToArray($checkResult);
48
+			$checkResult->getContextCursor()->storeCheckResultInArray($resultArray, $response);
49 49
 		}
50 50
 		return new CachedCheckConstraintsResponse(
51 51
 			$response,
@@ -53,19 +53,19 @@  discard block
 block discarded – undo
53 53
 		);
54 54
 	}
55 55
 
56
-	public function checkResultToArray( CheckResult $checkResult ): ?array {
57
-		if ( $checkResult instanceof NullResult ) {
56
+	public function checkResultToArray(CheckResult $checkResult): ?array {
57
+		if ($checkResult instanceof NullResult) {
58 58
 			return null;
59 59
 		}
60 60
 
61 61
 		$constraintId = $checkResult->getConstraint()->getConstraintId();
62 62
 		$typeItemId = $checkResult->getConstraint()->getConstraintTypeItemId();
63
-		$constraintPropertyId = new NumericPropertyId( $checkResult->getContextCursor()->getSnakPropertyId() );
63
+		$constraintPropertyId = new NumericPropertyId($checkResult->getContextCursor()->getSnakPropertyId());
64 64
 
65
-		$title = $this->entityTitleLookup->getTitleForId( $constraintPropertyId );
65
+		$title = $this->entityTitleLookup->getTitleForId($constraintPropertyId);
66 66
 		$talkTitle = $title->getTalkPageIfDefined();
67
-		$typeLabel = $this->entityIdLabelFormatter->formatEntityId( new ItemId( $typeItemId ) );
68
-		$link = $title->getFullURL() . '#' . $constraintId;
67
+		$typeLabel = $this->entityIdLabelFormatter->formatEntityId(new ItemId($typeItemId));
68
+		$link = $title->getFullURL().'#'.$constraintId;
69 69
 
70 70
 		$constraint = [
71 71
 			'id' => $constraintId,
@@ -81,28 +81,28 @@  discard block
 block discarded – undo
81 81
 			'constraint' => $constraint
82 82
 		];
83 83
 		$message = $checkResult->getMessage();
84
-		if ( $message ) {
85
-			$result['message-html'] = $this->violationMessageRenderer->render( $message );
84
+		if ($message) {
85
+			$result['message-html'] = $this->violationMessageRenderer->render($message);
86 86
 		}
87
-		$constraintClarification = $this->renderConstraintClarification( $checkResult );
88
-		if ( $constraintClarification !== null ) {
87
+		$constraintClarification = $this->renderConstraintClarification($checkResult);
88
+		if ($constraintClarification !== null) {
89 89
 			$result['constraint-clarification'] = $constraintClarification;
90 90
 		}
91
-		if ( $checkResult->getContextCursor()->getType() === Context::TYPE_STATEMENT ) {
91
+		if ($checkResult->getContextCursor()->getType() === Context::TYPE_STATEMENT) {
92 92
 			$result['claim'] = $checkResult->getContextCursor()->getStatementGuid();
93 93
 		}
94 94
 		$cachingMetadataArray = $checkResult->getMetadata()->getCachingMetadata()->toArray();
95
-		if ( $cachingMetadataArray !== null ) {
95
+		if ($cachingMetadataArray !== null) {
96 96
 			$result['cached'] = $cachingMetadataArray;
97 97
 		}
98 98
 
99 99
 		return $result;
100 100
 	}
101 101
 
102
-	private function renderConstraintClarification( CheckResult $result ): ?string {
102
+	private function renderConstraintClarification(CheckResult $result): ?string {
103 103
 		$texts = $result->getConstraintClarification()->getTexts();
104
-		foreach ( $this->languageFallbackChain->getFetchLanguageCodes() as $languageCode ) {
105
-			if ( array_key_exists( $languageCode, $texts ) ) {
104
+		foreach ($this->languageFallbackChain->getFetchLanguageCodes() as $languageCode) {
105
+			if (array_key_exists($languageCode, $texts)) {
106 106
 				return $texts[$languageCode]->getText();
107 107
 			}
108 108
 		}
Please login to merge, or discard this patch.
src/Api/CheckResultsRendererFactory.php 1 patch
Spacing   +3 added lines, -3 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\Api;
6 6
 
@@ -37,12 +37,12 @@  discard block
 block discarded – undo
37 37
 		Language $userLanguage,
38 38
 		MessageLocalizer $messageLocalizer
39 39
 	): CheckResultsRenderer {
40
-		$languageFallbackChain = $this->languageFallbackChainFactory->newFromLanguage( $userLanguage );
40
+		$languageFallbackChain = $this->languageFallbackChainFactory->newFromLanguage($userLanguage);
41 41
 
42 42
 		return new CheckResultsRenderer(
43 43
 			$this->entityTitleLookup,
44 44
 			$this->entityIdLabelFormatterFactory
45
-				->getEntityIdFormatter( $userLanguage ),
45
+				->getEntityIdFormatter($userLanguage),
46 46
 			$languageFallbackChain,
47 47
 			$this->violationMessageRendererFactory
48 48
 				->getViolationMessageRenderer(
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,41 +431,41 @@  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
 			throw new ConstraintParameterException(
462
-				( new ViolationMessage( 'wbqc-violation-message-range-parameters-same' ) )
463
-					->withEntityId( new NumericPropertyId( $minimumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
464
-					->withEntityId( new NumericPropertyId( $maximumId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
462
+				(new ViolationMessage('wbqc-violation-message-range-parameters-same'))
463
+					->withEntityId(new NumericPropertyId($minimumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
464
+					->withEntityId(new NumericPropertyId($maximumId), Role::CONSTRAINT_PARAMETER_PROPERTY)
465 465
 			);
466 466
 		}
467 467
 
468
-		return [ $min, $max ];
468
+		return [$min, $max];
469 469
 	}
470 470
 
471 471
 	/**
@@ -475,11 +475,11 @@  discard block
 block discarded – undo
475 475
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
476 476
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
477 477
 	 */
478
-	public function parseQuantityRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
478
+	public function parseQuantityRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
479 479
 		return $this->parseRangeParameter(
480 480
 			$constraintParameters,
481
-			$this->config->get( 'WBQualityConstraintsMinimumQuantityId' ),
482
-			$this->config->get( 'WBQualityConstraintsMaximumQuantityId' ),
481
+			$this->config->get('WBQualityConstraintsMinimumQuantityId'),
482
+			$this->config->get('WBQualityConstraintsMaximumQuantityId'),
483 483
 			$constraintTypeItemId,
484 484
 			'quantity'
485 485
 		);
@@ -492,11 +492,11 @@  discard block
 block discarded – undo
492 492
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
493 493
 	 * @return DataValue[] a pair of two data values, either of which may be null to signify an open range
494 494
 	 */
495
-	public function parseTimeRangeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
495
+	public function parseTimeRangeParameter(array $constraintParameters, string $constraintTypeItemId): array {
496 496
 		return $this->parseRangeParameter(
497 497
 			$constraintParameters,
498
-			$this->config->get( 'WBQualityConstraintsMinimumDateId' ),
499
-			$this->config->get( 'WBQualityConstraintsMaximumDateId' ),
498
+			$this->config->get('WBQualityConstraintsMinimumDateId'),
499
+			$this->config->get('WBQualityConstraintsMaximumDateId'),
500 500
 			$constraintTypeItemId,
501 501
 			'time'
502 502
 		);
@@ -509,20 +509,20 @@  discard block
 block discarded – undo
509 509
 	 * @throws ConstraintParameterException
510 510
 	 * @return string[]
511 511
 	 */
512
-	public function parseLanguageParameter( array $constraintParameters, string $constraintTypeItemId ): array {
513
-		$this->checkError( $constraintParameters );
514
-		$languagePropertyId = $this->config->get( 'WBQualityConstraintsLanguagePropertyId' );
515
-		if ( !array_key_exists( $languagePropertyId, $constraintParameters ) ) {
512
+	public function parseLanguageParameter(array $constraintParameters, string $constraintTypeItemId): array {
513
+		$this->checkError($constraintParameters);
514
+		$languagePropertyId = $this->config->get('WBQualityConstraintsLanguagePropertyId');
515
+		if (!array_key_exists($languagePropertyId, $constraintParameters)) {
516 516
 			throw new ConstraintParameterException(
517
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
518
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
519
-					->withEntityId( new NumericPropertyId( $languagePropertyId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
517
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
518
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
519
+					->withEntityId(new NumericPropertyId($languagePropertyId), Role::CONSTRAINT_PARAMETER_PROPERTY)
520 520
 			);
521 521
 		}
522 522
 
523 523
 		$languages = [];
524
-		foreach ( $constraintParameters[$languagePropertyId] as $snak ) {
525
-			$languages[] = $this->parseStringParameter( $snak, $languagePropertyId );
524
+		foreach ($constraintParameters[$languagePropertyId] as $snak) {
525
+			$languages[] = $this->parseStringParameter($snak, $languagePropertyId);
526 526
 		}
527 527
 		return $languages;
528 528
 	}
@@ -531,17 +531,17 @@  discard block
 block discarded – undo
531 531
 	 * Parse a single string parameter.
532 532
 	 * @throws ConstraintParameterException
533 533
 	 */
534
-	private function parseStringParameter( array $snakSerialization, string $parameterId ): string {
535
-		$snak = $this->snakDeserializer->deserialize( $snakSerialization );
536
-		$this->requireValueParameter( $snak, $parameterId );
534
+	private function parseStringParameter(array $snakSerialization, string $parameterId): string {
535
+		$snak = $this->snakDeserializer->deserialize($snakSerialization);
536
+		$this->requireValueParameter($snak, $parameterId);
537 537
 		$value = $snak->getDataValue();
538
-		if ( $value instanceof StringValue ) {
538
+		if ($value instanceof StringValue) {
539 539
 			return $value->getValue();
540 540
 		} else {
541 541
 			throw new ConstraintParameterException(
542
-				( new ViolationMessage( 'wbqc-violation-message-parameter-string' ) )
543
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
544
-					->withDataValue( $value, Role::CONSTRAINT_PARAMETER_VALUE )
542
+				(new ViolationMessage('wbqc-violation-message-parameter-string'))
543
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
544
+					->withDataValue($value, Role::CONSTRAINT_PARAMETER_VALUE)
545 545
 			);
546 546
 		}
547 547
 	}
@@ -552,15 +552,15 @@  discard block
 block discarded – undo
552 552
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
553 553
 	 * @return string
554 554
 	 */
555
-	public function parseNamespaceParameter( array $constraintParameters, string $constraintTypeItemId ): string {
556
-		$this->checkError( $constraintParameters );
557
-		$namespaceId = $this->config->get( 'WBQualityConstraintsNamespaceId' );
558
-		if ( !array_key_exists( $namespaceId, $constraintParameters ) ) {
555
+	public function parseNamespaceParameter(array $constraintParameters, string $constraintTypeItemId): string {
556
+		$this->checkError($constraintParameters);
557
+		$namespaceId = $this->config->get('WBQualityConstraintsNamespaceId');
558
+		if (!array_key_exists($namespaceId, $constraintParameters)) {
559 559
 			return '';
560 560
 		}
561 561
 
562
-		$this->requireSingleParameter( $constraintParameters, $namespaceId );
563
-		return $this->parseStringParameter( $constraintParameters[$namespaceId][0], $namespaceId );
562
+		$this->requireSingleParameter($constraintParameters, $namespaceId);
563
+		return $this->parseStringParameter($constraintParameters[$namespaceId][0], $namespaceId);
564 564
 	}
565 565
 
566 566
 	/**
@@ -569,19 +569,19 @@  discard block
 block discarded – undo
569 569
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
570 570
 	 * @return string
571 571
 	 */
572
-	public function parseFormatParameter( array $constraintParameters, string $constraintTypeItemId ): string {
573
-		$this->checkError( $constraintParameters );
574
-		$formatId = $this->config->get( 'WBQualityConstraintsFormatAsARegularExpressionId' );
575
-		if ( !array_key_exists( $formatId, $constraintParameters ) ) {
572
+	public function parseFormatParameter(array $constraintParameters, string $constraintTypeItemId): string {
573
+		$this->checkError($constraintParameters);
574
+		$formatId = $this->config->get('WBQualityConstraintsFormatAsARegularExpressionId');
575
+		if (!array_key_exists($formatId, $constraintParameters)) {
576 576
 			throw new ConstraintParameterException(
577
-				( new ViolationMessage( 'wbqc-violation-message-parameter-needed' ) )
578
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
579
-					->withEntityId( new NumericPropertyId( $formatId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
577
+				(new ViolationMessage('wbqc-violation-message-parameter-needed'))
578
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
579
+					->withEntityId(new NumericPropertyId($formatId), Role::CONSTRAINT_PARAMETER_PROPERTY)
580 580
 			);
581 581
 		}
582 582
 
583
-		$this->requireSingleParameter( $constraintParameters, $formatId );
584
-		return $this->parseStringParameter( $constraintParameters[$formatId][0], $formatId );
583
+		$this->requireSingleParameter($constraintParameters, $formatId);
584
+		return $this->parseStringParameter($constraintParameters[$formatId][0], $formatId);
585 585
 	}
586 586
 
587 587
 	/**
@@ -589,16 +589,16 @@  discard block
 block discarded – undo
589 589
 	 * @throws ConstraintParameterException if the parameter is invalid
590 590
 	 * @return EntityId[]
591 591
 	 */
592
-	public function parseExceptionParameter( array $constraintParameters ): array {
593
-		$this->checkError( $constraintParameters );
594
-		$exceptionId = $this->config->get( 'WBQualityConstraintsExceptionToConstraintId' );
595
-		if ( !array_key_exists( $exceptionId, $constraintParameters ) ) {
592
+	public function parseExceptionParameter(array $constraintParameters): array {
593
+		$this->checkError($constraintParameters);
594
+		$exceptionId = $this->config->get('WBQualityConstraintsExceptionToConstraintId');
595
+		if (!array_key_exists($exceptionId, $constraintParameters)) {
596 596
 			return [];
597 597
 		}
598 598
 
599 599
 		return array_map(
600
-			function ( $snakSerialization ) use ( $exceptionId ) {
601
-				return $this->parseEntityIdParameter( $snakSerialization, $exceptionId );
600
+			function($snakSerialization) use ($exceptionId) {
601
+				return $this->parseEntityIdParameter($snakSerialization, $exceptionId);
602 602
 			},
603 603
 			$constraintParameters[$exceptionId]
604 604
 		);
@@ -609,39 +609,39 @@  discard block
 block discarded – undo
609 609
 	 * @throws ConstraintParameterException if the parameter is invalid
610 610
 	 * @return string|null 'mandatory', 'suggestion' or null
611 611
 	 */
612
-	public function parseConstraintStatusParameter( array $constraintParameters ): ?string {
613
-		$this->checkError( $constraintParameters );
614
-		$constraintStatusId = $this->config->get( 'WBQualityConstraintsConstraintStatusId' );
615
-		if ( !array_key_exists( $constraintStatusId, $constraintParameters ) ) {
612
+	public function parseConstraintStatusParameter(array $constraintParameters): ?string {
613
+		$this->checkError($constraintParameters);
614
+		$constraintStatusId = $this->config->get('WBQualityConstraintsConstraintStatusId');
615
+		if (!array_key_exists($constraintStatusId, $constraintParameters)) {
616 616
 			return null;
617 617
 		}
618 618
 
619
-		$mandatoryId = $this->config->get( 'WBQualityConstraintsMandatoryConstraintId' );
620
-		$supportedStatuses = [ new ItemId( $mandatoryId ) ];
621
-		if ( $this->config->get( 'WBQualityConstraintsEnableSuggestionConstraintStatus' ) ) {
622
-			$suggestionId = $this->config->get( 'WBQualityConstraintsSuggestionConstraintId' );
623
-			$supportedStatuses[] = new ItemId( $suggestionId );
619
+		$mandatoryId = $this->config->get('WBQualityConstraintsMandatoryConstraintId');
620
+		$supportedStatuses = [new ItemId($mandatoryId)];
621
+		if ($this->config->get('WBQualityConstraintsEnableSuggestionConstraintStatus')) {
622
+			$suggestionId = $this->config->get('WBQualityConstraintsSuggestionConstraintId');
623
+			$supportedStatuses[] = new ItemId($suggestionId);
624 624
 		} else {
625 625
 			$suggestionId = null;
626 626
 		}
627 627
 
628
-		$this->requireSingleParameter( $constraintParameters, $constraintStatusId );
629
-		$snak = $this->snakDeserializer->deserialize( $constraintParameters[$constraintStatusId][0] );
630
-		$this->requireValueParameter( $snak, $constraintStatusId );
628
+		$this->requireSingleParameter($constraintParameters, $constraintStatusId);
629
+		$snak = $this->snakDeserializer->deserialize($constraintParameters[$constraintStatusId][0]);
630
+		$this->requireValueParameter($snak, $constraintStatusId);
631 631
 		'@phan-var \Wikibase\DataModel\Snak\PropertyValueSnak $snak';
632 632
 		$dataValue = $snak->getDataValue();
633 633
 		'@phan-var EntityIdValue $dataValue';
634 634
 		$entityId = $dataValue->getEntityId();
635 635
 		$statusId = $entityId->getSerialization();
636 636
 
637
-		if ( $statusId === $mandatoryId ) {
637
+		if ($statusId === $mandatoryId) {
638 638
 			return 'mandatory';
639
-		} elseif ( $statusId === $suggestionId ) {
639
+		} elseif ($statusId === $suggestionId) {
640 640
 			return 'suggestion';
641 641
 		} else {
642 642
 			throw new ConstraintParameterException(
643
-				( new ViolationMessage( 'wbqc-violation-message-parameter-oneof' ) )
644
-					->withEntityId( new NumericPropertyId( $constraintStatusId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
643
+				(new ViolationMessage('wbqc-violation-message-parameter-oneof'))
644
+					->withEntityId(new NumericPropertyId($constraintStatusId), Role::CONSTRAINT_PARAMETER_PROPERTY)
645 645
 					->withEntityIdList(
646 646
 						$supportedStatuses,
647 647
 						Role::CONSTRAINT_PARAMETER_VALUE
@@ -654,12 +654,12 @@  discard block
 block discarded – undo
654 654
 	 * Require that $dataValue is a {@link MonolingualTextValue}.
655 655
 	 * @throws ConstraintParameterException
656 656
 	 */
657
-	private function requireMonolingualTextParameter( DataValue $dataValue, string $parameterId ): void {
658
-		if ( !( $dataValue instanceof MonolingualTextValue ) ) {
657
+	private function requireMonolingualTextParameter(DataValue $dataValue, string $parameterId): void {
658
+		if (!($dataValue instanceof MonolingualTextValue)) {
659 659
 			throw new ConstraintParameterException(
660
-				( new ViolationMessage( 'wbqc-violation-message-parameter-monolingualtext' ) )
661
-					->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
662
-					->withDataValue( $dataValue, Role::CONSTRAINT_PARAMETER_VALUE )
660
+				(new ViolationMessage('wbqc-violation-message-parameter-monolingualtext'))
661
+					->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
662
+					->withDataValue($dataValue, Role::CONSTRAINT_PARAMETER_VALUE)
663 663
 			);
664 664
 		}
665 665
 	}
@@ -669,31 +669,31 @@  discard block
 block discarded – undo
669 669
 	 *
670 670
 	 * @throws ConstraintParameterException if invalid snaks are found or a language has multiple texts
671 671
 	 */
672
-	private function parseMultilingualTextParameter( array $snakSerializations, string $parameterId ): MultilingualTextValue {
672
+	private function parseMultilingualTextParameter(array $snakSerializations, string $parameterId): MultilingualTextValue {
673 673
 		$result = [];
674 674
 
675
-		foreach ( $snakSerializations as $snakSerialization ) {
676
-			$snak = $this->snakDeserializer->deserialize( $snakSerialization );
677
-			$this->requireValueParameter( $snak, $parameterId );
675
+		foreach ($snakSerializations as $snakSerialization) {
676
+			$snak = $this->snakDeserializer->deserialize($snakSerialization);
677
+			$this->requireValueParameter($snak, $parameterId);
678 678
 
679 679
 			$value = $snak->getDataValue();
680
-			$this->requireMonolingualTextParameter( $value, $parameterId );
680
+			$this->requireMonolingualTextParameter($value, $parameterId);
681 681
 			/** @var MonolingualTextValue $value */
682 682
 			'@phan-var MonolingualTextValue $value';
683 683
 
684 684
 			$code = $value->getLanguageCode();
685
-			if ( array_key_exists( $code, $result ) ) {
685
+			if (array_key_exists($code, $result)) {
686 686
 				throw new ConstraintParameterException(
687
-					( new ViolationMessage( 'wbqc-violation-message-parameter-single-per-language' ) )
688
-						->withEntityId( new NumericPropertyId( $parameterId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
689
-						->withLanguage( $code )
687
+					(new ViolationMessage('wbqc-violation-message-parameter-single-per-language'))
688
+						->withEntityId(new NumericPropertyId($parameterId), Role::CONSTRAINT_PARAMETER_PROPERTY)
689
+						->withLanguage($code)
690 690
 				);
691 691
 			}
692 692
 
693 693
 			$result[$code] = $value;
694 694
 		}
695 695
 
696
-		return new MultilingualTextValue( $result );
696
+		return new MultilingualTextValue($result);
697 697
 	}
698 698
 
699 699
 	/**
@@ -701,11 +701,11 @@  discard block
 block discarded – undo
701 701
 	 * @throws ConstraintParameterException if the parameter is invalid
702 702
 	 * @return MultilingualTextValue
703 703
 	 */
704
-	public function parseSyntaxClarificationParameter( array $constraintParameters ): MultilingualTextValue {
705
-		$syntaxClarificationId = $this->config->get( 'WBQualityConstraintsSyntaxClarificationId' );
704
+	public function parseSyntaxClarificationParameter(array $constraintParameters): MultilingualTextValue {
705
+		$syntaxClarificationId = $this->config->get('WBQualityConstraintsSyntaxClarificationId');
706 706
 
707
-		if ( !array_key_exists( $syntaxClarificationId, $constraintParameters ) ) {
708
-			return new MultilingualTextValue( [] );
707
+		if (!array_key_exists($syntaxClarificationId, $constraintParameters)) {
708
+			return new MultilingualTextValue([]);
709 709
 		}
710 710
 
711 711
 		$syntaxClarifications = $this->parseMultilingualTextParameter(
@@ -721,11 +721,11 @@  discard block
 block discarded – undo
721 721
 	 * @throws ConstraintParameterException if the parameter is invalid
722 722
 	 * @return MultilingualTextValue
723 723
 	 */
724
-	public function parseConstraintClarificationParameter( array $constraintParameters ): MultilingualTextValue {
725
-		$constraintClarificationId = $this->config->get( 'WBQualityConstraintsConstraintClarificationId' );
724
+	public function parseConstraintClarificationParameter(array $constraintParameters): MultilingualTextValue {
725
+		$constraintClarificationId = $this->config->get('WBQualityConstraintsConstraintClarificationId');
726 726
 
727
-		if ( !array_key_exists( $constraintClarificationId, $constraintParameters ) ) {
728
-			return new MultilingualTextValue( [] );
727
+		if (!array_key_exists($constraintClarificationId, $constraintParameters)) {
728
+			return new MultilingualTextValue([]);
729 729
 		}
730 730
 
731 731
 		$constraintClarifications = $this->parseMultilingualTextParameter(
@@ -758,14 +758,14 @@  discard block
 block discarded – undo
758 758
 		array $validContextTypes,
759 759
 		array $validEntityTypes
760 760
 	): array {
761
-		$contextTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintScopeId' );
761
+		$contextTypeParameterId = $this->config->get('WBQualityConstraintsConstraintScopeId');
762 762
 		$contextTypeItemIds = $this->parseItemIdsParameter(
763 763
 			$constraintParameters,
764 764
 			$constraintTypeItemId,
765 765
 			false,
766 766
 			$contextTypeParameterId
767 767
 		);
768
-		$entityTypeParameterId = $this->config->get( 'WBQualityConstraintsConstraintEntityTypesId' );
768
+		$entityTypeParameterId = $this->config->get('WBQualityConstraintsConstraintEntityTypesId');
769 769
 		$entityTypeItemIds = $this->parseItemIdsParameter(
770 770
 			$constraintParameters,
771 771
 			$constraintTypeItemId,
@@ -781,26 +781,26 @@  discard block
 block discarded – undo
781 781
 		$contextTypes = null;
782 782
 		$entityTypes = null;
783 783
 
784
-		if ( $contextTypeParameterId === $entityTypeParameterId ) {
784
+		if ($contextTypeParameterId === $entityTypeParameterId) {
785 785
 			$itemIds = $contextTypeItemIds;
786 786
 			$mapping = $contextTypeMapping + $entityTypeMapping;
787
-			foreach ( $itemIds as $itemId ) {
788
-				$mapped = $this->mapItemId( $itemId, $mapping, $contextTypeParameterId );
789
-				if ( in_array( $mapped, $contextTypeMapping, true ) ) {
787
+			foreach ($itemIds as $itemId) {
788
+				$mapped = $this->mapItemId($itemId, $mapping, $contextTypeParameterId);
789
+				if (in_array($mapped, $contextTypeMapping, true)) {
790 790
 					$contextTypes[] = $mapped;
791 791
 				} else {
792 792
 					$entityTypes[] = $mapped;
793 793
 				}
794 794
 			}
795 795
 		} else {
796
-			foreach ( $contextTypeItemIds as $contextTypeItemId ) {
796
+			foreach ($contextTypeItemIds as $contextTypeItemId) {
797 797
 				$contextTypes[] = $this->mapItemId(
798 798
 					$contextTypeItemId,
799 799
 					$contextTypeMapping,
800 800
 					$contextTypeParameterId
801 801
 				);
802 802
 			}
803
-			foreach ( $entityTypeItemIds as $entityTypeItemId ) {
803
+			foreach ($entityTypeItemIds as $entityTypeItemId) {
804 804
 				$entityTypes[] = $this->mapItemId(
805 805
 					$entityTypeItemId,
806 806
 					$entityTypeMapping,
@@ -809,21 +809,21 @@  discard block
 block discarded – undo
809 809
 			}
810 810
 		}
811 811
 
812
-		$this->checkValidScope( $constraintTypeItemId, $contextTypes, $validContextTypes );
813
-		$this->checkValidScope( $constraintTypeItemId, $entityTypes, $validEntityTypes );
812
+		$this->checkValidScope($constraintTypeItemId, $contextTypes, $validContextTypes);
813
+		$this->checkValidScope($constraintTypeItemId, $entityTypes, $validEntityTypes);
814 814
 
815
-		return [ $contextTypes, $entityTypes ];
815
+		return [$contextTypes, $entityTypes];
816 816
 	}
817 817
 
818
-	private function checkValidScope( string $constraintTypeItemId, ?array $types, array $validTypes ): void {
819
-		$invalidTypes = array_diff( $types ?: [], $validTypes );
820
-		if ( $invalidTypes !== [] ) {
821
-			$invalidType = array_pop( $invalidTypes );
818
+	private function checkValidScope(string $constraintTypeItemId, ?array $types, array $validTypes): void {
819
+		$invalidTypes = array_diff($types ?: [], $validTypes);
820
+		if ($invalidTypes !== []) {
821
+			$invalidType = array_pop($invalidTypes);
822 822
 			throw new ConstraintParameterException(
823
-				( new ViolationMessage( 'wbqc-violation-message-invalid-scope' ) )
824
-					->withConstraintScope( $invalidType, Role::CONSTRAINT_PARAMETER_VALUE )
825
-					->withEntityId( new ItemId( $constraintTypeItemId ), Role::CONSTRAINT_TYPE_ITEM )
826
-					->withConstraintScopeList( $validTypes, Role::CONSTRAINT_PARAMETER_VALUE )
823
+				(new ViolationMessage('wbqc-violation-message-invalid-scope'))
824
+					->withConstraintScope($invalidType, Role::CONSTRAINT_PARAMETER_VALUE)
825
+					->withEntityId(new ItemId($constraintTypeItemId), Role::CONSTRAINT_TYPE_ITEM)
826
+					->withConstraintScopeList($validTypes, Role::CONSTRAINT_PARAMETER_VALUE)
827 827
 			);
828 828
 		}
829 829
 	}
@@ -831,8 +831,8 @@  discard block
 block discarded – undo
831 831
 	/**
832 832
 	 * Turn an item ID into a full unit string (using the concept URI).
833 833
 	 */
834
-	private function parseUnitParameter( ItemId $unitId ): string {
835
-		return $this->unitItemConceptBaseUri . $unitId->getSerialization();
834
+	private function parseUnitParameter(ItemId $unitId): string {
835
+		return $this->unitItemConceptBaseUri.$unitId->getSerialization();
836 836
 	}
837 837
 
838 838
 	/**
@@ -840,23 +840,23 @@  discard block
 block discarded – undo
840 840
 	 *
841 841
 	 * @throws ConstraintParameterException
842 842
 	 */
843
-	private function parseUnitItem( ItemIdSnakValue $item ): UnitsParameter {
844
-		switch ( true ) {
843
+	private function parseUnitItem(ItemIdSnakValue $item): UnitsParameter {
844
+		switch (true) {
845 845
 			case $item->isValue():
846
-				$unit = $this->parseUnitParameter( $item->getItemId() );
846
+				$unit = $this->parseUnitParameter($item->getItemId());
847 847
 				return new UnitsParameter(
848
-					[ $item->getItemId() ],
849
-					[ UnboundedQuantityValue::newFromNumber( 1, $unit ) ],
848
+					[$item->getItemId()],
849
+					[UnboundedQuantityValue::newFromNumber(1, $unit)],
850 850
 					false
851 851
 				);
852 852
 			case $item->isSomeValue():
853
-				$qualifierId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
853
+				$qualifierId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
854 854
 				throw new ConstraintParameterException(
855
-					( new ViolationMessage( 'wbqc-violation-message-parameter-value-or-novalue' ) )
856
-						->withEntityId( new NumericPropertyId( $qualifierId ), Role::CONSTRAINT_PARAMETER_PROPERTY )
855
+					(new ViolationMessage('wbqc-violation-message-parameter-value-or-novalue'))
856
+						->withEntityId(new NumericPropertyId($qualifierId), Role::CONSTRAINT_PARAMETER_PROPERTY)
857 857
 				);
858 858
 			case $item->isNoValue():
859
-				return new UnitsParameter( [], [], true );
859
+				return new UnitsParameter([], [], true);
860 860
 		}
861 861
 	}
862 862
 
@@ -866,36 +866,36 @@  discard block
 block discarded – undo
866 866
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
867 867
 	 * @return UnitsParameter
868 868
 	 */
869
-	public function parseUnitsParameter( array $constraintParameters, string $constraintTypeItemId ): UnitsParameter {
870
-		$items = $this->parseItemsParameter( $constraintParameters, $constraintTypeItemId, true );
869
+	public function parseUnitsParameter(array $constraintParameters, string $constraintTypeItemId): UnitsParameter {
870
+		$items = $this->parseItemsParameter($constraintParameters, $constraintTypeItemId, true);
871 871
 		$unitItems = [];
872 872
 		$unitQuantities = [];
873 873
 		$unitlessAllowed = false;
874 874
 
875
-		foreach ( $items as $item ) {
876
-			$unit = $this->parseUnitItem( $item );
877
-			$unitItems = array_merge( $unitItems, $unit->getUnitItemIds() );
878
-			$unitQuantities = array_merge( $unitQuantities, $unit->getUnitQuantities() );
875
+		foreach ($items as $item) {
876
+			$unit = $this->parseUnitItem($item);
877
+			$unitItems = array_merge($unitItems, $unit->getUnitItemIds());
878
+			$unitQuantities = array_merge($unitQuantities, $unit->getUnitQuantities());
879 879
 			$unitlessAllowed = $unitlessAllowed || $unit->getUnitlessAllowed();
880 880
 		}
881 881
 
882
-		if ( $unitQuantities === [] && !$unitlessAllowed ) {
882
+		if ($unitQuantities === [] && !$unitlessAllowed) {
883 883
 			throw new LogicException(
884 884
 				'The "units" parameter is required, and yet we seem to be missing any allowed unit'
885 885
 			);
886 886
 		}
887 887
 
888
-		return new UnitsParameter( $unitItems, $unitQuantities, $unitlessAllowed );
888
+		return new UnitsParameter($unitItems, $unitQuantities, $unitlessAllowed);
889 889
 	}
890 890
 
891 891
 	private function getEntityTypeMapping(): array {
892 892
 		return [
893
-			$this->config->get( 'WBQualityConstraintsWikibaseItemId' ) => 'item',
894
-			$this->config->get( 'WBQualityConstraintsWikibasePropertyId' ) => 'property',
895
-			$this->config->get( 'WBQualityConstraintsWikibaseLexemeId' ) => 'lexeme',
896
-			$this->config->get( 'WBQualityConstraintsWikibaseFormId' ) => 'form',
897
-			$this->config->get( 'WBQualityConstraintsWikibaseSenseId' ) => 'sense',
898
-			$this->config->get( 'WBQualityConstraintsWikibaseMediaInfoId' ) => 'mediainfo',
893
+			$this->config->get('WBQualityConstraintsWikibaseItemId') => 'item',
894
+			$this->config->get('WBQualityConstraintsWikibasePropertyId') => 'property',
895
+			$this->config->get('WBQualityConstraintsWikibaseLexemeId') => 'lexeme',
896
+			$this->config->get('WBQualityConstraintsWikibaseFormId') => 'form',
897
+			$this->config->get('WBQualityConstraintsWikibaseSenseId') => 'sense',
898
+			$this->config->get('WBQualityConstraintsWikibaseMediaInfoId') => 'mediainfo',
899 899
 		];
900 900
 	}
901 901
 
@@ -905,10 +905,10 @@  discard block
 block discarded – undo
905 905
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
906 906
 	 * @return EntityTypesParameter
907 907
 	 */
908
-	public function parseEntityTypesParameter( array $constraintParameters, string $constraintTypeItemId ): EntityTypesParameter {
908
+	public function parseEntityTypesParameter(array $constraintParameters, string $constraintTypeItemId): EntityTypesParameter {
909 909
 		$entityTypes = [];
910 910
 		$entityTypeItemIds = [];
911
-		$parameterId = $this->config->get( 'WBQualityConstraintsQualifierOfPropertyConstraintId' );
911
+		$parameterId = $this->config->get('WBQualityConstraintsQualifierOfPropertyConstraintId');
912 912
 		$itemIds = $this->parseItemIdsParameter(
913 913
 			$constraintParameters,
914 914
 			$constraintTypeItemId,
@@ -917,22 +917,22 @@  discard block
 block discarded – undo
917 917
 		);
918 918
 
919 919
 		$mapping = $this->getEntityTypeMapping();
920
-		foreach ( $itemIds as $itemId ) {
921
-			$entityType = $this->mapItemId( $itemId, $mapping, $parameterId );
920
+		foreach ($itemIds as $itemId) {
921
+			$entityType = $this->mapItemId($itemId, $mapping, $parameterId);
922 922
 			$entityTypes[] = $entityType;
923 923
 			$entityTypeItemIds[] = $itemId;
924 924
 		}
925 925
 
926
-		if ( empty( $entityTypes ) ) {
926
+		if (empty($entityTypes)) {
927 927
 			// @codeCoverageIgnoreStart
928 928
 			throw new LogicException(
929
-				'The "entity types" parameter is required, ' .
929
+				'The "entity types" parameter is required, '.
930 930
 				'and yet we seem to be missing any allowed entity type'
931 931
 			);
932 932
 			// @codeCoverageIgnoreEnd
933 933
 		}
934 934
 
935
-		return new EntityTypesParameter( $entityTypes, $entityTypeItemIds );
935
+		return new EntityTypesParameter($entityTypes, $entityTypeItemIds);
936 936
 	}
937 937
 
938 938
 	/**
@@ -940,18 +940,18 @@  discard block
 block discarded – undo
940 940
 	 * @throws ConstraintParameterException if the parameter is invalid
941 941
 	 * @return PropertyId[]
942 942
 	 */
943
-	public function parseSeparatorsParameter( array $constraintParameters ): array {
944
-		$separatorId = $this->config->get( 'WBQualityConstraintsSeparatorId' );
943
+	public function parseSeparatorsParameter(array $constraintParameters): array {
944
+		$separatorId = $this->config->get('WBQualityConstraintsSeparatorId');
945 945
 
946
-		if ( !array_key_exists( $separatorId, $constraintParameters ) ) {
946
+		if (!array_key_exists($separatorId, $constraintParameters)) {
947 947
 			return [];
948 948
 		}
949 949
 
950 950
 		$parameters = $constraintParameters[$separatorId];
951 951
 		$separators = [];
952 952
 
953
-		foreach ( $parameters as $parameter ) {
954
-			$separators[] = $this->parsePropertyIdParameter( $parameter, $separatorId );
953
+		foreach ($parameters as $parameter) {
954
+			$separators[] = $this->parsePropertyIdParameter($parameter, $separatorId);
955 955
 		}
956 956
 
957 957
 		return $separators;
@@ -959,17 +959,17 @@  discard block
 block discarded – undo
959 959
 
960 960
 	private function getConstraintScopeContextTypeMapping(): array {
961 961
 		return [
962
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnMainValueId' ) => Context::TYPE_STATEMENT,
963
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnQualifiersId' ) => Context::TYPE_QUALIFIER,
964
-			$this->config->get( 'WBQualityConstraintsConstraintCheckedOnReferencesId' ) => Context::TYPE_REFERENCE,
962
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnMainValueId') => Context::TYPE_STATEMENT,
963
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnQualifiersId') => Context::TYPE_QUALIFIER,
964
+			$this->config->get('WBQualityConstraintsConstraintCheckedOnReferencesId') => Context::TYPE_REFERENCE,
965 965
 		];
966 966
 	}
967 967
 
968 968
 	private function getPropertyScopeContextTypeMapping(): array {
969 969
 		return [
970
-			$this->config->get( 'WBQualityConstraintsAsMainValueId' ) => Context::TYPE_STATEMENT,
971
-			$this->config->get( 'WBQualityConstraintsAsQualifiersId' ) => Context::TYPE_QUALIFIER,
972
-			$this->config->get( 'WBQualityConstraintsAsReferencesId' ) => Context::TYPE_REFERENCE,
970
+			$this->config->get('WBQualityConstraintsAsMainValueId') => Context::TYPE_STATEMENT,
971
+			$this->config->get('WBQualityConstraintsAsQualifiersId') => Context::TYPE_QUALIFIER,
972
+			$this->config->get('WBQualityConstraintsAsReferencesId') => Context::TYPE_REFERENCE,
973 973
 		];
974 974
 	}
975 975
 
@@ -979,9 +979,9 @@  discard block
 block discarded – undo
979 979
 	 * @throws ConstraintParameterException if the parameter is invalid or missing
980 980
 	 * @return string[] list of Context::TYPE_* constants
981 981
 	 */
982
-	public function parsePropertyScopeParameter( array $constraintParameters, string $constraintTypeItemId ): array {
982
+	public function parsePropertyScopeParameter(array $constraintParameters, string $constraintTypeItemId): array {
983 983
 		$contextTypes = [];
984
-		$parameterId = $this->config->get( 'WBQualityConstraintsPropertyScopeId' );
984
+		$parameterId = $this->config->get('WBQualityConstraintsPropertyScopeId');
985 985
 		$itemIds = $this->parseItemIdsParameter(
986 986
 			$constraintParameters,
987 987
 			$constraintTypeItemId,
@@ -990,14 +990,14 @@  discard block
 block discarded – undo
990 990
 		);
991 991
 
992 992
 		$mapping = $this->getPropertyScopeContextTypeMapping();
993
-		foreach ( $itemIds as $itemId ) {
994
-			$contextTypes[] = $this->mapItemId( $itemId, $mapping, $parameterId );
993
+		foreach ($itemIds as $itemId) {
994
+			$contextTypes[] = $this->mapItemId($itemId, $mapping, $parameterId);
995 995
 		}
996 996
 
997
-		if ( empty( $contextTypes ) ) {
997
+		if (empty($contextTypes)) {
998 998
 			// @codeCoverageIgnoreStart
999 999
 			throw new LogicException(
1000
-				'The "property scope" parameter is required, ' .
1000
+				'The "property scope" parameter is required, '.
1001 1001
 				'and yet we seem to be missing any allowed scope'
1002 1002
 			);
1003 1003
 			// @codeCoverageIgnoreEnd
Please login to merge, or discard this patch.
src/ConstraintCheck/DelegatingConstraintChecker.php 1 patch
Spacing   +171 added lines, -171 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;
6 6
 
@@ -123,10 +123,10 @@  discard block
 block discarded – undo
123 123
 		callable $defaultResultsPerEntity = null
124 124
 	): array {
125 125
 		$checkResults = [];
126
-		$entity = $this->entityLookup->getEntity( $entityId );
126
+		$entity = $this->entityLookup->getEntity($entityId);
127 127
 
128
-		if ( $entity instanceof StatementListProvidingEntity ) {
129
-			$startTime = microtime( true );
128
+		if ($entity instanceof StatementListProvidingEntity) {
129
+			$startTime = microtime(true);
130 130
 
131 131
 			$checkResults = $this->checkEveryStatement(
132 132
 				$entity,
@@ -134,9 +134,9 @@  discard block
 block discarded – undo
134 134
 				$defaultResultsPerContext
135 135
 			);
136 136
 
137
-			$endTime = microtime( true );
137
+			$endTime = microtime(true);
138 138
 
139
-			if ( $constraintIds === null ) { // only log full constraint checks
139
+			if ($constraintIds === null) { // only log full constraint checks
140 140
 				$this->loggingHelper->logConstraintCheckOnEntity(
141 141
 					$entityId,
142 142
 					$checkResults,
@@ -146,11 +146,11 @@  discard block
 block discarded – undo
146 146
 			}
147 147
 		}
148 148
 
149
-		if ( $defaultResultsPerEntity !== null ) {
150
-			$checkResults = array_merge( $defaultResultsPerEntity( $entityId ), $checkResults );
149
+		if ($defaultResultsPerEntity !== null) {
150
+			$checkResults = array_merge($defaultResultsPerEntity($entityId), $checkResults);
151 151
 		}
152 152
 
153
-		return $this->sortResult( $checkResults );
153
+		return $this->sortResult($checkResults);
154 154
 	}
155 155
 
156 156
 	/**
@@ -172,19 +172,19 @@  discard block
 block discarded – undo
172 172
 		callable $defaultResults = null
173 173
 	): array {
174 174
 
175
-		$parsedGuid = $this->statementGuidParser->parse( $guid );
175
+		$parsedGuid = $this->statementGuidParser->parse($guid);
176 176
 		$entityId = $parsedGuid->getEntityId();
177
-		$entity = $this->entityLookup->getEntity( $entityId );
178
-		if ( $entity instanceof StatementListProvidingEntity ) {
179
-			$statement = $entity->getStatements()->getFirstStatementWithGuid( $guid );
180
-			if ( $statement ) {
177
+		$entity = $this->entityLookup->getEntity($entityId);
178
+		if ($entity instanceof StatementListProvidingEntity) {
179
+			$statement = $entity->getStatements()->getFirstStatementWithGuid($guid);
180
+			if ($statement) {
181 181
 				$result = $this->checkStatement(
182 182
 					$entity,
183 183
 					$statement,
184 184
 					$constraintIds,
185 185
 					$defaultResults
186 186
 				);
187
-				$output = $this->sortResult( $result );
187
+				$output = $this->sortResult($result);
188 188
 				return $output;
189 189
 			}
190 190
 		}
@@ -192,8 +192,8 @@  discard block
 block discarded – undo
192 192
 		return [];
193 193
 	}
194 194
 
195
-	private function getValidContextTypes( Constraint $constraint ): array {
196
-		if ( !array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
195
+	private function getValidContextTypes(Constraint $constraint): array {
196
+		if (!array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
197 197
 			return [
198 198
 				Context::TYPE_STATEMENT,
199 199
 				Context::TYPE_QUALIFIER,
@@ -201,25 +201,25 @@  discard block
 block discarded – undo
201 201
 			];
202 202
 		}
203 203
 
204
-		return array_keys( array_filter(
204
+		return array_keys(array_filter(
205 205
 			$this->checkerMap[$constraint->getConstraintTypeItemId()]->getSupportedContextTypes(),
206
-			static function ( $resultStatus ) {
206
+			static function($resultStatus) {
207 207
 				return $resultStatus !== CheckResult::STATUS_NOT_IN_SCOPE;
208 208
 			}
209
-		) );
209
+		));
210 210
 	}
211 211
 
212
-	private function getValidEntityTypes( Constraint $constraint ): array {
213
-		if ( !array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
214
-			return array_keys( ConstraintChecker::ALL_ENTITY_TYPES_SUPPORTED );
212
+	private function getValidEntityTypes(Constraint $constraint): array {
213
+		if (!array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
214
+			return array_keys(ConstraintChecker::ALL_ENTITY_TYPES_SUPPORTED);
215 215
 		}
216 216
 
217
-		return array_keys( array_filter(
217
+		return array_keys(array_filter(
218 218
 			$this->checkerMap[$constraint->getConstraintTypeItemId()]->getSupportedEntityTypes(),
219
-			static function ( $resultStatus ) {
219
+			static function($resultStatus) {
220 220
 				return $resultStatus !== CheckResult::STATUS_NOT_IN_SCOPE;
221 221
 			}
222
-		) );
222
+		));
223 223
 	}
224 224
 
225 225
 	/**
@@ -230,38 +230,38 @@  discard block
 block discarded – undo
230 230
 	 *
231 231
 	 * @return ConstraintParameterException[]
232 232
 	 */
233
-	private function checkCommonConstraintParameters( Constraint $constraint ): array {
233
+	private function checkCommonConstraintParameters(Constraint $constraint): array {
234 234
 		$constraintParameters = $constraint->getConstraintParameters();
235 235
 		try {
236
-			$this->constraintParameterParser->checkError( $constraintParameters );
237
-		} catch ( ConstraintParameterException $e ) {
238
-			return [ $e ];
236
+			$this->constraintParameterParser->checkError($constraintParameters);
237
+		} catch (ConstraintParameterException $e) {
238
+			return [$e];
239 239
 		}
240 240
 
241 241
 		$problems = [];
242 242
 		try {
243
-			$this->constraintParameterParser->parseExceptionParameter( $constraintParameters );
244
-		} catch ( ConstraintParameterException $e ) {
243
+			$this->constraintParameterParser->parseExceptionParameter($constraintParameters);
244
+		} catch (ConstraintParameterException $e) {
245 245
 			$problems[] = $e;
246 246
 		}
247 247
 		try {
248
-			$this->constraintParameterParser->parseConstraintClarificationParameter( $constraintParameters );
249
-		} catch ( ConstraintParameterException $e ) {
248
+			$this->constraintParameterParser->parseConstraintClarificationParameter($constraintParameters);
249
+		} catch (ConstraintParameterException $e) {
250 250
 			$problems[] = $e;
251 251
 		}
252 252
 		try {
253
-			$this->constraintParameterParser->parseConstraintStatusParameter( $constraintParameters );
254
-		} catch ( ConstraintParameterException $e ) {
253
+			$this->constraintParameterParser->parseConstraintStatusParameter($constraintParameters);
254
+		} catch (ConstraintParameterException $e) {
255 255
 			$problems[] = $e;
256 256
 		}
257 257
 		try {
258 258
 			$this->constraintParameterParser->parseConstraintScopeParameters(
259 259
 				$constraintParameters,
260 260
 				$constraint->getConstraintTypeItemId(),
261
-				$this->getValidContextTypes( $constraint ),
262
-				$this->getValidEntityTypes( $constraint )
261
+				$this->getValidContextTypes($constraint),
262
+				$this->getValidEntityTypes($constraint)
263 263
 			);
264
-		} catch ( ConstraintParameterException $e ) {
264
+		} catch (ConstraintParameterException $e) {
265 265
 			$problems[] = $e;
266 266
 		}
267 267
 		return $problems;
@@ -274,16 +274,16 @@  discard block
 block discarded – undo
274 274
 	 * @return ConstraintParameterException[][] first level indexed by constraint ID,
275 275
 	 * second level like checkConstraintParametersOnConstraintId (but without possibility of null)
276 276
 	 */
277
-	public function checkConstraintParametersOnPropertyId( NumericPropertyId $propertyId ): array {
278
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
277
+	public function checkConstraintParametersOnPropertyId(NumericPropertyId $propertyId): array {
278
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
279 279
 		$result = [];
280 280
 
281
-		foreach ( $constraints as $constraint ) {
282
-			$problems = $this->checkCommonConstraintParameters( $constraint );
281
+		foreach ($constraints as $constraint) {
282
+			$problems = $this->checkCommonConstraintParameters($constraint);
283 283
 
284
-			if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
284
+			if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
285 285
 				$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
286
-				$problems = array_merge( $problems, $checker->checkConstraintParameters( $constraint ) );
286
+				$problems = array_merge($problems, $checker->checkConstraintParameters($constraint));
287 287
 			}
288 288
 
289 289
 			$result[$constraint->getConstraintId()] = $problems;
@@ -300,18 +300,18 @@  discard block
 block discarded – undo
300 300
 	 * @return ConstraintParameterException[]|null list of constraint parameter exceptions
301 301
 	 * (empty means all parameters okay), or null if constraint is not found
302 302
 	 */
303
-	public function checkConstraintParametersOnConstraintId( string $constraintId ): ?array {
304
-		$propertyId = $this->statementGuidParser->parse( $constraintId )->getEntityId();
303
+	public function checkConstraintParametersOnConstraintId(string $constraintId): ?array {
304
+		$propertyId = $this->statementGuidParser->parse($constraintId)->getEntityId();
305 305
 		'@phan-var NumericPropertyId $propertyId';
306
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
306
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
307 307
 
308
-		foreach ( $constraints as $constraint ) {
309
-			if ( $constraint->getConstraintId() === $constraintId ) {
310
-				$problems = $this->checkCommonConstraintParameters( $constraint );
308
+		foreach ($constraints as $constraint) {
309
+			if ($constraint->getConstraintId() === $constraintId) {
310
+				$problems = $this->checkCommonConstraintParameters($constraint);
311 311
 
312
-				if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
312
+				if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
313 313
 					$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
314
-					$problems = array_merge( $problems, $checker->checkConstraintParameters( $constraint ) );
314
+					$problems = array_merge($problems, $checker->checkConstraintParameters($constraint));
315 315
 				}
316 316
 
317 317
 				return $problems;
@@ -336,14 +336,14 @@  discard block
 block discarded – undo
336 336
 		$result = [];
337 337
 
338 338
 		/** @var Statement $statement */
339
-		foreach ( $entity->getStatements() as $statement ) {
340
-			$result = array_merge( $result,
339
+		foreach ($entity->getStatements() as $statement) {
340
+			$result = array_merge($result,
341 341
 				$this->checkStatement(
342 342
 					$entity,
343 343
 					$statement,
344 344
 					$constraintIds,
345 345
 					$defaultResultsPerContext
346
-				) );
346
+				));
347 347
 		}
348 348
 
349 349
 		return $result;
@@ -365,32 +365,32 @@  discard block
 block discarded – undo
365 365
 	): array {
366 366
 		$result = [];
367 367
 
368
-		$result = array_merge( $result,
368
+		$result = array_merge($result,
369 369
 			$this->checkConstraintsForMainSnak(
370 370
 				$entity,
371 371
 				$statement,
372 372
 				$constraintIds,
373 373
 				$defaultResultsPerContext
374
-			) );
374
+			));
375 375
 
376
-		if ( $this->checkQualifiers ) {
377
-			$result = array_merge( $result,
376
+		if ($this->checkQualifiers) {
377
+			$result = array_merge($result,
378 378
 				$this->checkConstraintsForQualifiers(
379 379
 					$entity,
380 380
 					$statement,
381 381
 					$constraintIds,
382 382
 					$defaultResultsPerContext
383
-				) );
383
+				));
384 384
 		}
385 385
 
386
-		if ( $this->checkReferences ) {
387
-			$result = array_merge( $result,
386
+		if ($this->checkReferences) {
387
+			$result = array_merge($result,
388 388
 				$this->checkConstraintsForReferences(
389 389
 					$entity,
390 390
 					$statement,
391 391
 					$constraintIds,
392 392
 					$defaultResultsPerContext
393
-				) );
393
+				));
394 394
 		}
395 395
 
396 396
 		return $result;
@@ -405,17 +405,17 @@  discard block
 block discarded – undo
405 405
 	 * @param string[]|null $constraintIds
406 406
 	 * @return Constraint[]
407 407
 	 */
408
-	private function getConstraintsToUse( PropertyId $propertyId, ?array $constraintIds ): array {
409
-		if ( !( $propertyId instanceof NumericPropertyId ) ) {
408
+	private function getConstraintsToUse(PropertyId $propertyId, ?array $constraintIds): array {
409
+		if (!($propertyId instanceof NumericPropertyId)) {
410 410
 			throw new InvalidArgumentException(
411
-				'Non-numeric property ID not supported:' . $propertyId->getSerialization()
411
+				'Non-numeric property ID not supported:'.$propertyId->getSerialization()
412 412
 			);
413 413
 		}
414
-		$constraints = $this->constraintLookup->queryConstraintsForProperty( $propertyId );
415
-		if ( $constraintIds !== null ) {
414
+		$constraints = $this->constraintLookup->queryConstraintsForProperty($propertyId);
415
+		if ($constraintIds !== null) {
416 416
 			$constraintsToUse = [];
417
-			foreach ( $constraints as $constraint ) {
418
-				if ( in_array( $constraint->getConstraintId(), $constraintIds ) ) {
417
+			foreach ($constraints as $constraint) {
418
+				if (in_array($constraint->getConstraintId(), $constraintIds)) {
419 419
 					$constraintsToUse[] = $constraint;
420 420
 				}
421 421
 			}
@@ -439,18 +439,18 @@  discard block
 block discarded – undo
439 439
 		?array $constraintIds,
440 440
 		?callable $defaultResults
441 441
 	): array {
442
-		$context = new MainSnakContext( $entity, $statement );
442
+		$context = new MainSnakContext($entity, $statement);
443 443
 		$constraints = $this->getConstraintsToUse(
444 444
 			$statement->getPropertyId(),
445 445
 			$constraintIds
446 446
 		);
447
-		$result = $defaultResults !== null ? $defaultResults( $context ) : [];
447
+		$result = $defaultResults !== null ? $defaultResults($context) : [];
448 448
 
449
-		foreach ( $constraints as $constraint ) {
449
+		foreach ($constraints as $constraint) {
450 450
 			$parameters = $constraint->getConstraintParameters();
451 451
 			try {
452
-				$exceptions = $this->constraintParameterParser->parseExceptionParameter( $parameters );
453
-			} catch ( ConstraintParameterException $e ) {
452
+				$exceptions = $this->constraintParameterParser->parseExceptionParameter($parameters);
453
+			} catch (ConstraintParameterException $e) {
454 454
 				$result[] = new CheckResult(
455 455
 					$context,
456 456
 					$constraint,
@@ -460,13 +460,13 @@  discard block
 block discarded – undo
460 460
 				continue;
461 461
 			}
462 462
 
463
-			if ( in_array( $entity->getId(), $exceptions ) ) {
464
-				$message = new ViolationMessage( 'wbqc-violation-message-exception' );
465
-				$result[] = new CheckResult( $context, $constraint, [], CheckResult::STATUS_EXCEPTION, $message );
463
+			if (in_array($entity->getId(), $exceptions)) {
464
+				$message = new ViolationMessage('wbqc-violation-message-exception');
465
+				$result[] = new CheckResult($context, $constraint, [], CheckResult::STATUS_EXCEPTION, $message);
466 466
 				continue;
467 467
 			}
468 468
 
469
-			$result[] = $this->getCheckResultFor( $context, $constraint );
469
+			$result[] = $this->getCheckResultFor($context, $constraint);
470 470
 		}
471 471
 
472 472
 		return $result;
@@ -488,24 +488,24 @@  discard block
 block discarded – undo
488 488
 	): array {
489 489
 		$result = [];
490 490
 
491
-		if ( in_array(
491
+		if (in_array(
492 492
 			$statement->getPropertyId()->getSerialization(),
493 493
 			$this->propertiesWithViolatingQualifiers
494
-		) ) {
494
+		)) {
495 495
 			return $result;
496 496
 		}
497 497
 
498
-		foreach ( $statement->getQualifiers() as $qualifier ) {
499
-			$qualifierContext = new QualifierContext( $entity, $statement, $qualifier );
500
-			if ( $defaultResultsPerContext !== null ) {
501
-				$result = array_merge( $result, $defaultResultsPerContext( $qualifierContext ) );
498
+		foreach ($statement->getQualifiers() as $qualifier) {
499
+			$qualifierContext = new QualifierContext($entity, $statement, $qualifier);
500
+			if ($defaultResultsPerContext !== null) {
501
+				$result = array_merge($result, $defaultResultsPerContext($qualifierContext));
502 502
 			}
503 503
 			$qualifierConstraints = $this->getConstraintsToUse(
504 504
 				$qualifierContext->getSnak()->getPropertyId(),
505 505
 				$constraintIds
506 506
 			);
507
-			foreach ( $qualifierConstraints as $qualifierConstraint ) {
508
-				$result[] = $this->getCheckResultFor( $qualifierContext, $qualifierConstraint );
507
+			foreach ($qualifierConstraints as $qualifierConstraint) {
508
+				$result[] = $this->getCheckResultFor($qualifierContext, $qualifierConstraint);
509 509
 			}
510 510
 		}
511 511
 
@@ -529,19 +529,19 @@  discard block
 block discarded – undo
529 529
 		$result = [];
530 530
 
531 531
 		/** @var Reference $reference */
532
-		foreach ( $statement->getReferences() as $reference ) {
533
-			foreach ( $reference->getSnaks() as $snak ) {
532
+		foreach ($statement->getReferences() as $reference) {
533
+			foreach ($reference->getSnaks() as $snak) {
534 534
 				$referenceContext = new ReferenceContext(
535 535
 					$entity, $statement, $reference, $snak
536 536
 				);
537
-				if ( $defaultResultsPerContext !== null ) {
538
-					$result = array_merge( $result, $defaultResultsPerContext( $referenceContext ) );
537
+				if ($defaultResultsPerContext !== null) {
538
+					$result = array_merge($result, $defaultResultsPerContext($referenceContext));
539 539
 				}
540 540
 				$referenceConstraints = $this->getConstraintsToUse(
541 541
 					$referenceContext->getSnak()->getPropertyId(),
542 542
 					$constraintIds
543 543
 				);
544
-				foreach ( $referenceConstraints as $referenceConstraint ) {
544
+				foreach ($referenceConstraints as $referenceConstraint) {
545 545
 					$result[] = $this->getCheckResultFor(
546 546
 						$referenceContext,
547 547
 						$referenceConstraint
@@ -553,20 +553,20 @@  discard block
 block discarded – undo
553 553
 		return $result;
554 554
 	}
555 555
 
556
-	private function getCheckResultFor( Context $context, Constraint $constraint ): CheckResult {
557
-		if ( array_key_exists( $constraint->getConstraintTypeItemId(), $this->checkerMap ) ) {
556
+	private function getCheckResultFor(Context $context, Constraint $constraint): CheckResult {
557
+		if (array_key_exists($constraint->getConstraintTypeItemId(), $this->checkerMap)) {
558 558
 			$checker = $this->checkerMap[$constraint->getConstraintTypeItemId()];
559
-			$result = $this->handleScope( $checker, $context, $constraint );
559
+			$result = $this->handleScope($checker, $context, $constraint);
560 560
 
561
-			if ( $result !== null ) {
562
-				$this->addMetadata( $context, $result );
561
+			if ($result !== null) {
562
+				$this->addMetadata($context, $result);
563 563
 				return $result;
564 564
 			}
565 565
 
566
-			$startTime = microtime( true );
566
+			$startTime = microtime(true);
567 567
 			try {
568
-				$result = $checker->checkConstraint( $context, $constraint );
569
-			} catch ( ConstraintParameterException $e ) {
568
+				$result = $checker->checkConstraint($context, $constraint);
569
+			} catch (ConstraintParameterException $e) {
570 570
 				$result = new CheckResult(
571 571
 					$context,
572 572
 					$constraint,
@@ -574,30 +574,30 @@  discard block
 block discarded – undo
574 574
 					CheckResult::STATUS_BAD_PARAMETERS,
575 575
 					$e->getViolationMessage()
576 576
 				);
577
-			} catch ( SparqlHelperException $e ) {
578
-				$message = new ViolationMessage( 'wbqc-violation-message-sparql-error' );
579
-				$result = new CheckResult( $context, $constraint, [], CheckResult::STATUS_TODO, $message );
577
+			} catch (SparqlHelperException $e) {
578
+				$message = new ViolationMessage('wbqc-violation-message-sparql-error');
579
+				$result = new CheckResult($context, $constraint, [], CheckResult::STATUS_TODO, $message);
580 580
 			}
581
-			$endTime = microtime( true );
581
+			$endTime = microtime(true);
582 582
 
583
-			$this->addMetadata( $context, $result );
583
+			$this->addMetadata($context, $result);
584 584
 
585
-			$this->addConstraintClarification( $result );
585
+			$this->addConstraintClarification($result);
586 586
 
587
-			$this->downgradeResultStatus( $result );
587
+			$this->downgradeResultStatus($result);
588 588
 
589 589
 			$this->loggingHelper->logConstraintCheck(
590 590
 				$context,
591 591
 				$constraint,
592 592
 				$result,
593
-				get_class( $checker ),
593
+				get_class($checker),
594 594
 				$endTime - $startTime,
595 595
 				__METHOD__
596 596
 			);
597 597
 
598 598
 			return $result;
599 599
 		} else {
600
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_TODO, null );
600
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_TODO, null);
601 601
 		}
602 602
 	}
603 603
 
@@ -606,97 +606,97 @@  discard block
 block discarded – undo
606 606
 		Context $context,
607 607
 		Constraint $constraint
608 608
 	): ?CheckResult {
609
-		$validContextTypes = $this->getValidContextTypes( $constraint );
610
-		$validEntityTypes = $this->getValidEntityTypes( $constraint );
609
+		$validContextTypes = $this->getValidContextTypes($constraint);
610
+		$validEntityTypes = $this->getValidEntityTypes($constraint);
611 611
 		try {
612
-			[ $checkedContextTypes, $checkedEntityTypes ] = $this->constraintParameterParser->parseConstraintScopeParameters(
612
+			[$checkedContextTypes, $checkedEntityTypes] = $this->constraintParameterParser->parseConstraintScopeParameters(
613 613
 				$constraint->getConstraintParameters(),
614 614
 				$constraint->getConstraintTypeItemId(),
615 615
 				$validContextTypes,
616 616
 				$validEntityTypes
617 617
 			);
618
-		} catch ( ConstraintParameterException $e ) {
619
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage() );
618
+		} catch (ConstraintParameterException $e) {
619
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_BAD_PARAMETERS, $e->getViolationMessage());
620 620
 		}
621 621
 
622
-		if ( $checkedContextTypes === null ) {
622
+		if ($checkedContextTypes === null) {
623 623
 			$checkedContextTypes = $checker->getDefaultContextTypes();
624 624
 		}
625 625
 		$contextType = $context->getType();
626
-		if ( !in_array( $contextType, $checkedContextTypes ) ) {
627
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_NOT_IN_SCOPE, null );
626
+		if (!in_array($contextType, $checkedContextTypes)) {
627
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_NOT_IN_SCOPE, null);
628 628
 		}
629
-		if ( $checker->getSupportedContextTypes()[$contextType] === CheckResult::STATUS_TODO ) {
630
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_TODO, null );
629
+		if ($checker->getSupportedContextTypes()[$contextType] === CheckResult::STATUS_TODO) {
630
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_TODO, null);
631 631
 		}
632 632
 
633
-		if ( $checkedEntityTypes === null ) {
633
+		if ($checkedEntityTypes === null) {
634 634
 			$checkedEntityTypes = $validEntityTypes;
635 635
 		}
636 636
 		$entityType = $context->getEntity()->getType();
637
-		if ( !in_array( $entityType, $checkedEntityTypes ) ) {
638
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_NOT_IN_SCOPE, null );
637
+		if (!in_array($entityType, $checkedEntityTypes)) {
638
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_NOT_IN_SCOPE, null);
639 639
 		}
640
-		if ( $checker->getSupportedEntityTypes()[$entityType] === CheckResult::STATUS_TODO ) {
641
-			return new CheckResult( $context, $constraint, [], CheckResult::STATUS_TODO, null );
640
+		if ($checker->getSupportedEntityTypes()[$entityType] === CheckResult::STATUS_TODO) {
641
+			return new CheckResult($context, $constraint, [], CheckResult::STATUS_TODO, null);
642 642
 		}
643 643
 
644 644
 		return null;
645 645
 	}
646 646
 
647
-	private function addMetadata( Context $context, CheckResult $result ): void {
648
-		$result->withMetadata( Metadata::merge( [
647
+	private function addMetadata(Context $context, CheckResult $result): void {
648
+		$result->withMetadata(Metadata::merge([
649 649
 			$result->getMetadata(),
650
-			Metadata::ofDependencyMetadata( DependencyMetadata::merge( [
651
-				DependencyMetadata::ofEntityId( $context->getEntity()->getId() ),
652
-				DependencyMetadata::ofEntityId( $result->getConstraint()->getPropertyId() ),
653
-			] ) ),
654
-		] ) );
650
+			Metadata::ofDependencyMetadata(DependencyMetadata::merge([
651
+				DependencyMetadata::ofEntityId($context->getEntity()->getId()),
652
+				DependencyMetadata::ofEntityId($result->getConstraint()->getPropertyId()),
653
+			])),
654
+		]));
655 655
 	}
656 656
 
657
-	private function addConstraintClarification( CheckResult $result ): void {
657
+	private function addConstraintClarification(CheckResult $result): void {
658 658
 		$constraint = $result->getConstraint();
659 659
 		try {
660 660
 			$constraintClarification = $this->constraintParameterParser
661
-				->parseConstraintClarificationParameter( $constraint->getConstraintParameters() );
662
-			$result->setConstraintClarification( $constraintClarification );
663
-		} catch ( ConstraintParameterException $e ) {
664
-			$result->setStatus( CheckResult::STATUS_BAD_PARAMETERS );
665
-			$result->setMessage( $e->getViolationMessage() );
661
+				->parseConstraintClarificationParameter($constraint->getConstraintParameters());
662
+			$result->setConstraintClarification($constraintClarification);
663
+		} catch (ConstraintParameterException $e) {
664
+			$result->setStatus(CheckResult::STATUS_BAD_PARAMETERS);
665
+			$result->setMessage($e->getViolationMessage());
666 666
 		}
667 667
 	}
668 668
 
669
-	private function downgradeResultStatus( CheckResult $result ): void {
669
+	private function downgradeResultStatus(CheckResult $result): void {
670 670
 		$constraint = $result->getConstraint();
671 671
 		try {
672 672
 			$constraintStatus = $this->constraintParameterParser
673
-				->parseConstraintStatusParameter( $constraint->getConstraintParameters() );
674
-		} catch ( ConstraintParameterException $e ) {
675
-			$result->setStatus( CheckResult::STATUS_BAD_PARAMETERS );
676
-			$result->setMessage( $e->getViolationMessage() );
673
+				->parseConstraintStatusParameter($constraint->getConstraintParameters());
674
+		} catch (ConstraintParameterException $e) {
675
+			$result->setStatus(CheckResult::STATUS_BAD_PARAMETERS);
676
+			$result->setMessage($e->getViolationMessage());
677 677
 			return;
678 678
 		}
679
-		if ( $constraintStatus === null ) {
679
+		if ($constraintStatus === null) {
680 680
 			// downgrade violation to warning
681
-			if ( $result->getStatus() === CheckResult::STATUS_VIOLATION ) {
682
-				$result->setStatus( CheckResult::STATUS_WARNING );
681
+			if ($result->getStatus() === CheckResult::STATUS_VIOLATION) {
682
+				$result->setStatus(CheckResult::STATUS_WARNING);
683 683
 			}
684
-		} elseif ( $constraintStatus === 'suggestion' ) {
684
+		} elseif ($constraintStatus === 'suggestion') {
685 685
 			// downgrade violation to suggestion
686
-			if ( $result->getStatus() === CheckResult::STATUS_VIOLATION ) {
687
-				$result->setStatus( CheckResult::STATUS_SUGGESTION );
686
+			if ($result->getStatus() === CheckResult::STATUS_VIOLATION) {
687
+				$result->setStatus(CheckResult::STATUS_SUGGESTION);
688 688
 			}
689
-			$result->addParameter( 'constraint_status', $constraintStatus );
689
+			$result->addParameter('constraint_status', $constraintStatus);
690 690
 		} else {
691
-			if ( $constraintStatus !== 'mandatory' ) {
691
+			if ($constraintStatus !== 'mandatory') {
692 692
 				// @codeCoverageIgnoreStart
693 693
 				throw new LogicException(
694
-					"Unknown constraint status '$constraintStatus', " .
694
+					"Unknown constraint status '$constraintStatus', ".
695 695
 					"only known statuses are 'mandatory' and 'suggestion'"
696 696
 				);
697 697
 				// @codeCoverageIgnoreEnd
698 698
 			}
699
-			$result->addParameter( 'constraint_status', $constraintStatus );
699
+			$result->addParameter('constraint_status', $constraintStatus);
700 700
 		}
701 701
 	}
702 702
 
@@ -705,12 +705,12 @@  discard block
 block discarded – undo
705 705
 	 *
706 706
 	 * @return CheckResult[]
707 707
 	 */
708
-	private function sortResult( array $result ): array {
709
-		if ( count( $result ) < 2 ) {
708
+	private function sortResult(array $result): array {
709
+		if (count($result) < 2) {
710 710
 			return $result;
711 711
 		}
712 712
 
713
-		$sortFunction = static function ( CheckResult $a, CheckResult $b ) {
713
+		$sortFunction = static function(CheckResult $a, CheckResult $b) {
714 714
 			$orderNum = 0;
715 715
 			$order = [
716 716
 				CheckResult::STATUS_BAD_PARAMETERS => $orderNum++,
@@ -727,55 +727,55 @@  discard block
 block discarded – undo
727 727
 			$statusA = $a->getStatus();
728 728
 			$statusB = $b->getStatus();
729 729
 
730
-			$orderA = array_key_exists( $statusA, $order ) ? $order[ $statusA ] : $order[ 'other' ];
731
-			$orderB = array_key_exists( $statusB, $order ) ? $order[ $statusB ] : $order[ 'other' ];
730
+			$orderA = array_key_exists($statusA, $order) ? $order[$statusA] : $order['other'];
731
+			$orderB = array_key_exists($statusB, $order) ? $order[$statusB] : $order['other'];
732 732
 
733
-			if ( $orderA === $orderB ) {
733
+			if ($orderA === $orderB) {
734 734
 				$cursorA = $a->getContextCursor();
735 735
 				$cursorB = $b->getContextCursor();
736 736
 
737
-				if ( $cursorA instanceof EntityContextCursor ) {
737
+				if ($cursorA instanceof EntityContextCursor) {
738 738
 					return $cursorB instanceof EntityContextCursor ? 0 : -1;
739 739
 				}
740
-				if ( $cursorB instanceof EntityContextCursor ) {
740
+				if ($cursorB instanceof EntityContextCursor) {
741 741
 					return $cursorA instanceof EntityContextCursor ? 0 : 1;
742 742
 				}
743 743
 
744 744
 				$pidA = $cursorA->getSnakPropertyId();
745 745
 				$pidB = $cursorB->getSnakPropertyId();
746 746
 
747
-				if ( $pidA === $pidB ) {
747
+				if ($pidA === $pidB) {
748 748
 					$hashA = $cursorA->getSnakHash();
749 749
 					$hashB = $cursorB->getSnakHash();
750 750
 
751
-					if ( $hashA === $hashB ) {
752
-						if ( $a instanceof NullResult ) {
751
+					if ($hashA === $hashB) {
752
+						if ($a instanceof NullResult) {
753 753
 							return $b instanceof NullResult ? 0 : -1;
754 754
 						}
755
-						if ( $b instanceof NullResult ) {
755
+						if ($b instanceof NullResult) {
756 756
 							return $a instanceof NullResult ? 0 : 1;
757 757
 						}
758 758
 
759 759
 						$typeA = $a->getConstraint()->getConstraintTypeItemId();
760 760
 						$typeB = $b->getConstraint()->getConstraintTypeItemId();
761 761
 
762
-						if ( $typeA == $typeB ) {
762
+						if ($typeA == $typeB) {
763 763
 							return 0;
764 764
 						} else {
765
-							return ( $typeA > $typeB ) ? 1 : -1;
765
+							return ($typeA > $typeB) ? 1 : -1;
766 766
 						}
767 767
 					} else {
768
-						return ( $hashA > $hashB ) ? 1 : -1;
768
+						return ($hashA > $hashB) ? 1 : -1;
769 769
 					}
770 770
 				} else {
771
-					return ( $pidA > $pidB ) ? 1 : -1;
771
+					return ($pidA > $pidB) ? 1 : -1;
772 772
 				}
773 773
 			} else {
774
-				return ( $orderA > $orderB ) ? 1 : -1;
774
+				return ($orderA > $orderB) ? 1 : -1;
775 775
 			}
776 776
 		};
777 777
 
778
-		uasort( $result, $sortFunction );
778
+		uasort($result, $sortFunction);
779 779
 
780 780
 		return $result;
781 781
 	}
Please login to merge, or discard this patch.
src/ConstraintCheck/Result/CheckResult.php 1 patch
Spacing   +9 added lines, -9 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\Result;
6 6
 
@@ -117,12 +117,12 @@  discard block
 block discarded – undo
117 117
 		string $status = self::STATUS_TODO,
118 118
 		ViolationMessage $message = null
119 119
 	) {
120
-		if ( $contextCursor instanceof Context ) {
120
+		if ($contextCursor instanceof Context) {
121 121
 			$context = $contextCursor;
122 122
 			$this->contextCursor = $context->getCursor();
123 123
 			$this->snakType = $context->getSnak()->getType();
124 124
 			$mainSnak = $context->getSnak();
125
-			if ( $mainSnak instanceof PropertyValueSnak ) {
125
+			if ($mainSnak instanceof PropertyValueSnak) {
126 126
 				$this->dataValue = $mainSnak->getDataValue();
127 127
 			} else {
128 128
 				$this->dataValue = null;
@@ -137,7 +137,7 @@  discard block
 block discarded – undo
137 137
 		$this->status = $status;
138 138
 		$this->message = $message;
139 139
 		$this->metadata = Metadata::blank();
140
-		$this->constraintClarification = new MultilingualTextValue( [] );
140
+		$this->constraintClarification = new MultilingualTextValue([]);
141 141
 	}
142 142
 
143 143
 	public function getContextCursor(): ContextCursor {
@@ -173,7 +173,7 @@  discard block
 block discarded – undo
173 173
 		return $this->parameters;
174 174
 	}
175 175
 
176
-	public function addParameter( string $key, string $value ): void {
176
+	public function addParameter(string $key, string $value): void {
177 177
 		$this->parameters[$key][] = $value;
178 178
 	}
179 179
 
@@ -184,7 +184,7 @@  discard block
 block discarded – undo
184 184
 		return $this->status;
185 185
 	}
186 186
 
187
-	public function setStatus( string $status ): void {
187
+	public function setStatus(string $status): void {
188 188
 		$this->status = $status;
189 189
 	}
190 190
 
@@ -192,11 +192,11 @@  discard block
 block discarded – undo
192 192
 		return $this->message;
193 193
 	}
194 194
 
195
-	public function setMessage( ?ViolationMessage $message ) {
195
+	public function setMessage(?ViolationMessage $message) {
196 196
 		$this->message = $message;
197 197
 	}
198 198
 
199
-	public function withMetadata( Metadata $metadata ): self {
199
+	public function withMetadata(Metadata $metadata): self {
200 200
 		$this->metadata = $metadata;
201 201
 		return $this;
202 202
 	}
@@ -209,7 +209,7 @@  discard block
 block discarded – undo
209 209
 		return $this->constraintClarification;
210 210
 	}
211 211
 
212
-	public function setConstraintClarification( MultilingualTextValue $constraintClarification ) {
212
+	public function setConstraintClarification(MultilingualTextValue $constraintClarification) {
213 213
 		$this->constraintClarification = $constraintClarification;
214 214
 	}
215 215
 
Please login to merge, or discard this patch.
src/ConstraintCheck/Result/CheckResultDeserializer.php 1 patch
Spacing   +25 added lines, -25 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\Result;
6 6
 
@@ -40,13 +40,13 @@  discard block
 block discarded – undo
40 40
 		$this->entityIdParser = $entityIdParser;
41 41
 	}
42 42
 
43
-	public function deserialize( array $serialization ): CheckResult {
43
+	public function deserialize(array $serialization): CheckResult {
44 44
 		$contextCursor = $this->contextCursorDeserializer->deserialize(
45 45
 			$serialization[CheckResultSerializer::KEY_CONTEXT_CURSOR]
46 46
 		);
47 47
 
48
-		if ( array_key_exists( CheckResultSerializer::KEY_NULL_RESULT, $serialization ) ) {
49
-			$result = new NullResult( $contextCursor );
48
+		if (array_key_exists(CheckResultSerializer::KEY_NULL_RESULT, $serialization)) {
49
+			$result = new NullResult($contextCursor);
50 50
 			$cachingMetadata = CachingMetadata::fresh();
51 51
 		} else {
52 52
 			$constraint = $this->constraintDeserializer->deserialize(
@@ -57,7 +57,7 @@  discard block
 block discarded – undo
57 57
 
58 58
 			$status = $serialization[CheckResultSerializer::KEY_CHECK_RESULT_STATUS];
59 59
 
60
-			$violationMessage = $this->getViolationMessageFromSerialization( $serialization );
60
+			$violationMessage = $this->getViolationMessageFromSerialization($serialization);
61 61
 
62 62
 			$result = new CheckResult(
63 63
 				$contextCursor,
@@ -68,7 +68,7 @@  discard block
 block discarded – undo
68 68
 			);
69 69
 
70 70
 			$result->setConstraintClarification(
71
-				$this->getConstraintClarificationFromSerialization( $serialization )
71
+				$this->getConstraintClarificationFromSerialization($serialization)
72 72
 			);
73 73
 
74 74
 			$cachingMetadata = $this->deserializeCachingMetadata(
@@ -76,18 +76,18 @@  discard block
 block discarded – undo
76 76
 			);
77 77
 		}
78 78
 
79
-		$dependencyMetadata = $this->getDependencyMetadataFromSerialization( $serialization );
79
+		$dependencyMetadata = $this->getDependencyMetadataFromSerialization($serialization);
80 80
 
81 81
 		return $result->withMetadata(
82
-			Metadata::merge( [
83
-				Metadata::ofCachingMetadata( $cachingMetadata ),
84
-				Metadata::ofDependencyMetadata( $dependencyMetadata ),
85
-			] )
82
+			Metadata::merge([
83
+				Metadata::ofCachingMetadata($cachingMetadata),
84
+				Metadata::ofDependencyMetadata($dependencyMetadata),
85
+			])
86 86
 		);
87 87
 	}
88 88
 
89
-	private function getViolationMessageFromSerialization( array $serialization ): ?ViolationMessage {
90
-		if ( array_key_exists( CheckResultSerializer::KEY_VIOLATION_MESSAGE, $serialization ) ) {
89
+	private function getViolationMessageFromSerialization(array $serialization): ?ViolationMessage {
90
+		if (array_key_exists(CheckResultSerializer::KEY_VIOLATION_MESSAGE, $serialization)) {
91 91
 			return $this->violationMessageDeserializer->deserialize(
92 92
 				$serialization[CheckResultSerializer::KEY_VIOLATION_MESSAGE]
93 93
 			);
@@ -99,17 +99,17 @@  discard block
 block discarded – undo
99 99
 	private function getConstraintClarificationFromSerialization(
100 100
 		array $serialization
101 101
 	): MultilingualTextValue {
102
-		if ( array_key_exists( CheckResultSerializer::KEY_CONSTRAINT_CLARIFICATION, $serialization ) ) {
102
+		if (array_key_exists(CheckResultSerializer::KEY_CONSTRAINT_CLARIFICATION, $serialization)) {
103 103
 			return MultilingualTextValue::newFromArray(
104 104
 				$serialization[CheckResultSerializer::KEY_CONSTRAINT_CLARIFICATION]
105 105
 			);
106 106
 		} else {
107
-			return new MultilingualTextValue( [] );
107
+			return new MultilingualTextValue([]);
108 108
 		}
109 109
 	}
110 110
 
111
-	private function getDependencyMetadataFromSerialization( array $serialization ): DependencyMetadata {
112
-		if ( array_key_exists( CheckResultSerializer::KEY_DEPENDENCY_METADATA, $serialization ) ) {
111
+	private function getDependencyMetadataFromSerialization(array $serialization): DependencyMetadata {
112
+		if (array_key_exists(CheckResultSerializer::KEY_DEPENDENCY_METADATA, $serialization)) {
113 113
 			return $this->deserializeDependencyMetadata(
114 114
 				$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA]
115 115
 			);
@@ -118,7 +118,7 @@  discard block
 block discarded – undo
118 118
 		}
119 119
 	}
120 120
 
121
-	private function deserializeCachingMetadata( array $serialization ): CachingMetadata {
121
+	private function deserializeCachingMetadata(array $serialization): CachingMetadata {
122 122
 		if (
123 123
 			array_key_exists(
124 124
 				CheckResultSerializer::KEY_CACHING_METADATA_MAX_AGE,
@@ -133,7 +133,7 @@  discard block
 block discarded – undo
133 133
 		}
134 134
 	}
135 135
 
136
-	private function deserializeDependencyMetadata( array $serialization ): DependencyMetadata {
136
+	private function deserializeDependencyMetadata(array $serialization): DependencyMetadata {
137 137
 		if (
138 138
 			array_key_exists(
139 139
 				CheckResultSerializer::KEY_DEPENDENCY_METADATA_FUTURE_TIME,
@@ -143,20 +143,20 @@  discard block
 block discarded – undo
143 143
 			$futureTime = TimeValue::newFromArray(
144 144
 				$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA_FUTURE_TIME]
145 145
 			);
146
-			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime( $futureTime );
146
+			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime($futureTime);
147 147
 		} else {
148 148
 			$futureTimeDependencyMetadata = DependencyMetadata::blank();
149 149
 		}
150 150
 
151 151
 		$dependencyMetadata = array_reduce(
152 152
 			$serialization[CheckResultSerializer::KEY_DEPENDENCY_METADATA_ENTITY_IDS],
153
-			function ( DependencyMetadata $metadata, $entityIdSerialization ) {
154
-				$entityId = $this->entityIdParser->parse( $entityIdSerialization );
153
+			function(DependencyMetadata $metadata, $entityIdSerialization) {
154
+				$entityId = $this->entityIdParser->parse($entityIdSerialization);
155 155
 
156
-				return DependencyMetadata::merge( [
156
+				return DependencyMetadata::merge([
157 157
 					$metadata,
158
-					DependencyMetadata::ofEntityId( $entityId )
159
-				] );
158
+					DependencyMetadata::ofEntityId($entityId)
159
+				]);
160 160
 			},
161 161
 			$futureTimeDependencyMetadata
162 162
 		);
Please login to merge, or discard this patch.
src/ConstraintCheck/Result/CheckResultSerializer.php 1 patch
Spacing   +16 added lines, -16 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\Result;
6 6
 
@@ -60,14 +60,14 @@  discard block
 block discarded – undo
60 60
 		$this->serializeDependencyMetadata = $serializeDependencyMetadata;
61 61
 	}
62 62
 
63
-	public function serialize( CheckResult $checkResult ): array {
63
+	public function serialize(CheckResult $checkResult): array {
64 64
 		$contextCursor = $checkResult->getContextCursor();
65 65
 
66 66
 		$serialization = [
67
-			self::KEY_CONTEXT_CURSOR => $this->contextCursorSerializer->serialize( $contextCursor ),
67
+			self::KEY_CONTEXT_CURSOR => $this->contextCursorSerializer->serialize($contextCursor),
68 68
 		];
69 69
 
70
-		if ( $checkResult instanceof NullResult ) {
70
+		if ($checkResult instanceof NullResult) {
71 71
 			$serialization[self::KEY_NULL_RESULT] = 1;
72 72
 		} else {
73 73
 			$constraint = $checkResult->getConstraint();
@@ -76,57 +76,57 @@  discard block
 block discarded – undo
76 76
 			$clarification = $checkResult->getConstraintClarification();
77 77
 
78 78
 			$serialization[self::KEY_CONSTRAINT] =
79
-				$this->constraintSerializer->serialize( $constraint );
79
+				$this->constraintSerializer->serialize($constraint);
80 80
 			$serialization[self::KEY_CHECK_RESULT_STATUS] =
81 81
 				$checkResult->getStatus();
82 82
 			$serialization[self::KEY_CACHING_METADATA] =
83
-				$this->serializeCachingMetadata( $cachingMetadata );
83
+				$this->serializeCachingMetadata($cachingMetadata);
84 84
 
85
-			if ( $violationMessage !== null ) {
85
+			if ($violationMessage !== null) {
86 86
 				$serialization[self::KEY_VIOLATION_MESSAGE] =
87
-					$this->violationMessageSerializer->serialize( $violationMessage );
87
+					$this->violationMessageSerializer->serialize($violationMessage);
88 88
 			}
89
-			if ( $clarification->getTexts() !== [] ) {
89
+			if ($clarification->getTexts() !== []) {
90 90
 				$serialization[self::KEY_CONSTRAINT_CLARIFICATION] =
91 91
 					$clarification->getArrayValue();
92 92
 			}
93 93
 		}
94 94
 
95
-		if ( $this->serializeDependencyMetadata ) {
95
+		if ($this->serializeDependencyMetadata) {
96 96
 			$serialization[self::KEY_DEPENDENCY_METADATA] =
97
-				$this->serializeDependencyMetadata( $checkResult );
97
+				$this->serializeDependencyMetadata($checkResult);
98 98
 		}
99 99
 
100 100
 		return $serialization;
101 101
 	}
102 102
 
103
-	private function serializeCachingMetadata( CachingMetadata $cachingMetadata ): array {
103
+	private function serializeCachingMetadata(CachingMetadata $cachingMetadata): array {
104 104
 		$maximumAge = $cachingMetadata->getMaximumAgeInSeconds();
105 105
 
106 106
 		$serialization = [];
107 107
 
108
-		if ( $maximumAge > 0 ) {
108
+		if ($maximumAge > 0) {
109 109
 			$serialization[self::KEY_CACHING_METADATA_MAX_AGE] = $maximumAge;
110 110
 		}
111 111
 
112 112
 		return $serialization;
113 113
 	}
114 114
 
115
-	private function serializeDependencyMetadata( CheckResult $checkResult ): array {
115
+	private function serializeDependencyMetadata(CheckResult $checkResult): array {
116 116
 		$dependencyMetadata = $checkResult->getMetadata()->getDependencyMetadata();
117 117
 		$entityIds = $dependencyMetadata->getEntityIds();
118 118
 		$futureTime = $dependencyMetadata->getFutureTime();
119 119
 
120 120
 		$serialization = [
121 121
 			self::KEY_DEPENDENCY_METADATA_ENTITY_IDS => array_map(
122
-				static function ( EntityId $entityId ) {
122
+				static function(EntityId $entityId) {
123 123
 					return $entityId->getSerialization();
124 124
 				},
125 125
 				$entityIds
126 126
 			),
127 127
 		];
128 128
 
129
-		if ( $futureTime !== null ) {
129
+		if ($futureTime !== null) {
130 130
 			$serialization[self::KEY_DEPENDENCY_METADATA_FUTURE_TIME] =
131 131
 				$futureTime->getArrayValue();
132 132
 		}
Please login to merge, or discard this patch.