Merge branch '12.x' into json-api-resource

Author: crynobone

src/Illuminate/Broadcasting/UniqueBroadcastEvent.php

@@ -29,8 +29,6 @@ class UniqueBroadcastEvent extends BroadcastEvent implements ShouldBeUnique
      */
     public function __construct($event)
     {
-        $this->uniqueId = get_class($event);
-
         if (method_exists($event, 'uniqueId')) {
             $this->uniqueId .= $event->uniqueId();
         } elseif (property_exists($event, 'uniqueId')) {

src/Illuminate/Bus/UniqueLock.php

@@ -69,6 +69,10 @@ public static function getKey($job)
             ? $job->uniqueId()
             : ($job->uniqueId ?? '');
 
-        return 'laravel_unique_job:'.get_class($job).':'.$uniqueId;
+        $jobName = method_exists($job, 'displayName')
+            ? $job->displayName()
+            : get_class($job);
+
+        return 'laravel_unique_job:'.$jobName.':'.$uniqueId;
     }
 }

src/Illuminate/Cache/Console/stubs/cache.stub

@@ -14,13 +14,13 @@ return new class extends Migration
         Schema::create('cache', function (Blueprint $table) {
             $table->string('key')->primary();
             $table->mediumText('value');
-            $table->integer('expiration');
+            $table->integer('expiration')->index();
         });
 
         Schema::create('cache_locks', function (Blueprint $table) {
             $table->string('key')->primary();
             $table->string('owner');
-            $table->integer('expiration');
+            $table->integer('expiration')->index();
         });
     }
 

src/Illuminate/Collections/Arr.php

@@ -242,7 +242,7 @@ public static function exists($array, $key)
     }
 
     /**
-     * Return the first element in an array passing a given truth test.
+     * Return the first element in an iterable passing a given truth test.
      *
      * @template TKey
      * @template TValue
@@ -271,6 +271,8 @@ public static function first($array, ?callable $callback = null, $default = null
             return value($default);
         }
 
+        $array = static::from($array);
+
         $key = array_find_key($array, $callback);
 
         return $key !== null ? $array[$key] : value($default);

src/Illuminate/Container/Container.php

@@ -13,19 +13,19 @@
 use Illuminate\Contracts\Container\Container as ContainerContract;
 use Illuminate\Contracts\Container\ContextualAttribute;
 use Illuminate\Contracts\Container\SelfBuilding;
-use Illuminate\Support\Collection;
+use Illuminate\Support\Traits\ReflectsClosures;
 use LogicException;
 use ReflectionAttribute;
 use ReflectionClass;
 use ReflectionException;
 use ReflectionFunction;
-use ReflectionIntersectionType;
 use ReflectionParameter;
-use ReflectionUnionType;
 use TypeError;
 
 class Container implements ArrayAccess, ContainerContract
 {
+    use ReflectsClosures;
+
     /**
      * The current globally available container (if any).
      *
@@ -568,35 +568,6 @@ protected function bindBasedOnClosureReturnTypes($abstract, $concrete = null, $s
         }
     }
 
-    /**
-     * Get the class names / types of the return type of the given Closure.
-     *
-     * @param  \Closure  $closure
-     * @return list<class-string>
-     *
-     * @throws \ReflectionException
-     */
-    protected function closureReturnTypes(Closure $closure)
-    {
-        $reflection = new ReflectionFunction($closure);
-
-        if ($reflection->getReturnType() === null ||
-            $reflection->getReturnType() instanceof ReflectionIntersectionType) {
-            return [];
-        }
-
-        $types = $reflection->getReturnType() instanceof ReflectionUnionType
-            ? $reflection->getReturnType()->getTypes()
-            : [$reflection->getReturnType()];
-
-        return (new Collection($types))
-            ->reject(fn ($type) => $type->isBuiltin())
-            ->reject(fn ($type) => in_array($type->getName(), ['static', 'self']))
-            ->map(fn ($type) => $type->getName())
-            ->values()
-            ->all();
-    }
-
     /**
      * "Extend" an abstract type in the container.
      *

src/Illuminate/Database/Connection.php

@@ -646,14 +646,16 @@ public function pretend(Closure $callback)
         return $this->withFreshQueryLog(function () use ($callback) {
             $this->pretending = true;
 
-            // Basically to make the database connection "pretend", we will just return
-            // the default values for all the query methods, then we will return an
-            // array of queries that were "executed" within the Closure callback.
-            $callback($this);
-
-            $this->pretending = false;
-
-            return $this->queryLog;
+            try {
+                // Basically to make the database connection "pretend", we will just return
+                // the default values for all the query methods, then we will return an
+                // array of queries that were "executed" within the Closure callback.
+                $callback($this);
+
+                return $this->queryLog;
+            } finally {
+                $this->pretending = false;
+            }
         });
     }
 

src/Illuminate/Database/Eloquent/Model.php

@@ -2447,11 +2447,11 @@ public function offsetExists($offset): bool
 
         static::$modelsShouldPreventAccessingMissingAttributes = false;
 
-        $result = ! is_null($this->getAttribute($offset));
-
-        static::$modelsShouldPreventAccessingMissingAttributes = $shouldPrevent;
-
-        return $result;
+        try {
+            return ! is_null($this->getAttribute($offset));
+        } finally {
+            static::$modelsShouldPreventAccessingMissingAttributes = $shouldPrevent;
+        }
     }
 
     /**

src/Illuminate/Foundation/Console/ReloadCommand.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Illuminate\Foundation\Console;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Collection;
+use Illuminate\Support\ServiceProvider;
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Input\InputOption;
+
+#[AsCommand(name: 'reload')]
+class ReloadCommand extends Command
+{
+    /**
+     * The console command name.
+     *
+     * @var string
+     */
+    protected $name = 'reload';
+
+    /**
+     * The console command description.
+     *
+     * @var string
+     */
+    protected $description = 'Reload running services';
+
+    /**
+     * Execute the console command.
+     *
+     * @return void
+     */
+    public function handle()
+    {
+        $this->components->info('Reloading services.');
+
+        $exceptions = Collection::wrap(explode(',', $this->option('except') ?? ''))
+            ->map(fn ($except) => trim($except))
+            ->filter()
+            ->unique()
+            ->flip();
+
+        $tasks = Collection::wrap($this->getReloadTasks())
+            ->reject(fn ($command, $key) => $exceptions->hasAny([$command, $key]))
+            ->toArray();
+
+        foreach ($tasks as $description => $command) {
+            $this->components->task($description, fn () => $this->callSilently($command) == 0);
+        }
+
+        $this->newLine();
+    }
+
+    /**
+     * Get the commands that should be run to clear the "optimization" files.
+     *
+     * @return array
+     */
+    public function getReloadTasks()
+    {
+        return [
+            'queue' => 'queue:restart',
+            ...ServiceProvider::$reloadCommands,
+        ];
+    }
+
+    /**
+     * Get the console command arguments.
+     *
+     * @return array
+     */
+    protected function getOptions()
+    {
+        return [
+            ['except', 'e', InputOption::VALUE_OPTIONAL, 'The commands to skip'],
+        ];
+    }
+}

src/Illuminate/Foundation/Providers/ArtisanServiceProvider.php

@@ -70,6 +70,7 @@
 use Illuminate\Foundation\Console\PackageDiscoverCommand;
 use Illuminate\Foundation\Console\PolicyMakeCommand;
 use Illuminate\Foundation\Console\ProviderMakeCommand;
+use Illuminate\Foundation\Console\ReloadCommand;
 use Illuminate\Foundation\Console\RequestMakeCommand;
 use Illuminate\Foundation\Console\ResourceMakeCommand;
 use Illuminate\Foundation\Console\RouteCacheCommand;
@@ -160,6 +161,7 @@ class ArtisanServiceProvider extends ServiceProvider implements DeferrableProvid
         'QueueRetry' => QueueRetryCommand::class,
         'QueueRetryBatch' => QueueRetryBatchCommand::class,
         'QueueWork' => QueueWorkCommand::class,
+        'Reload' => ReloadCommand::class,
         'RouteCache' => RouteCacheCommand::class,
         'RouteClear' => RouteClearCommand::class,
         'RouteList' => RouteListCommand::class,

src/Illuminate/Http/Client/FluentPromise.php

@@ -0,0 +1,95 @@
+<?php
+
+namespace Illuminate\Http\Client;
+
+use GuzzleHttp\Promise\PromiseInterface;
+use Illuminate\Support\Traits\ForwardsCalls;
+
+/**
+ * A decorated Promise which allows for chaining callbacks.
+ */
+class FluentPromise implements PromiseInterface
+{
+    use ForwardsCalls;
+
+    /**
+     * Create a new fluent promise instance.
+     *
+     * @param  \GuzzleHttp\Promise\PromiseInterface  $guzzlePromise
+     */
+    public function __construct(protected PromiseInterface $guzzlePromise)
+    {
+    }
+
+    #[\Override]
+    public function then(?callable $onFulfilled = null, ?callable $onRejected = null): PromiseInterface
+    {
+        return $this->__call('then', [$onFulfilled, $onRejected]);
+    }
+
+    #[\Override]
+    public function otherwise(callable $onRejected): PromiseInterface
+    {
+        return $this->__call('otherwise', [$onRejected]);
+    }
+
+    #[\Override]
+    public function resolve($value): void
+    {
+        $this->guzzlePromise->resolve($value);
+    }
+
+    #[\Override]
+    public function reject($reason): void
+    {
+        $this->guzzlePromise->reject($reason);
+    }
+
+    #[\Override]
+    public function cancel(): void
+    {
+        $this->guzzlePromise->cancel();
+    }
+
+    #[\Override]
+    public function wait(bool $unwrap = true)
+    {
+        return $this->__call('wait', [$unwrap]);
+    }
+
+    #[\Override]
+    public function getState(): string
+    {
+        return $this->guzzlePromise->getState();
+    }
+
+    /**
+     * Get the underlying Guzzle promise.
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    public function getGuzzlePromise(): PromiseInterface
+    {
+        return $this->guzzlePromise;
+    }
+
+    /**
+     * Proxy requests to the underlying promise interface and update the local promise.
+     *
+     * @param  string  $method
+     * @param  array  $parameters
+     * @return mixed
+     */
+    public function __call($method, $parameters)
+    {
+        $result = $this->forwardCallTo($this->guzzlePromise, $method, $parameters);
+
+        if (! $result instanceof PromiseInterface) {
+            return $result;
+        }
+
+        $this->guzzlePromise = $result;
+
+        return $this;
+    }
+}