Refactor

nicoSWD · nicoSWD · commit 3881799568b7 · 2025-10-08T21:28:21.000+02:00
diff --git a/src/Compiler/StandardCompiler.php b/src/Compiler/StandardCompiler.php
@@ -19,8 +19,8 @@
 
 final class StandardCompiler implements CompilerInterface
 {
-    private const OPENING_PARENTHESIS = '(';
-    private const CLOSING_PARENTHESIS = ')';
+    private const string OPENING_PARENTHESIS = '(';
+    private const string CLOSING_PARENTHESIS = ')';
 
     private string $output = '';
     private int $openParenthesis = 0;
diff --git a/src/Expression/ExpressionFactory.php b/src/Expression/ExpressionFactory.php
@@ -9,12 +9,13 @@
 
 use nicoSWD\Rule\Parser\Exception\ParserException;
 use nicoSWD\Rule\TokenStream\Token;
+use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
 final class ExpressionFactory implements ExpressionFactoryInterface
 {
     /** @throws ParserException */
-    public function createFromOperator(Operator $operator): BaseExpression
+    public function createFromOperator(BaseToken & Operator $operator): BaseExpression
     {
         return match ($operator::class) {
             Token\TokenEqual::class => new EqualExpression(),
diff --git a/src/Expression/ExpressionFactoryInterface.php b/src/Expression/ExpressionFactoryInterface.php
@@ -7,9 +7,10 @@
  */
 namespace nicoSWD\Rule\Expression;
 
+use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
 interface ExpressionFactoryInterface
 {
-    public function createFromOperator(Operator $operator): BaseExpression;
+    public function createFromOperator(BaseToken & Operator $operator): BaseExpression;
 }
diff --git a/src/Grammar/Definition.php b/src/Grammar/Definition.php
@@ -9,12 +9,12 @@
 
 use nicoSWD\Rule\TokenStream\Token\Token;
 
-final class Definition
+final readonly class Definition
 {
     public function __construct(
-        public readonly Token $token,
-        public readonly string $regex,
-        public readonly int $priority,
+        public Token $token,
+        public string $regex,
+        public int $priority,
     ) {
     }
 }
diff --git a/src/Grammar/InternalFunction.php b/src/Grammar/InternalFunction.php
@@ -7,11 +7,11 @@
  */
 namespace nicoSWD\Rule\Grammar;
 
-final class InternalFunction
+final readonly class InternalFunction
 {
     public function __construct(
-        public readonly string $name,
-        public readonly string $class,
+        public string $name,
+        public string $class,
     ) {
     }
 }
diff --git a/src/Grammar/InternalMethod.php b/src/Grammar/InternalMethod.php
@@ -7,11 +7,11 @@
  */
 namespace nicoSWD\Rule\Grammar;
 
-final class InternalMethod
+final readonly class InternalMethod
 {
     public function __construct(
-        public readonly string $name,
-        public readonly string $class,
+        public string $name,
+        public string $class,
     ) {
     }
 }
diff --git a/src/Grammar/JavaScript/Methods/Substr.php b/src/Grammar/JavaScript/Methods/Substr.php
@@ -15,14 +15,8 @@ final class Substr extends CallableFunction
 {
     public function call(?BaseToken ...$parameters): BaseToken
     {
-        $params = [];
         $start = $this->parseParameter($parameters, numParam: 0);
-
-        if (!$start) {
-            $params[] = 0;
-        } else {
-            $params[] = (int) $start->getValue();
-        }
+        $params = [(int) $start?->getValue()];
 
         $offset = $this->parseParameter($parameters, numParam: 1);
 
diff --git a/src/Grammar/JavaScript/Methods/Test.php b/src/Grammar/JavaScript/Methods/Test.php
@@ -27,7 +27,7 @@ public function call(?BaseToken ...$parameters): BaseToken
         if (!$string) {
             $bool = false;
         } else {
-            // Remove "g" modifier as is does not exist in PHP
+            // Remove "g" modifier as it does not exist in PHP
             // It's also irrelevant in .test() but allowed in JS here
             $pattern = preg_replace_callback(
                 '~/[igm]{0,3}$~',
diff --git a/src/Highlighter/Highlighter.php b/src/Highlighter/Highlighter.php
@@ -7,15 +7,15 @@
  */
 namespace nicoSWD\Rule\Highlighter;
 
-use ArrayIterator;
+use Iterator;
 use nicoSWD\Rule\Tokenizer\TokenizerInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
 use SplObjectStorage;
 
 final class Highlighter
 {
-    private readonly SplObjectStorage $styles;
+    private SplObjectStorage $styles;
 
     public function __construct(
         private readonly TokenizerInterface $tokenizer,
@@ -33,7 +33,7 @@ public function highlightString(string $string): string
         return $this->highlightTokens($this->tokenizer->tokenize($string));
     }
 
-    public function highlightTokens(ArrayIterator $tokens): string
+    public function highlightTokens(Iterator $tokens): string
     {
         $string = '';
 
diff --git a/src/Parser/Parser.php b/src/Parser/Parser.php
@@ -15,12 +15,12 @@
 use nicoSWD\Rule\TokenStream\Token\TokenType;
 use nicoSWD\Rule\TokenStream\Token\Type\Operator;
 
-final class Parser
+final readonly class Parser
 {
     public function __construct(
-        private readonly TokenStream $tokenStream,
-        private readonly EvaluatableExpressionFactory $expressionFactory,
-        private readonly CompilerFactoryInterface $compilerFactory,
+        private TokenStream $tokenStream,
+        private EvaluatableExpressionFactory $expressionFactory,
+        private CompilerFactoryInterface $compilerFactory,
     ) {
     }
 
diff --git a/src/TokenStream/Token/TokenFactory.php b/src/TokenStream/Token/TokenFactory.php
@@ -27,40 +27,42 @@ public function createFromPHPType(mixed $value): BaseToken
         };
     }
 
-    public function createFromToken(Token $token): string
+    public function createFromToken(Token $token, array $matches, int $offset): BaseToken
     {
+        $args = [$matches[$token->value], $offset];
+
         return match ($token) {
-            Token::AND => TokenAnd::class,
-            Token::OR => TokenOr::class,
-            Token::NOT_EQUAL_STRICT => TokenNotEqualStrict::class,
-            Token::NOT_EQUAL => TokenNotEqual::class,
-            Token::EQUAL_STRICT => TokenEqualStrict::class,
-            Token::EQUAL => TokenEqual::class,
-            Token::IN => TokenIn::class,
-            Token::NOT_IN => TokenNotIn::class,
-            Token::BOOL_TRUE => TokenBoolTrue::class,
-            Token::BOOL_FALSE => TokenBoolFalse::class,
-            Token::NULL => TokenNull::class,
-            Token::METHOD => TokenMethod::class,
-            Token::FUNCTION => TokenFunction::class,
-            Token::VARIABLE => TokenVariable::class,
-            Token::FLOAT => TokenFloat::class,
-            Token::INTEGER => TokenInteger::class,
-            Token::ENCAPSED_STRING => TokenEncapsedString::class,
-            Token::SMALLER_EQUAL => TokenSmallerEqual::class,
-            Token::GREATER_EQUAL => TokenGreaterEqual::class,
-            Token::SMALLER => TokenSmaller::class,
-            Token::GREATER => TokenGreater::class,
-            Token::OPENING_PARENTHESIS => TokenOpeningParenthesis::class,
-            Token::CLOSING_PARENTHESIS => TokenClosingParenthesis::class,
-            Token::OPENING_ARRAY => TokenOpeningArray::class,
-            Token::CLOSING_ARRAY => TokenClosingArray::class,
-            Token::COMMA => TokenComma::class,
-            Token::REGEX => TokenRegex::class,
-            Token::COMMENT => TokenComment::class,
-            Token::NEWLINE => TokenNewline::class,
-            Token::SPACE => TokenSpace::class,
-            Token::UNKNOWN => TokenUnknown::class,
+            Token::AND => new TokenAnd(...$args),
+            Token::OR => new TokenOr(...$args),
+            Token::NOT_EQUAL_STRICT => new TokenNotEqualStrict(...$args),
+            Token::NOT_EQUAL => new TokenNotEqual(...$args),
+            Token::EQUAL_STRICT => new TokenEqualStrict(...$args),
+            Token::EQUAL => new TokenEqual(...$args),
+            Token::IN => new TokenIn(...$args),
+            Token::NOT_IN => new TokenNotIn(...$args),
+            Token::BOOL_TRUE => new TokenBoolTrue(...$args),
+            Token::BOOL_FALSE => new TokenBoolFalse(...$args),
+            Token::NULL => new TokenNull(...$args),
+            Token::METHOD => new TokenMethod(...$args),
+            Token::FUNCTION => new TokenFunction(...$args),
+            Token::VARIABLE => new TokenVariable(...$args),
+            Token::FLOAT => new TokenFloat(...$args),
+            Token::INTEGER => new TokenInteger(...$args),
+            Token::ENCAPSED_STRING => new TokenEncapsedString(...$args),
+            Token::SMALLER_EQUAL => new TokenSmallerEqual(...$args),
+            Token::GREATER_EQUAL => new TokenGreaterEqual(...$args),
+            Token::SMALLER => new TokenSmaller(...$args),
+            Token::GREATER => new TokenGreater(...$args),
+            Token::OPENING_PARENTHESIS => new TokenOpeningParenthesis(...$args),
+            Token::CLOSING_PARENTHESIS => new TokenClosingParenthesis(...$args),
+            Token::OPENING_ARRAY => new TokenOpeningArray(...$args),
+            Token::CLOSING_ARRAY => new TokenClosingArray(...$args),
+            Token::COMMA => new TokenComma(...$args),
+            Token::REGEX => new TokenRegex(...$args),
+            Token::COMMENT => new TokenComment(...$args),
+            Token::NEWLINE => new TokenNewline(...$args),
+            Token::SPACE => new TokenSpace(...$args),
+            Token::UNKNOWN => new TokenUnknown(...$args),
         };
     }
 
diff --git a/src/TokenStream/TokenIterator.php b/src/TokenStream/TokenIterator.php
@@ -13,11 +13,11 @@
 use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 
-class TokenIterator implements Iterator
+readonly class TokenIterator implements Iterator
 {
     public function __construct(
-        private readonly Iterator $stack,
-        private readonly TokenStream $tokenStream,
+        private Iterator $stack,
+        private TokenStream $tokenStream,
     ) {
     }
 
diff --git a/src/Tokenizer/Tokenizer.php b/src/Tokenizer/Tokenizer.php
@@ -29,9 +29,7 @@ public function tokenize(string $string): Iterator
 
         while (preg_match($regex, $string, $matches, offset: $offset)) {
             $token = $this->getMatchedToken($matches);
-            $className = $this->tokenFactory->createFromToken($token);
-
-            $stack[] = new $className($matches[$token->value], $offset);
+            $stack[] = $this->tokenFactory->createFromToken($token, $matches, $offset);
             $offset += strlen($matches[0]);
         }
 
diff --git a/tests/unit/Parser/ParserTest.php b/tests/unit/Parser/ParserTest.php
@@ -7,6 +7,7 @@
  */
 namespace nicoSWD\Rule\tests\unit\Parser;
 
+use ArrayIterator;
 use Mockery as m;
 use Mockery\Adapter\Phpunit\MockeryPHPUnitIntegration;
 use nicoSWD\Rule\Compiler\StandardCompiler;
@@ -54,18 +55,11 @@ public function givenARuleStringWhenValidItShouldReturnTheCompiledRule(): void
         ];
 
         $compiler = new StandardCompiler();
-
-        /** @var m\MockInterface $tokenStream */
-        $tokenStream = \Mockery::mock(TokenIterator::class);
-        $tokenStream->shouldReceive('rewind')->once();
-        $tokenStream->shouldReceive('next');
-        $tokenStream->shouldReceive('current')->andReturn(...$tokens);
-        $tokenStream->shouldReceive('valid')->andReturnUsing(function () use (&$tokens) {
-            return !!next($tokens);
-        });
+        $arrayIterator = new ArrayIterator($tokens);
+        $tokenIterator = new TokenIterator($arrayIterator, $this->tokenStream);
 
         $this->compilerFactory->shouldReceive('create')->once()->andReturn($compiler);
-        $this->tokenStream->shouldReceive('getStream')->once()->andReturn($tokenStream);
+        $this->tokenStream->shouldReceive('getStream')->once()->andReturn($tokenIterator);
 
         $this->assertSame('(1)&1', $this->parser->parse('(1=="1")&&2>1 // true dat!'));
     }
diff --git a/tests/unit/Token/TokenFactoryTest.php b/tests/unit/Token/TokenFactoryTest.php
@@ -45,6 +45,6 @@ public function unsupportedTypeThrowsException(): void
     #[Test]
     public function givenAValidTokenNameItShouldReturnItsCorrespondingClassName(): void
     {
-        $this->assertSame(TokenEqualStrict::class, $this->tokenFactory->createFromToken(Token\Token::EQUAL_STRICT));
+        $this->assertInstanceOf(TokenEqualStrict::class, $this->tokenFactory->createFromToken(Token\Token::EQUAL_STRICT, ['EqualStrict' => '==='], 0));
     }
 }
diff --git a/tests/unit/TokenStream/Token/BaseTokenTest.php b/tests/unit/TokenStream/Token/BaseTokenTest.php
@@ -7,12 +7,14 @@
  */
 namespace nicoSWD\Rule\tests\unit\TokenStream\Token;
 
+use ArrayIterator;
 use Mockery\MockInterface;
 use nicoSWD\Rule\TokenStream\Token\BaseToken;
 use nicoSWD\Rule\TokenStream\Token\TokenType;
 use nicoSWD\Rule\TokenStream\TokenIterator;
-use PHPUnit\Framework\TestCase;
+use nicoSWD\Rule\TokenStream\TokenStream;
 use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
 
 final class BaseTokenTest extends TestCase
 {
@@ -30,33 +32,35 @@ public function getType(): TokenType
     }
 
     #[Test]
-    public function offset(): void
+    public function givenATokenWhenGettingOffsetItShouldReturnTheExpectedOffset(): void
     {
         $this->assertSame(1337, $this->token->getOffset());
     }
 
     #[Test]
-    public function getValue(): void
+    public function givenATokenWhenGettingValueItShouldReturnTheExpectedValue(): void
     {
         $this->assertSame('&&', $this->token->getValue());
     }
 
     #[Test]
-    public function getOriginalValue(): void
+    public function givenATokenWhenGettingOriginalValueItShouldReturnTheExpectedOriginalValue(): void
     {
         $this->assertSame('&&', $this->token->getOriginalValue());
     }
 
     #[Test]
-    public function createNode(): void
+    public function givenATokenIteratorWhenCreatingNodeItShouldReturnTheSameToken(): void
     {
-        /** @var TokenIterator|MockInterface $tokenStream */
-        $tokenStream = \Mockery::mock(TokenIterator::class);
-        $this->assertSame($this->token, $this->token->createNode($tokenStream));
+        /** @var TokenStream|MockInterface $tokenStream */
+        $tokenStream = \Mockery::mock(TokenStream::class);
+        $iterator = new TokenIterator(new ArrayIterator([]), $tokenStream);
+
+        $this->assertSame($this->token, $this->token->createNode($iterator));
     }
 
     #[Test]
-    public function isOfType(): void
+    public function givenALogicalTokenWhenCheckingTypeItShouldReturnTrueForLogicalAndFalseForComma(): void
     {
         $this->assertTrue($this->token->isOfType(TokenType::LOGICAL));
         $this->assertFalse($this->token->isOfType(TokenType::COMMA));
diff --git a/tests/unit/TokenStream/TokenStreamTest.php b/tests/unit/TokenStream/TokenStreamTest.php
@@ -123,7 +123,7 @@ private function createGrammarWithInternalFunctions(array $internalFunctions = [
     {
         return new class($internalFunctions) extends Grammar {
             public function __construct(
-                private array $internalFunctions,
+                private readonly array $internalFunctions,
             ) {
             }
 
@@ -150,7 +150,7 @@ private function createCallableUserMethodFactory(): CallableUserMethodFactoryInt
             public function create(
                 BaseToken $token,
                 TokenFactory $tokenFactory,
-                string $methodName
+                string $methodName,
             ): CallableUserFunctionInterface {
                 return new class implements CallableUserFunctionInterface {
                     public function call(?BaseToken ...$param): BaseToken
diff --git a/tests/unit/Tokenizer/TokenizerTest.php b/tests/unit/Tokenizer/TokenizerTest.php
@@ -11,8 +11,8 @@
 use nicoSWD\Rule\Grammar\Grammar;
 use nicoSWD\Rule\TokenStream\Token;
 use nicoSWD\Rule\Tokenizer\Tokenizer;
-use PHPUnit\Framework\TestCase;
 use PHPUnit\Framework\Attributes\Test;
+use PHPUnit\Framework\TestCase;
 
 final class TokenizerTest extends TestCase
 {
@@ -81,11 +81,8 @@ private function tokenizeWithGrammar(string $rule, array $definition): array
     private function getTokenizer(array $definition): Tokenizer
     {
         $grammar = new class($definition) extends Grammar {
-            private array $definition;
-
-            public function __construct(array $definition)
+            public function __construct(private readonly array $definition)
             {
-                $this->definition = $definition;
             }
 
             public function getDefinition(): array

Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,8 @@`
`19`	`19`
`20`	`20`	`final class StandardCompiler implements CompilerInterface`
`21`	`21`	`{`
`22`		`- private const OPENING_PARENTHESIS = '(';`
`23`		`- private const CLOSING_PARENTHESIS = ')';`
	`22`	`+ private const string OPENING_PARENTHESIS = '(';`
	`23`	`+ private const string CLOSING_PARENTHESIS = ')';`
`24`	`24`
`25`	`25`	`private string $output = '';`
`26`	`26`	`private int $openParenthesis = 0;`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,13 @@`
`9`	`9`
`10`	`10`	`use nicoSWD\Rule\Parser\Exception\ParserException;`
`11`	`11`	`use nicoSWD\Rule\TokenStream\Token;`
	`12`	`+use nicoSWD\Rule\TokenStream\Token\BaseToken;`
`12`	`13`	`use nicoSWD\Rule\TokenStream\Token\Type\Operator;`
`13`	`14`
`14`	`15`	`final class ExpressionFactory implements ExpressionFactoryInterface`
`15`	`16`	`{`
`16`	`17`	`/** @throws ParserException */`
`17`		`- public function createFromOperator(Operator $operator): BaseExpression`
	`18`	`+ public function createFromOperator(BaseToken & Operator $operator): BaseExpression`
`18`	`19`	`{`
`19`	`20`	`return match ($operator::class) {`
`20`	`21`	`Token\TokenEqual::class => new EqualExpression(),`
Original file line number	Diff line number	Diff line change
`@@ -7,9 +7,10 @@`
`7`	`7`	`*/`
`8`	`8`	`namespace nicoSWD\Rule\Expression;`
`9`	`9`
	`10`	`+use nicoSWD\Rule\TokenStream\Token\BaseToken;`
`10`	`11`	`use nicoSWD\Rule\TokenStream\Token\Type\Operator;`
`11`	`12`
`12`	`13`	`interface ExpressionFactoryInterface`
`13`	`14`	`{`
`14`		`- public function createFromOperator(Operator $operator): BaseExpression;`
	`15`	`+ public function createFromOperator(BaseToken & Operator $operator): BaseExpression;`
`15`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,12 @@`
`9`	`9`
`10`	`10`	`use nicoSWD\Rule\TokenStream\Token\Token;`
`11`	`11`
`12`		`-final class Definition`
	`12`	`+final readonly class Definition`
`13`	`13`	`{`
`14`	`14`	`public function __construct(`
`15`		`- public readonly Token $token,`
`16`		`- public readonly string $regex,`
`17`		`- public readonly int $priority,`
	`15`	`+ public Token $token,`
	`16`	`+ public string $regex,`
	`17`	`+ public int $priority,`
`18`	`18`	`) {`
`19`	`19`	`}`
`20`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,11 @@`
`7`	`7`	`*/`
`8`	`8`	`namespace nicoSWD\Rule\Grammar;`
`9`	`9`
`10`		`-final class InternalFunction`
	`10`	`+final readonly class InternalFunction`
`11`	`11`	`{`
`12`	`12`	`public function __construct(`
`13`		`- public readonly string $name,`
`14`		`- public readonly string $class,`
	`13`	`+ public string $name,`
	`14`	`+ public string $class,`
`15`	`15`	`) {`
`16`	`16`	`}`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,14 +15,8 @@ final class Substr extends CallableFunction`
`15`	`15`	`{`
`16`	`16`	`public function call(?BaseToken ...$parameters): BaseToken`
`17`	`17`	`{`
`18`		`- $params = [];`
`19`	`18`	`$start = $this->parseParameter($parameters, numParam: 0);`
`20`		`-`
`21`		`- if (!$start) {`
`22`		`- $params[] = 0;`
`23`		`- } else {`
`24`		`- $params[] = (int) $start->getValue();`
`25`		`- }`
	`19`	`+ $params = [(int) $start?->getValue()];`
`26`	`20`
`27`	`21`	`$offset = $this->parseParameter($parameters, numParam: 1);`
`28`	`22`