Deserializers\TypedObjectDeserializer

Complexity

Total Complexity

14

Size/Duplication

Total Lines	68
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

34.38%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	assertCanDeserialize()	0	9	3
A	isDeserializerFor()	0	3	2
A	hasCorrectObjectType()	0	3	1
A	hasObjectType()	0	4	2
A	requireAttribute()	0	7	2
A	assertAttributeIsArray()	0	3	1
A	assertAttributeInternalType()	0	9	2

<?php

namespace Deserializers;

use Deserializers\Exceptions\InvalidAttributeException;
use Deserializers\Exceptions\MissingAttributeException;
use Deserializers\Exceptions\MissingTypeException;
use Deserializers\Exceptions\UnsupportedTypeException;

/**
 * @since 1.0
 *
 * @license GPL-2.0+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
abstract class TypedObjectDeserializer implements DispatchableDeserializer {

	/**
	 * @var string
	 */
	private $objectType;

	/**
	 * @var string
	 */
	private $typeKey;

	/**
	 * @param string $objectType
	 * @param string $typeKey
	 */
	public function __construct( $objectType, $typeKey = 'objectType' ) {
		$this->objectType = $objectType;
		$this->typeKey = $typeKey;

	}

	protected function assertCanDeserialize( $serialization ) {
		if ( !$this->hasObjectType( $serialization ) ) {
			throw new MissingTypeException();
		}

		if ( !$this->hasCorrectObjectType( $serialization ) ) {
			throw new UnsupportedTypeException( $serialization[$this->typeKey] );
		}
	}

	public function isDeserializerFor( $serialization ) {
		return $this->hasObjectType( $serialization ) && $this->hasCorrectObjectType( $serialization );
	}

	private function hasCorrectObjectType( $serialization ) {
		return $serialization[$this->typeKey] === $this->objectType;
	}

	private function hasObjectType( $serialization ) {
		return is_array( $serialization )
			&& array_key_exists( $this->typeKey, $serialization );
	}

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

	protected function assertAttributeIsArray( array $array, $attributeName ) {
		$this->assertAttributeInternalType( $array, $attributeName, 'array' );
	}

	protected function assertAttributeInternalType( array $array, $attributeName, $internalType ) {
		if ( gettype( $array[$attributeName] ) !== $internalType ) {
			throw new InvalidAttributeException(
				$attributeName,
				$array[$attributeName],
				"The internal type of attribute '$attributeName'  needs to be '$internalType'"
			);
		}
	}

}