rector_rules_overview.md

50 Rules Overview

AddArgumentDefaultValueRector

Adds default value for arguments in defined methods.

🔧 configure it!

• class: RectorLaravel\Rector\ClassMethod\AddArgumentDefaultValueRector

<?php

declare(strict_types=1);

use RectorLaravel\Rector\ClassMethod\AddArgumentDefaultValueRector;
use RectorLaravel\ValueObject\AddArgumentDefaultValue;
use Rector\Config\RectorConfig;

return static function (RectorConfig $rectorConfig): void {
    $containerConfigurator->extension('rectorConfig', [
        [
            'class' => AddArgumentDefaultValueRector::class,
            'configuration' => [
                'added_arguments' => [
                    new AddArgumentDefaultValue('SomeClass', 'someMethod', 0, false),
                ],
            ],
        ],
    ]);
};

↓

 class SomeClass
 {
-    public function someMethod($value)
+    public function someMethod($value = false)
     {
     }
 }

AddExtendsAnnotationToModelFactoriesRector

Adds the @extends annotation to Factories.

• class: RectorLaravel\Rector\Class_\AddExtendsAnnotationToModelFactoriesRector

 use Illuminate\Database\Eloquent\Factories\Factory;

+/**
+ * @extends \Illuminate\Database\Eloquent\Factories\Factory<\App\Models\User>
+ */
 class UserFactory extends Factory
 {
     protected $model = \App\Models\User::class;
 }

AddGenericReturnTypeToRelationsRector

Add generic return type to relations in child of Illuminate\Database\Eloquent\Model

• class: RectorLaravel\Rector\ClassMethod\AddGenericReturnTypeToRelationsRector

 use App\Account;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Database\Eloquent\Relations\HasMany;

 class User extends Model
 {
+    /** @return HasMany<Account> */
     public function accounts(): HasMany
     {
         return $this->hasMany(Account::class);
     }
 }

AddGuardToLoginEventRector

Add new $guard argument to Illuminate\Auth\Events\Login

• class: RectorLaravel\Rector\New_\AddGuardToLoginEventRector

 use Illuminate\Auth\Events\Login;

 final class SomeClass
 {
     public function run(): void
     {
-        $loginEvent = new Login('user', false);
+        $guard = config('auth.defaults.guard');
+        $loginEvent = new Login($guard, 'user', false);
     }
 }

AddMockConsoleOutputFalseToConsoleTestsRector

Add "$this->mockConsoleOutput = false"; to console tests that work with output content

• class: RectorLaravel\Rector\Class_\AddMockConsoleOutputFalseToConsoleTestsRector

 use Illuminate\Support\Facades\Artisan;
 use Illuminate\Foundation\Testing\TestCase;

 final class SomeTest extends TestCase
 {
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        $this->mockConsoleOutput = false;
+    }
+
     public function test(): void
     {
         $this->assertEquals('content', \trim((new Artisan())::output()));
     }
 }

AddParentBootToModelClassMethodRector

Add parent::boot(); call to boot() class method in child of Illuminate\Database\Eloquent\Model

• class: RectorLaravel\Rector\ClassMethod\AddParentBootToModelClassMethodRector

 use Illuminate\Database\Eloquent\Model;

 class Product extends Model
 {
     public function boot()
     {
+        parent::boot();
     }
 }

AddParentRegisterToEventServiceProviderRector

Add parent::register(); call to register() class method in child of Illuminate\Foundation\Support\Providers\EventServiceProvider

• class: RectorLaravel\Rector\ClassMethod\AddParentRegisterToEventServiceProviderRector

 use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;

 class EventServiceProvider extends ServiceProvider
 {
     public function register()
     {
+        parent::register();
     }
 }

AnonymousMigrationsRector

Convert migrations to anonymous classes.

• class: RectorLaravel\Rector\Class_\AnonymousMigrationsRector

 use Illuminate\Database\Migrations\Migration;

-class CreateUsersTable extends Migration
+return new class extends Migration
 {
     // ...
-}
+};

AppEnvironmentComparisonToParameterRector

Replace $app->environment() === 'local' with $app->environment('local')

• class: RectorLaravel\Rector\Expr\AppEnvironmentComparisonToParameterRector

-$app->environment() === 'production';
+$app->environment('production');

ArgumentFuncCallToMethodCallRector

Move help facade-like function calls to constructor injection

🔧 configure it!

• class: RectorLaravel\Rector\FuncCall\ArgumentFuncCallToMethodCallRector

<?php

declare(strict_types=1);

use RectorLaravel\Rector\FuncCall\ArgumentFuncCallToMethodCallRector;
use RectorLaravel\ValueObject\ArgumentFuncCallToMethodCall;
use Rector\Config\RectorConfig;

return static function (RectorConfig $rectorConfig): void {
    $containerConfigurator->extension('rectorConfig', [
        [
            'class' => ArgumentFuncCallToMethodCallRector::class,
            'configuration' => [
                new ArgumentFuncCallToMethodCall('view', 'Illuminate\Contracts\View\Factory', 'make'),
            ],
        ],
    ]);
};

↓

 class SomeController
 {
+    /**
+     * @var \Illuminate\Contracts\View\Factory
+     */
+    private $viewFactory;
+
+    public function __construct(\Illuminate\Contracts\View\Factory $viewFactory)
+    {
+        $this->viewFactory = $viewFactory;
+    }
+
     public function action()
     {
-        $template = view('template.blade');
-        $viewFactory = view();
+        $template = $this->viewFactory->make('template.blade');
+        $viewFactory = $this->viewFactory;
     }
 }

AssertStatusToAssertMethodRector

Replace (new \Illuminate\Testing\TestResponse)->assertStatus(200) with (new \Illuminate\Testing\TestResponse)->assertOk()

• class: RectorLaravel\Rector\MethodCall\AssertStatusToAssertMethodRector

 class ExampleTest extends \Illuminate\Foundation\Testing\TestCase
 {
     public function testOk()
     {
-        $this->get('/')->assertStatus(200);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_OK);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_OK);
+        $this->get('/')->assertOk();
+        $this->get('/')->assertOk();
+        $this->get('/')->assertOk();
     }

     public function testNoContent()
     {
-        $this->get('/')->assertStatus(204);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_NO_CONTENT);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_NO_CONTENT);
+        $this->get('/')->assertNoContent();
+        $this->get('/')->assertNoContent();
+        $this->get('/')->assertNoContent();
     }

     public function testUnauthorized()
     {
-        $this->get('/')->assertStatus(401);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_UNAUTHORIZED);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_UNAUTHORIZED);
+        $this->get('/')->assertUnauthorized();
+        $this->get('/')->assertUnauthorized();
+        $this->get('/')->assertUnauthorized();
     }

     public function testForbidden()
     {
-        $this->get('/')->assertStatus(403);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_FORBIDDEN);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_FORBIDDEN);
+        $this->get('/')->assertForbidden();
+        $this->get('/')->assertForbidden();
+        $this->get('/')->assertForbidden();
     }

     public function testNotFound()
     {
-        $this->get('/')->assertStatus(404);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_NOT_FOUND);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_NOT_FOUND);
+        $this->get('/')->assertNotFound();
+        $this->get('/')->assertNotFound();
+        $this->get('/')->assertNotFound();
     }

     public function testMethodNotAllowed()
     {
-        $this->get('/')->assertStatus(405);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_METHOD_NOT_ALLOWED);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_METHOD_NOT_ALLOWED);
+        $this->get('/')->assertMethodNotAllowed();
+        $this->get('/')->assertMethodNotAllowed();
+        $this->get('/')->assertMethodNotAllowed();
     }

     public function testUnprocessableEntity()
     {
-        $this->get('/')->assertStatus(422);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_UNPROCESSABLE_ENTITY);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_UNPROCESSABLE_ENTITY);
+        $this->get('/')->assertUnprocessable();
+        $this->get('/')->assertUnprocessable();
+        $this->get('/')->assertUnprocessable();
     }

     public function testGone()
     {
-        $this->get('/')->assertStatus(410);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_GONE);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_GONE);
+        $this->get('/')->assertGone();
+        $this->get('/')->assertGone();
+        $this->get('/')->assertGone();
     }

     public function testInternalServerError()
     {
-        $this->get('/')->assertStatus(500);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_INTERNAL_SERVER_ERROR);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_INTERNAL_SERVER_ERROR);
+        $this->get('/')->assertInternalServerError();
+        $this->get('/')->assertInternalServerError();
+        $this->get('/')->assertInternalServerError();
     }

     public function testServiceUnavailable()
     {
-        $this->get('/')->assertStatus(503);
-        $this->get('/')->assertStatus(\Illuminate\Http\Response::HTTP_SERVICE_UNAVAILABLE);
-        $this->get('/')->assertStatus(\Symfony\Component\HttpFoundation\Response::HTTP_SERVICE_UNAVAILABLE);
+        $this->get('/')->asserServiceUnavailable();
+        $this->get('/')->asserServiceUnavailable();
+        $this->get('/')->asserServiceUnavailable();
     }
 }

CallOnAppArrayAccessToStandaloneAssignRector

Replace magical call on $this->app["something"] to standalone type assign variable

• class: RectorLaravel\Rector\Assign\CallOnAppArrayAccessToStandaloneAssignRector

 class SomeClass
 {
     /**
      * @var \Illuminate\Contracts\Foundation\Application
      */
     private $app;

     public function run()
     {
-        $validator = $this->app['validator']->make('...');
+        /** @var \Illuminate\Validation\Factory $validationFactory */
+        $validationFactory = $this->app['validator'];
+        $validator = $validationFactory->make('...');
     }
 }

CashierStripeOptionsToStripeRector

Renames the Billable stripeOptions() to stripe().

• class: RectorLaravel\Rector\Class_\CashierStripeOptionsToStripeRector

 use Illuminate\Database\Eloquent\Model;
 use Laravel\Cashier\Billable;

 class User extends Model
 {
     use Billable;

-    public function stripeOptions(array $options = []) {
+    public function stripe(array $options = []) {
         return [];
     }
 }

ChangeQueryWhereDateValueWithCarbonRector

Add parent::boot(); call to boot() class method in child of Illuminate\Database\Eloquent\Model

• class: RectorLaravel\Rector\MethodCall\ChangeQueryWhereDateValueWithCarbonRector

 use Illuminate\Database\Query\Builder;

 final class SomeClass
 {
     public function run(Builder $query)
     {
-        $query->whereDate('created_at', '<', Carbon::now());
+        $dateTime = Carbon::now();
+        $query->whereDate('created_at', '<=', $dateTime);
+        $query->whereTime('created_at', '<=', $dateTime);
     }
 }

DatabaseExpressionCastsToMethodCallRector

Convert DB Expression string casts to getValue() method calls.

• class: RectorLaravel\Rector\Cast\DatabaseExpressionCastsToMethodCallRector

 use Illuminate\Support\Facades\DB;

-$string = (string) DB::raw('select 1');
+$string = DB::raw('select 1')->getValue(DB::connection()->getQueryGrammar());

DatabaseExpressionToStringToMethodCallRector

Convert DB Expression __toString() calls to getValue() method calls.

• class: RectorLaravel\Rector\MethodCall\DatabaseExpressionToStringToMethodCallRector

 use Illuminate\Support\Facades\DB;

-$string = DB::raw('select 1')->__toString();
+$string = DB::raw('select 1')->getValue(DB::connection()->getQueryGrammar());

EloquentMagicMethodToQueryBuilderRector

The EloquentMagicMethodToQueryBuilderRule is designed to automatically transform certain magic method calls on Eloquent Models into corresponding Query Builder method calls.

• class: RectorLaravel\Rector\StaticCall\EloquentMagicMethodToQueryBuilderRector

 use App\Models\User;

-$user = User::find(1);
+$user = User::query()->find(1);

EloquentOrderByToLatestOrOldestRector

Changes orderBy() to latest() or oldest()

🔧 configure it!

• class: RectorLaravel\Rector\MethodCall\EloquentOrderByToLatestOrOldestRector

<?php

declare(strict_types=1);

use RectorLaravel\Rector\MethodCall\EloquentOrderByToLatestOrOldestRector;
use Rector\Config\RectorConfig;

return static function (RectorConfig $rectorConfig): void {
    $containerConfigurator->extension('rectorConfig', [
        [
            'class' => EloquentOrderByToLatestOrOldestRector::class,
            'configuration' => [
                'allowed_patterns' => [
                    'submitted_a*',
                    '*tested_at',
                    '$allowed_variable_name',
                ],
            ],
        ],
    ]);
};

↓

 use Illuminate\Database\Eloquent\Builder;

 $column = 'tested_at';

-$builder->orderBy('created_at');
-$builder->orderBy('created_at', 'desc');
-$builder->orderBy('submitted_at');
-$builder->orderByDesc('submitted_at');
-$builder->orderBy($allowed_variable_name);
+$builder->oldest();
+$builder->latest();
+$builder->oldest('submitted_at');
+$builder->latest('submitted_at');
+$builder->oldest($allowed_variable_name);
 $builder->orderBy($unallowed_variable_name);
 $builder->orderBy('unallowed_column_name');

EloquentWhereRelationTypeHintingParameterRector

Add type hinting to where relation has methods e.g. whereHas, orWhereHas, whereDoesntHave, orWhereDoesntHave, whereHasMorph, orWhereHasMorph, whereDoesntHaveMorph, orWhereDoesntHaveMorph

• class: RectorLaravel\Rector\MethodCall\EloquentWhereRelationTypeHintingParameterRector

-User::whereHas('posts', function ($query) {
+User::whereHas('posts', function (\Illuminate\Contracts\Database\Query\Builder $query) {
     $query->where('is_published', true);
 });

-$query->whereHas('posts', function ($query) {
+$query->whereHas('posts', function (\Illuminate\Contracts\Database\Query\Builder $query) {
     $query->where('is_published', true);
 });

EloquentWhereTypeHintClosureParameterRector

Change typehint of closure parameter in where method of Eloquent Builder

• class: RectorLaravel\Rector\MethodCall\EloquentWhereTypeHintClosureParameterRector

-$query->where(function ($query) {
+$query->where(function (\Illuminate\Contracts\Database\Eloquent\Builder $query) {
     $query->where('id', 1);
 });

EmptyToBlankAndFilledFuncRector

Replace use of the unsafe empty() function with Laravel's safer blank() & filled() functions.

• class: RectorLaravel\Rector\Empty_\EmptyToBlankAndFilledFuncRector

-empty([]);
-!empty([]);
+blank([]);
+filled([]);

FactoryApplyingStatesRector

Call the state methods directly instead of specify the name of state.

• class: RectorLaravel\Rector\MethodCall\FactoryApplyingStatesRector

-$factory->state('delinquent');
-$factory->states('premium', 'delinquent');
+$factory->delinquent();
+$factory->premium()->delinquent();

FactoryDefinitionRector

Upgrade legacy factories to support classes.

• class: RectorLaravel\Rector\Namespace_\FactoryDefinitionRector

 use Faker\Generator as Faker;

-$factory->define(App\User::class, function (Faker $faker) {
-    return [
-        'name' => $faker->name,
-        'email' => $faker->unique()->safeEmail,
-    ];
-});
+class UserFactory extends \Illuminate\Database\Eloquent\Factories\Factory
+{
+    protected $model = App\User::class;
+    public function definition()
+    {
+        return [
+            'name' => $this->faker->name,
+            'email' => $this->faker->unique()->safeEmail,
+        ];
+    }
+}

FactoryFuncCallToStaticCallRector

Use the static factory method instead of global factory function.

• class: RectorLaravel\Rector\FuncCall\FactoryFuncCallToStaticCallRector

-factory(User::class);
+User::factory();

HelperFuncCallToFacadeClassRector

Change app() func calls to facade calls

• class: RectorLaravel\Rector\FuncCall\HelperFuncCallToFacadeClassRector

 class SomeClass
 {
     public function run()
     {
-        return app('translator')->trans('value');
+        return \Illuminate\Support\Facades\App::get('translator')->trans('value');
     }
 }

JsonCallToExplicitJsonCallRector

Change method calls from $this->json to $this->postJson, $this->putJson, etc.

• class: RectorLaravel\Rector\MethodCall\JsonCallToExplicitJsonCallRector

-$this->json("POST", "/api/v1/users", $data);
+§this->postJson("/api/v1/users", $data);

LumenRoutesStringActionToUsesArrayRector

Changes action in rule definitions from string to array notation.

• class: RectorLaravel\Rector\MethodCall\LumenRoutesStringActionToUsesArrayRector

-$router->get('/user', 'UserController@get');
+$router->get('/user', ['uses => 'UserController@get']);

LumenRoutesStringMiddlewareToArrayRector

Changes middlewares from rule definitions from string to array notation.

• class: RectorLaravel\Rector\MethodCall\LumenRoutesStringMiddlewareToArrayRector

-$router->get('/user', ['middleware => 'test']);
-$router->post('/user', ['middleware => 'test|authentication']);
+$router->get('/user', ['middleware => ['test']]);
+$router->post('/user', ['middleware => ['test', 'authentication']]);

MigrateToSimplifiedAttributeRector

Migrate to the new Model attributes syntax

• class: RectorLaravel\Rector\ClassMethod\MigrateToSimplifiedAttributeRector

 use Illuminate\Database\Eloquent\Model;

 class User extends Model
 {
-    public function getFirstNameAttribute($value)
+    protected function firstName(): \Illuminate\Database\Eloquent\Casts\Attribute
     {
-        return ucfirst($value);
-    }
-
-    public function setFirstNameAttribute($value)
-    {
-        $this->attributes['first_name'] = strtolower($value);
-        $this->attributes['first_name_upper'] = strtoupper($value);
+        return \Illuminate\Database\Eloquent\Casts\Attribute::make(get: function ($value) {
+            return ucfirst($value);
+        }, set: function ($value) {
+            return ['first_name' => strtolower($value), 'first_name_upper' => strtoupper($value)];
+        });
     }
 }

MinutesToSecondsInCacheRector

Change minutes argument to seconds in Illuminate\Contracts\Cache\Store and Illuminate\Support\Facades\Cache

• class: RectorLaravel\Rector\StaticCall\MinutesToSecondsInCacheRector

 class SomeClass
 {
     public function run()
     {
-        Illuminate\Support\Facades\Cache::put('key', 'value', 60);
+        Illuminate\Support\Facades\Cache::put('key', 'value', 60 * 60);
     }
 }

NotFilledBlankFuncCallToBlankFilledFuncCallRector

Swap the use of NotBooleans used with filled() and blank() to the correct helper.

• class: RectorLaravel\Rector\FuncCall\NotFilledBlankFuncCallToBlankFilledFuncCallRector

-!filled([]);
-!blank([]);
+blank([]);
+filled([]);

NowFuncWithStartOfDayMethodCallToTodayFuncRector

Use today() instead of now()->startOfDay()

• class: RectorLaravel\Rector\FuncCall\NowFuncWithStartOfDayMethodCallToTodayFuncRector

-$now = now()->startOfDay();
+$now = today();

OptionalToNullsafeOperatorRector

Convert simple calls to optional helper to use the nullsafe operator

🔧 configure it!

• class: RectorLaravel\Rector\PropertyFetch\OptionalToNullsafeOperatorRector

<?php

declare(strict_types=1);

use RectorLaravel\Rector\PropertyFetch\OptionalToNullsafeOperatorRector;
use Rector\Config\RectorConfig;

return static function (RectorConfig $rectorConfig): void {
    $containerConfigurator->extension('rectorConfig', [
        [
            'class' => OptionalToNullsafeOperatorRector::class,
            'configuration' => [
                'exclude_methods' => [
                    'present',
                ],
            ],
        ],
    ]);
};

↓

-optional($user)->getKey();
-optional($user)->id;
+$user?->getKey();
+$user?->id;
 // macro methods
 optional($user)->present()->getKey();

PropertyDeferToDeferrableProviderToRector

Change deprecated $defer = true; to Illuminate\Contracts\Support\DeferrableProvider interface

• class: RectorLaravel\Rector\Class_\PropertyDeferToDeferrableProviderToRector

 use Illuminate\Support\ServiceProvider;
+use Illuminate\Contracts\Support\DeferrableProvider;

-final class SomeServiceProvider extends ServiceProvider
+final class SomeServiceProvider extends ServiceProvider implements DeferrableProvider
 {
-    /**
-     * @var bool
-     */
-    protected $defer = true;
 }

Redirect301ToPermanentRedirectRector

Change "redirect" call with 301 to "permanentRedirect"

• class: RectorLaravel\Rector\StaticCall\Redirect301ToPermanentRedirectRector

 class SomeClass
 {
     public function run()
     {
-        Illuminate\Routing\Route::redirect('/foo', '/bar', 301);
+        Illuminate\Routing\Route::permanentRedirect('/foo', '/bar');
     }
 }

RedirectBackToBackHelperRector

Replace redirect()->back() and Redirect::back() with back()

• class: RectorLaravel\Rector\MethodCall\RedirectBackToBackHelperRector

 use Illuminate\Support\Facades\Redirect;

 class MyController
 {
     public function store()
     {
-        return redirect()->back()->with('error', 'Incorrect Details.')
+        return back()->with('error', 'Incorrect Details.')
     }

     public function update()
     {
-        return Redirect::back()->with('error', 'Incorrect Details.')
+        return back()->with('error', 'Incorrect Details.')
     }
 }

RedirectRouteToToRouteHelperRector

Replace redirect()->route("home") and Redirect::route("home") with to_route("home")

• class: RectorLaravel\Rector\MethodCall\RedirectRouteToToRouteHelperRector

 use Illuminate\Support\Facades\Redirect;

 class MyController
 {
     public function store()
     {
-        return redirect()->route('home')->with('error', 'Incorrect Details.')
+        return to_route('home')->with('error', 'Incorrect Details.')
     }

     public function update()
     {
-        return Redirect::route('home')->with('error', 'Incorrect Details.')
+        return to_route('home')->with('error', 'Incorrect Details.')
     }
 }

RemoveDumpDataDeadCodeRector

It will removes the dump data just like dd or dump functions from the code.`

• class: RectorLaravel\Rector\FuncCall\RemoveDumpDataDeadCodeRector

 class MyController
 {
     public function store()
     {
-        dd('test');
         return true;
     }

     public function update()
     {
-        dump('test');
         return true;
     }
 }

RemoveModelPropertyFromFactoriesRector

Removes the $model property from Factories.

• class: RectorLaravel\Rector\Class_\RemoveModelPropertyFromFactoriesRector

 use Illuminate\Database\Eloquent\Factories\Factory;

 class UserFactory extends Factory
 {
-    protected $model = \App\Models\User::class;
 }

ReplaceAssertTimesSendWithAssertSentTimesRector

Replace assertTimesSent with assertSentTimes

• class: RectorLaravel\Rector\StaticCall\ReplaceAssertTimesSendWithAssertSentTimesRector

-Notification::assertTimesSent(1, SomeNotification::class);
+Notification::assertSentTimes(SomeNotification::class, 1);

ReplaceExpectsMethodsInTestsRector

Replace expectJobs and expectEvents methods in tests

• class: RectorLaravel\Rector\Class_\ReplaceExpectsMethodsInTestsRector

 use Illuminate\Foundation\Testing\TestCase;

 class SomethingTest extends TestCase
 {
     public function testSomething()
     {
-        $this->expectsJobs([\App\Jobs\SomeJob::class, \App\Jobs\SomeOtherJob::class]);
-        $this->expectsEvents(\App\Events\SomeEvent::class);
+        \Illuminate\Support\Facades\Bus::fake([\App\Jobs\SomeJob::class, \App\Jobs\SomeOtherJob::class]);
+        \Illuminate\Support\Facades\Event::fake([\App\Events\SomeEvent::class]);

         $this->get('/');
+
+        \Illuminate\Support\Facades\Bus::assertDispatched(\App\Jobs\SomeJob::class);
+        \Illuminate\Support\Facades\Bus::assertDispatched(\App\Jobs\SomeOtherJob::class);
+        \Illuminate\Support\Facades\Event::assertDispatched(\App\Events\SomeEvent::class);
     }
 }

ReplaceFakerInstanceWithHelperRector

Replace $this->faker with the fake() helper function in Factories

• class: RectorLaravel\Rector\PropertyFetch\ReplaceFakerInstanceWithHelperRector

 class UserFactory extends Factory
 {
     public function definition()
     {
         return [
-            'name' => $this->faker->name,
-            'email' => $this->faker->unique()->safeEmail,
+            'name' => fake()->name,
+            'email' => fake()->unique()->safeEmail,
         ];
     }
 }

ReplaceWithoutJobsEventsAndNotificationsWithFacadeFakeRector

Replace withoutJobs, withoutEvents and withoutNotifications with Facade fake

• class: RectorLaravel\Rector\MethodCall\ReplaceWithoutJobsEventsAndNotificationsWithFacadeFakeRector

-$this->withoutJobs();
-$this->withoutEvents();
-$this->withoutNotifications();
+\Illuminate\Support\Facades\Bus::fake();
+\Illuminate\Support\Facades\Event::fake();
+\Illuminate\Support\Facades\Notification::fake();

RequestStaticValidateToInjectRector

Change static validate() method to $request->validate()

• class: RectorLaravel\Rector\StaticCall\RequestStaticValidateToInjectRector

 use Illuminate\Http\Request;

 class SomeClass
 {
-    public function store()
+    public function store(\Illuminate\Http\Request $request)
     {
-        $validatedData = Request::validate(['some_attribute' => 'required']);
+        $validatedData = $request->validate(['some_attribute' => 'required']);
     }
 }

RouteActionCallableRector

Use PHP callable syntax instead of string syntax for controller route declarations.

🔧 configure it!

• class: RectorLaravel\Rector\StaticCall\RouteActionCallableRector

<?php

declare(strict_types=1);

use RectorLaravel\Rector\StaticCall\RouteActionCallableRector;
use Rector\Config\RectorConfig;

return static function (RectorConfig $rectorConfig): void {
    $containerConfigurator->extension('rectorConfig', [
        [
            'class' => RouteActionCallableRector::class,
            'configuration' => [
                'namespace' => 'App\Http\Controllers',
            ],
        ],
    ]);
};

↓

-Route::get('/users', 'UserController@index');
+Route::get('/users', [\App\Http\Controllers\UserController::class, 'index']);

SleepFuncToSleepStaticCallRector

Use Sleep::sleep() and Sleep::usleep() instead of the sleep() and usleep() function.

• class: RectorLaravel\Rector\FuncCall\SleepFuncToSleepStaticCallRector

-sleep(5);
+\Illuminate\Support\Sleep::sleep(5);

SubStrToStartsWithOrEndsWithStaticMethodCallRector

Use Str::startsWith() or Str::endsWith() instead of substr() === $str

• class: RectorLaravel\Rector\Expr\SubStrToStartsWithOrEndsWithStaticMethodCallRector\SubStrToStartsWithOrEndsWithStaticMethodCallRector

-if (substr($str, 0, 3) === 'foo') {
+if (Str::startsWith($str, 'foo')) {
     // do something
 }

ThrowIfRector

Change if throw to throw_if

• class: RectorLaravel\Rector\If_\ThrowIfRector

-if ($condition) {
-    throw new Exception();
-}
-if (!$condition) {
-    throw new Exception();
-}
+throw_if($condition, new Exception());
+throw_unless($condition, new Exception());

UnifyModelDatesWithCastsRector

Unify Model $dates property with $casts

• class: RectorLaravel\Rector\Class_\UnifyModelDatesWithCastsRector

 use Illuminate\Database\Eloquent\Model;

 class Person extends Model
 {
     protected $casts = [
-        'age' => 'integer',
+        'age' => 'integer', 'birthday' => 'datetime',
     ];
-
-    protected $dates = ['birthday'];
 }

UseComponentPropertyWithinCommandsRector

Use $this->components property within commands

• class: RectorLaravel\Rector\MethodCall\UseComponentPropertyWithinCommandsRector

 use Illuminate\Console\Command;

 class CommandWithComponents extends Command
 {
     public function handle()
     {
-        $this->ask('What is your name?');
-        $this->line('A line!');
-        $this->info('Info!');
-        $this->error('Error!');
+        $this->components->ask('What is your name?');
+        $this->components->line('A line!');
+        $this->components->info('Info!');
+        $this->components->error('Error!');
     }
 }