SG\Cache\CacheInvalidator

Complexity

Total Complexity

20

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

92.73%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	clear()	0	3	1
A	setCache()	0	3	1
A	invalidateCacheOnPageMove()	0	4	1
A	hasSemanticDataDeviation()	0	9	4
A	getInstance()	0	12	2
A	invalidateCacheOnStoreUpdate()	0	11	2
A	invalidateCacheOnPageDelete()	0	11	2
A	matchAllSubobjects()	0	14	3
A	matchSubobjectsToSubject()	0	14	3
A	purgeCache()	0	8	1

<?php

namespace SG\Cache;

use SG\SemanticDataComparator;
use SG\PropertyRegistry;

use SMW\Store;
use SMW\SemanticData;
use SMW\DIWikiPage;
use SMW\DIProperty;

use Lingo\LingoParser;

use Title;

/**
 * @ingroup SG
 * @ingroup SemanticGlossary
 *
 * @license GNU GPL v2+
 * @since 1.0
 *
 * @author Stephan Gambke
 * @author mwjames
 */
class CacheInvalidator {

	/**
	 * @var CacheInvalidator
	 */
	private static $instance = null;

	/**
	 * @var GlossaryCache
	 */
	private $cache = null;

The property $cache is not used and could be removed.

	/**
	 * @since 1.0
	 *
	 * @return CacheInvalidator
	 */
	public static function getInstance() {

		if ( self::$instance === null ) {

			$instance = new self();
			$instance->setCache( new GlossaryCache() );

			self::$instance = $instance;
		}

		return self::$instance;
	}

	/**
	 * @since 1.0
	 */
	public static function clear() {
		self::$instance = null;
	}

	/**
	 * @since 1.0
	 *
	 * @param GlossaryCache $glossaryCache
	 */
	public function setCache( GlossaryCache $glossaryCache ) {
		$this->glossaryCache = $glossaryCache;

The property glossaryCache does not exist. Did you maybe forget to declare it?

	}

	/**
	 * @since 1.0
	 *
	 * @param Store $store
	 * @param SemanticData $semanticData
	 *
	 * @return boolean
	 */
	public function invalidateCacheOnStoreUpdate( Store $store, SemanticData $semanticData ) {

		$this->matchAllSubobjects( $store, $semanticData );

		if ( $this->hasSemanticDataDeviation( $store, $semanticData ) ) {
			$this->purgeCache( $semanticData->getSubject() );
			LingoParser::purgeCache();

The method Lingo\LingoParser::purgeCache() has been deprecated with message: 2.0.2

		}

		return true;
	}

	/**
	 * @since 1.0
	 *
	 * @param Store $store
	 * @param DIWikiPage $subject
	 * @param boolean|true $purgeLingo
	 *
	 * @return boolean
	 */
	public function invalidateCacheOnPageDelete( Store $store, DIWikiPage $subject, $purgeLingo = true ) {

		$this->matchSubobjectsToSubject( $store, $subject );
		$this->purgeCache( $subject );

		if ( $purgeLingo ) {
			LingoParser::purgeCache();

The method Lingo\LingoParser::purgeCache() has been deprecated with message: 2.0.2

		}

		return true;
	}

	/**
	 * @since 1.0
	 *
	 * @param Title $title
	 *
	 * @return boolean
	 */
	public function invalidateCacheOnPageMove( Title $title ) {
		$this->purgeCache( DIWikiPage::newFromTitle( $title ) );
		return true;
	}

	private function matchAllSubobjects( Store $store, SemanticData $semanticData ) {

		$properties = $semanticData->getProperties();

		if ( array_key_exists( DIProperty::TYPE_SUBOBJECT, $properties ) ) {
			foreach ( $semanticData->getPropertyValues( $properties[ DIProperty::TYPE_SUBOBJECT ] ) as $subobject ) {
				$this->invalidateCacheOnStoreUpdate(
					$store,
					$semanticData->findSubSemanticData( $subobject->getSubobjectName() ),

It seems like $semanticData->findSubSemanticData($subobject->getSubobjectName()) can be null; however, invalidateCacheOnStoreUpdate() does not accept null, maybe add an additional type check?

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

					false

The call to CacheInvalidator::invalidateCacheOnStoreUpdate() has too many arguments starting with false.

				);
			}
		}
	}

	private function matchSubobjectsToSubject( Store $store, DIWikiPage $subject ) {

		$properties = $store->getProperties( $subject );

		if ( array_key_exists( DIProperty::TYPE_SUBOBJECT, $properties ) ) {
			foreach ( $store->getPropertyValues( $subject, $properties[ DIProperty::TYPE_SUBOBJECT ] ) as $subobject ) {
				$this->invalidateCacheOnPageDelete(
					$store,
					$subobject->getSubject(),
					false
				);
			}
		}
	}

	private function hasSemanticDataDeviation( Store $store, SemanticData $semanticData ) {

		$dataComparator = new SemanticDataComparator( $store, $semanticData );

		return $dataComparator->compareForProperty( PropertyRegistry::SG_TERM ) ||
			$dataComparator->compareForProperty( PropertyRegistry::SG_DEFINITION ) ||
			$dataComparator->compareForProperty( PropertyRegistry::SG_LINK ) ||
			$dataComparator->compareForProperty( PropertyRegistry::SG_STYLE );
	}

	private function purgeCache( DIWikiPage $subject ) {

		$this->glossaryCache->getCache()->delete(
			$this->glossaryCache->getKeyForSubject( $subject )
		);

		return true;
	}

}