SMW\DataValues\MonolingualTextValue

Complexity

Total Complexity

42

Size/Duplication

Total Lines	280
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	14

Test Coverage

Coverage

83.64%

Importance

Changes	3
Bugs	0	Features	3

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setFieldProperties()	0	4	1
A	needsLanguageCode()	0	3	1
C	parseUserValue()	0	43	12
A	getValuesFromString()	0	3	1
A	loadDataItem()	0	14	3
A	getShortWikiText()	0	3	1
A	getShortHTMLText()	0	3	1
A	getLongWikiText()	0	3	1
A	getLongHTMLText()	0	3	1
A	getWikiValue()	0	3	1
A	getPropertyDataItems()	0	12	4
A	getDataItems()	0	21	4
B	getTextValueByLanguage()	0	29	6
A	newContainerSemanticData()	0	20	2
A	newLanguageCodeValue()	0	12	2

<?php

namespace SMW\DataValues;

use SMWDataValue as DataValue;
use SMW\DIProperty;
use SMW\Localizer;
use SMW\DIWikiPage;
use SMW\DataValueFactory;
use SMW\ApplicationFactory;
use SMWContainerSemanticData as ContainerSemanticData;
use SMWDIContainer as DIContainer;
use SMWDataItem as DataItem;
use SMW\DataValues\ValueFormatters\DataValueFormatter;

/**
 * MonolingualTextValue requires two components, a language code and a
 * text.
 *
 * A text `foo@en` is expected to be invoked with a BCP47 language
 * code tag and a language dependent text component.
 *
 * Internally, the value is stored as container object that represents
 * the language code and text as separate entities in order to be queried
 * individually.
 *
 * External output representation depends on the context (wiki, html)
 * whether the language code is omitted or not.
 *
 * @license GNU GPL v2+
 * @since 2.4
 *
 * @author mwjames
 */
class MonolingualTextValue extends DataValue {

	/**
	 * @var DIProperty[]|null
	 */
	private static $properties = null;

	/**
	 * @var MonolingualTextValueParser
	 */
	private $monolingualTextValueParser = null;

	/**
	 * @param string $typeid
	 */
	public function __construct( $typeid = '' ) {
		parent::__construct( '_mlt_rec' );
		$this->monolingualTextValueParser = ValueParserFactory::getInstance()->newMonolingualTextValueParser();

It seems like \SMW\DataValues\ValueParserFactory::getInstance()->newMonolingualTextValueParser() of type object<SMW\DataValues\ValueParsers\MonolingualTextValueParser> is incompatible with the declared type object<SMW\DataValues\MonolingualTextValueParser> of property $monolingualTextValueParser.

	}

	/**
	 * @see RecordValue::setFieldProperties
	 *
	 * @param SMWDIProperty[] $properties
	 */
	public function setFieldProperties( array $properties ) {

The parameter $properties is not used and could be removed.

		// Keep the interface, but the properties for this type
		// are fixed.
	}

	/**
	 * @since 2.4
	 *
	 * @return integer
	 */
	public function needsLanguageCode() {
		return ( $this->getOptionValueFor( 'smwgDVFeatures' ) & SMW_DV_MLTV_LCODE ) != 0;
	}

	/**
	 * @see DataValue::parseUserValue
	 * @note called by DataValue::setUserValue
	 *
	 * @param string $value

There is no parameter named $value. Was it maybe removed?

	 */
	protected function parseUserValue( $userValue ) {

		list( $text, $languageCode ) = $this->getValuesFromString( $userValue );

		$languageCodeValue = $this->newLanguageCodeValue( $languageCode );

		if (
			( $languageCode !== '' && $languageCodeValue->getErrors() !== array() ) ||
			( $languageCode === '' && $this->needsLanguageCode() ) ) {
			$this->addError( $languageCodeValue->getErrors() );
			return;
		}

		$dataValues = array();

		foreach ( $this->getPropertyDataItems() as $property ) {

The expression $this->getPropertyDataItems() of type array<integer,object<SMW\DIProperty>>|null is not guaranteed to be traversable. How about adding an additional type check?

			if (
				( $languageCode === '' && $property->getKey() === '_LCODE' ) ||
				( $text === '' && $property->getKey() === '_TEXT' ) ) {
				continue;
			}

			$dataValue = DataValueFactory::getInstance()->newPropertyObjectValue(
				$property,
				$property->getKey() === '_LCODE' ? $languageCode : $text,
				false,
				$this->m_contextPage
			);

			$dataValues[] = $dataValue;
		}

		// Generate a hash from the normalized representation so that foo@en being
		// the same as foo@EN independent of a user input
		$containerSemanticData = $this->newContainerSemanticData( $text . '@' . $languageCode );

		foreach ( $dataValues as $dataValue ) {
			$containerSemanticData->addDataValue( $dataValue );
		}

		$this->m_dataitem = new DIContainer( $containerSemanticData );
	}

	/**
	 * @note called by MonolingualTextValueDescriptionDeserializer::deserialize
	 * and MonolingualTextValue::parseUserValue
	 *
	 * No explicit check is made on the validity of a language code and is
	 * expected to be done before calling this method.
	 *
	 * @since 2.4
	 *
	 * @param string $userValue
	 *
	 * @return array
	 */
	public function getValuesFromString( $userValue ) {
		return $this->monolingualTextValueParser->parse( $userValue );
	}

	/**
	 * @see DataValue::loadDataItem
	 *
	 * @param DataItem $dataItem
	 *
	 * @return boolean
	 */
	protected function loadDataItem( DataItem $dataItem ) {

		if ( $dataItem->getDIType() === DataItem::TYPE_CONTAINER ) {
			$this->m_dataitem = $dataItem;
			return true;
		} elseif ( $dataItem->getDIType() === DataItem::TYPE_WIKIPAGE ) {
			$semanticData = new ContainerSemanticData( $dataItem );

$dataItem of type object<SMWDataItem> is not a sub-type of object<SMW\DIWikiPage>. It seems like you assume a child class of the class SMWDataItem to be always present.

			$semanticData->copyDataFrom( ApplicationFactory::getInstance()->getStore()->getSemanticData( $dataItem ) );

$dataItem of type object<SMWDataItem> is not a sub-type of object<SMW\DIWikiPage>. It seems like you assume a child class of the class SMWDataItem to be always present.

			$this->m_dataitem = new DIContainer( $semanticData );
			return true;
		}

		return false;
	}

	/**
	 * @see DataValue::getShortWikiText
	 */
	public function getShortWikiText( $linker = null ) {
		return $this->getDataValueFormatter()->format( DataValueFormatter::WIKI_SHORT, $linker );
	}

	/**
	 * @see DataValue::getShortHTMLText
	 */
	public function getShortHTMLText( $linker = null ) {
		return $this->getDataValueFormatter()->format( DataValueFormatter::HTML_SHORT, $linker );
	}

	/**
	 * @see DataValue::getLongWikiText
	 */
	public function getLongWikiText( $linker = null ) {
		return $this->getDataValueFormatter()->format( DataValueFormatter::WIKI_LONG, $linker );
	}

	/**
	 * @see DataValue::getLongHTMLText
	 */
	public function getLongHTMLText( $linker = null ) {
		return $this->getDataValueFormatter()->format( DataValueFormatter::HTML_LONG, $linker );
	}

	/**
	 * @see DataValue::getWikiValue
	 */
	public function getWikiValue() {
		return $this->getDataValueFormatter()->format( DataValueFormatter::VALUE );
	}

	/**
	 * @since 2.4
	 * @note called by SMWResultArray::getNextDataValue
	 *
	 * @return DIProperty[]
	 */
	public static function getPropertyDataItems() {

		if ( self::$properties !== null && self::$properties !== array() ) {
			return self::$properties;
		}

		foreach ( array( '_TEXT', '_LCODE' ) as  $id ) {
			self::$properties[] = new DIProperty( $id );
		}

		return self::$properties;
	}

	/**
	 * @since 2.4
	 * @note called by SMWResultArray::loadContent
	 *
	 * @return DataItem[]
	 */
	public function getDataItems() {

		if ( !$this->isValid() ) {
			return array();
		}

		$result = array();
		$index = 0;

		foreach ( $this->getPropertyDataItems() as $diProperty ) {

The expression $this->getPropertyDataItems() of type array<integer,object<SMW\DIProperty>>|null is not guaranteed to be traversable. How about adding an additional type check?

			$values = $this->getDataItem()->getSemanticData()->getPropertyValues( $diProperty );

It seems like you code against a specific sub-type and not the parent class SMWDataItem as the method getSemanticData() does only exist in the following sub-classes of SMWDataItem: SMWDIContainer. Maybe you want to instanceof check for one of these explicitly?

			if ( count( $values ) > 0 ) {
				$result[$index] = reset( $values );
			} else {
				$result[$index] = null;
			}
			$index += 1;
		}

		return $result;
	}

	/**
	 * @since 2.4
	 *
	 * @return DataValue|null
	 */
	public function getTextValueByLanguage( $languageCode ) {

		if ( !$this->isValid() || $this->getDataItem() === array() ) {
			return null;
		}

		$semanticData = $this->getDataItem()->getSemanticData();

It seems like you code against a specific sub-type and not the parent class SMWDataItem as the method getSemanticData() does only exist in the following sub-classes of SMWDataItem: SMWDIContainer. Maybe you want to instanceof check for one of these explicitly?

		$dataItems = $semanticData->getPropertyValues( new DIProperty( '_LCODE' ) );
		$dataItem = reset( $dataItems );

		if ( $dataItem === false || ( $dataItem->getString() !== Localizer::asBCP47FormattedLanguageCode( $languageCode ) ) ) {
			return null;
		}

		$dataItems = $semanticData->getPropertyValues( new DIProperty( '_TEXT' ) );
		$dataItem = reset( $dataItems );

		if ( $dataItem === false ) {
			return null;
		}

		$dataValue = DataValueFactory::getInstance()->newDataItemValue(
			$dataItem,
			new DIProperty( '_TEXT' )
		);

		return $dataValue;
	}

	private function newContainerSemanticData( $value ) {

		if ( $this->m_contextPage === null ) {
			$containerSemanticData = ContainerSemanticData::makeAnonymousContainer();
			$containerSemanticData->skipAnonymousCheck();
		} else {
			$subobjectName = '_ML' . md5( $value );

			$subject = new DIWikiPage(
				$this->m_contextPage->getDBkey(),
				$this->m_contextPage->getNamespace(),
				$this->m_contextPage->getInterwiki(),
				$subobjectName
			);

			$containerSemanticData = new ContainerSemanticData( $subject );
		}

		return $containerSemanticData;
	}

	private function newLanguageCodeValue( $languageCode ) {

		$languageCodeValue = new LanguageCodeValue();

		if ( $this->m_property !== null ) {
			$languageCodeValue->setProperty( $this->m_property );
		}

		$languageCodeValue->setUserValue( $languageCode );

		return $languageCodeValue;
	}

}