Wikibase\DataModel\Deserializers\SnakDeserializer

Complexity

Total Complexity

26

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

100%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	assertCanDeserialize()	0	13	4
A	requireAttribute()	0	7	2
A	__construct()	0	3	1
A	isDeserializerFor()	0	5	3
A	hasSnakType()	0	3	1
A	hasCorrectSnakType()	0	3	1
A	deserialize()	0	6	1
A	getDeserialized()	0	10	3
A	newNoValueSnak()	0	3	1
A	newSomeValueSnak()	0	3	1
A	newValueSnak()	0	8	1
B	deserializeDataValue()	0	15	5
A	deserializePropertyId()	0	11	2

<?php

namespace Wikibase\DataModel\Deserializers;

use DataValues\DataValue;
use DataValues\Deserializers\DataValueDeserializer;
use DataValues\UnDeserializableValue;
use Deserializers\Deserializer;
use Deserializers\DispatchableDeserializer;
use Deserializers\Exceptions\DeserializationException;
use Deserializers\Exceptions\InvalidAttributeException;
use Deserializers\Exceptions\MissingAttributeException;
use Deserializers\Exceptions\MissingTypeException;
use Deserializers\Exceptions\UnsupportedTypeException;
use InvalidArgumentException;
use Wikibase\DataModel\Entity\PropertyId;
use Wikibase\DataModel\Snak\PropertyNoValueSnak;
use Wikibase\DataModel\Snak\PropertySomeValueSnak;
use Wikibase\DataModel\Snak\PropertyValueSnak;

/**
 * Package private
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 * @author Thomas Pellissier Tanon
 */
class SnakDeserializer implements DispatchableDeserializer {

	/**
	 * @var Deserializer
	 */
	private $dataValueDeserializer;

	public function __construct( Deserializer $dataValueDeserializer ) {
		$this->dataValueDeserializer = $dataValueDeserializer;
	}

	/**
	 * @see Deserializer::isDeserializerFor
	 *
	 * @param mixed $serialization
	 *
	 * @return bool
	 */
	public function isDeserializerFor( $serialization ) {
		return is_array( $serialization )
			&& $this->hasSnakType( $serialization )
			&& $this->hasCorrectSnakType( $serialization );
	}

	private function hasSnakType( $serialization ) {
		return array_key_exists( 'snaktype', $serialization );
	}

	private function hasCorrectSnakType( $serialization ) {
		return in_array( $serialization['snaktype'], [ 'novalue', 'somevalue', 'value' ] );
	}

	/**
	 * @see Deserializer::deserialize
	 *
	 * @param array $serialization
	 *
	 * @throws DeserializationException
	 * @return PropertyNoValueSnak|PropertySomeValueSnak|PropertyValueSnak
	 */
	public function deserialize( $serialization ) {
		$this->assertCanDeserialize( $serialization );
		$this->requireAttribute( $serialization, 'property' );

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

	/**
	 * @see SnakDeserializer::hasCorrectSnakType
	 *
	 * @param array $serialization
	 *
	 * @throws InvalidAttributeException
	 * @return PropertyNoValueSnak|PropertySomeValueSnak|PropertyValueSnak
	 */
	private function getDeserialized( array $serialization ) {
		switch ( $serialization['snaktype'] ) {
			case 'novalue':
				return $this->newNoValueSnak( $serialization );
			case 'somevalue':
				return $this->newSomeValueSnak( $serialization );
			default:
				return $this->newValueSnak( $serialization );
		}
	}

	private function newNoValueSnak( array $serialization ) {
		return new PropertyNoValueSnak( $this->deserializePropertyId( $serialization['property'] ) );
	}

	private function newSomeValueSnak( array $serialization ) {
		return new PropertySomeValueSnak( $this->deserializePropertyId( $serialization['property'] ) );
	}

	private function newValueSnak( array $serialization ) {
		$this->requireAttribute( $serialization, 'datavalue' );

		return new PropertyValueSnak(
			$this->deserializePropertyId( $serialization['property'] ),
			$this->deserializeDataValue( $serialization['datavalue'] )
		);
	}

	/**
	 * @param array $serialization
	 *
	 * @return DataValue
	 */
	private function deserializeDataValue( $serialization ) {
		try {
			return $this->dataValueDeserializer->deserialize( $serialization );
		} catch ( DeserializationException $ex ) {
			$value = isset( $serialization[DataValueDeserializer::VALUE_KEY] )
				? $serialization[DataValueDeserializer::VALUE_KEY]
				: null;
			$type = isset( $serialization[DataValueDeserializer::TYPE_KEY] )
				? $serialization[DataValueDeserializer::TYPE_KEY]
				: null;
			$error = isset( $serialization['error'] ) ? $serialization['error'] : $ex->getMessage();

			return new UnDeserializableValue( $value, $type, $error );
		}
	}

	/**
	 * @param string $serialization
	 *
	 * @throws InvalidAttributeException
	 * @return PropertyId
	 */
	private function deserializePropertyId( $serialization ) {
		try {
			return new PropertyId( $serialization );
		} catch ( InvalidArgumentException $ex ) {
			throw new InvalidAttributeException(
				'property',
				$serialization,
				"'$serialization' is not a valid property ID"
			);
		}
	}

	private function assertCanDeserialize( $serialization ) {
		if ( !is_array( $serialization ) ) {
			throw new DeserializationException( 'The snak serialization should be an array' );
		}

		if ( !$this->hasSnakType( $serialization ) ) {
			throw new MissingTypeException();
		}

		if ( !$this->hasCorrectSnakType( $serialization ) ) {
			throw new UnsupportedTypeException( $serialization['snaktype'] );
		}
	}

	private function requireAttribute( array $array, $attributeName ) {
		if ( !array_key_exists( $attributeName, $array ) ) {
			throw new MissingAttributeException(
				$attributeName
			);
		}
	}

}