WikibaseQuality\ConstraintReport\ConstraintCheck\Message\ViolationMessageDeserializer

Complexity

Total Complexity

25

Size/Duplication

Total Lines	202
Duplicated Lines	19.8 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	unabbreviateViolationMessageKey()	0	3	1
A	deserialize()	0	13	2
A	deserializeArgument()	8	32	2
A	deserializeStringByIdentity()	0	3	1
A	deserializeEntityId()	0	3	1
A	deserializeEntityIdList()	0	3	1
A	deserializeItemIdSnakValue()	0	10	3
A	deserializeItemIdSnakValueList()	0	3	1
A	deserializeDataValue()	0	3	1
A	deserializeConstraintScope()	16	16	4
A	deserializeConstraintScopeList()	0	3	1
A	deserializePropertyScope()	16	16	4
A	deserializePropertyScopeList()	0	3	1
A	deserializeMultilingualText()	0	3	1

<?php

namespace WikibaseQuality\ConstraintReport\ConstraintCheck\Message;

use DataValues\DataValue;
use DataValues\DataValueFactory;
use DataValues\MultilingualTextValue;
use Deserializers\Deserializer;
use InvalidArgumentException;
use LogicException;
use Wikibase\DataModel\Entity\EntityId;
use Wikibase\DataModel\Entity\EntityIdParser;
use WikibaseQuality\ConstraintReport\ConstraintCheck\Context\Context;
use WikibaseQuality\ConstraintReport\ConstraintCheck\ItemIdSnakValue;
use Wikimedia\Assert\Assert;

/**
 * A deserializer for {@link ViolationMessage}s.
 *
 * @license GPL-2.0-or-later
 */
class ViolationMessageDeserializer implements Deserializer {

	/**
	 * @var EntityIdParser
	 */
	private $entityIdParser;

	/**
	 * @var DataValueFactory
	 */
	private $dataValueFactory;

	public function __construct(
		EntityIdParser $entityIdParser,
		DataValueFactory $dataValueFactory
	) {
		$this->entityIdParser = $entityIdParser;
		$this->dataValueFactory = $dataValueFactory;
	}

	public function unabbreviateViolationMessageKey( $messageKeySuffix ) {
		return ViolationMessage::MESSAGE_KEY_PREFIX . $messageKeySuffix;
	}

	/**
	 * @param array $serialization
	 * @return ViolationMessage
	 */
	public function deserialize( $serialization ) {
		Assert::parameterType( 'array', $serialization, '$serialization' );

		$message = new ViolationMessage(
			$this->unabbreviateViolationMessageKey( $serialization['k'] )
		);

		foreach ( $serialization['a'] as $serializedArgument ) {
			$message = $this->deserializeArgument( $message, $serializedArgument );
		}

		return $message;
	}

	/**
	 * @param ViolationMessage $message
	 * @param array $serializedArgument [ 't' => ViolationMessage::TYPE_*, 'v' => serialized value, 'r' => $role ]
	 * @return ViolationMessage $message with the deserialized argument appended
	 */
	private function deserializeArgument( ViolationMessage $message, array $serializedArgument ) {
		$methods = [
			ViolationMessage::TYPE_ENTITY_ID => 'deserializeEntityId',
			ViolationMessage::TYPE_ENTITY_ID_LIST => 'deserializeEntityIdList',
			ViolationMessage::TYPE_ITEM_ID_SNAK_VALUE => 'deserializeItemIdSnakValue',
			ViolationMessage::TYPE_ITEM_ID_SNAK_VALUE_LIST => 'deserializeItemIdSnakValueList',
			ViolationMessage::TYPE_DATA_VALUE => 'deserializeDataValue',
			ViolationMessage::TYPE_DATA_VALUE_TYPE => 'deserializeStringByIdentity',
			ViolationMessage::TYPE_INLINE_CODE => 'deserializeStringByIdentity',
			ViolationMessage::TYPE_CONSTRAINT_SCOPE => 'deserializeConstraintScope',
			ViolationMessage::TYPE_CONSTRAINT_SCOPE_LIST => 'deserializeConstraintScopeList',
			ViolationMessage::TYPE_PROPERTY_SCOPE => 'deserializePropertyScope',
			ViolationMessage::TYPE_PROPERTY_SCOPE_LIST => 'deserializePropertyScopeList',
			ViolationMessage::TYPE_LANGUAGE => 'deserializeStringByIdentity',
			ViolationMessage::TYPE_MULTILINGUAL_TEXT => 'deserializeMultilingualText',
		];

		$type = $serializedArgument['t'];
		$serializedValue = $serializedArgument['v'];
		$role = $serializedArgument['r'];

		if ( array_key_exists( $type, $methods ) ) {

This code seems to be duplicated across your project.

			$method = $methods[$type];
			$value = $this->$method( $serializedValue );
		} else {
			throw new InvalidArgumentException(
				'Unknown ViolationMessage argument type ' . $type . '!'
			);
		}

		return $message->withArgument( $type, $role, $value );
	}

	/**
	 * @param string $string any value that shall simply be deserialized into itself
	 * @return string that same value, unchanged
	 */
	private function deserializeStringByIdentity( $string ) {
		return $string;
	}

	/**
	 * @param string $entityIdSerialization entity ID serialization
	 * @return EntityId
	 */
	private function deserializeEntityId( $entityIdSerialization ) {
		return $this->entityIdParser->parse( $entityIdSerialization );
	}

	/**
	 * @param string[] $entityIdSerializations entity ID serializations
	 * @return EntityId[]
	 */
	private function deserializeEntityIdList( array $entityIdSerializations ) {
		return array_map( [ $this, 'deserializeEntityId' ], $entityIdSerializations );
	}

	/**
	 * @param string $valueSerialization entity ID serialization, '::somevalue' or '::novalue'
	 * @return ItemIdSnakValue
	 */
	private function deserializeItemIdSnakValue( $valueSerialization ) {
		switch ( $valueSerialization ) {
			case '::somevalue':
				return ItemIdSnakValue::someValue();
			case '::novalue':
				return ItemIdSnakValue::noValue();
			default:
				return ItemIdSnakValue::fromItemId( $this->deserializeEntityId( $valueSerialization ) );

$this->deserializeEntityId($valueSerialization) of type object<Wikibase\DataModel\Entity\EntityId> is not a sub-type of object<Wikibase\DataModel\Entity\ItemId>. It seems like you assume a child class of the class Wikibase\DataModel\Entity\EntityId to be always present.

		}
	}

	/**
	 * @param string[] $valueSerializations entity ID serializations, '::somevalue's or '::novalue's
	 * @return ItemIdSnakValue[]
	 */
	private function deserializeItemIdSnakValueList( $valueSerializations ) {
		return array_map( [ $this, 'deserializeItemIdSnakValue' ], $valueSerializations );
	}

	/**
	 * @param array $dataValueSerialization the data value in array form
	 * @return DataValue
	 */
	private function deserializeDataValue( array $dataValueSerialization ) {
		return $this->dataValueFactory->newFromArray( $dataValueSerialization );
	}

	/**
	 * @param string $scopeAbbreviation
	 * @return string one of the Context::TYPE_* constants
	 */
	private function deserializeConstraintScope( $scopeAbbreviation ) {

This method seems to be duplicated in your project.

		switch ( $scopeAbbreviation ) {
			case 's':
				return Context::TYPE_STATEMENT;
			case 'q':
				return Context::TYPE_QUALIFIER;
			case 'r':
				return Context::TYPE_REFERENCE;
			default:
				// @codeCoverageIgnoreStart
				throw new LogicException(
					'Unknown constraint scope abbreviation ' . $scopeAbbreviation
				);
				// @codeCoverageIgnoreEnd
		}
	}

	/**
	 * @param string[] $scopeAbbreviations
	 * @return string[] Context::TYPE_* constants
	 */
	private function deserializeConstraintScopeList( array $scopeAbbreviations ) {
		return array_map( [ $this, 'deserializeConstraintScope' ], $scopeAbbreviations );
	}

	/**
	 * @param string $scopeAbbreviation
	 * @return string one of the Context::TYPE_* constants
	 */
	private function deserializePropertyScope( $scopeAbbreviation ) {

This method seems to be duplicated in your project.

		switch ( $scopeAbbreviation ) {
			case 's':
				return Context::TYPE_STATEMENT;
			case 'q':
				return Context::TYPE_QUALIFIER;
			case 'r':
				return Context::TYPE_REFERENCE;
			default:
				// @codeCoverageIgnoreStart
				throw new LogicException(
					'Unknown property scope abbreviation ' . $scopeAbbreviation
				);
				// @codeCoverageIgnoreEnd
		}
	}

	/**
	 * @param string[] $scopeAbbreviations
	 * @return string[] Context::TYPE_* constants
	 */
	private function deserializePropertyScopeList( array $scopeAbbreviations ) {
		return array_map( [ $this, 'deserializePropertyScope' ], $scopeAbbreviations );
	}

	/**
	 * @param mixed $textSerialization {@see MultilingualTextValue::getArrayValue}
	 * @return MultilingualTextValue
	 */
	private function deserializeMultilingualText( $textSerialization ) {
		return MultilingualTextValue::newFromArray( $textSerialization );
	}

}