Maps\LocationParser

Complexity

Total Complexity

23

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

81.97%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	newInstance()	0	6	1
C	parse()	0	35	8
A	setTitleOrLink()	0	8	2
A	isLink()	0	3	1
A	setLink()	0	4	1
A	getExpandedLink()	0	13	3
A	stringToLatLongValue()	0	16	3
A	isAddress()	0	12	2
A	__construct()	0	6	2

<?php

namespace Maps;

use DataValues\Geo\Parsers\LatLongParser;
use DataValues\Geo\Values\LatLongValue;
use Maps\Elements\Location;
use Maps\Geocoders\Geocoder;
use Title;
use ValueParsers\ParseException;
use ValueParsers\StringValueParser;
use ValueParsers\ValueParser;

/**
 * ValueParser that parses the string representation of a location.
 *
 * @since 3.0
 *
 * @licence GNU GPL v2+
 * @author Jeroen De Dauw < jeroendedauw@gmail.com >
 */
class LocationParser implements ValueParser {

	private $geocoder;
	private $useAddressAsTitle;

	/**
	 * @deprecated Use newInstance instead
	 */
	public function __construct( $enableLegacyCrud = true ) {
		if ( $enableLegacyCrud ) {
			$this->geocoder = MapsFactory::newDefault()->newGeocoder();
			$this->useAddressAsTitle = false;
		}
	}

	/**
	 * @param Geocoder $geocoder
	 * @param bool $useAddressAsTitle
	 * @return self
	 */
	public static function newInstance( Geocoder $geocoder, $useAddressAsTitle = false ) {
		$instance = new self( false );
		$instance->geocoder = $geocoder;
		$instance->useAddressAsTitle = $useAddressAsTitle;
		return $instance;
	}

	/**
	 * @see StringValueParser::stringParse
	 *
	 * @since 3.0
	 *
	 * @param string $value
	 *
	 * @return Location
	 * @throws ParseException
	 */
	public function parse( $value ) {
		$separator = '~';

		$metaData = explode( $separator, $value );

		$coordinatesOrAddress = array_shift( $metaData );
		$coordinates = $this->stringToLatLongValue( $coordinatesOrAddress );

		$location = new Location( $coordinates );

		if ( $metaData !== [] ) {
			$this->setTitleOrLink( $location, array_shift( $metaData ) );
		}
		else if ( $this->useAddressAsTitle && $this->isAddress( $coordinatesOrAddress ) ) {
			$location->setTitle( $coordinatesOrAddress );
		}

		if ( $metaData !== [] ) {
			$location->setText( array_shift( $metaData ) );
		}

		if ( $metaData !== [] ) {
			$location->setIcon( array_shift( $metaData ) );
		}

		if ( $metaData !== [] ) {
			$location->setGroup( array_shift( $metaData ) );
		}

		if ( $metaData !== [] ) {
			$location->setInlineLabel( array_shift( $metaData ) );
		}

		return $location;
	}

	private function setTitleOrLink( Location $location, $titleOrLink ) {
		if ( $this->isLink( $titleOrLink ) ) {
			$this->setLink( $location, $titleOrLink );
		}
		else {
			$location->setTitle( $titleOrLink );
		}
	}

	private function isLink( $value ) {
		return strpos( $value , 'link:' ) === 0;
	}

	private function setLink( Location $location, $link ) {
		$link = substr( $link, 5 );
		$location->setLink( $this->getExpandedLink( $link ) );
	}

	private function getExpandedLink( $link ) {
		if ( filter_var( $link , FILTER_VALIDATE_URL , FILTER_FLAG_SCHEME_REQUIRED ) ) {
			return $link;
		}

		$title = Title::newFromText( $link );

		if ( $title === null ) {
			return '';
		}

		return $title->getFullURL();
	}

	/**
	 * @param string $location
	 *
	 * @return LatLongValue
	 * @throws ParseException
	 */
	private function stringToLatLongValue( $location ) {
		$parser = new LatLongParser();

		try {
			return $parser->parse( $location );
		}
		catch ( ParseException $parseException ) {
			$latLongValue = $this->geocoder->geocode( $location );

			if ( $latLongValue === null ) {
				throw new ParseException( 'Failed to parse or geocode' );
			}

			return $latLongValue;
		}
	}

	/**
	 * @param string $coordsOrAddress
	 *
	 * @return boolean
	 */
	private function isAddress( $coordsOrAddress ) {
		$coordinateParser = new LatLongParser();

		try {
			$coordinateParser->parse( $coordsOrAddress );
		}
		catch ( ParseException $parseException ) {
			return true;
		}

		return false;
	}

}