Maps\MapsFactory

Complexity

Total Complexity

42

Size/Duplication

Total Lines	254
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	32

Test Coverage

Coverage

73.88%

Importance

Changes

0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	globalInstance()	0	7	2
A	newDefault()	0	3	1
A	newLocationParser()	0	6	1
A	getGeocoder()	0	13	2
A	newCoreGeocoder()	0	21	5
A	newGoogleGeocoder()	0	7	1
A	getFileFetcher()	0	3	1
A	newFileFetcher()	0	3	1
A	getGeoJsonFileFetcher()	0	10	2
A	getMediaWikiSimpleCache()	0	6	1
A	getMediaWikiCache()	0	3	1
A	getPageContentFetcher()	0	6	1
A	getCoordinateFormatter()	0	3	1
A	getFileUrlFinder()	0	3	1
A	getMappingServices()	0	8	1
A	getGoogleMapsService()	0	7	2
A	getLeafletService()	0	9	2
A	getDisplayMapFunction()	0	5	1
A	getParamDefinitionFactory()	0	15	1
A	newGeoJsonFetcher()	0	7	1
A	smwIntegrationIsEnabled()	0	3	2
A	newSemanticMapsSetup()	0	3	1
A	newSemanticGeoJsonStore()	0	8	1
A	getSmwFactory()	0	3	1
A	getImageRepository()	0	5	1
A	getRepoGroup()	0	3	1
A	getMapOutputBuilder()	0	6	1
A	newCargoOutputBuilder()	0	8	1
A	newParserHookSetup()	0	3	1
A	newNonMapParserHooks()	0	15	2

<?php

declare( strict_types = 1 );

namespace Maps;

use DataValues\Geo\Parsers\LatLongParser;
use FileFetcher\Cache\Factory as CacheFactory;
use FileFetcher\FileFetcher;
use Jeroen\SimpleGeocoder\Geocoder;
use Jeroen\SimpleGeocoder\Geocoders\Decorators\CoordinateFriendlyGeocoder;
use Jeroen\SimpleGeocoder\Geocoders\FileFetchers\GeoNamesGeocoder;
use Jeroen\SimpleGeocoder\Geocoders\FileFetchers\GoogleGeocoder;
use Jeroen\SimpleGeocoder\Geocoders\FileFetchers\NominatimGeocoder;
use Jeroen\SimpleGeocoder\Geocoders\NullGeocoder;
use Maps\DataAccess\CachingGeocoder;
use Maps\DataAccess\GeoJsonFetcher;
use Maps\DataAccess\ImageRepository;
use Maps\DataAccess\MapsFileFetcher;
use Maps\DataAccess\MediaWikiFileUrlFinder;
use Maps\DataAccess\MwImageRepository;
use Maps\DataAccess\PageContentFetcher;
use Maps\GeoJsonPages\GeoJsonStore;
use Maps\GeoJsonPages\Semantic\SemanticGeoJsonStore;
use Maps\GeoJsonPages\Semantic\SubObjectBuilder;
use Maps\Map\CargoFormat\CargoOutputBuilder;
use Maps\Map\DisplayMap\DisplayMapFunction;
use Maps\Map\MapOutputBuilder;
use Maps\ParserHooks\CoordinatesFunction;
use Maps\ParserHooks\DistanceFunction;
use Maps\ParserHooks\FindDestinationFunction;
use Maps\ParserHooks\GeocodeFunction;
use Maps\ParserHooks\GeoDistanceFunction;
use Maps\ParserHooks\MapsDocFunction;
use Maps\Presentation\CoordinateFormatter;
use Maps\WikitextParsers\CircleParser;
use Maps\WikitextParsers\DistanceParser;
use Maps\WikitextParsers\ImageOverlayParser;
use Maps\WikitextParsers\LineParser;
use Maps\WikitextParsers\LocationParser;
use Maps\WikitextParsers\PolygonParser;
use Maps\WikitextParsers\RectangleParser;
use Maps\WikitextParsers\WmsOverlayParser;
use MediaWiki\MediaWikiServices;
use ParamProcessor\ParamDefinitionFactory;
use Parser;
use ParserHook;
use RepoGroup;
use SimpleCache\Cache\Cache;
use SimpleCache\Cache\MediaWikiCache;
use SMW\ApplicationFactory;
use Title;

/**
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
class MapsFactory {

	protected static $globalInstance = null;

	private $settings;
	private $mediaWikiServices;

	private $leafletService;
	private $googleService;

	private function __construct( array $settings, MediaWikiServices $mediaWikiServices ) {
		$this->settings = $settings;
		$this->mediaWikiServices = $mediaWikiServices;
	}

	/**
	 * Only for legacy code where dependency injection is not possible
	 */
	public static function globalInstance(): self {
		if ( self::$globalInstance === null ) {
			self::$globalInstance = self::newDefault();
		}

		return self::$globalInstance;
	}

	protected static function newDefault(): self {
		return new static( $GLOBALS, MediaWikiServices::getInstance() );
	}

	public function newLocationParser(): LocationParser {
		return LocationParser::newInstance(
			$this->getGeocoder(),
			$this->getFileUrlFinder()
		);
	}

	public function getGeocoder(): Geocoder {
		$geocoder = new CoordinateFriendlyGeocoder( $this->newCoreGeocoder() );

		if ( $this->settings['egMapsEnableGeoCache'] ) {
			return new CachingGeocoder(
				$geocoder,
				$this->getMediaWikiCache(),
				$this->settings['egMapsGeoCacheTtl']
			);
		}

		return $geocoder;
	}

	private function newCoreGeocoder(): Geocoder {
		switch ( $this->settings['egMapsDefaultGeoService'] ) {
			case 'geonames':
				if ( $this->settings['egMapsGeoNamesUser'] === '' ) {
					return $this->newGoogleGeocoder();
				}

				return new GeoNamesGeocoder(
					$this->newFileFetcher(),
					$this->settings['egMapsGeoNamesUser']
				);
			case 'google':
				return $this->newGoogleGeocoder();
			case 'nominatim':
				return new NominatimGeocoder(
					$this->newFileFetcher()
				);
			default:
				return new NullGeocoder();
		}
	}

	private function newGoogleGeocoder(): Geocoder {
		return new GoogleGeocoder(
			$this->newFileFetcher(),
			$this->settings['egMapsGMaps3ApiKey'],
			$this->settings['egMapsGMaps3ApiVersion']
		);
	}

	public function getFileFetcher(): FileFetcher {
		return $this->newFileFetcher();
	}

	private function newFileFetcher(): FileFetcher {
		return new MapsFileFetcher();
	}

	public function getGeoJsonFileFetcher(): FileFetcher {
		if ( $this->settings['egMapsGeoJsonCacheTtl'] === 0 ) {
			return $this->getFileFetcher();
		}

		return ( new CacheFactory() )->newJeroenSimpleCacheFetcher(
			$this->getFileFetcher(),
			$this->getMediaWikiSimpleCache( $this->settings['egMapsGeoJsonCacheTtl'] )
		);
	}

	private function getMediaWikiSimpleCache( int $ttlInSeconds ): Cache {
		return new MediaWikiCache(
			$this->getMediaWikiCache(),
			$ttlInSeconds
		);
	}

	private function getMediaWikiCache(): \BagOStuff {
		return wfGetCache( $this->settings['egMapsGeoCacheType'] );
	}

	public function getPageContentFetcher(): PageContentFetcher {
		return new PageContentFetcher(
			$this->mediaWikiServices->getTitleParser(),
			$this->mediaWikiServices->getRevisionLookup()
		);
	}

	public function getCoordinateFormatter(): CoordinateFormatter {
		return new CoordinateFormatter();
	}

	public function getFileUrlFinder(): FileUrlFinder {
		return new MediaWikiFileUrlFinder();
	}

	public function getMappingServices(): MappingServices {
		return new MappingServices(
			$this->settings['egMapsAvailableServices'],
			$this->settings['egMapsDefaultService'],
			$this->getGoogleMapsService(),
			$this->getLeafletService()
		);
	}

	private function getGoogleMapsService(): GoogleMapsService {
		if ( $this->googleService === null ) {
			$this->googleService = new GoogleMapsService();
		}

		return $this->googleService;
	}

	private function getLeafletService(): LeafletService {
		if ( $this->leafletService === null ) {
			$this->leafletService = new LeafletService(
				$this->getImageRepository()
			);
		}

		return $this->leafletService;
	}

	public function getDisplayMapFunction(): DisplayMapFunction {
		return new DisplayMapFunction(
			$this->getMappingServices()
		);
	}

	public function getParamDefinitionFactory(): ParamDefinitionFactory {
		$factory = ParamDefinitionFactory::newDefault();

		$factory->registerType( 'coordinate', [ 'string-parser' => LatLongParser::class ] );
		$factory->registerType( 'mapslocation', [ 'string-parser' => LocationParser::class ] );
		$factory->registerType( 'mapsline', [ 'string-parser' => LineParser::class ] );
		$factory->registerType( 'mapscircle', [ 'string-parser' => CircleParser::class ] );
		$factory->registerType( 'mapsrectangle', [ 'string-parser' => RectangleParser::class ] );
		$factory->registerType( 'mapspolygon', [ 'string-parser' => PolygonParser::class ] );
		$factory->registerType( 'distance', [ 'string-parser' => DistanceParser::class ] );
		$factory->registerType( 'wmsoverlay', [ 'string-parser' => WmsOverlayParser::class ] );
		$factory->registerType( 'mapsimageoverlay', [ 'string-parser' => ImageOverlayParser::class ] );

		return $factory;
	}

	public function newGeoJsonFetcher( FileFetcher $fileFetcher = null ): GeoJsonFetcher {
		return new GeoJsonFetcher(
			$fileFetcher ?? $this->getGeoJsonFileFetcher(),
			$this->mediaWikiServices->getTitleParser(),
			$this->mediaWikiServices->getRevisionLookup()
		);
	}

	public function smwIntegrationIsEnabled(): bool {
		return !$this->settings['egMapsDisableSmwIntegration'] && defined( 'SMW_VERSION' );
	}

	public function newSemanticMapsSetup( &$mwGlobals ): SemanticMapsSetup {
		return SemanticMapsSetup::newFromMediaWikiGlobals( $mwGlobals, $this->getMappingServices() );
	}

	public function newSemanticGeoJsonStore( \ParserOutput $parserOutput, Title $subjectPage ): GeoJsonStore {
		return new SemanticGeoJsonStore(
			$this->getSmwFactory()->newParserData( $subjectPage, $parserOutput ),
			$subjectPage,
			$this->getSmwFactory()->getEventDispatcher(),
			new SubObjectBuilder( $subjectPage )
		);
	}

	private function getSmwFactory(): ApplicationFactory {
		return ApplicationFactory::getInstance();
	}

	public function getImageRepository(): ImageRepository {
		return new MwImageRepository(
			$this->getRepoGroup()
		);
	}

	private function getRepoGroup(): RepoGroup {
		return RepoGroup::singleton();
	}

	public function getMapOutputBuilder(): MapOutputBuilder {
		return new MapOutputBuilder(
//			$this->getMappingServices(),
//			$this->getParamDefinitionFactory()
		);
	}

	public function newCargoOutputBuilder(): CargoOutputBuilder {
		return new CargoOutputBuilder(
			$this->getMapOutputBuilder(),
			$this->getMappingServices(),
			$this->getParamDefinitionFactory(),
			$this->getImageRepository()
		);
	}

	public function newParserHookSetup( Parser $parser ): ParserHookSetup {
		return new ParserHookSetup( $parser );
	}

	/**
	 * @return ParserHook[]
	 */
	public function newNonMapParserHooks(): array {
		$hooks = [
			new DistanceFunction(),
			new FindDestinationFunction(),
			new GeocodeFunction(),
			new GeoDistanceFunction(),
			new MapsDocFunction(),
		];

		if ( $this->settings['egMapsEnableCoordinateFunction'] ) {
			$hooks[] = new CoordinatesFunction();
		}

		return $hooks;
	}

}