Laravel is such a ravioli!

Just here to vent a bit.

So, I wanted to find how is the password reset functionality tied to a field called `email` on the user model.

First off, sending. The documentation [says](https://laravel.com/docs/5.6/passwords#password-customization) that one can override the `sendPasswordNotification` method on the user. Okay then, it must be calling the method, so let's look at the default which is:

```php
public function sendPasswordNotification($token)
{
$this->notify(new ResetPasswordNotification($token));
}
```
Notify? That must come from the `Notifiable` trait on the user model, right? It's `Illuminate\Notifications\Notifiable`. Well, here's the whole file:

```php
send($this, $instance);
}
```

Dispatcher? We can see `use Illuminate\Contracts\Notifications\Dispatcher;` at the top of this file. I should get used to this by now, but this catches me off guard every time - I visit the file. And it's a fucking interface! Ah, the contract magic! Whatever, let's look up the [docs](https://laravel.com/docs/5.6/contracts#contract-reference) - it's equivalent to `Notification` facade. Hit the [docs](https://laravel.com/docs/5.6/facades#facade-class-reference) again. And we've finally found the class: `Illuminate\Notifications\ChannelManager` (how is that name related to anything we are looking for??), thus we're back in the same folder again.

```php
/**
* Send the given notification to the given notifiable entities.
*
* @param \Illuminate\Support\Collection|array|mixed $notifiables
* @param mixed $notification
* @return void
*/
public function send($notifiables, $notification)
{
return (new NotificationSender(
$this, $this->app->make(Bus::class), $this->app->make(Dispatcher::class), $this->locale)
)->send($notifiables, $notification);
}
```

Great, a one-liner again! And not only we are cycling through a dozen of single line methods (or even files), but these one-liners are not even real one-liners. Does it really cost you that much to make up a couple of short lived variables? Couldn't you make it at least a bit readable like this?

```php
public function send($notifiables, $notification)
{
$bus = $this->app->make(Bus::class);
$dispatcher = $this->app->make(Dispatcher::class);
$notificationSender = new NotificationSender($this, $bus, $dispatcher, $this->locale);

return $notificationSender->send($notifiables, $notification);
}
```

Whatever, back to reading Laravel. Opening the next file (`NotificationSender.php`) I found the function:
```php
/**
* Send the given notification to the given notifiable entities.
*
* @param \Illuminate\Support\Collection|array|mixed $notifiables
* @param mixed $notification
* @return void
*/
public function send($notifiables, $notification)
{
$notifiables = $this->formatNotifiables($notifiables);
if ($notification instanceof ShouldQueue) {
return $this->queueNotification($notifiables, $notification);
}
return $this->sendNow($notifiables, $notification);
}
```

Are you kidding me? Did the `send` method invoke a `send` method on another class with exactly the same docblock? OK, whatever. I inspected `formatNotifiables` and it just wraps it in a collection or array if it's a single item. Queueing is also something that doesn't seems involved in password resets, right? So let's go to `sendNow` (this is the first time we get to find the next method in the same file).

```php
public function sendNow($notifiables, $notification, array $channels = null)
{
$notifiables = $this->formatNotifiables($notifiables);
$original = clone $notification;
foreach ($notifiables as $notifiable) {
if (empty($viaChannels = $channels ?: $notification->via($notifiable))) {
continue;
}
$this->withLocale($this->preferredLocale($notifiable, $notification), function () use ($viaChannels, $notifiable, $original) {
$notificationId = Str::uuid()->toString();
foreach ((array) $viaChannels as $channel) {
$this->sendToNotifiable($notifiable, $notificationId, clone $original, $channel);
}
});
}
}
```

Hello? Didn't we just `formatNotifiables`? It seems that the next step is `sendToNotifiable` method. This checks if it should send notification, send it and dispatches an event. The main line is this:
```php
$response = $this->manager->driver($channel)->send($notifiable, $notification);
```

`$this->manager` - that's assigned in the constructor as the first argument. Stepping back a bit we see that `ChannelManager` instantiated the `NotificationSender` and passed `$this` as the first argument. BUT THERE IS NO `driver` METHOD! The `ChannelManager` extends `Illuminate/Support/Driver`. And it seems to retrieve or create a driver. It seems that the argument (`$channel`) was filled with `$notification->via($notifiable)` as no `$channels` were passed to `sendNow`.

What's the `$notification`? Well it's the `new ResetPasswordNotification($token)` from the very start. Except the problem that there is no such class in Laravel. Where does that come from? We have to find up the trait that made that call - `Illuminate/Auth/Passwords/CanResetPassword`. We see that `ResetPasswordNotification` is `Illuminate\Auth\Notifications\ResetPassword`. And we also see a method `getEmailForPasswordReset`. Maybe it's the end of our journey? Not so soon. You can [search on github](https://github.com/laravel/framework/search?q=getEmailForPasswordReset) and you'll find that this method is only used when working with tokens. How does an address get into `To:` field of email is still a mystery.

Notice that `ResetPassword` has the `via` method returning `['mail']`. Looking back into manager, it should either create or retrieve a previously created `'mail'` driver. The `createDriver` method calls a custom creator and defaults to constructed `$this->createMailDriver()` method if nothing custom exists. Of course the `createMailDriver` does not exist on `Manager` and nothing in the codebase extends manager with a `'mail'` driver. Excellent.

It turns out that the `ChannelManager` (which extends `Manager`) has the method:
```php
protected function createMailDriver()
{
return $this->app->make(Channels\MailChannel::class);
}
```

Finally, we're pretty much done. We open up `Illuminate\Notifications\Channels\MailChannel` and `send` is indeed there. It does this and that but the crucial part is here:
```php
$this->mailer->send(
$this->buildView($message),
array_merge($message->data(), $this->additionalMessageData($notification)),
$this->messageBuilder($notifiable, $notification, $message)
);
```

Inspecting the calls we see that most are not what we need, except for `messageBuilder` maybe.
```php
protected function messageBuilder($notifiable, $notification, $message)
{
return function ($mailMessage) use ($notifiable, $notification, $message) {
$this->buildMessage($mailMessage, $notifiable, $notification, $message);
};
}
```

I am honestly tired of these super-composite one-liners extracted everywhere... `buildMessage`, could that be the one? Not really, but it contains this suspiciously named method call.
```php
$this->addressMessage($mailMessage, $notifiable, $notification, $message);
```

In that `addressMessage` we have
```php
$mailMessage->to($this->getRecipients($notifiable, $notification, $message));
```

And finally
```php
protected function getRecipients($notifiable, $notification, $message)
{
if (is_string($recipients = $notifiable->routeNotificationFor('mail', $notification))) {
$recipients = [$recipients];
}

return collect($recipients)->mapWithKeys(function ($recipient, $email) {
return is_numeric($email)
? [$email => (is_string($recipient) ? $recipient : $recipient->email)]
: [$email => $recipient];
})->all();
}
```

The `$notifiable->routeNotificationFor('mail', $notification)` seems to call that method on user and it must be the method implemented in `Illuminate\Notifications\RoutesNotifications` which either calls `routeNotificationForMail` if it exists on the user model or returns the `email` attribute of user. GG.