Wikibase\Client\DataAccess\Scribunto\CachingFallbackBasedTermLookup

Complexity

Total Complexity

18

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	getLabel()	0	3	1
A	getDescription()	0	3	1
B	getTerm()	0	44	8
A	getLabels()	0	3	1
A	getDescriptions()	0	3	1
A	getLookup()	0	6	2
A	lookupWithoutCache()	0	11	3

<?php

declare( strict_types=1 );
namespace Wikibase\Client\DataAccess\Scribunto;

use Language;
use LogicException;
use MediaWiki\Languages\LanguageFactory;
use MWException;
use Wikibase\DataModel\Entity\EntityId;
use Wikibase\DataModel\Services\Lookup\TermLookup;
use Wikibase\DataModel\Term\TermFallback;
use Wikibase\DataModel\Term\TermTypes;
use Wikibase\Lib\ContentLanguages;
use Wikibase\Lib\FormatterCache\TermFallbackCacheFacade;
use Wikibase\Lib\Store\LanguageFallbackLabelDescriptionLookup;
use Wikibase\Lib\Store\LanguageFallbackLabelDescriptionLookupFactory;
use Wikibase\Lib\Store\RedirectResolvingLatestRevisionLookup;

/**
 * This TermLookup allows exposes language based lookups for getLabel and getDescription
 * and is backed by the shared TermFallbackCache which stores TermFallback objects.
 *
 * The lookup tries to find the term in the cache and if not present builds a
 * LanguageFallbackLabelDescriptionLookup based on the TermFallbackChain generated by the requested Language.
 *
 * If the requested language does not match the actual language of the TermFallback this value
 * will still be written to the cache but not returned.
 *
 * If the TermFallback returns null this value will also be written to the cache as this means no term is available
 * in the requested language.
 *
 * @see TermFallbackCacheFacade
 *
 * @license GPL-2.0-or-later
 */
class CachingFallbackBasedTermLookup implements TermLookup {

	/** @var TermFallbackCacheFacade */
	private $formatterCache;

	/** @var RedirectResolvingLatestRevisionLookup */
	private $redirectResolvingLatestRevisionLookup;

	/** @var LanguageFallbackLabelDescriptionLookupFactory */
	private $lookupFactory;

	/** @var LanguageFactory */
	private $languageFactory;

	/** @var ContentLanguages */
	private $contentLanguages;

	/** @var LanguageFallbackLabelDescriptionLookup[] */
	private $lookups;

	public function __construct(
		TermFallbackCacheFacade $formatterCache,
		RedirectResolvingLatestRevisionLookup $redirectResolvingLatestRevisionLookup,
		LanguageFallbackLabelDescriptionLookupFactory $lookupFactory,
		LanguageFactory $languageFactory,
		ContentLanguages $contentLanguages
	) {
		$this->formatterCache = $formatterCache;
		$this->redirectResolvingLatestRevisionLookup = $redirectResolvingLatestRevisionLookup;
		$this->lookupFactory = $lookupFactory;
		$this->languageFactory = $languageFactory;
		$this->contentLanguages = $contentLanguages;
	}

	public function getLabel( EntityId $entityId, $languageCode ) {
		return $this->getTerm( $entityId, $languageCode, TermTypes::TYPE_LABEL );
	}

	public function getDescription( EntityId $entityId, $languageCode ) {
		return $this->getTerm( $entityId, $languageCode, TermTypes::TYPE_DESCRIPTION );
	}

	private function getTerm( EntityId $entityId, string $languageCode, string $termType ): ?string {
		$resolutionResult = $this->redirectResolvingLatestRevisionLookup->lookupLatestRevisionResolvingRedirect( $entityId );
		if ( $resolutionResult === null ) {
			return null;
		}

		// try getting the requested language first
		// probably less expensive than hitting memcache with an invalid language
		if ( !$this->contentLanguages->hasLanguage( $languageCode ) ) {
			return null;
		}

		try {
			$language = $this->languageFactory->getLanguage( $languageCode );
		} catch ( MWException $e ) {

The class MWException does not exist. Is this class maybe located in a folder that is not analyzed, or in a newer version of your dependencies than listed in your composer.lock/composer.json?

			return null;
		}

		list( $revisionId, $targetEntityId ) = $resolutionResult;

		$termFallback = $this->formatterCache->get( $targetEntityId, $revisionId, $languageCode, $termType );

		// We have already cached the fact that there is no value for this term
		if ( $termFallback === null ) {
			return null;
		}

		if ( $termFallback === TermFallbackCacheFacade::NO_VALUE ) {
			// fetch fresh using a term lookup
			$termFallback = $this->lookupWithoutCache( $targetEntityId, $language, $termType );

			// this can be stored in cache, either the term or null
			$this->formatterCache->set( $termFallback, $targetEntityId, $revisionId, $languageCode, $termType );

			if ( $termFallback === null ) {
				return null;
			}
		}

		if ( $termFallback->getActualLanguageCode() === $languageCode ) {
			return $termFallback->getText();
		}
		return null;
	}

	public function getLabels( EntityId $entityId, array $languageCodes ) {
		throw new LogicException( 'Not implemented' );
	}

	public function getDescriptions( EntityId $entityId, array $languageCodes ) {
		throw new LogicException( 'Not implemented' );
	}

	private function getLookup( Language $language ): LanguageFallbackLabelDescriptionLookup {
		if ( !isset( $this->lookups[ $language->getCode() ] ) ) {
			$this->lookups[ $language->getCode() ] = $this->lookupFactory->newLabelDescriptionLookup( $language );
		}
		return $this->lookups[ $language->getCode() ];
	}

	/**
	 * @param EntityId $entityId
	 * @param Language $language
	 * @param $termType
	 * @return TermFallback|null
	 */
	private function lookupWithoutCache( EntityId $entityId, Language $language, $termType ): ?TermFallback {
		$withoutCacheLookup = $this->getLookup( $language );

		if ( $termType === TermTypes::TYPE_LABEL ) {
			return $withoutCacheLookup->getLabel( $entityId );
		} elseif ( $termType === TermTypes::TYPE_DESCRIPTION ) {
			return $withoutCacheLookup->getDescription( $entityId );
		}

		throw new LogicException( "$termType is not supported." );
	}
}