Wikibase\InternalSerialization\Deserializers\LegacySiteLinkListDeserializer

Complexity

Total Complexity

21

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	deserialize()	0	5	1
A	assertStructureIsValid()	0	10	3
A	assertKeyIsValid()	0	5	2
A	assertElementIsValid()	0	9	4
A	assertElementIsValidArray()	0	9	3
A	getDeserialized()	0	9	2
A	newSiteLinkFromSerialization()	0	7	2
A	tryNewSiteLinkFromSerialization()	0	11	2
A	getDeserializedBadges()	0	9	2

<?php

namespace Wikibase\InternalSerialization\Deserializers;

use Deserializers\Deserializer;
use Deserializers\Exceptions\DeserializationException;
use Deserializers\Exceptions\MissingAttributeException;
use InvalidArgumentException;
use Wikibase\DataModel\Entity\ItemId;
use Wikibase\DataModel\SiteLink;
use Wikibase\DataModel\SiteLinkList;

/**
 * @license GPL-2.0-or-later
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
class LegacySiteLinkListDeserializer implements Deserializer {

	/**
	 * @param array $serialization
	 *
	 * @return SiteLink[]
	 * @throws DeserializationException
	 */
	public function deserialize( $serialization ) {
		$this->assertStructureIsValid( $serialization );

		return $this->getDeserialized( $serialization );
	}

	private function assertStructureIsValid( $serialization ) {
		if ( !is_array( $serialization ) ) {
			throw new DeserializationException( 'SiteLink list serializations should be arrays' );
		}

		foreach ( $serialization as $key => $arrayElement ) {
			$this->assertKeyIsValid( $key );
			$this->assertElementIsValid( $arrayElement );
		}
	}

	private function assertKeyIsValid( $key ) {
		if ( !is_string( $key ) ) {
			throw new DeserializationException( 'All array keys should be strings' );
		}
	}

	private function assertElementIsValid( $arrayElement ) {
		if ( !is_string( $arrayElement ) && !is_array( $arrayElement ) ) {
			throw new DeserializationException( 'All array elements should be of type string or array' );
		}

		if ( is_array( $arrayElement ) ) {
			$this->assertElementIsValidArray( $arrayElement );
		}
	}

	private function assertElementIsValidArray( array $arrayElement ) {
		if ( !array_key_exists( 'name', $arrayElement ) ) {
			throw new MissingAttributeException( 'name' );
		}

		if ( !array_key_exists( 'badges', $arrayElement ) ) {
			throw new MissingAttributeException( 'badges' );
		}
	}

	/**
	 * @param array $siteLinkArray
	 *
	 * @return SiteLinkList
	 */
	private function getDeserialized( array $siteLinkArray ) {
		$siteLinks = array();

		foreach ( $siteLinkArray as $siteId => $siteLinkData ) {
			$siteLinks[] = $this->newSiteLinkFromSerialization( $siteId, $siteLinkData );
		}

		return new SiteLinkList( $siteLinks );
	}

	/**
	 * @param string $siteId
	 * @param string|array $siteLinkData
	 *
	 * @throws DeserializationException
	 * @return SiteLink
	 */
	private function newSiteLinkFromSerialization( $siteId, $siteLinkData ) {
		try {
			return $this->tryNewSiteLinkFromSerialization( $siteId, $siteLinkData );
		} catch ( InvalidArgumentException $ex ) {
			throw new DeserializationException( $ex->getMessage(), $ex );
		}
	}

	/**
	 * @param string $siteId
	 * @param string|array $siteLinkData
	 *
	 * @return SiteLink
	 */
	private function tryNewSiteLinkFromSerialization( $siteId, $siteLinkData ) {
		if ( is_array( $siteLinkData ) ) {
			$pageName = $siteLinkData['name'];
			$badges = $this->getDeserializedBadges( $siteLinkData['badges'] );
		} else {
			$pageName = $siteLinkData;
			$badges = array();
		}

		return new SiteLink( $siteId, $pageName, $badges );
	}

	/**
	 * @param string[] $badgesSerialization
	 *
	 * @return ItemId[]
	 */
	private function getDeserializedBadges( array $badgesSerialization ) {
		$badges = array();

		foreach ( $badgesSerialization as $badgeSerialization ) {
			$badges[] = new ItemId( $badgeSerialization );
		}

		return $badges;
	}

}