Yoshi2889 / validation-closures

src/Ranges.php

Indentation +81 added lines, -81 removed lines

@@ -11,39 +11,39 @@ 
 
 class Ranges
 {
-	/**
-	 * @param int $minimumLength
-	 * @param int $maximumLength
-	 *
-	 * @return \Closure
-	 */
-	public static function stringWithLengthBetween(int $minimumLength, int $maximumLength): \Closure
-	{
-		if ($maximumLength < 0 || $maximumLength < 1)
-			throw new \InvalidArgumentException('Minimum length cannot be below 0, maximum length cannot be below 1');
+    /**
+     * @param int $minimumLength
+     * @param int $maximumLength
+     *
+     * @return \Closure
+     */
+    public static function stringWithLengthBetween(int $minimumLength, int $maximumLength): \Closure
+    {
+        if ($maximumLength < 0 || $maximumLength < 1)
+            throw new \InvalidArgumentException('Minimum length cannot be below 0, maximum length cannot be below 1');
 
-		return function ($value) use ($minimumLength, $maximumLength)
-		{
-			return Types::string()($value) && static::intBetween($minimumLength, $maximumLength)(strlen($value));
-		};
-	}
+        return function ($value) use ($minimumLength, $maximumLength)
+        {
+            return Types::string()($value) && static::intBetween($minimumLength, $maximumLength)(strlen($value));
+        };
+    }
 
-	/**
-	 * @param int $minimum
-	 * @param int $maximum
-	 *
-	 * @return \Closure
-	 */
-	public static function intBetween(int $minimum, int $maximum): \Closure
-	{
+    /**
+     * @param int $minimum
+     * @param int $maximum
+     *
+     * @return \Closure
+     */
+    public static function intBetween(int $minimum, int $maximum): \Closure
+    {
         if ($maximum <= $minimum)
             throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
         
-		return function ($value) use ($minimum, $maximum)
-		{
-			return Types::int()($value) && ($value >= $minimum && $value <= $maximum);
-		};
-	}
+        return function ($value) use ($minimum, $maximum)
+        {
+            return Types::int()($value) && ($value >= $minimum && $value <= $maximum);
+        };
+    }
 
     /**
      * @param int $minimum
@@ -60,24 +60,24 @@ 
         {
             return Types::int()($value) && ($value > $minimum && $value < $maximum);
         };
-	}
+    }
 
-	/**
-	 * @param float $minimum
-	 * @param float $maximum
-	 *
-	 * @return \Closure
-	 */
-	public static function floatBetween(float $minimum, float $maximum): \Closure
-	{
+    /**
+     * @param float $minimum
+     * @param float $maximum
+     *
+     * @return \Closure
+     */
+    public static function floatBetween(float $minimum, float $maximum): \Closure
+    {
         if ($maximum <= $minimum)
             throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
         
-		return function ($value) use ($minimum, $maximum)
-		{
-			return Types::float()($value) && ($value >= $minimum && $value <= $maximum);
-		};
-	}
+        return function ($value) use ($minimum, $maximum)
+        {
+            return Types::float()($value) && ($value >= $minimum && $value <= $maximum);
+        };
+    }
 
     /**
      * @param float $minimum
@@ -94,47 +94,47 @@ 
         {
             return Types::float()($value) && ($value > $minimum && $value < $maximum);
         };
-	}
+    }
 
-	/**
-	 * @param array ...$allowedValues
-	 *
-	 * @return \Closure
-	 */
-	public static function enum(...$allowedValues): \Closure
-	{
-		return function ($value) use ($allowedValues)
-		{
-			return in_array($value, $allowedValues, true);
-		};
-	}
+    /**
+     * @param array ...$allowedValues
+     *
+     * @return \Closure
+     */
+    public static function enum(...$allowedValues): \Closure
+    {
+        return function ($value) use ($allowedValues)
+        {
+            return in_array($value, $allowedValues, true);
+        };
+    }
 
-	/**
-	 * @param array ...$allowedTypes
-	 *
-	 * @return \Closure
-	 */
-	public static function typeEnum(...$allowedTypes): \Closure
-	{
-		return function ($value) use ($allowedTypes)
-		{
-			return in_array(gettype($value), $allowedTypes, true);
-		};
-	}
+    /**
+     * @param array ...$allowedTypes
+     *
+     * @return \Closure
+     */
+    public static function typeEnum(...$allowedTypes): \Closure
+    {
+        return function ($value) use ($allowedTypes)
+        {
+            return in_array(gettype($value), $allowedTypes, true);
+        };
+    }
 
-	/**
-	 * @param array ...$allowedValues
-	 *
-	 * @return \Closure
-	 */
-	public static function stringOneOf(...$allowedValues): \Closure
-	{
-		if (!Utils::validateArray(Types::string(), $allowedValues))
-			throw new \InvalidArgumentException('Ranges::stringOneOf expects arguments of type string only');
+    /**
+     * @param array ...$allowedValues
+     *
+     * @return \Closure
+     */
+    public static function stringOneOf(...$allowedValues): \Closure
+    {
+        if (!Utils::validateArray(Types::string(), $allowedValues))
+            throw new \InvalidArgumentException('Ranges::stringOneOf expects arguments of type string only');
 
-		return function ($value) use ($allowedValues)
-		{
-			return Types::string() && in_array($value, $allowedValues);
-		};
-	}
+        return function ($value) use ($allowedValues)
+        {
+            return Types::string() && in_array($value, $allowedValues);
+        };
+    }
 }
\ No newline at end of file

Braces +18 added lines, -12 removed lines

@@ -19,8 +19,9 @@ 
 	 */
 	public static function stringWithLengthBetween(int $minimumLength, int $maximumLength): \Closure
 	{
-		if ($maximumLength < 0 || $maximumLength < 1)
-			throw new \InvalidArgumentException('Minimum length cannot be below 0, maximum length cannot be below 1');
+		if ($maximumLength < 0 || $maximumLength < 1) {
+					throw new \InvalidArgumentException('Minimum length cannot be below 0, maximum length cannot be below 1');
+		}
 
 		return function ($value) use ($minimumLength, $maximumLength)
 		{
@@ -36,8 +37,9 @@ 
 	 */
 	public static function intBetween(int $minimum, int $maximum): \Closure
 	{
-        if ($maximum <= $minimum)
-            throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        if ($maximum <= $minimum) {
+                    throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        }
         
 		return function ($value) use ($minimum, $maximum)
 		{
@@ -53,8 +55,9 @@ 
      */
     public static function intBetweenExclusive(int $minimum, int $maximum): \Closure
     {
-        if ($maximum <= $minimum)
-            throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        if ($maximum <= $minimum) {
+                    throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        }
         
         return function ($value) use ($minimum, $maximum)
         {
@@ -70,8 +73,9 @@ 
 	 */
 	public static function floatBetween(float $minimum, float $maximum): \Closure
 	{
-        if ($maximum <= $minimum)
-            throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        if ($maximum <= $minimum) {
+                    throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        }
         
 		return function ($value) use ($minimum, $maximum)
 		{
@@ -87,8 +91,9 @@ 
      */
     public static function floatBetweenExclusive(float $minimum, float $maximum): \Closure
     {
-        if ($maximum <= $minimum)
-            throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        if ($maximum <= $minimum) {
+                    throw new \InvalidArgumentException('Maximum can not be lesser than or equal to minimum.');
+        }
         
         return function ($value) use ($minimum, $maximum)
         {
@@ -129,8 +134,9 @@ 
 	 */
 	public static function stringOneOf(...$allowedValues): \Closure
 	{
-		if (!Utils::validateArray(Types::string(), $allowedValues))
-			throw new \InvalidArgumentException('Ranges::stringOneOf expects arguments of type string only');
+		if (!Utils::validateArray(Types::string(), $allowedValues)) {
+					throw new \InvalidArgumentException('Ranges::stringOneOf expects arguments of type string only');
+		}
 
 		return function ($value) use ($allowedValues)
 		{

src/Types.php

Indentation +62 added lines, -62 removed lines

@@ -10,61 +10,61 @@ 
 
 class Types
 {
-	/**
-	 * @return \Closure
-	 */
-	public static function string(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_string');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function string(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_string');
+    }
 
-	/**
-	 * @return \Closure
-	 */
-	public static function int(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_int');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function int(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_int');
+    }
 
-	/**
-	 * @return \Closure
-	 */
-	public static function float(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_float');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function float(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_float');
+    }
 
-	/**
-	 * @return \Closure
-	 */
-	public static function boolean(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_bool');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function boolean(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_bool');
+    }
 
-	/**
-	 * @return \Closure
-	 */
-	public static function array(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_array');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function array(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_array');
+    }
 
-	/**
-	 * @return \Closure
-	 */
-	public static function callable(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_callable');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function callable(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_callable');
+    }
 
-	/**
-	 * @return \Closure
-	 */
-	public static function object(): \Closure
-	{
-		return Utils::createClosureFromCallable('is_object');
-	}
+    /**
+     * @return \Closure
+     */
+    public static function object(): \Closure
+    {
+        return Utils::createClosureFromCallable('is_object');
+    }
 
     /**
      * @return \Closure
@@ -72,18 +72,18 @@ 
     public static function numeric(): \Closure
     {
         return Utils::createClosureFromCallable('is_numeric');
-	}
+    }
 
-	/**
-	 * @param string $class
-	 *
-	 * @return \Closure
-	 */
-	public static function instanceof(string $class): \Closure
-	{
-		return function ($value) use ($class)
-		{
-			return $value instanceof $class;
-		};
-	}
+    /**
+     * @param string $class
+     *
+     * @return \Closure
+     */
+    public static function instanceof(string $class): \Closure
+    {
+        return function ($value) use ($class)
+        {
+            return $value instanceof $class;
+        };
+    }
 }
\ No newline at end of file

src/Reflection.php

Indentation +29 added lines, -29 removed lines

@@ -36,38 +36,38 @@
  */
 class Reflection
 {
-	/**
-	 * @param string $class
-	 *
-	 * @return \ReflectionClass
-	 */
-	public static function createReflectionObject(string $class): \ReflectionClass
-	{
-		if (!class_exists($class))
-			throw new \InvalidArgumentException('The given class does not exist');
+    /**
+     * @param string $class
+     *
+     * @return \ReflectionClass
+     */
+    public static function createReflectionObject(string $class): \ReflectionClass
+    {
+        if (!class_exists($class))
+            throw new \InvalidArgumentException('The given class does not exist');
 
-		return new \ReflectionClass($class);
-	}
+        return new \ReflectionClass($class);
+    }
 
-	/**
-	 * @param string $method
-	 * @param array $arguments
-	 *
-	 * @return \Closure
-	 */
-	public static function __callStatic(string $method, array $arguments): \Closure
-	{
-		if (!method_exists(\ReflectionClass::class, $method))
-			throw new \InvalidArgumentException('Cannot create closure from method ReflectionClass::' . $method . ', it does not exist');
+    /**
+     * @param string $method
+     * @param array $arguments
+     *
+     * @return \Closure
+     */
+    public static function __callStatic(string $method, array $arguments): \Closure
+    {
+        if (!method_exists(\ReflectionClass::class, $method))
+            throw new \InvalidArgumentException('Cannot create closure from method ReflectionClass::' . $method . ', it does not exist');
 
-		return function ($value) use ($method, $arguments)
-		{
-			if (!Types::string()($value))
-				return false;
+        return function ($value) use ($method, $arguments)
+        {
+            if (!Types::string()($value))
+                return false;
 
-			$reflection = static::createReflectionObject($value);
+            $reflection = static::createReflectionObject($value);
 
-			return call_user_func_array([$reflection, $method], $arguments);
-		};
-	}
+            return call_user_func_array([$reflection, $method], $arguments);
+        };
+    }
 }
\ No newline at end of file

Braces +9 added lines, -6 removed lines

@@ -43,8 +43,9 @@ 
 	 */
 	public static function createReflectionObject(string $class): \ReflectionClass
 	{
-		if (!class_exists($class))
-			throw new \InvalidArgumentException('The given class does not exist');
+		if (!class_exists($class)) {
+					throw new \InvalidArgumentException('The given class does not exist');
+		}
 
 		return new \ReflectionClass($class);
 	}
@@ -57,13 +58,15 @@ 
 	 */
 	public static function __callStatic(string $method, array $arguments): \Closure
 	{
-		if (!method_exists(\ReflectionClass::class, $method))
-			throw new \InvalidArgumentException('Cannot create closure from method ReflectionClass::' . $method . ', it does not exist');
+		if (!method_exists(\ReflectionClass::class, $method)) {
+					throw new \InvalidArgumentException('Cannot create closure from method ReflectionClass::' . $method . ', it does not exist');
+		}
 
 		return function ($value) use ($method, $arguments)
 		{
-			if (!Types::string()($value))
-				return false;
+			if (!Types::string()($value)) {
+							return false;
+			}
 
 			$reflection = static::createReflectionObject($value);
 

src/Utils.php

Indentation +52 added lines, -52 removed lines

@@ -10,61 +10,61 @@ 
 
 class Utils
 {
-	/**
-	 * @param \Closure $closure
-	 *
-	 * @return \Closure
-	 */
-	public static function invert(\Closure $closure): \Closure
-	{
-		return function ($value) use ($closure)
-		{
-			return !$closure($value);
-		};
-	}
+    /**
+     * @param \Closure $closure
+     *
+     * @return \Closure
+     */
+    public static function invert(\Closure $closure): \Closure
+    {
+        return function ($value) use ($closure)
+        {
+            return !$closure($value);
+        };
+    }
 
-	/**
-	 * @param \Closure $closure1
-	 * @param \Closure $closure2
-	 *
-	 * @return \Closure
-	 */
-	public static function merge(\Closure $closure1, \Closure $closure2): \Closure
-	{
-		return function ($value) use ($closure1, $closure2)
-		{
-			return $closure1($value) || $closure2($value);
-		};
-	}
+    /**
+     * @param \Closure $closure1
+     * @param \Closure $closure2
+     *
+     * @return \Closure
+     */
+    public static function merge(\Closure $closure1, \Closure $closure2): \Closure
+    {
+        return function ($value) use ($closure1, $closure2)
+        {
+            return $closure1($value) || $closure2($value);
+        };
+    }
 
-	/**
-	 * @param \Closure $closure1
-	 * @param \Closure $closure2
-	 *
-	 * @return \Closure
-	 */
-	public static function both(\Closure $closure1, \Closure $closure2): \Closure
-	{
-		return function ($value) use ($closure1, $closure2)
-		{
-			return $closure1($value) && $closure2($value);
-		};
-	}
+    /**
+     * @param \Closure $closure1
+     * @param \Closure $closure2
+     *
+     * @return \Closure
+     */
+    public static function both(\Closure $closure1, \Closure $closure2): \Closure
+    {
+        return function ($value) use ($closure1, $closure2)
+        {
+            return $closure1($value) && $closure2($value);
+        };
+    }
 
-	/**
-	 * @param \Closure $closure
-	 * @param array $values
-	 *
-	 * @return bool
-	 */
-	public static function validateArray(\Closure $closure, array $values): bool
-	{
-		foreach ($values as $value)
-			if (!$closure($value))
-				return false;
+    /**
+     * @param \Closure $closure
+     * @param array $values
+     *
+     * @return bool
+     */
+    public static function validateArray(\Closure $closure, array $values): bool
+    {
+        foreach ($values as $value)
+            if (!$closure($value))
+                return false;
 
-		return true;
-	}
+        return true;
+    }
 
     /**
      * @param callable $callable
@@ -81,5 +81,5 @@ 
         {
             return $callable($value);
         };
-	}
+    }
 }
\ No newline at end of file

Braces +6 added lines, -4 removed lines

@@ -60,8 +60,9 @@ 
 	public static function validateArray(\Closure $closure, array $values): bool
 	{
 		foreach ($values as $value)
-			if (!$closure($value))
-				return false;
+			if (!$closure($value)) {
+							return false;
+			}
 
 		return true;
 	}
@@ -74,8 +75,9 @@ 
     public static function createClosureFromCallable(callable $callable)
     {
         // Closure::fromCallable was introduced in PHP 7.1.0
-        if (version_compare(PHP_VERSION, '7.1.0', '>='))
-            return \Closure::fromCallable($callable);
+        if (version_compare(PHP_VERSION, '7.1.0', '>=')) {
+                    return \Closure::fromCallable($callable);
+        }
         
         return function ($value) use ($callable)
         {