wikimedia / mediawiki-extensions-WikibaseQualityExternalValidation

includes/CrossCheck/Result/ComparisonResult.php

Spacing +8 added lines, -8 removed lines

@@ -45,12 +45,12 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	public function __construct( DataValue $localValue, array $externalValues, $status ) {
-		Assert::parameterElementType( DataValue::class, $externalValues, '$externalValues' );
+	public function __construct(DataValue $localValue, array $externalValues, $status) {
+		Assert::parameterElementType(DataValue::class, $externalValues, '$externalValues');
 
 		$this->localValue = $localValue;
 		$this->externalValues = $externalValues;
-		$this->setStatus( $status );
+		$this->setStatus($status);
 	}
 
 	/**
@@ -79,14 +79,14 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function setStatus( $status ) {
-		Assert::parameterType( 'string', $status, '$status' );
-		if ( !in_array(
+	private function setStatus($status) {
+		Assert::parameterType('string', $status, '$status');
+		if (!in_array(
 			$status,
-			array( self::STATUS_MATCH, self::STATUS_PARTIAL_MATCH, self::STATUS_MISMATCH )
+			array(self::STATUS_MATCH, self::STATUS_PARTIAL_MATCH, self::STATUS_MISMATCH)
 		)
 		) {
-			throw new InvalidArgumentException( '$status must be one of the status constants.' );
+			throw new InvalidArgumentException('$status must be one of the status constants.');
 		}
 
 		$this->status = $status;

includes/CrossCheck/Comparer/EntityIdValueComparer.php

Spacing +11 added lines, -11 removed lines

@@ -32,7 +32,7 @@ 
 	 * @param TermIndex $termIndex
 	 * @param StringComparer $stringComparer
 	 */
-	public function __construct( TermIndex $termIndex, StringComparer $stringComparer ) {
+	public function __construct(TermIndex $termIndex, StringComparer $stringComparer) {
 		$this->termIndex = $termIndex;
 		$this->stringComparer = $stringComparer;
 	}
@@ -45,9 +45,9 @@ 
 	 *
 	 * @return string|null One of the ComparisonResult::STATUS_... constants.
 	 */
-	public function compare( DataValue $value, DataValue $comparativeValue ) {
-		Assert::parameterType( EntityIdValue::class, $value, '$value' );
-		Assert::parameterType( MonolingualTextValue::class, $comparativeValue, '$comparativeValue' );
+	public function compare(DataValue $value, DataValue $comparativeValue) {
+		Assert::parameterType(EntityIdValue::class, $value, '$value');
+		Assert::parameterType(MonolingualTextValue::class, $comparativeValue, '$comparativeValue');
 
 		/**
 		 * @var EntityIdValue $value
@@ -56,10 +56,10 @@ 
 
 		$entityId = $value->getEntityId();
 		$language = $comparativeValue->getLanguageCode();
-		$terms = $this->getTerms( $entityId, $language );
+		$terms = $this->getTerms($entityId, $language);
 
-		if ( $terms ) {
-			return $this->stringComparer->compareWithArray( $comparativeValue->getText(), $terms );
+		if ($terms) {
+			return $this->stringComparer->compareWithArray($comparativeValue->getText(), $terms);
 		}
 
 		return null;
@@ -73,18 +73,18 @@ 
 	 *
 	 * @return array
 	 */
-	private function getTerms( EntityId $entityId, $language ) {
+	private function getTerms(EntityId $entityId, $language) {
 		$terms = $this->termIndex->getTermsOfEntity(
 			$entityId,
 			array(
 				TermIndexEntry::TYPE_LABEL,
 				TermIndexEntry::TYPE_ALIAS
 			),
-			array( $language )
+			array($language)
 		);
 
 		return array_map(
-			function( TermIndexEntry $term ) {
+			function(TermIndexEntry $term) {
 				return $term->getText();
 			},
 			$terms
@@ -98,7 +98,7 @@ 
 	 * @param DataValue $comparativeValue
 	 * @return bool
 	 */
-	public function canCompare( DataValue $value, DataValue $comparativeValue ) {
+	public function canCompare(DataValue $value, DataValue $comparativeValue) {
 		return $value instanceof EntityIdValue && $comparativeValue instanceof MonolingualTextValue;
 	}
 

includes/CrossCheck/CrossChecker.php

Spacing +56 added lines, -56 removed lines

@@ -95,22 +95,22 @@ 
 	 * @return CrossCheckResultList
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckStatements( StatementList $entityStatements, StatementList $statements ) {
+	public function crossCheckStatements(StatementList $entityStatements, StatementList $statements) {
 		$statementsOfEntity = $entityStatements->toArray();
 
-		foreach ( $statements as $statement ) {
-			if ( !in_array( $statement, $statementsOfEntity ) ) {
-				throw new InvalidArgumentException( 'All statements in $statements must belong to the entity.' );
+		foreach ($statements as $statement) {
+			if (!in_array($statement, $statementsOfEntity)) {
+				throw new InvalidArgumentException('All statements in $statements must belong to the entity.');
 			}
 		}
 
 		$resultList = new CrossCheckResultList();
-		if ( $statements->count() > 0 ) {
-			$applicableDumps = $this->getApplicableDumps( $entityStatements );
-			foreach ( $applicableDumps as $identifierPropertyId => $dumpMetaInformationList ) {
-				$identifierPropertyId = new PropertyId( $identifierPropertyId );
+		if ($statements->count() > 0) {
+			$applicableDumps = $this->getApplicableDumps($entityStatements);
+			foreach ($applicableDumps as $identifierPropertyId => $dumpMetaInformationList) {
+				$identifierPropertyId = new PropertyId($identifierPropertyId);
 
-				if( $this->isIdentifierProperty( $identifierPropertyId ) ) {
+				if ($this->isIdentifierProperty($identifierPropertyId)) {
 					$resultList->merge(
 						$this->crossCheckStatementsWithIdentifier(
 							$entityStatements,
@@ -133,17 +133,17 @@ 
 	 *
 	 * @return array[]
 	 */
-	private function getApplicableDumps( StatementList $statements ) {
+	private function getApplicableDumps(StatementList $statements) {
 		$applicableDumps = array();
 		$identifierPropertyIds = $statements->getPropertyIds();
 		$dumpMetaInformation = $this->dumpMetaInformationLookup->getWithIdentifierProperties(
 			$identifierPropertyIds
 		);
 
-		foreach ( $dumpMetaInformation as $dump ) {
-			foreach ( $dump->getIdentifierPropertyIds() as $identifierPropertyId ) {
+		foreach ($dumpMetaInformation as $dump) {
+			foreach ($dump->getIdentifierPropertyIds() as $identifierPropertyId) {
 				$serialization = $identifierPropertyId->getSerialization();
-				$applicableDumps[ $serialization ][ $dump->getDumpId() ] = $dump;
+				$applicableDumps[$serialization][$dump->getDumpId()] = $dump;
 			}
 		}
 
@@ -168,36 +168,36 @@ 
 	) {
 		$resultList = new CrossCheckResultList();
 
-		$externalIds = $this->getExternalIds( $entityStatements, $identifierPropertyId );
-		if( !$externalIds ) {
+		$externalIds = $this->getExternalIds($entityStatements, $identifierPropertyId);
+		if (!$externalIds) {
 			return $resultList;
 		}
 
 		$dumpIds = array_map(
-			function ( DumpMetaInformation $dumpMetaInformation ) {
+			function(DumpMetaInformation $dumpMetaInformation) {
 				return $dumpMetaInformation->getDumpId();
 			},
 			$dumpMetaInformationList
 		);
-		$externalData = $this->externalDataRepo->getExternalData( $dumpIds, $externalIds, $statements->getPropertyIds() );
+		$externalData = $this->externalDataRepo->getExternalData($dumpIds, $externalIds, $statements->getPropertyIds());
 
-		foreach ( $externalData as $dumpId => $externalDataPerDump ) {
-			$dumpMetaInformation = $dumpMetaInformationList[ $dumpId ];
+		foreach ($externalData as $dumpId => $externalDataPerDump) {
+			$dumpMetaInformation = $dumpMetaInformationList[$dumpId];
 			$comparativeValueParser = $this->valueParserFactory->newComparativeValueParser(
 				$dumpMetaInformation->getLanguageCode()
 			);
 
-			foreach ( $externalDataPerDump as $externalId => $externalDataPerId ) {
+			foreach ($externalDataPerDump as $externalId => $externalDataPerId) {
 				$externalId = (string)$externalId;
-				foreach ( $externalDataPerId as $propertyId => $externalValues ) {
-					$propertyId = new PropertyId( $propertyId );
+				foreach ($externalDataPerId as $propertyId => $externalValues) {
+					$propertyId = new PropertyId($propertyId);
 					$resultList->merge(
 						$this->crossCheckExternalValues(
 							$dumpMetaInformation,
 							$identifierPropertyId,
 							$externalId,
 							$externalValues,
-							$statements->getByPropertyId( $propertyId ),
+							$statements->getByPropertyId($propertyId),
 							$comparativeValueParser
 						)
 					);
@@ -228,10 +228,10 @@ 
 	) {
 		$resultList = new CrossCheckResultList();
 
-		foreach ( $statements->toArray() as $statement ) {
-			$comparisonResult = $this->compareStatement( $statement, $externalValues, $comparativeValueParser );
+		foreach ($statements->toArray() as $statement) {
+			$comparisonResult = $this->compareStatement($statement, $externalValues, $comparativeValueParser);
 
-			if ( $comparisonResult ) {
+			if ($comparisonResult) {
 				$referencesResult = $this->referenceHandler->checkForReferences(
 					$statement,
 					$identifierPropertyId,
@@ -265,32 +265,32 @@ 
 	 * @return ComparisonResult|bool
 	 */
 	private function compareStatement(
-		Statement $statement,array $externalValues,
+		Statement $statement, array $externalValues,
 		ComparativeValueParser $comparativeValueParser
 	) {
 		$mainSnak = $statement->getMainSnak();
-		if ( $mainSnak instanceof PropertyValueSnak ) {
+		if ($mainSnak instanceof PropertyValueSnak) {
 			$dataValue = $mainSnak->getDataValue();
 
 			$results = array();
-			$comparativeValues = $this->parseExternalValues( $dataValue, $externalValues, $comparativeValueParser );
-			foreach ( $comparativeValues as $comparativeValue ) {
-				$result = $this->dataValueComparer->compare( $dataValue, $comparativeValue );
-				if( $result ) {
+			$comparativeValues = $this->parseExternalValues($dataValue, $externalValues, $comparativeValueParser);
+			foreach ($comparativeValues as $comparativeValue) {
+				$result = $this->dataValueComparer->compare($dataValue, $comparativeValue);
+				if ($result) {
 					$results[] = $result;
 				}
 			}
 
-			if( $results ) {
+			if ($results) {
 				$result = ComparisonResult::STATUS_MISMATCH;
-				if( in_array( ComparisonResult::STATUS_MATCH, $results ) ) {
+				if (in_array(ComparisonResult::STATUS_MATCH, $results)) {
 					$result = ComparisonResult::STATUS_MATCH;
 				}
-				elseif( in_array( ComparisonResult::STATUS_PARTIAL_MATCH, $results ) ) {
+				elseif (in_array(ComparisonResult::STATUS_PARTIAL_MATCH, $results)) {
 					$result = ComparisonResult::STATUS_PARTIAL_MATCH;
 				}
 
-				return new ComparisonResult( $dataValue, $comparativeValues, $result );
+				return new ComparisonResult($dataValue, $comparativeValues, $result);
 			}
 		}
 
@@ -310,14 +310,14 @@ 
 		ComparativeValueParser $comparativeValueParser
 	) {
 		$parsedValues = array();
-		foreach ( $externalValues as $externalValue ) {
+		foreach ($externalValues as $externalValue) {
 			try {
-				$parsedValue = $comparativeValueParser->parse( $externalValue, $dataValue->getType() );
-				if( $parsedValue ) {
+				$parsedValue = $comparativeValueParser->parse($externalValue, $dataValue->getType());
+				if ($parsedValue) {
 					$parsedValues[] = $parsedValue;
 				}
 			}
-			catch( ParseException $e ) {}
+			catch (ParseException $e) {}
 		}
 
 		return $parsedValues;
@@ -331,12 +331,12 @@ 
 	 *
 	 * @return string[]
 	 */
-	private function getExternalIds( StatementList $statements, PropertyId $identifierPropertyId ) {
+	private function getExternalIds(StatementList $statements, PropertyId $identifierPropertyId) {
 		$externalIds = array();
-		$identifierStatements = $statements->getByPropertyId( $identifierPropertyId );
-		$values = $this->getDataValues( $identifierStatements );
-		foreach ( $values as $value ) {
-			if ( $value instanceof StringValue ) {
+		$identifierStatements = $statements->getByPropertyId($identifierPropertyId);
+		$values = $this->getDataValues($identifierStatements);
+		foreach ($values as $value) {
+			if ($value instanceof StringValue) {
 				$externalIds[] = $value->getValue();
 			}
 		}
@@ -348,15 +348,15 @@ 
 	 * @param PropertyId $identifierPropertyId
 	 * @return bool
 	 */
-	private function isIdentifierProperty( PropertyId $identifierPropertyId ) {
+	private function isIdentifierProperty(PropertyId $identifierPropertyId) {
 		/** @var Property $property */
-		$property = $this->entityLookup->getEntity( $identifierPropertyId );
-		$instanceOfPropertyId = new PropertyId( INSTANCE_OF_PID );
-		$statements = $property->getStatements()->getByPropertyId( $instanceOfPropertyId );
-		$values = $this->getDataValues( $statements );
-		foreach ( $values as $value ) {
-			if( $value instanceof EntityIdValue ) {
-				if( $value->getEntityId()->getSerialization() === IDENTIFIER_PROPERTY_QID ) {
+		$property = $this->entityLookup->getEntity($identifierPropertyId);
+		$instanceOfPropertyId = new PropertyId(INSTANCE_OF_PID);
+		$statements = $property->getStatements()->getByPropertyId($instanceOfPropertyId);
+		$values = $this->getDataValues($statements);
+		foreach ($values as $value) {
+			if ($value instanceof EntityIdValue) {
+				if ($value->getEntityId()->getSerialization() === IDENTIFIER_PROPERTY_QID) {
 					return true;
 				}
 			}
@@ -371,12 +371,12 @@ 
 	 * @param StatementList $statementList
 	 * @return DataValue[]
 	 */
-	private function getDataValues( StatementList $statementList ){
+	private function getDataValues(StatementList $statementList) {
 		$dataValues = array();
 
-		foreach ( $statementList->toArray() as $statement ) {
+		foreach ($statementList->toArray() as $statement) {
 			$mainSnak = $statement->getMainSnak();
-			if ( $mainSnak instanceof PropertyValueSnak ) {
+			if ($mainSnak instanceof PropertyValueSnak) {
 				$dataValues[] = $mainSnak->getDataValue();
 			}
 		}

includes/CrossCheck/CrossCheckInteractor.php

Spacing +62 added lines, -62 removed lines

@@ -43,7 +43,7 @@ 
 	 * @param StatementGuidParser $statementGuidParser
 	 * @param CrossChecker $crossChecker
 	 */
-	public function __construct( EntityLookup $entityLookup, StatementGuidParser $statementGuidParser, CrossChecker $crossChecker ) {
+	public function __construct(EntityLookup $entityLookup, StatementGuidParser $statementGuidParser, CrossChecker $crossChecker) {
 		$this->entityLookup = $entityLookup;
 		$this->statementGuidParser = $statementGuidParser;
 		$this->crossChecker = $crossChecker;
@@ -56,11 +56,11 @@ 
 	 *
 	 * @return CrossCheckResultList|null
 	 */
-	public function crossCheckEntityById( EntityId $entityId ) {
-		$entity = $this->entityLookup->getEntity( $entityId );
+	public function crossCheckEntityById(EntityId $entityId) {
+		$entity = $this->entityLookup->getEntity($entityId);
 
-		if ( $entity instanceof StatementListProvider ) {
-			return $this->crossCheckStatements( $entity->getStatements() );
+		if ($entity instanceof StatementListProvider) {
+			return $this->crossCheckStatements($entity->getStatements());
 		}
 
 		return null;
@@ -73,12 +73,12 @@ 
 	 *
 	 * @return CrossCheckResultList[]
 	 */
-	public function crossCheckEntitiesByIds( array $entityIds ) {
-		Assert::parameterElementType( EntityId::class,  $entityIds, '$entityIds' );
+	public function crossCheckEntitiesByIds(array $entityIds) {
+		Assert::parameterElementType(EntityId::class, $entityIds, '$entityIds');
 
 		$results = array();
-		foreach ( $entityIds as $entityId ) {
-			$results[$entityId->getSerialization()] = $this->crossCheckEntityById( $entityId );
+		foreach ($entityIds as $entityId) {
+			$results[$entityId->getSerialization()] = $this->crossCheckEntityById($entityId);
 		}
 
 		return $results;
@@ -91,8 +91,8 @@ 
 	 *
 	 * @return CrossCheckResultList
 	 */
-	public function crossCheckStatements( StatementList $statements ) {
-		return $this->crossChecker->crossCheckStatements( $statements, $statements );
+	public function crossCheckStatements(StatementList $statements) {
+		return $this->crossChecker->crossCheckStatements($statements, $statements);
 	}
 
 	/**
@@ -103,14 +103,14 @@ 
 	 * @return CrossCheckResultList[]
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckEntities( array $entities ) {
-		Assert::parameterElementType( EntityDocument::class,  $entities, '$entities' );
+	public function crossCheckEntities(array $entities) {
+		Assert::parameterElementType(EntityDocument::class, $entities, '$entities');
 
 		$results = array();
-		foreach ( $entities as $entity ) {
+		foreach ($entities as $entity) {
 			$entityId = $entity->getId()->getSerialization();
-			if ( $entity instanceof StatementListProvider ) {
-				$results[$entityId] = $this->crossCheckStatements( $entity->getStatements() );
+			if ($entity instanceof StatementListProvider) {
+				$results[$entityId] = $this->crossCheckStatements($entity->getStatements());
 			}
 		}
 
@@ -126,13 +126,13 @@ 
 	 * @return CrossCheckResultList|null
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckEntityByIdWithProperties( EntityId $entityId, array $propertyIds ) {
-		Assert::parameterElementType( PropertyId::class,  $propertyIds, '$propertyIds' );
+	public function crossCheckEntityByIdWithProperties(EntityId $entityId, array $propertyIds) {
+		Assert::parameterElementType(PropertyId::class, $propertyIds, '$propertyIds');
 
-		$entity = $this->entityLookup->getEntity( $entityId );
+		$entity = $this->entityLookup->getEntity($entityId);
 
-		if ( $entity instanceof StatementListProvider ) {
-			return $this->crossCheckStatementsWithProperties( $entity->getStatements(), $propertyIds );
+		if ($entity instanceof StatementListProvider) {
+			return $this->crossCheckStatementsWithProperties($entity->getStatements(), $propertyIds);
 		}
 
 		return null;
@@ -147,13 +147,13 @@ 
 	 * @return CrossCheckResultList[]
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckEntitiesByIdWithProperties( array $entityIds, array $propertyIds ) {
-		Assert::parameterElementType( EntityId::class,  $entityIds, '$entityIds' );
-		Assert::parameterElementType( PropertyId::class,  $propertyIds, '$propertyIds' );
+	public function crossCheckEntitiesByIdWithProperties(array $entityIds, array $propertyIds) {
+		Assert::parameterElementType(EntityId::class, $entityIds, '$entityIds');
+		Assert::parameterElementType(PropertyId::class, $propertyIds, '$propertyIds');
 
 		$results = array();
-		foreach ( $entityIds as $entityId ) {
-			$results[$entityId->getSerialization()] = $this->crossCheckEntityByIdWithProperties( $entityId, $propertyIds );
+		foreach ($entityIds as $entityId) {
+			$results[$entityId->getSerialization()] = $this->crossCheckEntityByIdWithProperties($entityId, $propertyIds);
 		}
 
 		return $results;
@@ -168,17 +168,17 @@ 
 	 * @return CrossCheckResultList
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckStatementsWithProperties( StatementList $entityStatements, array $propertyIds ) {
-		Assert::parameterElementType( PropertyId::class,  $propertyIds, '$propertyIds' );
+	public function crossCheckStatementsWithProperties(StatementList $entityStatements, array $propertyIds) {
+		Assert::parameterElementType(PropertyId::class, $propertyIds, '$propertyIds');
 
 		$statements = new StatementList();
-		foreach ( $entityStatements->toArray() as $statement ) {
-			if ( in_array( $statement->getPropertyId(), $propertyIds ) ) {
-				$statements->addStatement( $statement );
+		foreach ($entityStatements->toArray() as $statement) {
+			if (in_array($statement->getPropertyId(), $propertyIds)) {
+				$statements->addStatement($statement);
 			}
 		}
 
-		return $this->crossChecker->crossCheckStatements( $entityStatements, $statements );
+		return $this->crossChecker->crossCheckStatements($entityStatements, $statements);
 	}
 
 	/**
@@ -190,14 +190,14 @@ 
 	 * @return CrossCheckResultList[]
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckEntitiesWithProperties( array $entities, array $propertyIds ) {
-		Assert::parameterElementType( EntityDocument::class,  $entities, '$entities' );
-		Assert::parameterElementType( PropertyId::class,  $propertyIds, '$propertyIds' );
+	public function crossCheckEntitiesWithProperties(array $entities, array $propertyIds) {
+		Assert::parameterElementType(EntityDocument::class, $entities, '$entities');
+		Assert::parameterElementType(PropertyId::class, $propertyIds, '$propertyIds');
 
 		$results = array();
-		foreach ( $entities as $entity ) {
+		foreach ($entities as $entity) {
 			$entityId = $entity->getId()->getSerialization();
-			if ( $entity instanceof StatementListProvider ) {
+			if ($entity instanceof StatementListProvider) {
 				$results[$entityId] = $this->crossCheckStatementsWithProperties(
 					$entity->getStatements(),
 					$propertyIds
@@ -216,12 +216,12 @@ 
 	 * @return CrossCheckResultList
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckStatementByGuid( $guid ) {
-		$this->assertIsString( $guid, '$guid' );
+	public function crossCheckStatementByGuid($guid) {
+		$this->assertIsString($guid, '$guid');
 
-		$resultList = $this->crossCheckStatementsByGuids( array( $guid ) );
+		$resultList = $this->crossCheckStatementsByGuids(array($guid));
 
-		return reset( $resultList );
+		return reset($resultList);
 	}
 
 	/**
@@ -232,21 +232,21 @@ 
 	 * @return CrossCheckResultList[]
 	 * @throws InvalidArgumentException
 	 */
-	public function crossCheckStatementsByGuids( array $guids ) {
-		$this->assertIsArrayOfStrings( $guids, '$guids' );
+	public function crossCheckStatementsByGuids(array $guids) {
+		$this->assertIsArrayOfStrings($guids, '$guids');
 
 		$entityIds = array();
 		$groupedStatementGuids = array();
-		foreach ( $guids as $guid ) {
-			$serializedEntityId = $this->statementGuidParser->parse( $guid )->getEntityId();
+		foreach ($guids as $guid) {
+			$serializedEntityId = $this->statementGuidParser->parse($guid)->getEntityId();
 			$entityIds[$serializedEntityId->getSerialization()] = $serializedEntityId;
 			$groupedStatementGuids[$serializedEntityId->getSerialization()][] = $guid;
 		}
 
 		$resultLists = array();
-		foreach ( $groupedStatementGuids as $serializedEntityId => $guidsOfEntity ) {
-			$entityId = $entityIds[ $serializedEntityId ];
-			$resultLists[ $serializedEntityId ] = $this->crossCheckClaimsOfEntity( $entityId, $guidsOfEntity );
+		foreach ($groupedStatementGuids as $serializedEntityId => $guidsOfEntity) {
+			$entityId = $entityIds[$serializedEntityId];
+			$resultLists[$serializedEntityId] = $this->crossCheckClaimsOfEntity($entityId, $guidsOfEntity);
 		}
 
 		return $resultLists;
@@ -258,18 +258,18 @@ 
 	 *
 	 * @return CrossCheckResultList|null
 	 */
-	private function crossCheckClaimsOfEntity( EntityId $entityId, array $guids ) {
-		$entity = $this->entityLookup->getEntity( $entityId );
+	private function crossCheckClaimsOfEntity(EntityId $entityId, array $guids) {
+		$entity = $this->entityLookup->getEntity($entityId);
 
-		if ( $entity instanceof StatementListProvider ) {
+		if ($entity instanceof StatementListProvider) {
 			$statements = new StatementList();
-			foreach ( $entity->getStatements()->toArray() as $statement ) {
-				if ( in_array( $statement->getGuid(), $guids ) ) {
-					$statements->addStatement( $statement );
+			foreach ($entity->getStatements()->toArray() as $statement) {
+				if (in_array($statement->getGuid(), $guids)) {
+					$statements->addStatement($statement);
 				}
 			}
 
-			return $this->crossChecker->crossCheckStatements( $entity->getStatements(), $statements );
+			return $this->crossChecker->crossCheckStatements($entity->getStatements(), $statements);
 		}
 
 		return null;
@@ -281,9 +281,9 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function assertIsString( $string, $parameterName ) {
-		if ( !is_string( $string ) ) {
-			throw new InvalidArgumentException( "$parameterName must be string." );
+	private function assertIsString($string, $parameterName) {
+		if (!is_string($string)) {
+			throw new InvalidArgumentException("$parameterName must be string.");
 		}
 	}
 
@@ -293,10 +293,10 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function assertIsArrayOfStrings( array $strings, $parameterName ) {
-		foreach ( $strings as $string ) {
-			if ( !is_string( $string ) ) {
-				throw new InvalidArgumentException( "Each element of $parameterName must be string." );
+	private function assertIsArrayOfStrings(array $strings, $parameterName) {
+		foreach ($strings as $string) {
+			if (!is_string($string)) {
+				throw new InvalidArgumentException("Each element of $parameterName must be string.");
 			}
 		}
 	}

includes/DumpMetaInformation/DumpMetaInformation.php

Spacing +30 added lines, -30 removed lines

@@ -83,27 +83,27 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	public function __construct( $dumpId,
+	public function __construct($dumpId,
 								 ItemId $sourceItemId,
 								 array $identifierPropertyIds,
 								 $importDate,
 								 $languageCode,
 								 $sourceUrl,
 								 $size,
-								 ItemId $licenseItemId ) {
+								 ItemId $licenseItemId) {
 		Assert::parameterElementType(
 			PropertyId::class,
 			$identifierPropertyIds,
 			'$identifierPropertyIds'
 		);
 
-		$this->setDumpId( $dumpId );
+		$this->setDumpId($dumpId);
 		$this->sourceItemId = $sourceItemId;
 		$this->identifierPropertyIds = $identifierPropertyIds;
-		$this->setImportDate( $importDate );
-		$this->setLanguageCode( $languageCode );
-		$this->setSourceUrl( $sourceUrl );
-		$this->setSize( $size );
+		$this->setImportDate($importDate);
+		$this->setLanguageCode($languageCode);
+		$this->setSourceUrl($sourceUrl);
+		$this->setSize($size);
 		$this->licenseItemId = $licenseItemId;
 	}
 
@@ -168,10 +168,10 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function setDumpId( $dumpId ) {
-		Assert::parameterType( 'string', $dumpId, '$dumpId' );
-		$length = strlen( $dumpId );
-		if ( $length < 1 || $length > 25 ) {
+	private function setDumpId($dumpId) {
+		Assert::parameterType('string', $dumpId, '$dumpId');
+		$length = strlen($dumpId);
+		if ($length < 1 || $length > 25) {
 			throw new InvalidArgumentException('$dumpId must be between 1 and 25 characters.');
 		}
 
@@ -183,10 +183,10 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function setLanguageCode( $languageCode ) {
-		Assert::parameterType( 'string', $languageCode, '$languageCode' );
-		if( !Language::isValidCode( $languageCode ) ) {
-			throw new InvalidArgumentException( '$languageCode is not valid.' );
+	private function setLanguageCode($languageCode) {
+		Assert::parameterType('string', $languageCode, '$languageCode');
+		if (!Language::isValidCode($languageCode)) {
+			throw new InvalidArgumentException('$languageCode is not valid.');
 		}
 
 		$this->languageCode = $languageCode;
@@ -197,12 +197,12 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function setImportDate( $importDate ) {
-		Assert::parameterType( 'string', $importDate, '$importDate' );
+	private function setImportDate($importDate) {
+		Assert::parameterType('string', $importDate, '$importDate');
 
-		$timestamp = wfTimestamp( TS_MW, $importDate );
-		if( !$timestamp ) {
-			throw new InvalidArgumentException( '$updatedAt has invalid timestamp format.' );
+		$timestamp = wfTimestamp(TS_MW, $importDate);
+		if (!$timestamp) {
+			throw new InvalidArgumentException('$updatedAt has invalid timestamp format.');
 		}
 
 		$this->importDate = $importDate;
@@ -213,13 +213,13 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function setSourceUrl( $sourceUrl ) {
-		Assert::parameterType( 'string', $sourceUrl, '$sourceUrl' );
-		if( strlen( $sourceUrl ) > 300 ) {
-			throw new InvalidArgumentException( '$sourceUrl must not be longer than 300 characters.' );
+	private function setSourceUrl($sourceUrl) {
+		Assert::parameterType('string', $sourceUrl, '$sourceUrl');
+		if (strlen($sourceUrl) > 300) {
+			throw new InvalidArgumentException('$sourceUrl must not be longer than 300 characters.');
 		}
-		if( !filter_var($sourceUrl, FILTER_VALIDATE_URL) ) {
-			throw new InvalidArgumentException( '$sourceUrl is not a valid url.' );
+		if (!filter_var($sourceUrl, FILTER_VALIDATE_URL)) {
+			throw new InvalidArgumentException('$sourceUrl is not a valid url.');
 		}
 
 		$this->sourceUrl = $sourceUrl;
@@ -230,10 +230,10 @@ 
 	 *
 	 * @throws InvalidArgumentException
 	 */
-	private function setSize( $size ){
-		Assert::parameterType( 'integer', $size, '$size' );
-		if( $size <= 0 ) {
-			throw new InvalidArgumentException( '$size must be positive integer.' );
+	private function setSize($size) {
+		Assert::parameterType('integer', $size, '$size');
+		if ($size <= 0) {
+			throw new InvalidArgumentException('$size must be positive integer.');
 		}
 
 		$this->size = $size;

WikibaseQualityExternalValidationHooks.php

Spacing +6 added lines, -6 removed lines

@@ -7,16 +7,16 @@
 	 *
 	 * @return bool
 	 */
-	public static function onCreateSchema( DatabaseUpdater $updater ) {
-		$updater->addExtensionTable( 'wbqev_dump_information', __DIR__ . '/sql/create_wbqev_dump_information.sql' );
-		$updater->addExtensionTable( 'wbqev_external_data', __DIR__ . '/sql/create_wbqev_external_data.sql' );
-		$updater->addExtensionTable( 'wbqev_identifier_properties', __DIR__ . '/sql/create_wbqev_identifier_properties.sql' );
+	public static function onCreateSchema(DatabaseUpdater $updater) {
+		$updater->addExtensionTable('wbqev_dump_information', __DIR__.'/sql/create_wbqev_dump_information.sql');
+		$updater->addExtensionTable('wbqev_external_data', __DIR__.'/sql/create_wbqev_external_data.sql');
+		$updater->addExtensionTable('wbqev_identifier_properties', __DIR__.'/sql/create_wbqev_identifier_properties.sql');
 
 		return true;
 	}
 
-	public static function onUnitTestsList( &$paths ) {
-		$paths[] = __DIR__ . '/tests/phpunit';
+	public static function onUnitTestsList(&$paths) {
+		$paths[] = __DIR__.'/tests/phpunit';
 		return true;
 	}
 

includes/CrossCheck/Comparer/TimeValueComparer.php

Spacing +23 added lines, -23 removed lines

@@ -30,9 +30,9 @@ 
 	 * @throws InvalidArgumentException
 	 * @return string One of the ComparisonResult::STATUS_... constants.
 	 */
-	public function compare( DataValue $value, DataValue $comparativeValue ) {
-		if ( !$this->canCompare( $value, $comparativeValue ) ) {
-			throw new InvalidArgumentException( 'Given values can not be compared using this comparer.' );
+	public function compare(DataValue $value, DataValue $comparativeValue) {
+		if (!$this->canCompare($value, $comparativeValue)) {
+			throw new InvalidArgumentException('Given values can not be compared using this comparer.');
 		}
 
 		/**
@@ -42,38 +42,38 @@ 
 
 		$result = ComparisonResult::STATUS_MISMATCH;
 
-		if ( !preg_match( '/^([-+]?)(\d*)((\d{4}\b).*)/', $value->getTime(), $localMatches )
-			|| !preg_match( '/^([-+]?)(\d*)((\d{4}\b).*)/', $comparativeValue->getTime(), $externalMatches )
+		if (!preg_match('/^([-+]?)(\d*)((\d{4}\b).*)/', $value->getTime(), $localMatches)
+			|| !preg_match('/^([-+]?)(\d*)((\d{4}\b).*)/', $comparativeValue->getTime(), $externalMatches)
 		) {
 			return ComparisonResult::STATUS_MISMATCH;
 		}
-		list( , $localSign, $localYearHigh, $localMwTime, $localYearLow ) = $localMatches;
-		list( , $externalSign, $externalYearHigh, $externalMwTime, $externalYearLow ) = $externalMatches;
-		if ( $localSign !== $externalSign && ( $localYearHigh . $localYearLow !== '0000'
-				|| $externalYearHigh . $externalYearLow !== '0000' )
+		list(, $localSign, $localYearHigh, $localMwTime, $localYearLow) = $localMatches;
+		list(, $externalSign, $externalYearHigh, $externalMwTime, $externalYearLow) = $externalMatches;
+		if ($localSign !== $externalSign && ($localYearHigh.$localYearLow !== '0000'
+				|| $externalYearHigh.$externalYearLow !== '0000')
 		) {
 			return ComparisonResult::STATUS_MISMATCH;
 		}
 
 		try {
-			$localTimestamp = new MWTimestamp( $localMwTime );
-			$externalTimestamp = new MWTimestamp( $externalMwTime );
-			$diff = $localTimestamp->diff( $externalTimestamp );
-			$diff->y += abs( $localYearHigh - $externalYearHigh ) * 10000;
+			$localTimestamp = new MWTimestamp($localMwTime);
+			$externalTimestamp = new MWTimestamp($externalMwTime);
+			$diff = $localTimestamp->diff($externalTimestamp);
+			$diff->y += abs($localYearHigh - $externalYearHigh) * 10000;
 
-			if ( $value->getPrecision() === $comparativeValue->getPrecision()
-				&& $this->resultOfDiffWithPrecision( $diff, $value->getPrecision() )
+			if ($value->getPrecision() === $comparativeValue->getPrecision()
+				&& $this->resultOfDiffWithPrecision($diff, $value->getPrecision())
 			) {
 				$result = ComparisonResult::STATUS_MATCH;
 			} elseif (
 				$this->resultOfDiffWithPrecision(
 					$diff,
-					min( $value->getPrecision(), $comparativeValue->getPrecision() )
+					min($value->getPrecision(), $comparativeValue->getPrecision())
 				)
 			) {
 				$result = ComparisonResult::STATUS_PARTIAL_MATCH;
 			}
-		} catch ( TimestampException $ex ) {
+		} catch (TimestampException $ex) {
 		}
 
 		return $result;
@@ -87,10 +87,10 @@ 
 	 *
 	 * @return bool
 	 */
-	private function resultOfDiffWithPrecision( DateInterval $diff, $precision ) {
+	private function resultOfDiffWithPrecision(DateInterval $diff, $precision) {
 		$result = true;
 
-		switch ( $precision ) {
+		switch ($precision) {
 			case TimeValue::PRECISION_SECOND:
 				$result = $diff->s === 0;
 				// Fall through with no break/return. This is critical for this algorithm.
@@ -134,10 +134,10 @@ 
 	 *
 	 * @return ValueParser
 	 */
-	protected function getExternalValueParser( DumpMetaInformation $dumpMetaInformation ) {
+	protected function getExternalValueParser(DumpMetaInformation $dumpMetaInformation) {
 		$parserOptions = new ParserOptions();
-		$parserOptions->setOption( ValueParser::OPT_LANG, $dumpMetaInformation->getLanguageCode() );
-		$timeParserFactory = new TimeParserFactory( $parserOptions );
+		$parserOptions->setOption(ValueParser::OPT_LANG, $dumpMetaInformation->getLanguageCode());
+		$timeParserFactory = new TimeParserFactory($parserOptions);
 
 		return $timeParserFactory->getTimeParser();
 	}
@@ -150,7 +150,7 @@ 
 	 *
 	 * @return bool
 	 */
-	public function canCompare( DataValue $value, DataValue $comparativeValue ) {
+	public function canCompare(DataValue $value, DataValue $comparativeValue) {
 		return $value instanceof TimeValue && $comparativeValue instanceof TimeValue;
 	}
 

includes/ExternalDataRepo.php

Spacing +31 added lines, -31 removed lines

@@ -24,23 +24,23 @@ 
 	 * @param PropertyId[] $propertyIds
 	 * @return array
 	 */
-	public function getExternalData( array $dumpIds, array $externalIds, array $propertyIds ) {
-		Assert::parameterElementType( 'string', $dumpIds, '$dumpIds' );
-		Assert::parameterElementType( 'string', $externalIds, '$externalIds' );
-		Assert::parameterElementType( PropertyId::class, $propertyIds, '$propertyIds' );
-		Assert::parameter( count( $dumpIds ) > 0, '$dumpIds', '$dumpIds has to contain at least one element.' );
-		Assert::parameter( count( $externalIds ) > 0, '$externalIds', '$externalIds has to contain at least one element.' );
+	public function getExternalData(array $dumpIds, array $externalIds, array $propertyIds) {
+		Assert::parameterElementType('string', $dumpIds, '$dumpIds');
+		Assert::parameterElementType('string', $externalIds, '$externalIds');
+		Assert::parameterElementType(PropertyId::class, $propertyIds, '$propertyIds');
+		Assert::parameter(count($dumpIds) > 0, '$dumpIds', '$dumpIds has to contain at least one element.');
+		Assert::parameter(count($externalIds) > 0, '$externalIds', '$externalIds has to contain at least one element.');
 
 		$conditions = array(
 			'dump_id' => $dumpIds,
 			'external_id' => $externalIds
 		);
-		if ( $propertyIds ) {
+		if ($propertyIds) {
 			$conditions['pid'] = $propertyIds;
 		}
 
 		$externalData = array();
-		$db = wfGetDB( DB_SLAVE );
+		$db = wfGetDB(DB_SLAVE);
 		$result = $db->select(
 			self::TABLE_NAME,
 			array(
@@ -52,7 +52,7 @@ 
 			$conditions
 		);
 
-		foreach ( $result as $row ) {
+		foreach ($result as $row) {
 			$externalData[$row->dump_id][$row->external_id][$row->pid][] = $row->external_value;
 		}
 
@@ -68,13 +68,13 @@ 
 	 * @param string $externalValue
 	 * @return bool
 	 */
-	public function insert( $dumpId, $externalId, PropertyId $propertyId, $externalValue ) {
-		Assert::parameterType( 'string', $dumpId, '$dumpId' );
-		Assert::parameterType( 'string', $externalId, '$externalId' );
-		Assert::parameterType( 'string', $externalValue, '$externalValue' );
+	public function insert($dumpId, $externalId, PropertyId $propertyId, $externalValue) {
+		Assert::parameterType('string', $dumpId, '$dumpId');
+		Assert::parameterType('string', $externalId, '$externalId');
+		Assert::parameterType('string', $externalValue, '$externalValue');
 
-		$externalDataBatch = array( func_get_args() );
-		return $this->insertBatch( $externalDataBatch );
+		$externalDataBatch = array(func_get_args());
+		return $this->insertBatch($externalDataBatch);
 	}
 
 	/**
@@ -84,10 +84,10 @@ 
 	 * @throws DBError
 	 * @return bool
 	 */
-	public function insertBatch( array $externalDataBatch ) {
-		$db = wfGetDB( DB_MASTER );
+	public function insertBatch(array $externalDataBatch) {
+		$db = wfGetDB(DB_MASTER);
 		$accumulator = array_map(
-			function ( $externalData ) use ( $db ) {
+			function($externalData) use ($db) {
 				return array(
 					'dump_id' => $externalData[0],
 					'external_id' => $externalData[1],
@@ -100,10 +100,10 @@ 
 
 		try {
 			$db->begin();
-			$result = $db->insert( self::TABLE_NAME, $accumulator );
+			$result = $db->insert(self::TABLE_NAME, $accumulator);
 			$db->commit();
 		}
-		catch( DBError $ex ) {
+		catch (DBError $ex) {
 			$db->rollback();
 			throw $ex;
 		}
@@ -118,21 +118,21 @@ 
 	 * @param int $batchSize
 	 * @throws \DBUnexpectedError
 	 */
-	public function deleteOfDump( $dumpId, $batchSize = 1000 ) {
-		Assert::parameterType( 'string', $dumpId, '$dumpId' );
-		Assert::parameterType( 'integer', $batchSize, 'batchSize' );
+	public function deleteOfDump($dumpId, $batchSize = 1000) {
+		Assert::parameterType('string', $dumpId, '$dumpId');
+		Assert::parameterType('integer', $batchSize, 'batchSize');
 
-		$db = wfGetDB( DB_MASTER );
-		if ( $db->getType() === 'sqlite' ) {
-			$db->delete( self::TABLE_NAME, array( 'dump_id' => $dumpId ) );
+		$db = wfGetDB(DB_MASTER);
+		if ($db->getType() === 'sqlite') {
+			$db->delete(self::TABLE_NAME, array('dump_id' => $dumpId));
 		} else {
 			do {
-				$db->commit( __METHOD__, 'flush' );
+				$db->commit(__METHOD__, 'flush');
 				wfGetLBFactory()->waitForReplication();
-				$table = $db->tableName( self::TABLE_NAME );
-				$condition = 'dump_id = ' . $db->addQuotes( $dumpId );
-				$db->query( sprintf( 'DELETE FROM %s WHERE %s LIMIT %s', $table, $condition, $batchSize ) );
-			} while ( $db->affectedRows() > 0 );
+				$table = $db->tableName(self::TABLE_NAME);
+				$condition = 'dump_id = '.$db->addQuotes($dumpId);
+				$db->query(sprintf('DELETE FROM %s WHERE %s LIMIT %s', $table, $condition, $batchSize));
+			} while ($db->affectedRows() > 0);
 		}
 	}
 

maintenance/UpdateExternalData.php

Spacing +10 added lines, -10 removed lines

@@ -7,10 +7,10 @@ 
 use WikibaseQuality\ExternalValidation\UpdateExternalData\CsvImportSettings;
 use WikibaseQuality\ExternalValidation\UpdateExternalData\ExternalDataImporter;
 
-$basePath = getenv( 'MW_INSTALL_PATH' ) !== false
-	? getenv( 'MW_INSTALL_PATH' )
-	: __DIR__ . '/../../..';
-require_once $basePath . '/maintenance/Maintenance.php';
+$basePath = getenv('MW_INSTALL_PATH') !== false
+	? getenv('MW_INSTALL_PATH')
+	: __DIR__.'/../../..';
+require_once $basePath.'/maintenance/Maintenance.php';
 
 /**
  * Maintenance script that evokes updates of wbqev_external_data, wbqev_dump_information, wbqev_identifier_properties
@@ -25,16 +25,16 @@ 
 	public function __construct() {
 		parent::__construct();
 
-		$this->addDescription( "Imports external entities from given CSV files into the local database. CSV files can be generated using the DumpConverter." );
-		$this->addOption( 'external-values-file', 'CSV file containing external values for import.', true, true );
-		$this->addOption( 'dump-information-file', 'CSV file containing dump meta information for import.', true, true );
-		$this->setBatchSize( 1000 );
+		$this->addDescription("Imports external entities from given CSV files into the local database. CSV files can be generated using the DumpConverter.");
+		$this->addOption('external-values-file', 'CSV file containing external values for import.', true, true);
+		$this->addOption('dump-information-file', 'CSV file containing dump meta information for import.', true, true);
+		$this->setBatchSize(1000);
 	}
 
 	public function execute() {
 		$context = new CsvImportSettings(
-			$this->getOption( 'external-values-file' ),
-			$this->getOption( 'dump-information-file' ),
+			$this->getOption('external-values-file'),
+			$this->getOption('dump-information-file'),
 			$this->mBatchSize,
 			$this->isQuiet()
 		);