Completed
Push — master ( 4f46ca...625545 )
by
unknown
14:36
created
src/Api/CheckConstraintsRdf.php 1 patch
Spacing   +29 added lines, -29 removed lines patch added patch discarded remove patch
@@ -39,13 +39,13 @@  discard block
 block discarded – undo
39 39
 		EntityIdLookup $entityIdLookup,
40 40
 		RdfVocabulary $rdfVocabulary
41 41
 	) {
42
-		parent::__construct( $page, $context );
42
+		parent::__construct($page, $context);
43 43
 		$this->resultsSource = $resultsSource;
44 44
 		$this->entityIdLookup = $entityIdLookup;
45 45
 		$this->rdfVocabulary = $rdfVocabulary;
46 46
 	}
47 47
 
48
-	public static function newFromGlobalState( Page $page, IContextSource $context ) {
48
+	public static function newFromGlobalState(Page $page, IContextSource $context) {
49 49
 		$repo = WikibaseRepo::getDefaultInstance();
50 50
 
51 51
 		return new static(
@@ -92,8 +92,8 @@  discard block
 block discarded – undo
92 92
 	 * @param string $guid
93 93
 	 * @return string
94 94
 	 */
95
-	private function cleanupGuid( $guid ) {
96
-		return preg_replace( '/[^\w-]/', '-', $guid );
95
+	private function cleanupGuid($guid) {
96
+		return preg_replace('/[^\w-]/', '-', $guid);
97 97
 	}
98 98
 
99 99
 	/**
@@ -105,60 +105,60 @@  discard block
 block discarded – undo
105 105
 		$response = $this->getRequest()->response();
106 106
 		$this->getOutput()->disable();
107 107
 
108
-		if ( !$this->resultsSource instanceof CachingResultsSource ) {
108
+		if (!$this->resultsSource instanceof CachingResultsSource) {
109 109
 			// TODO: make configurable whether only cached results are returned
110
-			$response->statusHeader( 501 ); // Not Implemented
110
+			$response->statusHeader(501); // Not Implemented
111 111
 			return null;
112 112
 		}
113 113
 
114
-		$entityId = $this->entityIdLookup->getEntityIdForTitle( $this->getTitle() );
115
-		if ( $entityId === null ) {
116
-			$response->statusHeader( 404 ); // Not Found
114
+		$entityId = $this->entityIdLookup->getEntityIdForTitle($this->getTitle());
115
+		if ($entityId === null) {
116
+			$response->statusHeader(404); // Not Found
117 117
 			return null;
118 118
 		}
119
-		$revId = $this->getRequest()->getVal( 'revision', 0 );
119
+		$revId = $this->getRequest()->getVal('revision', 0);
120 120
 
121
-		$results = $this->resultsSource->getStoredResults( $entityId, $revId );
122
-		if ( $results === null ) {
123
-			$response->statusHeader( 204 ); // No Content
121
+		$results = $this->resultsSource->getStoredResults($entityId, $revId);
122
+		if ($results === null) {
123
+			$response->statusHeader(204); // No Content
124 124
 			return null;
125 125
 		}
126 126
 
127 127
 		$format = 'ttl'; // TODO: make format an option
128 128
 
129 129
 		$writerFactory = new RdfWriterFactory();
130
-		$formatName = $writerFactory->getFormatName( $format );
131
-		$contentType = $writerFactory->getMimeTypes( $formatName )[0];
130
+		$formatName = $writerFactory->getFormatName($format);
131
+		$contentType = $writerFactory->getMimeTypes($formatName)[0];
132 132
 
133
-		$writer = $writerFactory->getWriter( $formatName );
134
-		foreach ( [ RdfVocabulary::NS_STATEMENT, RdfVocabulary::NS_ONTOLOGY ] as $ns ) {
135
-			$writer->prefix( $ns, $this->rdfVocabulary->getNamespaceURI( $ns ) );
133
+		$writer = $writerFactory->getWriter($formatName);
134
+		foreach ([RdfVocabulary::NS_STATEMENT, RdfVocabulary::NS_ONTOLOGY] as $ns) {
135
+			$writer->prefix($ns, $this->rdfVocabulary->getNamespaceURI($ns));
136 136
 		}
137 137
 		$writer->start();
138 138
 		$writtenAny = false;
139 139
 
140
-		foreach ( $results->getArray() as $checkResult ) {
141
-			if ( $checkResult instanceof NullResult ) {
140
+		foreach ($results->getArray() as $checkResult) {
141
+			if ($checkResult instanceof NullResult) {
142 142
 				continue;
143 143
 			}
144
-			if ( $checkResult->getStatus() === CheckResult::STATUS_BAD_PARAMETERS ) {
144
+			if ($checkResult->getStatus() === CheckResult::STATUS_BAD_PARAMETERS) {
145 145
 				continue;
146 146
 			}
147 147
 			$writtenAny = true;
148
-			$writer->about( RdfVocabulary::NS_STATEMENT,
149
-				$this->cleanupGuid( $checkResult->getContextCursor()->getStatementGuid() ) )
150
-				->say( RdfVocabulary::NS_ONTOLOGY, 'hasViolationForConstraint' )
151
-				->is( RdfVocabulary::NS_STATEMENT,
152
-					$this->cleanupGuid( $checkResult->getConstraint()->getConstraintId() ) );
148
+			$writer->about(RdfVocabulary::NS_STATEMENT,
149
+				$this->cleanupGuid($checkResult->getContextCursor()->getStatementGuid()))
150
+				->say(RdfVocabulary::NS_ONTOLOGY, 'hasViolationForConstraint')
151
+				->is(RdfVocabulary::NS_STATEMENT,
152
+					$this->cleanupGuid($checkResult->getConstraint()->getConstraintId()));
153 153
 		}
154 154
 		$writer->finish();
155
-		if ( $writtenAny ) {
156
-			$response->header( "Content-Type: $contentType; charset=UTF-8" );
155
+		if ($writtenAny) {
156
+			$response->header("Content-Type: $contentType; charset=UTF-8");
157 157
 			echo $writer->drain();
158 158
 		} else {
159 159
 			// Do not output RDF if we haven't written any actual statements. Output 204 instead
160 160
 			$writer->drain();
161
-			$response->statusHeader( 204 ); // No Content
161
+			$response->statusHeader(204); // No Content
162 162
 		}
163 163
 		return null;
164 164
 	}
Please login to merge, or discard this patch.
src/Api/CachingResultsSource.php 1 patch
Spacing   +79 added lines, -80 removed lines patch added patch discarded remove patch
@@ -143,7 +143,7 @@  discard block
 block discarded – undo
143 143
 			CheckResult::STATUS_WARNING,
144 144
 			CheckResult::STATUS_BAD_PARAMETERS,
145 145
 		];
146
-		$this->cachedStatusesFlipped = array_flip( $this->cachedStatuses );
146
+		$this->cachedStatusesFlipped = array_flip($this->cachedStatuses);
147 147
 	}
148 148
 
149 149
 	public function getResults(
@@ -154,15 +154,15 @@  discard block
 block discarded – undo
154 154
 	) {
155 155
 		$results = [];
156 156
 		$metadatas = [];
157
-		$statusesFlipped = array_flip( $statuses );
158
-		if ( $this->canUseStoredResults( $entityIds, $claimIds, $constraintIds, $statuses ) ) {
157
+		$statusesFlipped = array_flip($statuses);
158
+		if ($this->canUseStoredResults($entityIds, $claimIds, $constraintIds, $statuses)) {
159 159
 			$storedEntityIds = [];
160
-			foreach ( $entityIds as $entityId ) {
161
-				$storedResults = $this->getStoredResults( $entityId );
162
-				if ( $storedResults !== null ) {
163
-					$this->loggingHelper->logCheckConstraintsCacheHit( $entityId );
164
-					foreach ( $storedResults->getArray() as $checkResult ) {
165
-						if ( $this->statusSelected( $statusesFlipped, $checkResult ) ) {
160
+			foreach ($entityIds as $entityId) {
161
+				$storedResults = $this->getStoredResults($entityId);
162
+				if ($storedResults !== null) {
163
+					$this->loggingHelper->logCheckConstraintsCacheHit($entityId);
164
+					foreach ($storedResults->getArray() as $checkResult) {
165
+						if ($this->statusSelected($statusesFlipped, $checkResult)) {
166 166
 							$results[] = $checkResult;
167 167
 						}
168 168
 					}
@@ -170,19 +170,19 @@  discard block
 block discarded – undo
170 170
 					$storedEntityIds[] = $entityId;
171 171
 				}
172 172
 			}
173
-			$entityIds = array_values( array_diff( $entityIds, $storedEntityIds ) );
173
+			$entityIds = array_values(array_diff($entityIds, $storedEntityIds));
174 174
 		}
175
-		if ( $entityIds !== [] || $claimIds !== [] ) {
176
-			if ( $entityIds !== [] ) {
177
-				$this->loggingHelper->logCheckConstraintsCacheMisses( $entityIds );
175
+		if ($entityIds !== [] || $claimIds !== []) {
176
+			if ($entityIds !== []) {
177
+				$this->loggingHelper->logCheckConstraintsCacheMisses($entityIds);
178 178
 			}
179
-			$response = $this->getAndStoreResults( $entityIds, $claimIds, $constraintIds, $statuses );
180
-			$results = array_merge( $results, $response->getArray() );
179
+			$response = $this->getAndStoreResults($entityIds, $claimIds, $constraintIds, $statuses);
180
+			$results = array_merge($results, $response->getArray());
181 181
 			$metadatas[] = $response->getMetadata();
182 182
 		}
183 183
 		return new CachedCheckResults(
184 184
 			$results,
185
-			Metadata::merge( $metadatas )
185
+			Metadata::merge($metadatas)
186 186
 		);
187 187
 	}
188 188
 
@@ -205,13 +205,13 @@  discard block
 block discarded – undo
205 205
 		array $constraintIds = null,
206 206
 		array $statuses
207 207
 	) {
208
-		if ( $claimIds !== [] ) {
208
+		if ($claimIds !== []) {
209 209
 			return false;
210 210
 		}
211
-		if ( $constraintIds !== null ) {
211
+		if ($constraintIds !== null) {
212 212
 			return false;
213 213
 		}
214
-		if ( array_diff( $statuses, $this->cachedStatuses ) !== [] ) {
214
+		if (array_diff($statuses, $this->cachedStatuses) !== []) {
215 215
 			return false;
216 216
 		}
217 217
 		return true;
@@ -226,8 +226,8 @@  discard block
 block discarded – undo
226 226
 	 * @param CheckResult $result
227 227
 	 * @return bool
228 228
 	 */
229
-	private function statusSelected( array $statusesFlipped, CheckResult $result ) {
230
-		return array_key_exists( $result->getStatus(), $statusesFlipped ) ||
229
+	private function statusSelected(array $statusesFlipped, CheckResult $result) {
230
+		return array_key_exists($result->getStatus(), $statusesFlipped) ||
231 231
 			$result instanceof NullResult;
232 232
 	}
233 233
 
@@ -244,11 +244,11 @@  discard block
 block discarded – undo
244 244
 		array $constraintIds = null,
245 245
 		array $statuses
246 246
 	) {
247
-		$results = $this->resultsSource->getResults( $entityIds, $claimIds, $constraintIds, $statuses );
247
+		$results = $this->resultsSource->getResults($entityIds, $claimIds, $constraintIds, $statuses);
248 248
 
249
-		if ( $this->canStoreResults( $entityIds, $claimIds, $constraintIds, $statuses ) ) {
250
-			foreach ( $entityIds as $entityId ) {
251
-				$this->storeResults( $entityId, $results );
249
+		if ($this->canStoreResults($entityIds, $claimIds, $constraintIds, $statuses)) {
250
+			foreach ($entityIds as $entityId) {
251
+				$this->storeResults($entityId, $results);
252 252
 			}
253 253
 		}
254 254
 
@@ -279,10 +279,10 @@  discard block
 block discarded – undo
279 279
 		array $constraintIds = null,
280 280
 		array $statuses
281 281
 	) {
282
-		if ( $constraintIds !== null ) {
282
+		if ($constraintIds !== null) {
283 283
 			return false;
284 284
 		}
285
-		if ( array_diff( $this->cachedStatuses, $statuses ) !== [] ) {
285
+		if (array_diff($this->cachedStatuses, $statuses) !== []) {
286 286
 			return false;
287 287
 		}
288 288
 		return true;
@@ -296,21 +296,21 @@  discard block
 block discarded – undo
296 296
 	 * May include check results for other entity IDs as well,
297 297
 	 * or check results with statuses that we’re not interested in caching.
298 298
 	 */
299
-	private function storeResults( EntityId $entityId, CachedCheckResults $results ) {
299
+	private function storeResults(EntityId $entityId, CachedCheckResults $results) {
300 300
 		$latestRevisionIds = $this->getLatestRevisionIds(
301 301
 			$results->getMetadata()->getDependencyMetadata()->getEntityIds()
302 302
 		);
303
-		if ( $latestRevisionIds === null ) {
303
+		if ($latestRevisionIds === null) {
304 304
 			return;
305 305
 		}
306 306
 
307 307
 		$resultSerializations = [];
308
-		foreach ( $results->getArray() as $checkResult ) {
309
-			if ( $checkResult->getContextCursor()->getEntityId() !== $entityId->getSerialization() ) {
308
+		foreach ($results->getArray() as $checkResult) {
309
+			if ($checkResult->getContextCursor()->getEntityId() !== $entityId->getSerialization()) {
310 310
 				continue;
311 311
 			}
312
-			if ( $this->statusSelected( $this->cachedStatusesFlipped, $checkResult ) ) {
313
-				$resultSerializations[] = $this->checkResultSerializer->serialize( $checkResult );
312
+			if ($this->statusSelected($this->cachedStatusesFlipped, $checkResult)) {
313
+				$resultSerializations[] = $this->checkResultSerializer->serialize($checkResult);
314 314
 			}
315 315
 		}
316 316
 
@@ -319,11 +319,11 @@  discard block
 block discarded – undo
319 319
 			'latestRevisionIds' => $latestRevisionIds,
320 320
 		];
321 321
 		$futureTime = $results->getMetadata()->getDependencyMetadata()->getFutureTime();
322
-		if ( $futureTime !== null ) {
322
+		if ($futureTime !== null) {
323 323
 			$value['futureTime'] = $futureTime->getArrayValue();
324 324
 		}
325 325
 
326
-		$this->cache->set( $entityId, $value, $this->ttlInSeconds );
326
+		$this->cache->set($entityId, $value, $this->ttlInSeconds);
327 327
 	}
328 328
 
329 329
 	/**
@@ -337,31 +337,30 @@  discard block
 block discarded – undo
337 337
 		EntityId $entityId,
338 338
 		$forRevision = 0
339 339
 	) {
340
-		$value = $this->cache->get( $entityId, $curTTL, [], $asOf );
341
-		$now = call_user_func( $this->microtime, true );
340
+		$value = $this->cache->get($entityId, $curTTL, [], $asOf);
341
+		$now = call_user_func($this->microtime, true);
342 342
 
343
-		$dependencyMetadata = $this->checkDependencyMetadata( $value,
344
-			[ $entityId->getSerialization() => $forRevision ] );
345
-		if ( $dependencyMetadata === null ) {
343
+		$dependencyMetadata = $this->checkDependencyMetadata($value,
344
+			[$entityId->getSerialization() => $forRevision]);
345
+		if ($dependencyMetadata === null) {
346 346
 			return null;
347 347
 		}
348 348
 
349
-		$ageInSeconds = (int)ceil( $now - $asOf );
349
+		$ageInSeconds = (int) ceil($now - $asOf);
350 350
 		$cachingMetadata = $ageInSeconds > 0 ?
351
-			CachingMetadata::ofMaximumAgeInSeconds( $ageInSeconds ) :
352
-			CachingMetadata::fresh();
351
+			CachingMetadata::ofMaximumAgeInSeconds($ageInSeconds) : CachingMetadata::fresh();
353 352
 
354 353
 		$results = [];
355
-		foreach ( $value['results'] as $resultSerialization ) {
356
-			$results[] = $this->deserializeCheckResult( $resultSerialization, $cachingMetadata );
354
+		foreach ($value['results'] as $resultSerialization) {
355
+			$results[] = $this->deserializeCheckResult($resultSerialization, $cachingMetadata);
357 356
 		}
358 357
 
359 358
 		return new CachedCheckResults(
360 359
 			$results,
361
-			Metadata::merge( [
362
-				Metadata::ofCachingMetadata( $cachingMetadata ),
363
-				Metadata::ofDependencyMetadata( $dependencyMetadata ),
364
-			] )
360
+			Metadata::merge([
361
+				Metadata::ofCachingMetadata($cachingMetadata),
362
+				Metadata::ofDependencyMetadata($dependencyMetadata),
363
+			])
365 364
 		);
366 365
 	}
367 366
 
@@ -377,43 +376,43 @@  discard block
 block discarded – undo
377 376
 	 * @return DependencyMetadata|null the dependency metadata,
378 377
 	 * or null if $value should no longer be used
379 378
 	 */
380
-	private function checkDependencyMetadata( $value, $paramRevs ) {
381
-		if ( $value === false ) {
379
+	private function checkDependencyMetadata($value, $paramRevs) {
380
+		if ($value === false) {
382 381
 			return null;
383 382
 		}
384 383
 
385
-		if ( array_key_exists( 'futureTime', $value ) ) {
386
-			$futureTime = TimeValue::newFromArray( $value['futureTime'] );
387
-			if ( !$this->timeValueComparer->isFutureTime( $futureTime ) ) {
384
+		if (array_key_exists('futureTime', $value)) {
385
+			$futureTime = TimeValue::newFromArray($value['futureTime']);
386
+			if (!$this->timeValueComparer->isFutureTime($futureTime)) {
388 387
 				return null;
389 388
 			}
390
-			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime( $futureTime );
389
+			$futureTimeDependencyMetadata = DependencyMetadata::ofFutureTime($futureTime);
391 390
 		} else {
392 391
 			$futureTimeDependencyMetadata = DependencyMetadata::blank();
393 392
 		}
394 393
 
395
-		foreach ( $paramRevs as $id => $revision ) {
396
-			if ( $revision > 0 ) {
397
-				$value['latestRevisionIds'][$id] = min( $revision, $value['latestRevisionIds'][$id] ?? PHP_INT_MAX );
394
+		foreach ($paramRevs as $id => $revision) {
395
+			if ($revision > 0) {
396
+				$value['latestRevisionIds'][$id] = min($revision, $value['latestRevisionIds'][$id] ?? PHP_INT_MAX);
398 397
 			}
399 398
 		}
400 399
 
401 400
 		$dependedEntityIds = array_map(
402
-			[ $this->entityIdParser, "parse" ],
403
-			array_keys( $value['latestRevisionIds'] )
401
+			[$this->entityIdParser, "parse"],
402
+			array_keys($value['latestRevisionIds'])
404 403
 		);
405 404
 
406
-		if ( $value['latestRevisionIds'] !== $this->getLatestRevisionIds( $dependedEntityIds ) ) {
405
+		if ($value['latestRevisionIds'] !== $this->getLatestRevisionIds($dependedEntityIds)) {
407 406
 			return null;
408 407
 		}
409 408
 
410 409
 		return array_reduce(
411 410
 			$dependedEntityIds,
412
-			function( DependencyMetadata $metadata, EntityId $entityId ) {
413
-				return DependencyMetadata::merge( [
411
+			function(DependencyMetadata $metadata, EntityId $entityId) {
412
+				return DependencyMetadata::merge([
414 413
 					$metadata,
415
-					DependencyMetadata::ofEntityId( $entityId )
416
-				] );
414
+					DependencyMetadata::ofEntityId($entityId)
415
+				]);
417 416
 			},
418 417
 			$futureTimeDependencyMetadata
419 418
 		);
@@ -433,13 +432,13 @@  discard block
 block discarded – undo
433 432
 		array $resultSerialization,
434 433
 		CachingMetadata $cachingMetadata
435 434
 	) {
436
-		$result = $this->checkResultDeserializer->deserialize( $resultSerialization );
437
-		if ( $this->isPossiblyStaleResult( $result ) ) {
435
+		$result = $this->checkResultDeserializer->deserialize($resultSerialization);
436
+		if ($this->isPossiblyStaleResult($result)) {
438 437
 			$result->withMetadata(
439
-				Metadata::merge( [
438
+				Metadata::merge([
440 439
 					$result->getMetadata(),
441
-					Metadata::ofCachingMetadata( $cachingMetadata ),
442
-				] )
440
+					Metadata::ofCachingMetadata($cachingMetadata),
441
+				])
443 442
 			);
444 443
 		}
445 444
 		return $result;
@@ -449,8 +448,8 @@  discard block
 block discarded – undo
449 448
 	 * @param CheckResult $result
450 449
 	 * @return bool
451 450
 	 */
452
-	private function isPossiblyStaleResult( CheckResult $result ) {
453
-		if ( $result instanceof NullResult ) {
451
+	private function isPossiblyStaleResult(CheckResult $result) {
452
+		if ($result instanceof NullResult) {
454 453
 			return false;
455 454
 		}
456 455
 
@@ -465,14 +464,14 @@  discard block
 block discarded – undo
465 464
 	 * @return int[]|null array from entity ID serializations to revision ID,
466 465
 	 * or null to indicate that not all revision IDs could be loaded
467 466
 	 */
468
-	private function getLatestRevisionIds( array $entityIds ) {
469
-		if ( $entityIds === [] ) {
467
+	private function getLatestRevisionIds(array $entityIds) {
468
+		if ($entityIds === []) {
470 469
 			$this->loggingHelper->logEmptyDependencyMetadata();
471 470
 			return [];
472 471
 		}
473
-		if ( count( $entityIds ) > $this->maxRevisionIds ) {
472
+		if (count($entityIds) > $this->maxRevisionIds) {
474 473
 			// one of those entities will probably be edited soon, so might as well skip caching
475
-			$this->loggingHelper->logHugeDependencyMetadata( $entityIds, $this->maxRevisionIds );
474
+			$this->loggingHelper->logHugeDependencyMetadata($entityIds, $this->maxRevisionIds);
476 475
 			return null;
477 476
 		}
478 477
 
@@ -480,7 +479,7 @@  discard block
 block discarded – undo
480 479
 			$entityIds,
481 480
 			EntityRevisionLookup::LATEST_FROM_REPLICA
482 481
 		);
483
-		if ( $this->hasFalseElements( $latestRevisionIds ) ) {
482
+		if ($this->hasFalseElements($latestRevisionIds)) {
484 483
 			return null;
485 484
 		}
486 485
 		return $latestRevisionIds;
@@ -490,8 +489,8 @@  discard block
 block discarded – undo
490 489
 	 * @param array $array
491 490
 	 * @return bool
492 491
 	 */
493
-	private function hasFalseElements( array $array ) {
494
-		return in_array( false, $array, true );
492
+	private function hasFalseElements(array $array) {
493
+		return in_array(false, $array, true);
495 494
 	}
496 495
 
497 496
 	/**
@@ -499,7 +498,7 @@  discard block
 block discarded – undo
499 498
 	 *
500 499
 	 * @param callable $microtime
501 500
 	 */
502
-	public function setMicrotimeFunction( callable $microtime ) {
501
+	public function setMicrotimeFunction(callable $microtime) {
503 502
 		$this->microtime = $microtime;
504 503
 	}
505 504
 
Please login to merge, or discard this patch.