@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 | } |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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( |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
320 | 320 | $constraintTypeItemId, |
321 | 321 | $required, |
322 | 322 | $parameterId |
323 | - ) ); |
|
323 | + )); |
|
324 | 324 | } |
325 | 325 | |
326 | 326 | /** |
@@ -328,18 +328,18 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | } |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 |
||
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 | ); |
@@ -1,6 +1,6 @@ discard block |
||
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 |
||
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 |
||
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 | } |