LatLongParserBase::resolveDirection() - Code Metrics - Inspection of "WIP - remove dependency on DV common" - DataValues/Geo - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — rm-common ( 88d3f9 )

by Jeroen De

created 2017-11-01 10:22 UTC

LatLongParserBase::resolveDirection() B

↳ Parent: LatLongParserBase

Complexity

Conditions	5
Paths	4

Size

Total Lines	31
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	31
ccs	0
cts	16
cp	0
rs	8.439
cc	5
eloc	16
nc	4
nop	1
crap	30

<?php

namespace DataValues\Geo\Parsers;

use DataValues\Geo\Values\LatLongValue;
use ValueParsers\ParseException;
use ValueParsers\ParserOptions;
use ValueParsers\StringValueParser;
use ValueParsers\ValueParser;

/**
 * @since 0.1, renamed in 2.0
 *
 * @license GPL-2.0+
 * @author H. Snater < [email protected] >
 * @author Jeroen De Dauw < [email protected] >
 */
abstract class LatLongParserBase implements ValueParser {

	const FORMAT_NAME = 'geo-coordinate';

	/**
	 * The symbols representing the different directions for usage in directional notation.
	 */
	const OPT_NORTH_SYMBOL = 'north';
	const OPT_EAST_SYMBOL = 'east';
	const OPT_SOUTH_SYMBOL = 'south';
	const OPT_WEST_SYMBOL = 'west';

	/**
	 * The symbol to use as separator between latitude and longitude.
	 */
	const OPT_SEPARATOR_SYMBOL = 'separator';

	/**
	 * Delimiters used to split a coordinate string when unable to split by using the separator.
	 * @var string[]
	 */
	protected $defaultDelimiters;

	/**
	 * @var ParserOptions
	 */
	protected $options;

	public function __construct( ParserOptions $options = null ) {
		$this->options = $options ?: new ParserOptions();

		$this->options->defaultOption( ValueParser::OPT_LANG, 'en' );

		$this->options->defaultOption( self::OPT_NORTH_SYMBOL, 'N' );
		$this->options->defaultOption( self::OPT_EAST_SYMBOL, 'E' );
		$this->options->defaultOption( self::OPT_SOUTH_SYMBOL, 'S' );
		$this->options->defaultOption( self::OPT_WEST_SYMBOL, 'W' );

		$this->options->defaultOption( self::OPT_SEPARATOR_SYMBOL, ',' );
	}

	/**
	 * Parses a single coordinate segment (either latitude or longitude) and returns it as a float.
	 *
	 * @param string $coordinateSegment
	 *
	 * @throws ParseException
	 * @return float
	 */
	abstract protected function getParsedCoordinate( $coordinateSegment );

	/**
	 * Returns whether a coordinate split into its two segments is in the representation expected by
	 * this parser.
	 *
	 * @param string[] $normalizedCoordinateSegments
	 *
	 * @return boolean
	 */
	abstract protected function areValidCoordinates( array $normalizedCoordinateSegments );

	/**
	 * @see ValueParser::parse
	 *
	 * @param string $value
	 *
	 * @throws ParseException
	 * @return LatLongValue
	 */
	public function parse( $value ) {
		$rawValue = $value;

		$value = $this->removeInvalidChars( $value );

		$normalizedCoordinateSegments = $this->splitString( $value );

		if ( !$this->areValidCoordinates( $normalizedCoordinateSegments ) ) {
			throw new ParseException( 'Not a valid geographical coordinate', $rawValue, static::FORMAT_NAME );
		}

		list( $latitude, $longitude ) = $normalizedCoordinateSegments;

		return new LatLongValue(
			$this->getParsedCoordinate( $latitude ),
			$this->getParsedCoordinate( $longitude )
		);
	}

	/**
	 * Returns a string trimmed and with control characters and characters with ASCII values above
	 * 126 removed. SPACE characters within the string are not removed to retain the option to split
	 * the string using that character.
	 *
	 * @param string $string
	 *
	 * @return string
	 */
	protected function removeInvalidChars( $string ) {
		$filtered = [];

		foreach ( str_split( $string ) as $character ) {
			$asciiValue = ord( $character );

			if (
				( $asciiValue >= 32 && $asciiValue < 127 )
				|| $asciiValue == 194
				|| $asciiValue == 176
			) {
				$filtered[] = $character;
			}
		}

		return trim( implode( '', $filtered ) );
	}

	/**
	 * Splits a string into two strings using the separator specified in the options. If the string
	 * could not be split using the separator, the method will try to split the string by analyzing
	 * the used symbols. If the string could not be split into two parts, an empty array is
	 * returned.
	 *
	 * @param string $normalizedCoordinateString
	 *
	 * @throws ParseException if unable to split input string into two segments
	 * @return string[]
	 */
	protected function splitString( $normalizedCoordinateString ) {
		$separator = $this->getOption( self::OPT_SEPARATOR_SYMBOL );

		$normalizedCoordinateSegments = explode( $separator, $normalizedCoordinateString );

		if ( count( $normalizedCoordinateSegments ) !== 2 ) {
			// Separator not present within the string, trying to figure out the segments by
			// splitting after the first direction character or degree symbol:
			$delimiters = $this->defaultDelimiters;

			$ns = [
				$this->getOption( self::OPT_NORTH_SYMBOL ),
				$this->getOption( self::OPT_SOUTH_SYMBOL )
			];

			$ew = [
				$this->getOption( self::OPT_EAST_SYMBOL ),
				$this->getOption( self::OPT_WEST_SYMBOL )
			];

			foreach ( $ns as $delimiter ) {
				if ( mb_strpos( $normalizedCoordinateString, $delimiter ) === 0 ) {
					// String starts with "north" or "west" symbol: Separation needs to be done
					// before the "east" or "west" symbol.
					$delimiters = array_merge( $ew, $delimiters );
					break;
				}
			}

			if ( count( $delimiters ) !== count( $this->defaultDelimiters ) + 2 ) {
				$delimiters = array_merge( $ns, $delimiters );
			}

			foreach ( $delimiters as $delimiter ) {
				$delimiterPos = mb_strpos( $normalizedCoordinateString, $delimiter );
				if ( $delimiterPos !== false ) {
					$adjustPos = ( in_array( $delimiter, $ew ) ) ? 0 : mb_strlen( $delimiter );
					$normalizedCoordinateSegments = [
						mb_substr( $normalizedCoordinateString, 0, $delimiterPos + $adjustPos ),
						mb_substr( $normalizedCoordinateString, $delimiterPos + $adjustPos )
					];
					break;
				}
			}
		}

		if ( count( $normalizedCoordinateSegments ) !== 2 ) {
			throw new ParseException( __CLASS__ . ': Unable to split string '
				. $normalizedCoordinateString . ' into two coordinate segments' );
		}

		return $normalizedCoordinateSegments;
	}

	/**
	 * Turns directional notation (N/E/S/W) of a single coordinate into non-directional notation
	 * (+/-).
	 * This method assumes there are no preceding or tailing spaces.
	 *
	 * @param string $coordinateSegment
	 *
	 * @return string
	 */
	protected function resolveDirection( $coordinateSegment ) {
		$n = $this->getOption( self::OPT_NORTH_SYMBOL );
		$e = $this->getOption( self::OPT_EAST_SYMBOL );
		$s = $this->getOption( self::OPT_SOUTH_SYMBOL );
		$w = $this->getOption( self::OPT_WEST_SYMBOL );

		// If there is a direction indicator, remove it, and prepend a minus sign for south and west
		// directions. If there is no direction indicator, the coordinate is already non-directional
		// and no work is required.
		foreach ( [ $n, $e, $s, $w ] as $direction ) {
			// The coordinate segment may either start or end with a direction symbol.
			preg_match(
				'/^(' . $direction . '|)([^' . $direction . ']+)(' . $direction . '|)$/i',
				$coordinateSegment,
				$matches
			);

			if ( $matches[1] === $direction || $matches[3] === $direction ) {
				$coordinateSegment = $matches[2];

				if ( in_array( $direction, [ $s, $w ] ) ) {
					$coordinateSegment = '-' . $coordinateSegment;
				}

				return $coordinateSegment;
			}
		}

		// Coordinate segment does not include a direction symbol.
		return $coordinateSegment;
	}

	protected function getOption( $optionName ) {
		return $this->options->getOption( $optionName );
	}

}


1			<?php
2
3			namespace DataValues\Geo\Parsers;
4
5			use DataValues\Geo\Values\LatLongValue;
6			use ValueParsers\ParseException;
7			use ValueParsers\ParserOptions;
8			use ValueParsers\StringValueParser;
9			use ValueParsers\ValueParser;
10
11			/**
12			* @since 0.1, renamed in 2.0
13			*
14			* @license GPL-2.0+
15			* @author H. Snater < [email protected] >
16			* @author Jeroen De Dauw < [email protected] >
17			*/
18			abstract class LatLongParserBase implements ValueParser {
19
20			const FORMAT_NAME = 'geo-coordinate';
21
22			/**
23			* The symbols representing the different directions for usage in directional notation.
24			*/
25			const OPT_NORTH_SYMBOL = 'north';
26			const OPT_EAST_SYMBOL = 'east';
27			const OPT_SOUTH_SYMBOL = 'south';
28			const OPT_WEST_SYMBOL = 'west';
29
30			/**
31			* The symbol to use as separator between latitude and longitude.
32			*/
33			const OPT_SEPARATOR_SYMBOL = 'separator';
34
35			/**
36			* Delimiters used to split a coordinate string when unable to split by using the separator.
37			* @var string[]
38			*/
39			protected $defaultDelimiters;
40
41			/**
42			* @var ParserOptions
43			*/
44			protected $options;
45
46			public function __construct( ParserOptions $options = null ) {
47			$this->options = $options ?: new ParserOptions();
48
49			$this->options->defaultOption( ValueParser::OPT_LANG, 'en' );
50
51			$this->options->defaultOption( self::OPT_NORTH_SYMBOL, 'N' );
52			$this->options->defaultOption( self::OPT_EAST_SYMBOL, 'E' );
53			$this->options->defaultOption( self::OPT_SOUTH_SYMBOL, 'S' );
54			$this->options->defaultOption( self::OPT_WEST_SYMBOL, 'W' );
55
56			$this->options->defaultOption( self::OPT_SEPARATOR_SYMBOL, ',' );
57			}
58
59			/**
60			* Parses a single coordinate segment (either latitude or longitude) and returns it as a float.
61			*
62			* @param string $coordinateSegment
63			*
64			* @throws ParseException
65			* @return float
66			*/
67			abstract protected function getParsedCoordinate( $coordinateSegment );
68
69			/**
70			* Returns whether a coordinate split into its two segments is in the representation expected by
71			* this parser.
72			*
73			* @param string[] $normalizedCoordinateSegments
74			*
75			* @return boolean
76			*/
77			abstract protected function areValidCoordinates( array $normalizedCoordinateSegments );
78
79			/**
80			* @see ValueParser::parse
81			*
82			* @param string $value
83			*
84			* @throws ParseException
85			* @return LatLongValue
86			*/
87			public function parse( $value ) {
88			$rawValue = $value;
89
90			$value = $this->removeInvalidChars( $value );
91
92			$normalizedCoordinateSegments = $this->splitString( $value );
93
94			if ( !$this->areValidCoordinates( $normalizedCoordinateSegments ) ) {
95			throw new ParseException( 'Not a valid geographical coordinate', $rawValue, static::FORMAT_NAME );
96			}
97
98			list( $latitude, $longitude ) = $normalizedCoordinateSegments;
99
100			return new LatLongValue(
101			$this->getParsedCoordinate( $latitude ),
102			$this->getParsedCoordinate( $longitude )
103			);
104			}
105
106			/**
107			* Returns a string trimmed and with control characters and characters with ASCII values above
108			* 126 removed. SPACE characters within the string are not removed to retain the option to split
109			* the string using that character.
110			*
111			* @param string $string
112			*
113			* @return string
114			*/
115			protected function removeInvalidChars( $string ) {
116			$filtered = [];
117
118			foreach ( str_split( $string ) as $character ) {
119			$asciiValue = ord( $character );
120
121			if (
122			( $asciiValue >= 32 && $asciiValue < 127 )
123			\|\| $asciiValue == 194
124			\|\| $asciiValue == 176
125			) {
126			$filtered[] = $character;
127			}
128			}
129
130			return trim( implode( '', $filtered ) );
131			}
132
133			/**
134			* Splits a string into two strings using the separator specified in the options. If the string
135			* could not be split using the separator, the method will try to split the string by analyzing
136			* the used symbols. If the string could not be split into two parts, an empty array is
137			* returned.
138			*
139			* @param string $normalizedCoordinateString
140			*
141			* @throws ParseException if unable to split input string into two segments
142			* @return string[]
143			*/
144			protected function splitString( $normalizedCoordinateString ) {
145			$separator = $this->getOption( self::OPT_SEPARATOR_SYMBOL );
146
147			$normalizedCoordinateSegments = explode( $separator, $normalizedCoordinateString );
148
149			if ( count( $normalizedCoordinateSegments ) !== 2 ) {
150			// Separator not present within the string, trying to figure out the segments by
151			// splitting after the first direction character or degree symbol:
152			$delimiters = $this->defaultDelimiters;
153
154			$ns = [
155			$this->getOption( self::OPT_NORTH_SYMBOL ),
156			$this->getOption( self::OPT_SOUTH_SYMBOL )
157			];
158
159			$ew = [
160			$this->getOption( self::OPT_EAST_SYMBOL ),
161			$this->getOption( self::OPT_WEST_SYMBOL )
162			];
163
164			foreach ( $ns as $delimiter ) {
165			if ( mb_strpos( $normalizedCoordinateString, $delimiter ) === 0 ) {
166			// String starts with "north" or "west" symbol: Separation needs to be done
167			// before the "east" or "west" symbol.
168			$delimiters = array_merge( $ew, $delimiters );
169			break;
170			}
171			}
172
173			if ( count( $delimiters ) !== count( $this->defaultDelimiters ) + 2 ) {
174			$delimiters = array_merge( $ns, $delimiters );
175			}
176
177			foreach ( $delimiters as $delimiter ) {
178			$delimiterPos = mb_strpos( $normalizedCoordinateString, $delimiter );
179			if ( $delimiterPos !== false ) {
180			$adjustPos = ( in_array( $delimiter, $ew ) ) ? 0 : mb_strlen( $delimiter );
181			$normalizedCoordinateSegments = [
182			mb_substr( $normalizedCoordinateString, 0, $delimiterPos + $adjustPos ),
183			mb_substr( $normalizedCoordinateString, $delimiterPos + $adjustPos )
184			];
185			break;
186			}
187			}
188			}
189
190			if ( count( $normalizedCoordinateSegments ) !== 2 ) {
191			throw new ParseException( __CLASS__ . ': Unable to split string '
192			. $normalizedCoordinateString . ' into two coordinate segments' );
193			}
194
195			return $normalizedCoordinateSegments;
196			}
197
198			/**
199			* Turns directional notation (N/E/S/W) of a single coordinate into non-directional notation
200			* (+/-).
201			* This method assumes there are no preceding or tailing spaces.
202			*
203			* @param string $coordinateSegment
204			*
205			* @return string
206			*/
207			protected function resolveDirection( $coordinateSegment ) {
208			$n = $this->getOption( self::OPT_NORTH_SYMBOL );
209			$e = $this->getOption( self::OPT_EAST_SYMBOL );
210			$s = $this->getOption( self::OPT_SOUTH_SYMBOL );
211			$w = $this->getOption( self::OPT_WEST_SYMBOL );
212
213			// If there is a direction indicator, remove it, and prepend a minus sign for south and west
214			// directions. If there is no direction indicator, the coordinate is already non-directional
215			// and no work is required.
216			foreach ( [ $n, $e, $s, $w ] as $direction ) {
217			// The coordinate segment may either start or end with a direction symbol.
218			preg_match(
219			'/^(' . $direction . '\|)([^' . $direction . ']+)(' . $direction . '\|)$/i',
220			$coordinateSegment,
221			$matches
222			);
223
224			if ( $matches[1] === $direction \|\| $matches[3] === $direction ) {
225			$coordinateSegment = $matches[2];
226
227			if ( in_array( $direction, [ $s, $w ] ) ) {
228			$coordinateSegment = '-' . $coordinateSegment;
229			}
230
231			return $coordinateSegment;
232			}
233			}
234
235			// Coordinate segment does not include a direction symbol.
236			return $coordinateSegment;
237			}
238
239			protected function getOption( $optionName ) {
240			return $this->options->getOption( $optionName );
241			}
242
243			}
244

DataValues / Geo

Push — rm-common ( 88d3f9 )

LatLongParserBase::resolveDirection() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like