ApplicationFactory::getLoadBalancer() - Code Metrics - Inspection of "SMWSearch: Fix unit test; Move access to MediaWiki..." - SemanticMediaWiki/SemanticMediaWiki - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b79151...a6cb7c )

by mw

created 2016-10-23 02:49 UTC

ApplicationFactory::getLoadBalancer() A

↳ Parent: ApplicationFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

namespace SMW;

use Closure;
use Onoi\CallbackContainer\CallbackLoader;
use Onoi\CallbackContainer\DeferredCallbackLoader;
use Parser;
use ParserOutput;
use SMW\Factbox\FactboxFactory;
use SMW\Maintenance\MaintenanceFactory;
use SMW\MediaWiki\Jobs\JobFactory;
use SMW\MediaWiki\MwCollaboratorFactory;
use SMW\MediaWiki\PageCreator;
use SMW\MediaWiki\TitleCreator;
use SMW\Query\ProfileAnnotator\QueryProfileAnnotatorFactory;
use SMWQueryParser as QueryParser;
use Title;

/**
 * Application instances access for internal and external use
 *
 * @license GNU GPL v2+
 * @since 2.0
 *
 * @author mwjames
 */
class ApplicationFactory {

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

	/**
	 * @var CallbackLoader
	 */
	private $callbackLoader = null;

	/**
	 * @since 2.0
	 */
	public function __construct( CallbackLoader $callbackLoader = null ) {
		$this->callbackLoader = $callbackLoader;
	}

	/**
	 * This method returns the global instance of the application factory.
	 *
	 * Reliance on global state is needed at entry points into SMW such as
	 * hook handlers, special pages and jobs, since there we tend to not
	 * have control over the object lifecycle. Pragmatically we might also
	 * want to use this when refactoring legacy code that already has the
	 * global state dependency. For new code very special justification is
	 * required to rely on global state.
	 *
	 * @since 2.0
	 *
	 * @return self
	 */
	public static function getInstance() {

		if ( self::$instance === null ) {
			self::$instance = new self( self::registerBuilder() );
		}

		return self::$instance;
	}

	/**
	 * @since 2.0
	 */
	public static function clear() {

		if ( self::$instance !== null ) {
			self::$instance->getSettings()->clear();
		}

		self::$instance = null;
	}

	/**
	 * @since 2.0
	 *
	 * @param string $objectName
	 * @param callable|array $objectSignature
	 */
	public function registerObject( $objectName, $objectSignature ) {
		$this->callbackLoader->registerObject( $objectName, $objectSignature );
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
	}

	/**
	 * @private
	 *
	 * @since 2.4
	 *
	 * @return CallbackLoader
	 */
	public function getCallbackInstantiator() {
		return $this->callbackLoader;
	}

	/**
	 * @since 2.0
	 *
	 * @return SerializerFactory
	 */
	public function newSerializerFactory() {
		return new SerializerFactory();
	}

	/**
	 * @since 2.0
	 *
	 * @return FactboxFactory
	 */
	public function newFactboxFactory() {
		return $this->callbackLoader->load( 'FactboxFactory' );

	}

	/**
	 * @since 2.0
	 *
	 * @return PropertyAnnotatorFactory
	 */
	public function getPropertyAnnotatorFactory() {
		return $this->callbackLoader->singleton( 'PropertyAnnotatorFactory' );
	}

	/**
	 * @since 2.0
	 *
	 * @return JobFactory
	 */
	public function newJobFactory() {
		return $this->callbackLoader->load( 'JobFactory' );

	}

	/**
	 * @since 2.1
	 *
	 * @param Parser $parser
	 *
	 * @return ParserFunctionFactory
	 */
	public function newParserFunctionFactory( Parser $parser ) {
		return new ParserFunctionFactory( $parser );
	}

	/**
	 * @since 2.2
	 *
	 * @return MaintenanceFactory
	 */
	public function newMaintenanceFactory() {
		return new MaintenanceFactory();
	}

	/**
	 * @since 2.2
	 *
	 * @return CacheFactory
	 */
	public function newCacheFactory() {
		return $this->callbackLoader->load( 'CacheFactory', $this->getSettings()->get( 'smwgCacheType' ) );

	}

	/**
	 * @since 2.5
	 *
	 * @param string|null $source
	 *
	 * @return QueryEngine
	 */
	public function getQuerySource( $source = null ) {
		return $this->callbackLoader->singleton( 'QuerySourceFactory' )->getWithLocalFallback( $source );
	}

	/**
	 * @since 2.0
	 *
	 * @return Store
	 */
	public function getStore( $store = null ) {
		return $this->callbackLoader->singleton( 'Store', $store );

	}

	/**
	 * @since 2.0
	 *
	 * @return Settings
	 */
	public function getSettings() {
		return $this->callbackLoader->singleton( 'Settings' );
	}

	/**
	 * @since 2.0
	 *
	 * @return TitleCreator
	 */
	public function newTitleCreator() {
		return $this->callbackLoader->load( 'TitleCreator', $this->newPageCreator() );

	}

	/**
	 * @since 2.0
	 *
	 * @return PageCreator
	 */
	public function newPageCreator() {
		return $this->callbackLoader->load( 'PageCreator' );

	}

	/**
	 * @since 2.5
	 *
	 * @return IteratorFactory
	 */
	public function getIteratorFactory() {
		return $this->callbackLoader->singleton( 'IteratorFactory' );
	}

	/**
	 * @since 2.5
	 *
	 * @return DataValueFactory
	 */
	public function getDataValueFactory() {
		return DataValueFactory::getInstance();
	}

	/**
	 * @since 2.0
	 *
	 * @return Cache
	 */
	public function getCache() {
		return $this->callbackLoader->singleton( 'Cache' );
	}

	/**
	 * @since 2.0
	 *
	 * @return InTextAnnotationParser
	 */
	public function newInTextAnnotationParser( ParserData $parserData ) {

		$mwCollaboratorFactory = $this->newMwCollaboratorFactory();

		$inTextAnnotationParser = new InTextAnnotationParser(
			$parserData,
			$mwCollaboratorFactory->newMagicWordsFinder(),
			$mwCollaboratorFactory->newRedirectTargetFinder()
		);

		$inTextAnnotationParser->setStrictModeState(
			$this->getSettings()->get( 'smwgEnabledInTextAnnotationParserStrictMode' )
		);

		return $inTextAnnotationParser;
	}

	/**
	 * @since 2.0
	 *
	 * @return ParserData
	 */
	public function newParserData( Title $title, ParserOutput $parserOutput ) {
		return $this->callbackLoader->load( 'ParserData', $title, $parserOutput );

	}

	/**
	 * @since 2.0
	 *
	 * @return ContentParser
	 */
	public function newContentParser( Title $title ) {
		return $this->callbackLoader->load( 'ContentParser', $title );

	}

	/**
	 * @since 2.1
	 *
	 * @param SemanticData $semanticData
	 *
	 * @return StoreUpdater
	 */
	public function newStoreUpdater( SemanticData $semanticData ) {
		return new StoreUpdater( $this->getStore(), $semanticData );
	}

	/**
	 * @since 2.1
	 *
	 * @return MwCollaboratorFactory
	 */
	public function newMwCollaboratorFactory() {
		return new MwCollaboratorFactory( $this );
	}

	/**
	 * @since 2.1
	 *
	 * @return NamespaceExaminer
	 */
	public function getNamespaceExaminer() {
		return $this->callbackLoader->load( 'NamespaceExaminer' );

	}

	/**
	 * @since 2.4
	 *
	 * @return PropertySpecificationLookup
	 */
	public function getPropertySpecificationLookup() {
		return $this->callbackLoader->singleton( 'PropertySpecificationLookup' );
	}

	/**
	 * @since 2.4
	 *
	 * @return PropertyHierarchyLookup
	 */
	public function newPropertyHierarchyLookup() {
		return $this->callbackLoader->load( 'PropertyHierarchyLookup' );

	}

	/**
	 * @since 2.5
	 *
	 * @return PropertyLabelFinder
	 */
	public function newPropertyLabelFinder() {
		return $this->callbackLoader->create( 'PropertyLabelFinder' );
	}

	/**
	 * @since 2.4
	 *
	 * @return CachedPropertyValuesPrefetcher
	 */
	public function getCachedPropertyValuesPrefetcher() {
		return $this->callbackLoader->singleton( 'CachedPropertyValuesPrefetcher' );
	}

	/**
	 * @since 2.4
	 *
	 * @return MediaWikiNsContentReader
	 */
	public function getMediaWikiNsContentReader() {
		return $this->callbackLoader->singleton( 'MediaWikiNsContentReader' );
	}

	/**
	 * @since 2.4
	 *
	 * @return InMemoryPoolCache
	 */
	public function getInMemoryPoolCache() {
		return $this->callbackLoader->singleton( 'InMemoryPoolCache' );
	}

	/**
	 * @since 2.5
	 *
	 * @return \LoadBalancer
	 */
	public function getLoadBalancer() {
		return $this->callbackLoader->singleton( 'DBLoadBalancer' );
	}

	/**
	 * @since 2.5
	 *
	 * @param \IDatabase $db
	 * @return string
	 */
	public function getDefaultSearchEngineTypeForDB( \IDatabase $db ) {
		return $this->callbackLoader->create( 'DefaultSearchEngineTypeForDB', $db );


	}

	/**
	 * @since 2.4
	 *
	 * @param Closure $callback
	 *
	 * @return DeferredCallableUpdate
	 */
	public function newDeferredCallableUpdate( Closure $callback ) {

		$deferredCallableUpdate = $this->callbackLoader->create(
			'DeferredCallableUpdate',
			$callback

		);

		$deferredCallableUpdate->enabledDeferredUpdate(
			$this->getSettings()->get( 'smwgEnabledDeferredUpdate' )
		);

		return $deferredCallableUpdate;
	}

	/**
	 * @deprecated since 2.5, use QueryFactory::newQueryParser
	 * @since 2.1
	 *
	 * @return QueryParser
	 */
	public function newQueryParser() {
		return $this->getQueryFactory()->newQueryParser();
	}

	/**
	 * @since 2.5
	 *
	 * @return DataItemFactory
	 */
	public function getDataItemFactory() {
		return $this->callbackLoader->singleton( 'DataItemFactory' );
	}

	/**
	 * @since 2.5
	 *
	 * @return QueryFactory
	 */
	public function getQueryFactory() {
		return $this->callbackLoader->singleton( 'QueryFactory' );
	}

	private static function registerBuilder( CallbackLoader $callbackLoader = null ) {

		if ( $callbackLoader === null ) {
			$callbackLoader = new DeferredCallbackLoader( new SharedCallbackContainer() );
		}

		return $callbackLoader;
	}

}


1			<?php
2
3			namespace SMW;
4
5			use Closure;
6			use Onoi\CallbackContainer\CallbackLoader;
7			use Onoi\CallbackContainer\DeferredCallbackLoader;
8			use Parser;
9			use ParserOutput;
10			use SMW\Factbox\FactboxFactory;
11			use SMW\Maintenance\MaintenanceFactory;
12			use SMW\MediaWiki\Jobs\JobFactory;
13			use SMW\MediaWiki\MwCollaboratorFactory;
14			use SMW\MediaWiki\PageCreator;
15			use SMW\MediaWiki\TitleCreator;
16			use SMW\Query\ProfileAnnotator\QueryProfileAnnotatorFactory;
17			use SMWQueryParser as QueryParser;
18			use Title;
19
20			/**
21			* Application instances access for internal and external use
22			*
23			* @license GNU GPL v2+
24			* @since 2.0
25			*
26			* @author mwjames
27			*/
28			class ApplicationFactory {
29
30			/**
31			* @var ApplicationFactory
32			*/
33			private static $instance = null;
34
35			/**
36			* @var CallbackLoader
37			*/
38			private $callbackLoader = null;
39
40			/**

SemanticMediaWiki / SemanticMediaWiki

Push — master ( b79151...a6cb7c )

ApplicationFactory::getLoadBalancer() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like