Refactor enums ffrom snake_case to PascalCase.

Refactor Enums.md

Task Completed: Replaced All Enums with Pascal Case from SNAKE_CASE

Steps

1. Copy both files to the appropriate namespace.
2. Register the Rector rule:

   ->withRules([
       RenameEnumCasesToPascalCaseRector::class,
   ])

3. Run Rector:

   vendor/bin/rector process

4. Run the command to apply the same changes to Blade files:

   php artisan refactor:blade-enums

All set!

Limitations

• This approach does not work if you use self::YOUR_CASE in the enum class.
• It also fails if you use the following pattern in Blade templates:

  @use('App\Enums\SomeBigNameEnum', 'YourEnum')

• Avoid running the process twice to prevent conflicts.

RefactorBladeEnums.php

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\File;

class RefactorBladeEnums extends Command
{
    protected $signature = 'refactor:blade-enums';

    protected $description = 'Refactor enum cases in Blade templates from snake_case to PascalCase';

    public function handle()
    {
        $this->info('Refactoring Blade templates...');

        $enumClasses = $this->getEnumClasses();

        if ($enumClasses === []) {
            $this->info('No enum classes found.');

            return;
        }

        $bladeFiles = File::allFiles(resource_path('views'));

        foreach ($bladeFiles as $bladeFile) {
            $filePath = $bladeFile->getRealPath();
            $fileContents = File::get($filePath);

            foreach ($enumClasses as $enumClass) {
                $fileContents = $this->refactorEnumCases($fileContents, $enumClass);
            }

            File::put($filePath, $fileContents);
            $this->info("Refactored: {$filePath}");
        }

        $this->info('Refactoring completed!');
    }

    private function getEnumClasses(): array
    {
        $enumClasses = [];

        $phpFiles = File::allFiles(app_path());

        foreach ($phpFiles as $phpFile) {
            $filePath = $phpFile->getRealPath();
            $fileContents = File::get($filePath);

            if (preg_match_all('/enum\s+(\w+)/', $fileContents, $matches)) {
                foreach ($matches[1] as $enumClass) {
                    $namespace = $this->getNamespace($fileContents);
                    $enumClasses[] = $namespace.'\\'.$enumClass;
                }
            }
        }

        return $enumClasses;
    }

    private function getNamespace(string $fileContents): string
    {
        if (preg_match('/namespace\s+(.+?);/', $fileContents, $matches)) {
            return $matches[1];
        }

        return '';
    }

    private function refactorEnumCases(string $content, string $enumClass): string
    {
        $enumClassName = basename(str_replace('\\', '/', $enumClass));

        return preg_replace_callback("/$enumClassName::([A-Z_]+)/", function ($matches) use ($enumClassName) {
            $enumCase = $matches[1];
            $pascalCase = $this->convertSnakeToPascalCase($enumCase);

            return "{$enumClassName}::{$pascalCase}";
        }, $content);
    }

    private function convertSnakeToPascalCase(string $name): string
    {
        return str_replace(' ', '', ucwords(str_replace('_', ' ', strtolower($name))));
    }
}

RenameEnumCasesToPascalCaseRector.php

<?php

namespace App\Rector;

use PhpParser\Node;
use PhpParser\Node\Expr\ClassConstFetch;
use PhpParser\Node\Identifier;
use PhpParser\Node\Stmt\EnumCase;
use Rector\Rector\AbstractRector;
use ReflectionClass;
use ReflectionException;
use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
use PHPStan\Reflection\ReflectionProvider;

final class RenameEnumCasesToPascalCaseRector extends AbstractRector
{
    public function __construct(
        private ReflectionProvider $reflectionProvider
    ) {
    }
       
    
    public function getRuleDefinition(): RuleDefinition
    {
        return new RuleDefinition(
            'Convert snake_case enum cases to PascalCase',
            [
                new CodeSample(
                    <<<'CODE_SAMPLE'
                    enum SomeEnum
                    {
                        case SNAKE_CASE_CONSTANT;
                    }
                    function example() {
                        $value = SomeEnum::SNAKE_CASE_CONSTANT;
                    }
                    CODE_SAMPLE
                    ,
                    <<<'CODE_SAMPLE'
                    enum SomeEnum
                    {
                        case SnakeCaseConstant;
                    }
                    function example() {
                        $value = SomeEnum::SnakeCaseConstant;
                    }
            CODE_SAMPLE
                ),
            ]
        );
    }

    
    public function getNodeTypes(): array
    {
        return [EnumCase::class, ClassConstFetch::class];
    }

    public function refactor(Node $node): ?Node
    {
        if ($node instanceof EnumCase) {
            return $this->refactorEnumCase($node);
        }

        if ($node instanceof ClassConstFetch) {
            return $this->refactorEnumCaseFetch($node);
        }

        return null;
    }

    private function refactorEnumCase(EnumCase $node): ?Node
    {
        $oldName = $this->getName($node->name);
        $newName = $this->convertSnakeToPascalCase($oldName);

        if ($oldName !== $newName) {
            $node->name = new Identifier($newName);

            return $node;
        }

        return null;
    }

    private function refactorEnumCaseFetch(ClassConstFetch $node): ?Node
    {
        if ($this->isEnumCaseFetch($node)) {
            $oldName = $this->getName($node->name);
            if ($oldName === 'class' || $oldName === null) {
                return null;
            }
            $newName = $this->convertSnakeToPascalCase($oldName);
            if ($oldName !== $newName) {
                $node->name = new Identifier($newName);
            }
        }

        return $node;
    }

    private function isEnumCaseFetch(ClassConstFetch $node): bool
    {
        // the static reflection should be used instead, to avoid calling the analysed code
        // @see https://phpstan.org/blog/zero-config-analysis-with-static-reflection
        $objectType = $this->getType($node->class);
        
        return $objectType->isEnum()->yes();
    }

    private function convertSnakeToPascalCase(string $name): string
    {
       	if (!$this->isSnakeCase($name)) {
            return $name;
        }
        return str_replace(' ', '', ucwords(str_replace('_', ' ', mb_strtolower($name))));
    }
    
    private function isSnakeCase(string $name): bool
    {
        return str_contains($name, '_') || ctype_lower($name) === true || ctype_upper($name) === true;
    }
}

Just a small note, but if you want to make Rector a bit more efficient, your rules should only return a node if a change has been made, otherwise you should return null.

Just a small note, but if you want to make Rector a bit more efficient, your rules should only return a node if a change has been made, otherwise you should return null.

Noted 🤘
Thanks @peterfox 💪

@peterfox it's not working where self::some_case is there.
I tried but Idk how to detect it.