Merge branch '5.4'

Author: taylorotwell

src/Illuminate/Events/CallQueuedListener.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Illuminate\Events;
+
+use Illuminate\Container\Container;
+use Illuminate\Contracts\Queue\Job;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Contracts\Queue\ShouldQueue;
+
+class CallQueuedListener implements ShouldQueue
+{
+    use InteractsWithQueue;
+
+    /**
+     * The listener class name.
+     *
+     * @var string
+     */
+    public $class;
+
+    /**
+     * The listener method.
+     *
+     * @var string
+     */
+    public $method;
+
+    /**
+     * The data to be passed to the listener.
+     *
+     * @var string
+     */
+    public $data;
+
+    /**
+     * Create a new job instance.
+     *
+     * @param  string  $class
+     * @param  string  $method
+     * @param  string  $data
+     * @return void
+     */
+    public function __construct($class, $method, $data)
+    {
+        $this->data = $data;
+        $this->class = $class;
+        $this->method = $method;
+    }
+
+    /**
+     * Handle the queued job.
+     *
+     * @param  \Illuminate\Container\Container  $container
+     * @return void
+     */
+    public function handle(Container $container)
+    {
+        $handler = $this->setJobInstanceIfNecessary(
+            $this->job, $container->make($this->class)
+        );
+
+        call_user_func_array(
+            [$handler, $this->method], unserialize($this->data)
+        );
+    }
+
+    /**
+     * Set the job instance of the given class if necessary.
+     *
+     * @param  \Illuminate\Contracts\Queue\Job  $job
+     * @param  mixed  $instance
+     * @return mixed
+     */
+    protected function setJobInstanceIfNecessary(Job $job, $instance)
+    {
+        if (in_array(InteractsWithQueue::class, class_uses_recursive(get_class($instance)))) {
+            $instance->setJob($job);
+        }
+
+        return $instance;
+    }
+
+    /**
+     * Call the failed method on the job instance.
+     *
+     * The event instance and the exception will be passed.
+     *
+     * @param  \Exception  $e
+     * @return void
+     */
+    public function failed($e)
+    {
+        $handler = Container::getInstance()->make($this->class);
+
+        $parameters = array_merge(unserialize($this->data), [$e]);
+
+        if (method_exists($handler, 'failed')) {
+            call_user_func_array([$handler, 'failed'], $parameters);
+        }
+    }
+}

src/Illuminate/Events/Dispatcher.php

@@ -450,19 +450,15 @@ protected function callQueueMethodOnHandler($class, $method, $arguments)
      */
     protected function queueHandler($class, $method, $arguments)
     {
-        $handler = (new ReflectionClass($class))->newInstanceWithoutConstructor();
+        $listener = (new ReflectionClass($class))->newInstanceWithoutConstructor();
 
-        $connection = isset($handler->connection) ? $handler->connection : null;
+        $connection = isset($listener->connection) ? $listener->connection : null;
 
-        $queue = isset($handler->queue) ? $handler->queue : null;
+        $queue = isset($listener->queue) ? $listener->queue : null;
 
         $this->resolveQueue()
                 ->connection($connection)
-                ->pushOn($queue, 'Illuminate\Events\CallQueuedHandler@call', [
-                    'class' => $class,
-                    'method' => $method,
-                    'data' => serialize($arguments),
-                ]);
+                ->pushOn($queue, new CallQueuedListener($class, $method, serialize($arguments)));
     }
 
     /**

src/Illuminate/Foundation/Console/Kernel.php

@@ -231,7 +231,7 @@ public function call($command, array $parameters = [], $outputBuffer = null)
     public function queue($command, array $parameters = [])
     {
         $this->app[QueueContract::class]->push(
-            QueuedJob::class, func_get_args()
+            new QueuedCommand(func_get_args())
         );
     }
 

src/Illuminate/Foundation/Console/QueuedCommand.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Illuminate\Foundation\Console;
+
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Contracts\Console\Kernel as KernelContract;
+
+class QueuedCommand implements ShouldQueue
+{
+    /**
+     * The data to pass to the Artisan command.
+     *
+     * @var array
+     */
+    protected $data;
+
+    /**
+     * Create a new job instance.
+     *
+     * @param  array  $data
+     * @return void
+     */
+    public function __construct($data)
+    {
+        $this->data = $data;
+    }
+
+    /**
+     * Handle the job.
+     *
+     * @param  \Illuminate\Contracts\Console\Kernel  $kernel
+     * @return void
+     */
+    public function handle(KernelContract $kernel)
+    {
+        call_user_func_array([$kernel, 'call'], $this->data);
+    }
+}

src/Illuminate/Foundation/Console/QueuedJob.php

@@ -66,7 +66,9 @@ protected function loadCachedRoutes()
      */
     protected function loadRoutes()
     {
-        $this->app->call([$this, 'map']);
+        if (method_exists($this, 'map')) {
+            $this->app->call([$this, 'map']);
+        }
     }
 
     /**

src/Illuminate/Foundation/Support/Providers/RouteServiceProvider.php

@@ -239,11 +239,12 @@ public function useDailyFiles($path, $days = 0, $level = 'debug')
      *
      * @param  string  $name
      * @param  string  $level
+     * @param  mixed  $facility
      * @return \Psr\Log\LoggerInterface
      */
-    public function useSyslog($name = 'laravel', $level = 'debug')
+    public function useSyslog($name = 'laravel', $level = 'debug', $facility = LOG_USER)
     {
-        return $this->monolog->pushHandler(new SyslogHandler($name, LOG_USER, $level));
+        return $this->monolog->pushHandler(new SyslogHandler($name, $facility, $level));
     }
 
     /**

src/Illuminate/Log/Writer.php

@@ -27,6 +27,10 @@ public static function parse($job)
      */
     public static function resolve($name, $payload)
     {
+        if (isset($payload['displayName']) && ! empty($payload['displayName'])) {
+            return $payload['displayName'];
+        }
+
         if ($name === 'Illuminate\Queue\CallQueuedHandler@call') {
             return Arr::get($payload, 'data.commandName', $name);
         }

src/Illuminate/Queue/Jobs/JobName.php

@@ -3,6 +3,7 @@
 namespace Illuminate\Queue;
 
 use Illuminate\Container\Container;
+use Illuminate\Events\CallQueuedListener;
 
 abstract class Queue
 {
@@ -116,6 +117,7 @@ protected function createPayloadArray($job, $data = '', $queue = null)
     protected function createObjectPayload($job)
     {
         return [
+            'displayName' => $this->getDisplayName($job),
             'job' => 'Illuminate\Queue\CallQueuedHandler@call',
             'maxTries' => isset($job->tries) ? $job->tries : null,
             'timeout' => isset($job->timeout) ? $job->timeout : null,
@@ -126,6 +128,21 @@ protected function createObjectPayload($job)
         ];
     }
 
+    /**
+     * Get the display name for the given job.
+     *
+     * @param  mixed  $job
+     * @return string
+     */
+    protected function getDisplayName($job)
+    {
+        if ($job instanceof CallQueuedListener) {
+            return $job->class;
+        }
+
+        return get_class($job);
+    }
+
     /**
      * Create a typical, string based queue payload array.
      *

src/Illuminate/Queue/Queue.php

@@ -1174,6 +1174,19 @@ public function take($limit)
         return $this->slice(0, $limit);
     }
 
+    /**
+     * Pass the collection to the given callback and then return it.
+     *
+     * @param  callable  $callback
+     * @return $this
+     */
+    public function tap(callable $callback)
+    {
+        $callback(new static($this->items));
+
+        return $this;
+    }
+
     /**
      * Transform each item in the collection using a callback.
      *

src/Illuminate/Support/Collection.php

@@ -173,11 +173,7 @@ public function testQueuedEventHandlersAreQueued()
 
         $queue->shouldReceive('connection')->once()->with(null)->andReturnSelf();
 
-        $queue->shouldReceive('pushOn')->once()->with(null, 'Illuminate\Events\CallQueuedHandler@call', [
-            'class' => 'Illuminate\Tests\Events\TestDispatcherQueuedHandler',
-            'method' => 'someMethod',
-            'data' => serialize(['foo', 'bar']),
-        ]);
+        $queue->shouldReceive('pushOn')->once()->with(null, m::type('Illuminate\Events\CallQueuedListener'));
 
         $d->setQueueResolver(function () use ($queue) {
             return $queue;

tests/Events/EventsDispatcherTest.php

@@ -1882,6 +1882,19 @@ public function testHigherOrderPartition()
 
         $this->assertSame(['b' => ['free' => false]], $premium->toArray());
     }
+
+    public function testTap()
+    {
+        $collection = new Collection([1, 2, 3]);
+
+        $fromTap = [];
+        $collection = $collection->tap(function ($collection) use (&$fromTap) {
+            $fromTap = $collection->slice(0, 1)->toArray();
+        });
+
+        $this->assertSame([1], $fromTap);
+        $this->assertSame([1, 2, 3], $collection->toArray());
+    }
 }
 
 class TestSupportCollectionHigherOrderItem