Yoshi2889 / validation-closures

src/Reflection.php

Indentation +21 added lines, -21 removed lines

@@ -47,36 +47,36 @@
      * @return ReflectionClass
      * @throws ReflectionException
      */
-	public static function createReflectionObject(string $class): ReflectionClass
-	{
-		if (!class_exists($class)) {
+    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)) {
+    /**
+     * @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 static function ($value) use ($method, $arguments)
-		{
-			if (!Types::string()($value)) {
+        return static 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

src/Types.php

Indentation +62 added lines, -62 removed lines

@@ -12,61 +12,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
@@ -74,18 +74,18 @@ 
     public static function numeric(): Closure
     {
         return Utils::createClosureFromCallable('is_numeric');
-	}
+    }
 
-	/**
-	 * @param string $class
-	 *
-	 * @return Closure
-	 */
-	public static function instanceof(string $class): Closure
-	{
-		return static function ($value) use ($class)
-		{
-			return $value instanceof $class;
-		};
-	}
+    /**
+     * @param string $class
+     *
+     * @return Closure
+     */
+    public static function instanceof(string $class): Closure
+    {
+        return static function ($value) use ($class)
+        {
+            return $value instanceof $class;
+        };
+    }
 }
\ No newline at end of file

src/Utils.php

Indentation +50 added lines, -50 removed lines

@@ -12,63 +12,63 @@ 
 
 class Utils
 {
-	/**
-	 * @param Closure $closure
-	 *
-	 * @return Closure
-	 */
-	public static function invert(Closure $closure): Closure
-	{
-		return static function ($value) use ($closure)
-		{
-			return !$closure($value);
-		};
-	}
+    /**
+     * @param Closure $closure
+     *
+     * @return Closure
+     */
+    public static function invert(Closure $closure): Closure
+    {
+        return static 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 static 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 static 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 static 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 static 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) {
+    /**
+     * @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
@@ -78,5 +78,5 @@ 
     public static function createClosureFromCallable(callable $callable): callable
     {
         return Closure::fromCallable($callable);
-	}
+    }
 }
\ No newline at end of file

Braces +2 added lines, -1 removed lines

@@ -61,7 +61,8 @@
 	 */
 	public static function validateArray(Closure $closure, array $values): bool
 	{
-		foreach ($values as $value) {
+		foreach ($values as $value)
+		{
             if (!$closure($value)) {
                 return false;
             }

src/Ranges.php

Indentation +79 added lines, -79 removed lines

@@ -14,41 +14,41 @@ 
 
 class Ranges
 {
-	/**
-	 * @param int $minimumLength
-	 * @param int $maximumLength
-	 *
-	 * @return Closure
-	 */
-	public static function stringWithLengthBetween(int $minimumLength, int $maximumLength): Closure
-	{
-		if ($maximumLength < 0 || $maximumLength < 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 static function ($value) use ($minimumLength, $maximumLength)
-		{
-			return Types::string()($value) && static::intBetween($minimumLength, $maximumLength)(strlen($value));
-		};
-	}
+        return static 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 static function ($value) use ($minimum, $maximum)
-		{
-			return Types::int()($value) && ($value >= $minimum && $value <= $maximum);
-		};
-	}
+        return static function ($value) use ($minimum, $maximum)
+        {
+            return Types::int()($value) && ($value >= $minimum && $value <= $maximum);
+        };
+    }
 
     /**
      * @param int $minimum
@@ -66,25 +66,25 @@ 
         {
             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 static function ($value) use ($minimum, $maximum)
-		{
-			return Types::float()($value) && ($value >= $minimum && $value <= $maximum);
-		};
-	}
+        return static function ($value) use ($minimum, $maximum)
+        {
+            return Types::float()($value) && ($value >= $minimum && $value <= $maximum);
+        };
+    }
 
     /**
      * @param float $minimum
@@ -102,48 +102,48 @@ 
         {
             return Types::float()($value) && ($value > $minimum && $value < $maximum);
         };
-	}
+    }
 
-	/**
-	 * @param array ...$allowedValues
-	 *
-	 * @return Closure
-	 */
-	public static function enum(...$allowedValues): Closure
-	{
-		return static function ($value) use ($allowedValues)
-		{
-			return in_array($value, $allowedValues, true);
-		};
-	}
+    /**
+     * @param array ...$allowedValues
+     *
+     * @return Closure
+     */
+    public static function enum(...$allowedValues): Closure
+    {
+        return static function ($value) use ($allowedValues)
+        {
+            return in_array($value, $allowedValues, true);
+        };
+    }
 
-	/**
-	 * @param array ...$allowedTypes
-	 *
-	 * @return Closure
-	 */
-	public static function typeEnum(...$allowedTypes): Closure
-	{
-		return static function ($value) use ($allowedTypes)
-		{
-			return in_array(gettype($value), $allowedTypes, true);
-		};
-	}
+    /**
+     * @param array ...$allowedTypes
+     *
+     * @return Closure
+     */
+    public static function typeEnum(...$allowedTypes): Closure
+    {
+        return static 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)) {
+    /**
+     * @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 static function ($value) use ($allowedValues)
-		{
-			return Types::string() && in_array($value, $allowedValues, true);
-		};
-	}
+        return static function ($value) use ($allowedValues)
+        {
+            return Types::string() && in_array($value, $allowedValues, true);
+        };
+    }
 }
\ No newline at end of file

tests/ReflectionTest.php

Indentation +16 added lines, -16 removed lines

@@ -12,23 +12,23 @@
 
 class ReflectionTest extends TestCase
 {
-	public function testCreateReflectionObject()
-	{
-		$expectedReflection = new ReflectionClass(stdClass::class);
-		$reflection = Reflection::createReflectionObject(stdClass::class);
-		self::assertEquals($expectedReflection, $reflection);
+    public function testCreateReflectionObject()
+    {
+        $expectedReflection = new ReflectionClass(stdClass::class);
+        $reflection = Reflection::createReflectionObject(stdClass::class);
+        self::assertEquals($expectedReflection, $reflection);
 
-		$this->expectException(\InvalidArgumentException::class);
-		Reflection::createReflectionObject('blablabla\nonexistingclass');
-	}
+        $this->expectException(\InvalidArgumentException::class);
+        Reflection::createReflectionObject('blablabla\nonexistingclass');
+    }
 
-	public function testCallStaticMagicMethod()
-	{
-		self::assertFalse(Reflection::isInterface()(stdClass::class));
-		self::assertFalse(Reflection::isInterface()(10));
-		self::assertTrue(Reflection::isInstance(new stdClass())(stdClass::class));
+    public function testCallStaticMagicMethod()
+    {
+        self::assertFalse(Reflection::isInterface()(stdClass::class));
+        self::assertFalse(Reflection::isInterface()(10));
+        self::assertTrue(Reflection::isInstance(new stdClass())(stdClass::class));
 
-		$this->expectException(\InvalidArgumentException::class);
-		Reflection::nonExistingMethod();
-	}
+        $this->expectException(\InvalidArgumentException::class);
+        Reflection::nonExistingMethod();
+    }
 }

tests/UtilsTest.php

Indentation +47 added lines, -47 removed lines

@@ -11,62 +11,62 @@ 
 
 class UtilsTest extends TestCase
 {
-	public function testInvert()
-	{
-		$closure = \ValidationClosures\Types::string();
+    public function testInvert()
+    {
+        $closure = \ValidationClosures\Types::string();
 
-		// This should become equal to Types::notString()
-		$invertedClosure = Utils::invert($closure);
+        // This should become equal to Types::notString()
+        $invertedClosure = Utils::invert($closure);
 
-		self::assertTrue($invertedClosure(10));
-		self::assertFalse($invertedClosure('test'));
-		self::assertTrue($invertedClosure(1.2));
-		self::assertTrue($invertedClosure(false));
-		self::assertTrue($invertedClosure([ ]));
-		self::assertFalse($invertedClosure('in_array'));
-		self::assertTrue($invertedClosure(new stdClass()));
-	}
+        self::assertTrue($invertedClosure(10));
+        self::assertFalse($invertedClosure('test'));
+        self::assertTrue($invertedClosure(1.2));
+        self::assertTrue($invertedClosure(false));
+        self::assertTrue($invertedClosure([ ]));
+        self::assertFalse($invertedClosure('in_array'));
+        self::assertTrue($invertedClosure(new stdClass()));
+    }
 
-	public function testMerge()
-	{
-		$closure1 = \ValidationClosures\Types::int();
-		$closure2 = \ValidationClosures\Ranges::stringWithLengthBetween(2, 10);
+    public function testMerge()
+    {
+        $closure1 = \ValidationClosures\Types::int();
+        $closure2 = \ValidationClosures\Ranges::stringWithLengthBetween(2, 10);
 
-		$mergedClosure = Utils::merge($closure1, $closure2);
+        $mergedClosure = Utils::merge($closure1, $closure2);
 
-		self::assertTrue($mergedClosure(10));
-		self::assertTrue($mergedClosure('test'));
-		self::assertFalse($mergedClosure(1.2));
-		self::assertFalse($mergedClosure(false));
-		self::assertFalse($mergedClosure([ ]));
-		self::assertTrue($mergedClosure('in_array'));
-		self::assertFalse($mergedClosure(new stdClass()));
-	}
+        self::assertTrue($mergedClosure(10));
+        self::assertTrue($mergedClosure('test'));
+        self::assertFalse($mergedClosure(1.2));
+        self::assertFalse($mergedClosure(false));
+        self::assertFalse($mergedClosure([ ]));
+        self::assertTrue($mergedClosure('in_array'));
+        self::assertFalse($mergedClosure(new stdClass()));
+    }
 
-	public function testBoth()
-	{
-		$closure1 = \ValidationClosures\Ranges::stringOneOf('test', 'testing', 'te');
-		$closure2 = \ValidationClosures\Ranges::stringWithLengthBetween(2, 10);
+    public function testBoth()
+    {
+        $closure1 = \ValidationClosures\Ranges::stringOneOf('test', 'testing', 'te');
+        $closure2 = \ValidationClosures\Ranges::stringWithLengthBetween(2, 10);
 
-		$mergedClosure = Utils::both($closure1, $closure2);
+        $mergedClosure = Utils::both($closure1, $closure2);
 
-		self::assertFalse($mergedClosure(10));
-		self::assertTrue($mergedClosure('test'));
-		self::assertFalse($mergedClosure(1.2));
-		self::assertFalse($mergedClosure(false));
-		self::assertFalse($mergedClosure([ ]));
-		self::assertFalse($mergedClosure('in_array'));
-		self::assertFalse($mergedClosure(new stdClass()));
-	}
+        self::assertFalse($mergedClosure(10));
+        self::assertTrue($mergedClosure('test'));
+        self::assertFalse($mergedClosure(1.2));
+        self::assertFalse($mergedClosure(false));
+        self::assertFalse($mergedClosure([ ]));
+        self::assertFalse($mergedClosure('in_array'));
+        self::assertFalse($mergedClosure(new stdClass()));
+    }
 
-	public function testValidateArray()
-	{
-		$array = ['string', 'another string', 'a third string'];
-		self::assertTrue(Utils::validateArray(\ValidationClosures\Types::string(), $array));
+    public function testValidateArray()
+    {
+        $array = ['string', 'another string', 'a third string'];
+        self::assertTrue(Utils::validateArray(\ValidationClosures\Types::string(), $array));
 
-		$array = ['string', 'another string', 'a third string', 10];
-		self::assertFalse(Utils::validateArray(\ValidationClosures\Types::string(), $array));
-	}
+        $array = ['string', 'another string', 'a third string', 10];
+        self::assertFalse(Utils::validateArray(\ValidationClosures\Types::string(), $array));
+    }
 
     public function testCreateClosureFromCallable()
     {
@@ -78,5 +78,5 @@ 
         $actual = Utils::createClosureFromCallable('is_string');
         
         self::assertEquals($expected, $actual);
-	}
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -22,7 +22,7 @@ 
 		self::assertFalse($invertedClosure('test'));
 		self::assertTrue($invertedClosure(1.2));
 		self::assertTrue($invertedClosure(false));
-		self::assertTrue($invertedClosure([ ]));
+		self::assertTrue($invertedClosure([]));
 		self::assertFalse($invertedClosure('in_array'));
 		self::assertTrue($invertedClosure(new stdClass()));
 	}
@@ -38,7 +38,7 @@ 
 		self::assertTrue($mergedClosure('test'));
 		self::assertFalse($mergedClosure(1.2));
 		self::assertFalse($mergedClosure(false));
-		self::assertFalse($mergedClosure([ ]));
+		self::assertFalse($mergedClosure([]));
 		self::assertTrue($mergedClosure('in_array'));
 		self::assertFalse($mergedClosure(new stdClass()));
 	}
@@ -54,7 +54,7 @@ 
 		self::assertTrue($mergedClosure('test'));
 		self::assertFalse($mergedClosure(1.2));
 		self::assertFalse($mergedClosure(false));
-		self::assertFalse($mergedClosure([ ]));
+		self::assertFalse($mergedClosure([]));
 		self::assertFalse($mergedClosure('in_array'));
 		self::assertFalse($mergedClosure(new stdClass()));
 	}

tests/RangesTest.php

Indentation +143 added lines, -143 removed lines

@@ -11,83 +11,83 @@ 
 
 class RangesTest extends TestCase
 {
-	public function testStringWithLengthBetween()
-	{
-		$closure = Ranges::stringWithLengthBetween(0, 10);
-		self::assertFalse($closure(5));
-		self::assertTrue($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertTrue($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
+    public function testStringWithLengthBetween()
+    {
+        $closure = Ranges::stringWithLengthBetween(0, 10);
+        self::assertFalse($closure(5));
+        self::assertTrue($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertTrue($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
 
-		$closure = Ranges::stringWithLengthBetween(0, 1);
-		self::assertTrue($closure(''));
-		self::assertTrue($closure('a'));
-		self::assertFalse($closure('aaa'));
-		self::assertFalse($closure('aaaaa'));
+        $closure = Ranges::stringWithLengthBetween(0, 1);
+        self::assertTrue($closure(''));
+        self::assertTrue($closure('a'));
+        self::assertFalse($closure('aaa'));
+        self::assertFalse($closure('aaaaa'));
 
-		$closure = Ranges::stringWithLengthBetween(0, 5);
-		self::assertFalse($closure(5));
-		self::assertTrue($closure(''));
-		self::assertTrue($closure('a'));
-		self::assertTrue($closure('aaa'));
-		self::assertTrue($closure('aaaaa'));
+        $closure = Ranges::stringWithLengthBetween(0, 5);
+        self::assertFalse($closure(5));
+        self::assertTrue($closure(''));
+        self::assertTrue($closure('a'));
+        self::assertTrue($closure('aaa'));
+        self::assertTrue($closure('aaaaa'));
 
-		$closure = Ranges::stringWithLengthBetween(2, 4);
-		self::assertFalse($closure(5));
-		self::assertFalse($closure(''));
-		self::assertFalse($closure('a'));
-		self::assertTrue($closure('aa'));
-		self::assertTrue($closure('aaa'));
-		self::assertFalse($closure('aaaaa'));
-	}
+        $closure = Ranges::stringWithLengthBetween(2, 4);
+        self::assertFalse($closure(5));
+        self::assertFalse($closure(''));
+        self::assertFalse($closure('a'));
+        self::assertTrue($closure('aa'));
+        self::assertTrue($closure('aaa'));
+        self::assertFalse($closure('aaaaa'));
+    }
 
-	public function testStringWithLengthBetween_InvalidParams()
-	{
-		$this->expectException(InvalidArgumentException::class);
-		Ranges::stringWithLengthBetween(-1, 0);
+    public function testStringWithLengthBetween_InvalidParams()
+    {
+        $this->expectException(InvalidArgumentException::class);
+        Ranges::stringWithLengthBetween(-1, 0);
 
-		$this->expectException(InvalidArgumentException::class);
-		Ranges::stringWithLengthBetween(0, 0);
-	}
+        $this->expectException(InvalidArgumentException::class);
+        Ranges::stringWithLengthBetween(0, 0);
+    }
 
-	public function testIntBetween()
-	{
-		$closure = Ranges::intBetween(0, 3);
-		self::assertTrue($closure(2));
-		self::assertFalse($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
+    public function testIntBetween()
+    {
+        $closure = Ranges::intBetween(0, 3);
+        self::assertTrue($closure(2));
+        self::assertFalse($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
 
-		self::assertFalse($closure(-3));
-		self::assertFalse($closure(-2));
-		self::assertFalse($closure(-1));
-		self::assertTrue($closure(0));
-		self::assertTrue($closure(1));
-		self::assertTrue($closure(2));
-		self::assertTrue($closure(3));
-		self::assertFalse($closure(4));
-		self::assertFalse($closure(5));
+        self::assertFalse($closure(-3));
+        self::assertFalse($closure(-2));
+        self::assertFalse($closure(-1));
+        self::assertTrue($closure(0));
+        self::assertTrue($closure(1));
+        self::assertTrue($closure(2));
+        self::assertTrue($closure(3));
+        self::assertFalse($closure(4));
+        self::assertFalse($closure(5));
 
-		$closure = Ranges::intBetween(-2, 2);
-		self::assertFalse($closure(-3));
-		self::assertTrue($closure(-2));
-		self::assertTrue($closure(-1));
-		self::assertTrue($closure(0));
-		self::assertTrue($closure(1));
-		self::assertTrue($closure(2));
-		self::assertFalse($closure(3));
-		self::assertFalse($closure(4));
-		self::assertFalse($closure(5));
+        $closure = Ranges::intBetween(-2, 2);
+        self::assertFalse($closure(-3));
+        self::assertTrue($closure(-2));
+        self::assertTrue($closure(-1));
+        self::assertTrue($closure(0));
+        self::assertTrue($closure(1));
+        self::assertTrue($closure(2));
+        self::assertFalse($closure(3));
+        self::assertFalse($closure(4));
+        self::assertFalse($closure(5));
 		
-		self::expectException(\InvalidArgumentException::class);
-		Ranges::intBetween(5, 3);
-	}
+        self::expectException(\InvalidArgumentException::class);
+        Ranges::intBetween(5, 3);
+    }
 
     public function testIntBetweenExclusive()
     {
@@ -125,44 +125,44 @@ 
         Ranges::intBetweenExclusive(5, 3);
     }
 
-	public function testFloatBetween()
-	{
-		$closure = Ranges::floatBetween(0.0, 3.0);
-		self::assertFalse($closure(2));
-		self::assertFalse($closure('test'));
-		self::assertTrue($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
+    public function testFloatBetween()
+    {
+        $closure = Ranges::floatBetween(0.0, 3.0);
+        self::assertFalse($closure(2));
+        self::assertFalse($closure('test'));
+        self::assertTrue($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
 
-		self::assertFalse($closure(-3.0));
-		self::assertFalse($closure(-2.0));
-		self::assertFalse($closure(-1.0));
-		self::assertTrue($closure(0.0));
-		self::assertTrue($closure(1.0));
-		self::assertTrue($closure(2.0));
-		self::assertTrue($closure(3.0));
-		self::assertFalse($closure(3.1));
-		self::assertFalse($closure(4.0));
-		self::assertFalse($closure(5.0));
+        self::assertFalse($closure(-3.0));
+        self::assertFalse($closure(-2.0));
+        self::assertFalse($closure(-1.0));
+        self::assertTrue($closure(0.0));
+        self::assertTrue($closure(1.0));
+        self::assertTrue($closure(2.0));
+        self::assertTrue($closure(3.0));
+        self::assertFalse($closure(3.1));
+        self::assertFalse($closure(4.0));
+        self::assertFalse($closure(5.0));
 
-		$closure = Ranges::floatBetween(-2.0, 2.0);
-		self::assertFalse($closure(-3.0));
-		self::assertFalse($closure(-2.1));
-		self::assertTrue($closure(-2.0));
-		self::assertTrue($closure(-1.0));
-		self::assertTrue($closure(0.0));
-		self::assertTrue($closure(1.0));
-		self::assertTrue($closure(2.0));
-		self::assertFalse($closure(2.1));
-		self::assertFalse($closure(3.0));
-		self::assertFalse($closure(4.0));
-		self::assertFalse($closure(5.0));
+        $closure = Ranges::floatBetween(-2.0, 2.0);
+        self::assertFalse($closure(-3.0));
+        self::assertFalse($closure(-2.1));
+        self::assertTrue($closure(-2.0));
+        self::assertTrue($closure(-1.0));
+        self::assertTrue($closure(0.0));
+        self::assertTrue($closure(1.0));
+        self::assertTrue($closure(2.0));
+        self::assertFalse($closure(2.1));
+        self::assertFalse($closure(3.0));
+        self::assertFalse($closure(4.0));
+        self::assertFalse($closure(5.0));
 
         self::expectException(\InvalidArgumentException::class);
         Ranges::floatBetween(5.0, 3.0);
-	}
+    }
 
     public function testFloatBetweenExclusive()
     {
@@ -207,52 +207,52 @@ 
         Ranges::floatBetweenExclusive(5.0, 3.0);
     }
 
-	public function testEnum()
-	{
-		$closure = Ranges::enum(10, 'test', false);
+    public function testEnum()
+    {
+        $closure = Ranges::enum(10, 'test', false);
 
-		self::assertTrue($closure(10));
-		self::assertTrue($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertTrue($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
+        self::assertTrue($closure(10));
+        self::assertTrue($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertTrue($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
 
-	public function testTypeEnum()
-	{
-		$closure = Ranges::typeEnum('string', 'double');
+    public function testTypeEnum()
+    {
+        $closure = Ranges::typeEnum('string', 'double');
 
-		self::assertFalse($closure(10));
-		self::assertTrue($closure('test'));
-		self::assertTrue($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertTrue($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
+        self::assertFalse($closure(10));
+        self::assertTrue($closure('test'));
+        self::assertTrue($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertTrue($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
 
-	public function testStringOneOf()
-	{
-		$closure = Ranges::stringOneOf('test', 'ing');
-		self::assertFalse($closure(10));
-		self::assertTrue($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
+    public function testStringOneOf()
+    {
+        $closure = Ranges::stringOneOf('test', 'ing');
+        self::assertFalse($closure(10));
+        self::assertTrue($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
 
-		self::assertTrue($closure('test'));
-		self::assertTrue($closure('ing'));
-		self::assertFalse($closure('something else'));
-		self::assertFalse($closure(' '));
-	}
+        self::assertTrue($closure('test'));
+        self::assertTrue($closure('ing'));
+        self::assertFalse($closure('something else'));
+        self::assertFalse($closure(' '));
+    }
 
-	public function testStringOneOf_InvalidParams()
-	{
-		self::expectException(\InvalidArgumentException::class);
-		Ranges::stringOneOf(10, 'test');
-	}
+    public function testStringOneOf_InvalidParams()
+    {
+        self::expectException(\InvalidArgumentException::class);
+        Ranges::stringOneOf(10, 'test');
+    }
 }

Spacing +7 added lines, -7 removed lines

@@ -18,7 +18,7 @@ 
 		self::assertTrue($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertTrue($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 
@@ -60,7 +60,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 
@@ -96,7 +96,7 @@ 
         self::assertFalse($closure('test'));
         self::assertFalse($closure(1.2));
         self::assertFalse($closure(false));
-        self::assertFalse($closure([ ]));
+        self::assertFalse($closure([]));
         self::assertFalse($closure('in_array'));
         self::assertFalse($closure(new stdClass()));
 
@@ -132,7 +132,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertTrue($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 
@@ -171,7 +171,7 @@ 
         self::assertFalse($closure('test'));
         self::assertTrue($closure(1.2));
         self::assertFalse($closure(false));
-        self::assertFalse($closure([ ]));
+        self::assertFalse($closure([]));
         self::assertFalse($closure('in_array'));
         self::assertFalse($closure(new stdClass()));
 
@@ -215,7 +215,7 @@ 
 		self::assertTrue($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertTrue($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -228,7 +228,7 @@ 
 		self::assertTrue($closure('test'));
 		self::assertTrue($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertTrue($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}

tests/TypesTest.php

Indentation +100 added lines, -100 removed lines

@@ -11,97 +11,97 @@ 
 
 class TypesTest extends TestCase
 {
-	public function testInt()
-	{
-		$closure = Types::int();
-
-		self::assertTrue($closure(10));
-		self::assertFalse($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
-
-	public function testString()
-	{
-		$closure = Types::string();
-
-		self::assertFalse($closure(10));
-		self::assertTrue($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertTrue($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
-
-	public function testFloat()
-	{
-		$closure = Types::float();
-
-		self::assertFalse($closure(10));
-		self::assertFalse($closure('test'));
-		self::assertTrue($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
-
-	public function testBool()
-	{
-		$closure = Types::boolean();
-
-		self::assertFalse($closure(10));
-		self::assertFalse($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertTrue($closure(false));
-		self::assertTrue($closure(true));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
-
-	public function testArray()
-	{
-		$closure = Types::array();
-
-		self::assertFalse($closure(10));
-		self::assertFalse($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertTrue($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
-
-	public function testCallable()
-	{
-		$closure = Types::callable();
-
-		self::assertFalse($closure(10));
-		self::assertFalse($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertTrue($closure('in_array'));
-		self::assertFalse($closure(new stdClass()));
-	}
-
-	public function testObject()
-	{
-		$closure = Types::object();
-
-		self::assertFalse($closure(10));
-		self::assertFalse($closure('test'));
-		self::assertFalse($closure(1.2));
-		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
-		self::assertFalse($closure('in_array'));
-		self::assertTrue($closure(new stdClass()));
-	}
+    public function testInt()
+    {
+        $closure = Types::int();
+
+        self::assertTrue($closure(10));
+        self::assertFalse($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
+
+    public function testString()
+    {
+        $closure = Types::string();
+
+        self::assertFalse($closure(10));
+        self::assertTrue($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertTrue($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
+
+    public function testFloat()
+    {
+        $closure = Types::float();
+
+        self::assertFalse($closure(10));
+        self::assertFalse($closure('test'));
+        self::assertTrue($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
+
+    public function testBool()
+    {
+        $closure = Types::boolean();
+
+        self::assertFalse($closure(10));
+        self::assertFalse($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertTrue($closure(false));
+        self::assertTrue($closure(true));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
+
+    public function testArray()
+    {
+        $closure = Types::array();
+
+        self::assertFalse($closure(10));
+        self::assertFalse($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertTrue($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
+
+    public function testCallable()
+    {
+        $closure = Types::callable();
+
+        self::assertFalse($closure(10));
+        self::assertFalse($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertTrue($closure('in_array'));
+        self::assertFalse($closure(new stdClass()));
+    }
+
+    public function testObject()
+    {
+        $closure = Types::object();
+
+        self::assertFalse($closure(10));
+        self::assertFalse($closure('test'));
+        self::assertFalse($closure(1.2));
+        self::assertFalse($closure(false));
+        self::assertFalse($closure([ ]));
+        self::assertFalse($closure('in_array'));
+        self::assertTrue($closure(new stdClass()));
+    }
 
     public function testNumeric()
     {
@@ -114,16 +114,16 @@ 
         self::assertFalse($closure([ ]));
         self::assertFalse($closure('in_array'));
         self::assertFalse($closure(new stdClass()));
-	}
+    }
 
-	public function testInstanceOf()
-	{
-		$closure = Types::instanceof(Types::class);
+    public function testInstanceOf()
+    {
+        $closure = Types::instanceof(Types::class);
 
-		$stdClass = new stdClass();
-		self::assertFalse($closure($stdClass));
+        $stdClass = new stdClass();
+        self::assertFalse($closure($stdClass));
 
-		$types = new Types();
-		self::assertTrue($closure($types));
-	}
+        $types = new Types();
+        self::assertTrue($closure($types));
+    }
 }

Spacing +8 added lines, -8 removed lines

@@ -19,7 +19,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -32,7 +32,7 @@ 
 		self::assertTrue($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertTrue($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -45,7 +45,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertTrue($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -59,7 +59,7 @@ 
 		self::assertFalse($closure(1.2));
 		self::assertTrue($closure(false));
 		self::assertTrue($closure(true));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -72,7 +72,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertTrue($closure([ ]));
+		self::assertTrue($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -85,7 +85,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertTrue($closure('in_array'));
 		self::assertFalse($closure(new stdClass()));
 	}
@@ -98,7 +98,7 @@ 
 		self::assertFalse($closure('test'));
 		self::assertFalse($closure(1.2));
 		self::assertFalse($closure(false));
-		self::assertFalse($closure([ ]));
+		self::assertFalse($closure([]));
 		self::assertFalse($closure('in_array'));
 		self::assertTrue($closure(new stdClass()));
 	}
@@ -111,7 +111,7 @@ 
         self::assertFalse($closure('test'));
         self::assertTrue($closure(1.2));
         self::assertFalse($closure(false));
-        self::assertFalse($closure([ ]));
+        self::assertFalse($closure([]));
         self::assertFalse($closure('in_array'));
         self::assertFalse($closure(new stdClass()));
 	}