Merge pull request #75 from smartemailing/jirka

Added Arrays::getFloatArray

README.md

@@ -787,25 +787,36 @@ PrimitiveTypes::getStringOrNull([], true); // null
 Arrays::getArray([1, 2]); // [1, 2]
 Arrays::getArray([1, 'abcd']); // [1, 'abcd']
 Arrays::getIntArray([1, '2']); // [1, 2]
+Arrays::getIntArrayOrNull([1, '2']); // returns int[]|null
+Arrays::getFloatArray([1, '2']); // [1.0, 2.0]
+Arrays::getFloatArrayOrNull([1, '2']); // returns float[]|null
 Arrays::getStringArray([1, '2']); // ['1', '2']
+Arrays::getStringArrayOrNull([1, '2']); // returns string[]|null
 
 // All PrimitiveTypes::get* methods have their extract equivalent:
 
 PrimitiveTypes::extractInt($data, 'key');
 PrimitiveTypes::extractIntOrNull($data, 'key');
 PrimitiveTypes::extractIntOrNull($data, 'key', true);
+
 PrimitiveTypes::extractString($data, 'key');
 PrimitiveTypes::extractStringOrNull($data, 'key');
 PrimitiveTypes::extractStringOrNull($data, 'key', true);
-PrimitiveTypes::extractFloat($data, 'key');
 
+PrimitiveTypes::extractFloat($data, 'key');
+PrimitiveTypes::extractFloatOrNull($data, 'key');
+PrimitiveTypes::extractFloatOrNull($data, 'key', true);
 
+Arrays::extractArray($data, 'key'); //returns mixed[]
+Arrays::extractArrayOrNull($data, 'key'); //returns mixed[]|null
 
-Arrays::extractArray($data, 'key');
-Arrays::extractArrayOrNull($data, 'key');
 Arrays::extractIntArray($data, 'key'); //returns int[]
-Arrays::extractStringArray($data, 'key'); //returns string[]
 Arrays::extractIntArrayOrNull($data, 'key'); //returns int[]|null
+
+Arrays::extractFloatArray($data, 'key'); //returns float[]
+Arrays::extractFloatArrayOrNull($data, 'key'); //returns float[]|null
+
+Arrays::extractStringArray($data, 'key'); //returns string[]
 Arrays::extractStringArrayOrNull($data, 'key'); //returns string[]|null
 
 ```

src/Arrays.php

@@ -191,6 +191,99 @@ final public static function extractIntArrayOrNull(
 		return self::getIntArrayOrNull($array, $nullIfInvalid);
 	}
 
+
+	/**
+	 * @param mixed $value
+	 * @return float[]
+	 */
+	final public static function getFloatArray(
+		$value
+	): array {
+		$array = self::getArray($value);
+
+		$return = [];
+
+		foreach ($array as $index => $item) {
+			$return[$index] = PrimitiveTypes::getFloat($item);
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param mixed $value
+	 * @param bool $nullIfInvalid
+	 * @return float[]|null
+	 */
+	final public static function getFloatArrayOrNull(
+		$value,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = self::getArrayOrNull($value, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		$return = [];
+
+		try {
+			foreach ($array as $index => $item) {
+				$return[$index] = PrimitiveTypes::getFloat($item);
+			}
+		} catch (InvalidTypeException $e) {
+			if ($nullIfInvalid) {
+				return null;
+			}
+
+			throw $e;
+		}
+
+		return $return;
+	}
+
+	/**
+	 * @param mixed[] $data
+	 * @param string $key
+	 * @return float[]
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractFloatArray(
+		array $data,
+		string $key
+	): array {
+		$array = Arrays::extractArray($data, $key);
+
+		try {
+			$array = Arrays::getFloatArray($array);
+		} catch (InvalidTypeException $e) {
+			throw $e->wrap($key);
+		}
+
+		return $array;
+	}
+
+	/**
+	 * @param mixed[] $data
+	 * @param string $key
+	 * @param bool $nullIfInvalid
+	 * @return float[]|null
+	 * @throws \SmartEmailing\Types\InvalidTypeException
+	 */
+	final public static function extractFloatArrayOrNull(
+		array $data,
+		string $key,
+		bool $nullIfInvalid = false
+	): ?array {
+		$array = Arrays::extractArrayOrNull($data, $key, $nullIfInvalid);
+
+		if ($array === null) {
+			return null;
+		}
+
+		return self::getFloatArrayOrNull($array, $nullIfInvalid);
+	}
+
 	/**
 	 * @param mixed $value
 	 * @return string[]

tests/ArraysTest.phpt

@@ -161,6 +161,72 @@ final class ArraysTest extends TestCase
 		Assert::type('array', Arrays::extractStringArrayOrNull(['data' => ['1']], 'data'));
 	}
 
+
+	public function testGetFloatArray(): void
+	{
+		Assert::same([1.0, 1.1, 2.5], Arrays::getFloatArray([1, '1.1', 2.5]));
+
+		Assert::throws(
+			static function (): void {
+				Arrays::getFloatArray([1, 'failed', 2.5]);
+			},
+			InvalidTypeException::class,
+			'Expected float, got string (failed)'
+		);
+	}
+
+	public function testGetFloatArrayOrNull(): void
+	{
+		Assert::same([1.0, 1.1, 2.5], Arrays::getFloatArrayOrNull([1, '1.1', 2.5]));
+
+		Assert::null(Arrays::getFloatArrayOrNull(null));
+
+		Assert::null(Arrays::getFloatArrayOrNull([1, 'failed', 2.5], true));
+
+		Assert::throws(
+			static function (): void {
+				Arrays::getFloatArrayOrNull([1, 'failed', 2.5]);
+			},
+			InvalidTypeException::class,
+			'Expected float, got string (failed)'
+		);
+	}
+
+	public function testExtractFloatArray(): void
+	{
+		Assert::same([1.0, 1.1, 2.5], Arrays::extractFloatArray(['floats' => [1, '1.1', 2.5]], 'floats'));
+
+		Assert::throws(
+			static function (): void {
+				Arrays::extractFloatArray(['floats' => null], 'floats');
+			},
+			InvalidTypeException::class
+		);
+
+		Assert::throws(
+			static function (): void {
+				Assert::null(Arrays::extractFloatArray(['floats' => [1, 'failed', 2.5]], 'floats'));
+			},
+			InvalidTypeException::class
+		);
+	}
+
+	public function testExtractFloatArrayOrNull(): void
+	{
+		Assert::same([1.0, 1.1, 2.5], Arrays::extractFloatArrayOrNull(['floats' => [1, '1.1', 2.5]], 'floats'));
+
+		Assert::null(Arrays::extractFloatArrayOrNull(['floats' => null], 'floats'));
+
+		Assert::null(Arrays::extractFloatArrayOrNull(['floats' => [1, 'failed', 2.5]], 'floats', true));
+
+		Assert::throws(
+			static function (): void {
+				Assert::null(Arrays::extractFloatArrayOrNull(['floats' => [1, 'failed', 2.5]], 'floats'));
+			},
+			InvalidTypeException::class
+		);
+	}
+
 }
 
 (new ArraysTest())->run();