figtree-php / validation

src/AbstractRuleFactory.php

Indentation +19 added lines, -19 removed lines

@@ -4,27 +4,27 @@
 
 use Closure;
 use FigTree\Validation\Contracts\{
-	RuleInterface,
-	RuleFactoryInterface
+    RuleInterface,
+    RuleFactoryInterface
 };
 
 abstract class AbstractRuleFactory implements RuleFactoryInterface
 {
-	/**
-	 * Create a new Rule.
-	 *
-	 * @param int $filterType The filter type.
-	 * @param int $flags Bitewise set of filter flags.
-	 * @param array $options Filter options.
-	 * @param \Closure|null Callback method.
-	 *
-	 * @return \FigTree\Validation\Contracts\RuleInterface
-	 *
-	 * @see https://www.php.net/manual/en/filter.filters.php
-	 * @see https://www.php.net/manual/en/filter.filters.flags.php
-	 */
-	public function create(int $filterType, int $flags = 0, array $options = [], ?Closure $callback = null): RuleInterface
-	{
-		return new Rule($filterType, $flags, $options, $callback);
-	}
+    /**
+     * Create a new Rule.
+     *
+     * @param int $filterType The filter type.
+     * @param int $flags Bitewise set of filter flags.
+     * @param array $options Filter options.
+     * @param \Closure|null Callback method.
+     *
+     * @return \FigTree\Validation\Contracts\RuleInterface
+     *
+     * @see https://www.php.net/manual/en/filter.filters.php
+     * @see https://www.php.net/manual/en/filter.filters.flags.php
+     */
+    public function create(int $filterType, int $flags = 0, array $options = [], ?Closure $callback = null): RuleInterface
+    {
+        return new Rule($filterType, $flags, $options, $callback);
+    }
 }

src/FilterFactory.php

Indentation +18 added lines, -18 removed lines

@@ -8,28 +8,28 @@
 
 class FilterFactory
 {
-	public function __construct(protected RuleFactoryInterface $ruleFactory)
-	{
-		//
-	}
+    public function __construct(protected RuleFactoryInterface $ruleFactory)
+    {
+        //
+    }
 
-	public function create(Closure $closure)
-	{
-		$filter = new Filter($this->createRules($closure));
+    public function create(Closure $closure)
+    {
+        $filter = new Filter($this->createRules($closure));
 
-		$filter->setRuleFactory($this->ruleFactory);
+        $filter->setRuleFactory($this->ruleFactory);
 
-		return $filter;
-	}
+        return $filter;
+    }
 
-	protected function createRules(Closure $closure): array
-	{
-		$rules = $closure($this->ruleFactory);
+    protected function createRules(Closure $closure): array
+    {
+        $rules = $closure($this->ruleFactory);
 
-		if (!is_array($rules)) {
-			throw new UnexpectedTypeException($rules, 'array');
-		}
+        if (!is_array($rules)) {
+            throw new UnexpectedTypeException($rules, 'array');
+        }
 
-		return $rules;
-	}
+        return $rules;
+    }
 }

tests/TestPrinter.php

Indentation +10 added lines, -10 removed lines

@@ -8,17 +8,17 @@
 
 class TestPrinter extends DefaultResultPrinter
 {
-	protected function printDefect(TestFailure $defect, int $count): void
-	{
-		$this->printDefectHeader($defect, $count);
+    protected function printDefect(TestFailure $defect, int $count): void
+    {
+        $this->printDefectHeader($defect, $count);
 
-		$exception = $defect->thrownException();
+        $exception = $defect->thrownException();
 
-		if (!($exception instanceof Exception)) {
-			$this->write(sprintf('%s:%u', $exception->getFile(), $exception->getLine()));
-			$this->write(PHP_EOL);
-		}
+        if (!($exception instanceof Exception)) {
+            $this->write(sprintf('%s:%u', $exception->getFile(), $exception->getLine()));
+            $this->write(PHP_EOL);
+        }
 
-		$this->printDefectTrace($defect);
-	}
+        $this->printDefectTrace($defect);
+    }
 }

tests/ValidationTest.php

Indentation +268 added lines, -268 removed lines

@@ -4,278 +4,278 @@
 
 use Closure;
 use FigTree\Validation\{
-	Contracts\FilterInterface,
-	Contracts\RuleInterface,
-	Filter,
-	FilterFactory,
-	Rule,
-	RuleFactory,
+    Contracts\FilterInterface,
+    Contracts\RuleInterface,
+    Filter,
+    FilterFactory,
+    Rule,
+    RuleFactory,
 };
 use FigTree\Validation\Tests\{
-	AbstractTestCase,
-	Dummies\DummyFilter,
+    AbstractTestCase,
+    Dummies\DummyFilter,
 };
 
 class ValidationTest extends AbstractTestCase
 {
-	/**
-	 * @small
-	 *
-	 * @return void
-	 */
-	public function testFilterFactory()
-	{
-		$ruleFactory = new RuleFactory();
-
-		$filterFactory = new FilterFactory($ruleFactory);
-
-		$filter = $filterFactory->create(Closure::fromCallable(function (RuleFactory $rules) {
-			$rules = [
-				'int' => $rules->validInt(0, 10),
-			];
-
-			return $rules;
-		}));
-
-		$this->assertInstanceOf(Filter::class, $filter);
-	}
-
-	/**
-	 * @small
-	 *
-	 * @return void
-	 */
-	public function testFilter()
-	{
-		$filter = new DummyFilter();
-
-		$filter->setRuleFactory(new RuleFactory());
-
-		$this->assertInstanceOf(FilterInterface::class, $filter);
-
-		$rules = $filter->getRules();
-
-		$this->assertIsArray($rules);
-
-		foreach ($rules as $field => $rule) {
-			$this->assertIsString($field);
-			$this->assertInstanceOf(RuleInterface::class, $rule);
-
-			$definition = $rule->toArray();
-
-			$this->assertIsArray($definition);
-		}
-	}
-
-	/**
-	 * @medium
-	 */
-	public function testFilterRules()
-	{
-		$filter = new DummyFilter();
-
-		$filter->setRuleFactory(new RuleFactory());
-
-		$rules = $filter->getRules();
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_BOOL,
-			'flags' => FILTER_NULL_ON_FAILURE,
-		];
-
-		$this->assertEquals(new Rule(FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE), $rules['test_valid_bool']);
-		$this->assertEquals($expected, $rules['test_valid_bool']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_DOMAIN,
-		];
-
-		$this->assertEquals(new Rule(FILTER_VALIDATE_DOMAIN), $rules['test_valid_domain']);
-		$this->assertEquals($expected, $rules['test_valid_domain']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_EMAIL,
-		];
-
-		$this->assertEquals(new Rule(FILTER_VALIDATE_EMAIL), $rules['test_valid_email']);
-		$this->assertEquals($expected, $rules['test_valid_email']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_FLOAT,
-			'options' => [
-				'min_range' => -100,
-				'max_range' => 100,
-				'decimal' => 2,
-			]
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_VALIDATE_FLOAT, 0, ['min_range' => -100, 'max_range' => 100, 'decimal' => 2]),
-			$rules['test_valid_float']
-		);
-		$this->assertEquals($expected, $rules['test_valid_float']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_INT,
-			'options' => [
-				'min_range' => -100,
-				'max_range' => 100,
-			]
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_VALIDATE_INT, 0, ['min_range' => -100, 'max_range' => 100]),
-			$rules['test_valid_int']
-		);
-		$this->assertEquals($expected, $rules['test_valid_int']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_IP,
-		];
-
-		$this->assertEquals(new Rule(FILTER_VALIDATE_IP), $rules['test_valid_ip_address']);
-		$this->assertEquals($expected, $rules['test_valid_ip_address']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_MAC,
-		];
-
-		$this->assertEquals(new Rule(FILTER_VALIDATE_MAC), $rules['test_valid_mac_address']);
-		$this->assertEquals($expected, $rules['test_valid_mac_address']->toArray());
-
-		$expected = [
-			'filter' => FILTER_VALIDATE_REGEXP,
-			'options' => [
-				'regexp' => '/^valid value$/i',
-			]
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_VALIDATE_REGEXP, 0, ['regexp' => '/^valid value$/i']),
-			$rules['test_valid_regexp']
-		);
-		$this->assertEquals($expected, $rules['test_valid_regexp']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_ADD_SLASHES,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_ADD_SLASHES),
-			$rules['test_add_slashes']
-		);
-		$this->assertEquals($expected, $rules['test_add_slashes']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_EMAIL,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_EMAIL),
-			$rules['test_clean_email']
-		);
-		$this->assertEquals($expected, $rules['test_clean_email']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_ENCODED,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_ENCODED),
-			$rules['test_clean_encoded']
-		);
-		$this->assertEquals($expected, $rules['test_clean_encoded']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_NUMBER_FLOAT,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_NUMBER_FLOAT),
-			$rules['test_clean_float']
-		);
-		$this->assertEquals($expected, $rules['test_clean_float']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_FULL_SPECIAL_CHARS,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_FULL_SPECIAL_CHARS),
-			$rules['test_clean_full_special_chars']
-		);
-		$this->assertEquals($expected, $rules['test_clean_full_special_chars']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_NUMBER_INT,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_NUMBER_INT),
-			$rules['test_clean_int']
-		);
-		$this->assertEquals($expected, $rules['test_clean_int']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_SPECIAL_CHARS,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_SPECIAL_CHARS),
-			$rules['test_clean_special_chars']
-		);
-		$this->assertEquals($expected, $rules['test_clean_special_chars']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_STRING,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_STRING),
-			$rules['test_clean_string']
-		);
-		$this->assertEquals($expected, $rules['test_clean_string']->toArray());
-
-		$expected = [
-			'filter' => FILTER_UNSAFE_RAW,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_UNSAFE_RAW),
-			$rules['test_clean_unsafe']
-		);
-		$this->assertEquals($expected, $rules['test_clean_unsafe']->toArray());
-
-		$expected = [
-			'filter' => FILTER_SANITIZE_URL,
-		];
-
-		$this->assertEquals(
-			new Rule(FILTER_SANITIZE_URL),
-			$rules['test_clean_url']
-		);
-		$this->assertEquals($expected, $rules['test_clean_url']->toArray());
-
-		$expected = [
-			'filter' => FILTER_CALLBACK,
-			'options' => Closure::fromCallable('trim'),
-		];
-
-		$this->assertEquals(
-			(new Rule(FILTER_CALLBACK))->setCallback(Closure::fromCallable('trim')),
-			$rules['test_callable']
-		);
-		$this->assertEquals($expected, $rules['test_callable']->toArray());
-
-		$expected = [
-			'filter' => FILTER_CALLBACK,
-			'options' => $filter->mult(2),
-		];
-
-		$this->assertEquals(
-			(new Rule(FILTER_CALLBACK))->setCallback($filter->mult(2)),
-			$rules['test_closure']
-		);
-		$this->assertEquals($expected, $rules['test_closure']->toArray());
-	}
+    /**
+     * @small
+     *
+     * @return void
+     */
+    public function testFilterFactory()
+    {
+        $ruleFactory = new RuleFactory();
+
+        $filterFactory = new FilterFactory($ruleFactory);
+
+        $filter = $filterFactory->create(Closure::fromCallable(function (RuleFactory $rules) {
+            $rules = [
+                'int' => $rules->validInt(0, 10),
+            ];
+
+            return $rules;
+        }));
+
+        $this->assertInstanceOf(Filter::class, $filter);
+    }
+
+    /**
+     * @small
+     *
+     * @return void
+     */
+    public function testFilter()
+    {
+        $filter = new DummyFilter();
+
+        $filter->setRuleFactory(new RuleFactory());
+
+        $this->assertInstanceOf(FilterInterface::class, $filter);
+
+        $rules = $filter->getRules();
+
+        $this->assertIsArray($rules);
+
+        foreach ($rules as $field => $rule) {
+            $this->assertIsString($field);
+            $this->assertInstanceOf(RuleInterface::class, $rule);
+
+            $definition = $rule->toArray();
+
+            $this->assertIsArray($definition);
+        }
+    }
+
+    /**
+     * @medium
+     */
+    public function testFilterRules()
+    {
+        $filter = new DummyFilter();
+
+        $filter->setRuleFactory(new RuleFactory());
+
+        $rules = $filter->getRules();
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_BOOL,
+            'flags' => FILTER_NULL_ON_FAILURE,
+        ];
+
+        $this->assertEquals(new Rule(FILTER_VALIDATE_BOOL, FILTER_NULL_ON_FAILURE), $rules['test_valid_bool']);
+        $this->assertEquals($expected, $rules['test_valid_bool']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_DOMAIN,
+        ];
+
+        $this->assertEquals(new Rule(FILTER_VALIDATE_DOMAIN), $rules['test_valid_domain']);
+        $this->assertEquals($expected, $rules['test_valid_domain']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_EMAIL,
+        ];
+
+        $this->assertEquals(new Rule(FILTER_VALIDATE_EMAIL), $rules['test_valid_email']);
+        $this->assertEquals($expected, $rules['test_valid_email']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_FLOAT,
+            'options' => [
+                'min_range' => -100,
+                'max_range' => 100,
+                'decimal' => 2,
+            ]
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_VALIDATE_FLOAT, 0, ['min_range' => -100, 'max_range' => 100, 'decimal' => 2]),
+            $rules['test_valid_float']
+        );
+        $this->assertEquals($expected, $rules['test_valid_float']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_INT,
+            'options' => [
+                'min_range' => -100,
+                'max_range' => 100,
+            ]
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_VALIDATE_INT, 0, ['min_range' => -100, 'max_range' => 100]),
+            $rules['test_valid_int']
+        );
+        $this->assertEquals($expected, $rules['test_valid_int']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_IP,
+        ];
+
+        $this->assertEquals(new Rule(FILTER_VALIDATE_IP), $rules['test_valid_ip_address']);
+        $this->assertEquals($expected, $rules['test_valid_ip_address']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_MAC,
+        ];
+
+        $this->assertEquals(new Rule(FILTER_VALIDATE_MAC), $rules['test_valid_mac_address']);
+        $this->assertEquals($expected, $rules['test_valid_mac_address']->toArray());
+
+        $expected = [
+            'filter' => FILTER_VALIDATE_REGEXP,
+            'options' => [
+                'regexp' => '/^valid value$/i',
+            ]
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_VALIDATE_REGEXP, 0, ['regexp' => '/^valid value$/i']),
+            $rules['test_valid_regexp']
+        );
+        $this->assertEquals($expected, $rules['test_valid_regexp']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_ADD_SLASHES,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_ADD_SLASHES),
+            $rules['test_add_slashes']
+        );
+        $this->assertEquals($expected, $rules['test_add_slashes']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_EMAIL,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_EMAIL),
+            $rules['test_clean_email']
+        );
+        $this->assertEquals($expected, $rules['test_clean_email']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_ENCODED,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_ENCODED),
+            $rules['test_clean_encoded']
+        );
+        $this->assertEquals($expected, $rules['test_clean_encoded']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_NUMBER_FLOAT,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_NUMBER_FLOAT),
+            $rules['test_clean_float']
+        );
+        $this->assertEquals($expected, $rules['test_clean_float']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_FULL_SPECIAL_CHARS,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_FULL_SPECIAL_CHARS),
+            $rules['test_clean_full_special_chars']
+        );
+        $this->assertEquals($expected, $rules['test_clean_full_special_chars']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_NUMBER_INT,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_NUMBER_INT),
+            $rules['test_clean_int']
+        );
+        $this->assertEquals($expected, $rules['test_clean_int']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_SPECIAL_CHARS,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_SPECIAL_CHARS),
+            $rules['test_clean_special_chars']
+        );
+        $this->assertEquals($expected, $rules['test_clean_special_chars']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_STRING,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_STRING),
+            $rules['test_clean_string']
+        );
+        $this->assertEquals($expected, $rules['test_clean_string']->toArray());
+
+        $expected = [
+            'filter' => FILTER_UNSAFE_RAW,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_UNSAFE_RAW),
+            $rules['test_clean_unsafe']
+        );
+        $this->assertEquals($expected, $rules['test_clean_unsafe']->toArray());
+
+        $expected = [
+            'filter' => FILTER_SANITIZE_URL,
+        ];
+
+        $this->assertEquals(
+            new Rule(FILTER_SANITIZE_URL),
+            $rules['test_clean_url']
+        );
+        $this->assertEquals($expected, $rules['test_clean_url']->toArray());
+
+        $expected = [
+            'filter' => FILTER_CALLBACK,
+            'options' => Closure::fromCallable('trim'),
+        ];
+
+        $this->assertEquals(
+            (new Rule(FILTER_CALLBACK))->setCallback(Closure::fromCallable('trim')),
+            $rules['test_callable']
+        );
+        $this->assertEquals($expected, $rules['test_callable']->toArray());
+
+        $expected = [
+            'filter' => FILTER_CALLBACK,
+            'options' => $filter->mult(2),
+        ];
+
+        $this->assertEquals(
+            (new Rule(FILTER_CALLBACK))->setCallback($filter->mult(2)),
+            $rules['test_closure']
+        );
+        $this->assertEquals($expected, $rules['test_closure']->toArray());
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -29,7 +29,7 @@
 
 		$filterFactory = new FilterFactory($ruleFactory);
 
-		$filter = $filterFactory->create(Closure::fromCallable(function (RuleFactory $rules) {
+		$filter = $filterFactory->create(Closure::fromCallable(function(RuleFactory $rules) {
 			$rules = [
 				'int' => $rules->validInt(0, 10),
 			];

tests/AbstractTestCase.php

Indentation +1 added lines, -1 removed lines

@@ -6,5 +6,5 @@
 
 abstract class AbstractTestCase extends TestCase
 {
-	//
+    //
 }

tests/Dummies/DummyFilter.php

Indentation +33 added lines, -33 removed lines

@@ -6,41 +6,41 @@
 
 class DummyFilter extends AbstractFilter
 {
-	public function getRules(): array
-	{
-		/**
-		 * @var \FigTree\Validation\RuleFactory
-		 */
-		$rules = $this->ruleFactory;
+    public function getRules(): array
+    {
+        /**
+         * @var \FigTree\Validation\RuleFactory
+         */
+        $rules = $this->ruleFactory;
 
-		return [
-			'test_valid_bool' => $rules->validBool(),
-			'test_valid_domain' => $rules->validDomain(),
-			'test_valid_email' => $rules->validEmail(),
-			'test_valid_float' => $rules->validFloat(-100, 100, 2),
-			'test_valid_int' => $rules->validInt(-100, 100),
-			'test_valid_ip_address' => $rules->validIpAddress(),
-			'test_valid_mac_address' => $rules->validMacAddress(),
-			'test_valid_regexp' => $rules->validRegExp('/^valid value$/i'),
+        return [
+            'test_valid_bool' => $rules->validBool(),
+            'test_valid_domain' => $rules->validDomain(),
+            'test_valid_email' => $rules->validEmail(),
+            'test_valid_float' => $rules->validFloat(-100, 100, 2),
+            'test_valid_int' => $rules->validInt(-100, 100),
+            'test_valid_ip_address' => $rules->validIpAddress(),
+            'test_valid_mac_address' => $rules->validMacAddress(),
+            'test_valid_regexp' => $rules->validRegExp('/^valid value$/i'),
 
-			'test_add_slashes' => $rules->addSlashes(),
-			'test_clean_email' => $rules->cleanEmail(),
-			'test_clean_encoded' => $rules->cleanEncodedString(),
-			'test_clean_float' => $rules->cleanFloat(),
-			'test_clean_full_special_chars' => $rules->cleanFullSpecialChars(),
-			'test_clean_int' => $rules->cleanInt(),
-			'test_clean_special_chars' => $rules->cleanSpecialChars(),
-			'test_clean_string' => $rules->cleanString(),
-			'test_clean_unsafe' => $rules->cleanUnsafe(),
-			'test_clean_url' => $rules->cleanUrl(),
+            'test_add_slashes' => $rules->addSlashes(),
+            'test_clean_email' => $rules->cleanEmail(),
+            'test_clean_encoded' => $rules->cleanEncodedString(),
+            'test_clean_float' => $rules->cleanFloat(),
+            'test_clean_full_special_chars' => $rules->cleanFullSpecialChars(),
+            'test_clean_int' => $rules->cleanInt(),
+            'test_clean_special_chars' => $rules->cleanSpecialChars(),
+            'test_clean_string' => $rules->cleanString(),
+            'test_clean_unsafe' => $rules->cleanUnsafe(),
+            'test_clean_url' => $rules->cleanUrl(),
 
-			'test_callable' => $rules->withCallable('trim'),
-			'test_closure' => $rules->withClosure($this->mult(2)),
-		];
-	}
+            'test_callable' => $rules->withCallable('trim'),
+            'test_closure' => $rules->withClosure($this->mult(2)),
+        ];
+    }
 
-	public function mult(int $factor)
-	{
-		return fn ($value) => intval($value) * $factor;
-	}
+    public function mult(int $factor)
+    {
+        return fn ($value) => intval($value) * $factor;
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -41,6 +41,6 @@
 
 	public function mult(int $factor)
 	{
-		return fn ($value) => intval($value) * $factor;
+		return fn($value) => intval($value) * $factor;
 	}
 }