Refactor class name extraction logic with helper methods

Simplify the class name extraction by introducing helper methods for token parsing. This improves readability and maintainability of the code. Added Psalm type annotations for better static analysis.

src/ClassName.php

@@ -4,6 +4,7 @@
 
 namespace Ray\Aop;
 
+use function assert;
 use function count;
 use function file_exists;
 use function file_get_contents;
@@ -24,6 +25,10 @@
 /**
  * Extracting the fully qualified class name from a given PHP file
  *
+ * @psalm-type TokenValue = array{0: int, 1: string, 2: int}
+ * @psalm-type Token = TokenValue|string
+ * @psalm-type Tokens = array<int, Token>
+ * @psalm-type ParserResult = array{string, int}
  * @psalm-immutable
  */
 final class ClassName
@@ -32,97 +37,140 @@ final class ClassName
 
     /**
      * Extract fully qualified class name from file
-     *
-     * @psalm-return string|null
      */
     public static function from(string $filePath): ?string
     {
         if (! file_exists($filePath)) {
             return null;
         }
 
-        $namespace = '';
-        $className = null;
-        /** @var array<int, array{0: int, 1: string, 2: int}|string> $tokens */
-        $tokens = token_get_all(file_get_contents($filePath)); // @phpstan-ignore-line
+        $tokens = token_get_all(file_get_contents($filePath));
+        assert($tokens instanceof Tokens); // @phpstan-ignore-line
         $count = count($tokens);
+        $position = 0;
+        $namespace = '';
 
-        $i = 0;
-        while ($i < $count) {
-            /** @var array{0: int, 1: string, 2: int}|string $token */
-            $token = $tokens[$i];
-
-            if (is_array($token) && $token[0] === T_NAMESPACE) {
-                $i++;
-                while ($i < $count && is_array($tokens[$i]) && $tokens[$i][0] === T_WHITESPACE) {
-                    $i++;
-                }
+        while ($position < $count) {
+            [$token, $position] = self::nextToken($tokens, $position);
+            if (! is_array($token)) {
+                continue;
+            }
 
-                /** @var array{0: int, 1: string, 2: int}|string $token */
-                $token = $tokens[$i];
-                if (is_array($token)) {
-                    if ($token[0] === self::T_NAME_QUALIFIED) {
-                        $namespace = $token[1];
-                    } elseif ($token[0] === T_STRING) {
-                        /** @var list<string> $namespaceParts */
-                        $namespaceParts = [];
-                        while ($i < $count) {
-                            /** @var array{0: int, 1: string, 2: int}|string $token */
-                            $token = $tokens[$i];
-                            if (is_array($token) && $token[0] === T_STRING) {
-                                $namespaceParts[] = $token[1];
-                                $i++;
-                                if ($i < $count && $tokens[$i] === '\\') {
-                                    $namespaceParts[] = '\\';
-                                    $i++;
-                                }
-
-                                continue;
-                            }
-
-                            if ($token === ';' || $token === '{') {
-                                break;
-                            }
-
-                            $i++;
-                        }
-
-                        $namespace = implode('', $namespaceParts);
+            switch ($token[0]) {
+                case T_NAMESPACE:
+                    [$namespace, $position] = self::parseNamespace($tokens, $position + 1, $count);
+                    continue 2;
+                case T_CLASS:
+                    $className = self::parseClassName($tokens, $position + 1, $count);
+                    if ($className !== null) {
+                        /** @var string $namespace */
+                        return $namespace !== '' ? $namespace . '\\' . $className : $className;
                     }
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @param Tokens $tokens
+     *
+     * @return array{Token, int}
+     */
+    private static function nextToken(array $tokens, int $position): array
+    {
+        if (is_array($tokens[$position]) && in_array($tokens[$position][0], [T_ABSTRACT, T_FINAL], true)) {
+            $position++;
+        }
+
+        return [$tokens[$position], $position + 1];
+    }
+
+    /** @param Tokens $tokens */
+    private static function parseClassName(array $tokens, int $position, int $count): ?string
+    {
+        $position = self::skipWhitespace($tokens, $position, $count);
+        if ($position >= $count || ! is_array($tokens[$position])) {
+            return null;
+        }
+
+        return $tokens[$position][1];
+    }
+
+    /** @param Tokens $tokens */
+    private static function skipWhitespace(array $tokens, int $position, int $count): int
+    {
+        while (
+            $position < $count &&
+            is_array($tokens[$position]) &&
+            in_array($tokens[$position][0], [T_WHITESPACE, T_COMMENT, T_DOC_COMMENT], true)
+        ) {
+            $position++;
+        }
+
+        return $position;
+    }
+
+    /**
+     * @param Tokens $tokens
+     *
+     * @return ParserResult
+     */
+    private static function parseNamespace(array $tokens, int $position, int $count): array
+    {
+        $position = self::skipWhitespace($tokens, $position, $count);
+        if (! is_array($tokens[$position])) {
+            return ['', $position];
+        }
+
+        if ($tokens[$position][0] === self::T_NAME_QUALIFIED) {
+            return [$tokens[$position][1], $position + 1];
+        }
+
+        return $tokens[$position][0] === T_STRING
+            ? self::parseNamespaceParts($tokens, $position, $count)
+            : ['', $position];
+    }
+
+    /**
+     * @param Tokens $tokens
+     *
+     * @return ParserResult
+     */
+    private static function parseNamespaceParts(array $tokens, int $position, int $count): array
+    {
+        /** @var list<string> $namespaceParts */
+        $namespaceParts = [];
+
+        while ($position < $count) {
+            $token = $tokens[$position];
+            assert($token instanceof Token);
+
+            if (! is_array($token)) {
+                if ($token === ';' || $token === '{') {
+                    break;
                 }
 
+                $position++;
                 continue;
             }
 
-            if (is_array($token) && in_array($token[0], [T_ABSTRACT, T_FINAL], true)) {
-                $i++;
+            if ($token[0] !== T_STRING) {
+                $position++;
                 continue;
             }
 
-            if (is_array($token) && $token[0] === T_CLASS) {
-                $i++;
-                while (
-                    $i < $count &&
-                    is_array($tokens[$i]) &&
-                    in_array($tokens[$i][0], [T_WHITESPACE, T_COMMENT, T_DOC_COMMENT], true)
-                ) {
-                    $i++;
-                }
+            $namespaceParts[] = $token[1];
+            $position++;
 
-                if ($i < $count && is_array($tokens[$i])) {
-                    $className = $tokens[$i][1];
-                    break;
-                }
+            if ($position >= $count || $tokens[$position] !== '\\') {
+                continue;
             }
 
-            $i++;
-        }
-
-        if ($className === null) {
-            return null;
+            $namespaceParts[] = '\\';
+            $position++;
         }
 
-        /** @var string $namespace */
-        return $namespace !== '' ? $namespace . '\\' . $className : $className;
+        return [implode('', $namespaceParts), $position];
     }
 }