<form method="POST">
    <h3>Editing: Mailable.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Mail;

use Illuminate\Container\Container;
use Illuminate\Contracts\Filesystem\Factory as FilesystemFactory;
use Illuminate\Contracts\Mail\Factory as MailFactory;
use Illuminate\Contracts\Mail\Mailable as MailableContract;
use Illuminate\Contracts\Queue\Factory as Queue;
use Illuminate\Contracts\Support\Htmlable;
use Illuminate\Contracts\Support\Renderable;
use Illuminate\Support\Collection;
use Illuminate\Support\HtmlString;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\Conditionable;
use Illuminate\Support\Traits\ForwardsCalls;
use Illuminate\Support\Traits\Localizable;
use PHPUnit\Framework\Assert as PHPUnit;
use ReflectionClass;
use ReflectionProperty;

class Mailable implements MailableContract, Renderable
{
    use Conditionable, ForwardsCalls, Localizable;

    /**
     * The locale of the message.
     *
     * @var string
     */
    public $locale;

    /**
     * The person the message is from.
     *
     * @var array
     */
    public $from = [];

    /**
     * The &quot;to&quot; recipients of the message.
     *
     * @var array
     */
    public $to = [];

    /**
     * The &quot;cc&quot; recipients of the message.
     *
     * @var array
     */
    public $cc = [];

    /**
     * The &quot;bcc&quot; recipients of the message.
     *
     * @var array
     */
    public $bcc = [];

    /**
     * The &quot;reply to&quot; recipients of the message.
     *
     * @var array
     */
    public $replyTo = [];

    /**
     * The subject of the message.
     *
     * @var string
     */
    public $subject;

    /**
     * The Markdown template for the message (if applicable).
     *
     * @var string
     */
    public $markdown;

    /**
     * The HTML to use for the message.
     *
     * @var string
     */
    protected $html;

    /**
     * The view to use for the message.
     *
     * @var string
     */
    public $view;

    /**
     * The plain text view to use for the message.
     *
     * @var string
     */
    public $textView;

    /**
     * The view data for the message.
     *
     * @var array
     */
    public $viewData = [];

    /**
     * The attachments for the message.
     *
     * @var array
     */
    public $attachments = [];

    /**
     * The raw attachments for the message.
     *
     * @var array
     */
    public $rawAttachments = [];

    /**
     * The attachments from a storage disk.
     *
     * @var array
     */
    public $diskAttachments = [];

    /**
     * The callbacks for the message.
     *
     * @var array
     */
    public $callbacks = [];

    /**
     * The name of the theme that should be used when formatting the message.
     *
     * @var string|null
     */
    public $theme;

    /**
     * The name of the mailer that should send the message.
     *
     * @var string
     */
    public $mailer;

    /**
     * The rendered mailable views for testing / assertions.
     *
     * @var array
     */
    protected $assertionableRenderStrings;

    /**
     * The callback that should be invoked while building the view data.
     *
     * @var callable
     */
    public static $viewDataCallback;

    /**
     * Send the message using the given mailer.
     *
     * @param  \Illuminate\Contracts\Mail\Factory|\Illuminate\Contracts\Mail\Mailer  $mailer
     * @return void
     */
    public function send($mailer)
    {
        $this-&gt;withLocale($this-&gt;locale, function () use ($mailer) {
            Container::getInstance()-&gt;call([$this, 'build']);

            $mailer = $mailer instanceof MailFactory
                            ? $mailer-&gt;mailer($this-&gt;mailer)
                            : $mailer;

            return $mailer-&gt;send($this-&gt;buildView(), $this-&gt;buildViewData(), function ($message) {
                $this-&gt;buildFrom($message)
                     -&gt;buildRecipients($message)
                     -&gt;buildSubject($message)
                     -&gt;runCallbacks($message)
                     -&gt;buildAttachments($message);
            });
        });
    }

    /**
     * Queue the message for sending.
     *
     * @param  \Illuminate\Contracts\Queue\Factory  $queue
     * @return mixed
     */
    public function queue(Queue $queue)
    {
        if (isset($this-&gt;delay)) {
            return $this-&gt;later($this-&gt;delay, $queue);
        }

        $connection = property_exists($this, 'connection') ? $this-&gt;connection : null;

        $queueName = property_exists($this, 'queue') ? $this-&gt;queue : null;

        return $queue-&gt;connection($connection)-&gt;pushOn(
            $queueName ?: null, $this-&gt;newQueuedJob()
        );
    }

    /**
     * Deliver the queued message after the given delay.
     *
     * @param  \DateTimeInterface|\DateInterval|int  $delay
     * @param  \Illuminate\Contracts\Queue\Factory  $queue
     * @return mixed
     */
    public function later($delay, Queue $queue)
    {
        $connection = property_exists($this, 'connection') ? $this-&gt;connection : null;

        $queueName = property_exists($this, 'queue') ? $this-&gt;queue : null;

        return $queue-&gt;connection($connection)-&gt;laterOn(
            $queueName ?: null, $delay, $this-&gt;newQueuedJob()
        );
    }

    /**
     * Make the queued mailable job instance.
     *
     * @return mixed
     */
    protected function newQueuedJob()
    {
        return (new SendQueuedMailable($this))
                    -&gt;through(array_merge(
                        method_exists($this, 'middleware') ? $this-&gt;middleware() : [],
                        $this-&gt;middleware ?? []
                    ));
    }

    /**
     * Render the mailable into a view.
     *
     * @return string
     *
     * @throws \ReflectionException
     */
    public function render()
    {
        return $this-&gt;withLocale($this-&gt;locale, function () {
            Container::getInstance()-&gt;call([$this, 'build']);

            return Container::getInstance()-&gt;make('mailer')-&gt;render(
                $this-&gt;buildView(), $this-&gt;buildViewData()
            );
        });
    }

    /**
     * Build the view for the message.
     *
     * @return array|string
     *
     * @throws \ReflectionException
     */
    protected function buildView()
    {
        if (isset($this-&gt;html)) {
            return array_filter([
                'html' =&gt; new HtmlString($this-&gt;html),
                'text' =&gt; $this-&gt;textView ?? null,
            ]);
        }

        if (isset($this-&gt;markdown)) {
            return $this-&gt;buildMarkdownView();
        }

        if (isset($this-&gt;view, $this-&gt;textView)) {
            return [$this-&gt;view, $this-&gt;textView];
        } elseif (isset($this-&gt;textView)) {
            return ['text' =&gt; $this-&gt;textView];
        }

        return $this-&gt;view;
    }

    /**
     * Build the Markdown view for the message.
     *
     * @return array
     *
     * @throws \ReflectionException
     */
    protected function buildMarkdownView()
    {
        $markdown = Container::getInstance()-&gt;make(Markdown::class);

        if (isset($this-&gt;theme)) {
            $markdown-&gt;theme($this-&gt;theme);
        }

        $data = $this-&gt;buildViewData();

        return [
            'html' =&gt; $markdown-&gt;render($this-&gt;markdown, $data),
            'text' =&gt; $this-&gt;buildMarkdownText($markdown, $data),
        ];
    }

    /**
     * Build the view data for the message.
     *
     * @return array
     *
     * @throws \ReflectionException
     */
    public function buildViewData()
    {
        $data = $this-&gt;viewData;

        if (static::$viewDataCallback) {
            $data = array_merge($data, call_user_func(static::$viewDataCallback, $this));
        }

        foreach ((new ReflectionClass($this))-&gt;getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
            if ($property-&gt;getDeclaringClass()-&gt;getName() !== self::class) {
                $data[$property-&gt;getName()] = $property-&gt;getValue($this);
            }
        }

        return $data;
    }

    /**
     * Build the text view for a Markdown message.
     *
     * @param  \Illuminate\Mail\Markdown  $markdown
     * @param  array  $data
     * @return string
     */
    protected function buildMarkdownText($markdown, $data)
    {
        return $this-&gt;textView
                ?? $markdown-&gt;renderText($this-&gt;markdown, $data);
    }

    /**
     * Add the sender to the message.
     *
     * @param  \Illuminate\Mail\Message  $message
     * @return $this
     */
    protected function buildFrom($message)
    {
        if (! empty($this-&gt;from)) {
            $message-&gt;from($this-&gt;from[0]['address'], $this-&gt;from[0]['name']);
        }

        return $this;
    }

    /**
     * Add all of the recipients to the message.
     *
     * @param  \Illuminate\Mail\Message  $message
     * @return $this
     */
    protected function buildRecipients($message)
    {
        foreach (['to', 'cc', 'bcc', 'replyTo'] as $type) {
            foreach ($this-&gt;{$type} as $recipient) {
                $message-&gt;{$type}($recipient['address'], $recipient['name']);
            }
        }

        return $this;
    }

    /**
     * Set the subject for the message.
     *
     * @param  \Illuminate\Mail\Message  $message
     * @return $this
     */
    protected function buildSubject($message)
    {
        if ($this-&gt;subject) {
            $message-&gt;subject($this-&gt;subject);
        } else {
            $message-&gt;subject(Str::title(Str::snake(class_basename($this), ' ')));
        }

        return $this;
    }

    /**
     * Add all of the attachments to the message.
     *
     * @param  \Illuminate\Mail\Message  $message
     * @return $this
     */
    protected function buildAttachments($message)
    {
        foreach ($this-&gt;attachments as $attachment) {
            $message-&gt;attach($attachment['file'], $attachment['options']);
        }

        foreach ($this-&gt;rawAttachments as $attachment) {
            $message-&gt;attachData(
                $attachment['data'], $attachment['name'], $attachment['options']
            );
        }

        $this-&gt;buildDiskAttachments($message);

        return $this;
    }

    /**
     * Add all of the disk attachments to the message.
     *
     * @param  \Illuminate\Mail\Message  $message
     * @return void
     */
    protected function buildDiskAttachments($message)
    {
        foreach ($this-&gt;diskAttachments as $attachment) {
            $storage = Container::getInstance()-&gt;make(
                FilesystemFactory::class
            )-&gt;disk($attachment['disk']);

            $message-&gt;attachData(
                $storage-&gt;get($attachment['path']),
                $attachment['name'] ?? basename($attachment['path']),
                array_merge(['mime' =&gt; $storage-&gt;mimeType($attachment['path'])], $attachment['options'])
            );
        }
    }

    /**
     * Run the callbacks for the message.
     *
     * @param  \Illuminate\Mail\Message  $message
     * @return $this
     */
    protected function runCallbacks($message)
    {
        foreach ($this-&gt;callbacks as $callback) {
            $callback($message-&gt;getSwiftMessage());
        }

        return $this;
    }

    /**
     * Set the locale of the message.
     *
     * @param  string  $locale
     * @return $this
     */
    public function locale($locale)
    {
        $this-&gt;locale = $locale;

        return $this;
    }

    /**
     * Set the priority of this message.
     *
     * The value is an integer where 1 is the highest priority and 5 is the lowest.
     *
     * @param  int  $level
     * @return $this
     */
    public function priority($level = 3)
    {
        $this-&gt;callbacks[] = function ($message) use ($level) {
            $message-&gt;setPriority($level);
        };

        return $this;
    }

    /**
     * Set the sender of the message.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return $this
     */
    public function from($address, $name = null)
    {
        return $this-&gt;setAddress($address, $name, 'from');
    }

    /**
     * Determine if the given recipient is set on the mailable.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return bool
     */
    public function hasFrom($address, $name = null)
    {
        return $this-&gt;hasRecipient($address, $name, 'from');
    }

    /**
     * Set the recipients of the message.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return $this
     */
    public function to($address, $name = null)
    {
        return $this-&gt;setAddress($address, $name, 'to');
    }

    /**
     * Determine if the given recipient is set on the mailable.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return bool
     */
    public function hasTo($address, $name = null)
    {
        return $this-&gt;hasRecipient($address, $name, 'to');
    }

    /**
     * Set the recipients of the message.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return $this
     */
    public function cc($address, $name = null)
    {
        return $this-&gt;setAddress($address, $name, 'cc');
    }

    /**
     * Determine if the given recipient is set on the mailable.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return bool
     */
    public function hasCc($address, $name = null)
    {
        return $this-&gt;hasRecipient($address, $name, 'cc');
    }

    /**
     * Set the recipients of the message.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return $this
     */
    public function bcc($address, $name = null)
    {
        return $this-&gt;setAddress($address, $name, 'bcc');
    }

    /**
     * Determine if the given recipient is set on the mailable.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return bool
     */
    public function hasBcc($address, $name = null)
    {
        return $this-&gt;hasRecipient($address, $name, 'bcc');
    }

    /**
     * Set the &quot;reply to&quot; address of the message.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return $this
     */
    public function replyTo($address, $name = null)
    {
        return $this-&gt;setAddress($address, $name, 'replyTo');
    }

    /**
     * Determine if the given replyTo is set on the mailable.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return bool
     */
    public function hasReplyTo($address, $name = null)
    {
        return $this-&gt;hasRecipient($address, $name, 'replyTo');
    }

    /**
     * Set the recipients of the message.
     *
     * All recipients are stored internally as [['name' =&gt; ?, 'address' =&gt; ?]]
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @param  string  $property
     * @return $this
     */
    protected function setAddress($address, $name = null, $property = 'to')
    {
        if (empty($address)) {
            return $this;
        }

        foreach ($this-&gt;addressesToArray($address, $name) as $recipient) {
            $recipient = $this-&gt;normalizeRecipient($recipient);

            $this-&gt;{$property}[] = [
                'name' =&gt; $recipient-&gt;name ?? null,
                'address' =&gt; $recipient-&gt;email,
            ];
        }

        return $this;
    }

    /**
     * Convert the given recipient arguments to an array.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @return array
     */
    protected function addressesToArray($address, $name)
    {
        if (! is_array($address) &amp;&amp; ! $address instanceof Collection) {
            $address = is_string($name) ? [['name' =&gt; $name, 'email' =&gt; $address]] : [$address];
        }

        return $address;
    }

    /**
     * Convert the given recipient into an object.
     *
     * @param  mixed  $recipient
     * @return object
     */
    protected function normalizeRecipient($recipient)
    {
        if (is_array($recipient)) {
            if (array_values($recipient) === $recipient) {
                return (object) array_map(function ($email) {
                    return compact('email');
                }, $recipient);
            }

            return (object) $recipient;
        } elseif (is_string($recipient)) {
            return (object) ['email' =&gt; $recipient];
        }

        return $recipient;
    }

    /**
     * Determine if the given recipient is set on the mailable.
     *
     * @param  object|array|string  $address
     * @param  string|null  $name
     * @param  string  $property
     * @return bool
     */
    protected function hasRecipient($address, $name = null, $property = 'to')
    {
        if (empty($address)) {
            return false;
        }

        $expected = $this-&gt;normalizeRecipient(
            $this-&gt;addressesToArray($address, $name)[0]
        );

        $expected = [
            'name' =&gt; $expected-&gt;name ?? null,
            'address' =&gt; $expected-&gt;email,
        ];

        return collect($this-&gt;{$property})-&gt;contains(function ($actual) use ($expected) {
            if (! isset($expected['name'])) {
                return $actual['address'] == $expected['address'];
            }

            return $actual == $expected;
        });
    }

    /**
     * Set the subject of the message.
     *
     * @param  string  $subject
     * @return $this
     */
    public function subject($subject)
    {
        $this-&gt;subject = $subject;

        return $this;
    }

    /**
     * Set the Markdown template for the message.
     *
     * @param  string  $view
     * @param  array  $data
     * @return $this
     */
    public function markdown($view, array $data = [])
    {
        $this-&gt;markdown = $view;
        $this-&gt;viewData = array_merge($this-&gt;viewData, $data);

        return $this;
    }

    /**
     * Set the view and view data for the message.
     *
     * @param  string  $view
     * @param  array  $data
     * @return $this
     */
    public function view($view, array $data = [])
    {
        $this-&gt;view = $view;
        $this-&gt;viewData = array_merge($this-&gt;viewData, $data);

        return $this;
    }

    /**
     * Set the rendered HTML content for the message.
     *
     * @param  string  $html
     * @return $this
     */
    public function html($html)
    {
        $this-&gt;html = $html;

        return $this;
    }

    /**
     * Set the plain text view for the message.
     *
     * @param  string  $textView
     * @param  array  $data
     * @return $this
     */
    public function text($textView, array $data = [])
    {
        $this-&gt;textView = $textView;
        $this-&gt;viewData = array_merge($this-&gt;viewData, $data);

        return $this;
    }

    /**
     * Set the view data for the message.
     *
     * @param  string|array  $key
     * @param  mixed  $value
     * @return $this
     */
    public function with($key, $value = null)
    {
        if (is_array($key)) {
            $this-&gt;viewData = array_merge($this-&gt;viewData, $key);
        } else {
            $this-&gt;viewData[$key] = $value;
        }

        return $this;
    }

    /**
     * Attach a file to the message.
     *
     * @param  string  $file
     * @param  array  $options
     * @return $this
     */
    public function attach($file, array $options = [])
    {
        $this-&gt;attachments = collect($this-&gt;attachments)
                    -&gt;push(compact('file', 'options'))
                    -&gt;unique('file')
                    -&gt;all();

        return $this;
    }

    /**
     * Attach a file to the message from storage.
     *
     * @param  string  $path
     * @param  string|null  $name
     * @param  array  $options
     * @return $this
     */
    public function attachFromStorage($path, $name = null, array $options = [])
    {
        return $this-&gt;attachFromStorageDisk(null, $path, $name, $options);
    }

    /**
     * Attach a file to the message from storage.
     *
     * @param  string  $disk
     * @param  string  $path
     * @param  string|null  $name
     * @param  array  $options
     * @return $this
     */
    public function attachFromStorageDisk($disk, $path, $name = null, array $options = [])
    {
        $this-&gt;diskAttachments = collect($this-&gt;diskAttachments)-&gt;push([
            'disk' =&gt; $disk,
            'path' =&gt; $path,
            'name' =&gt; $name ?? basename($path),
            'options' =&gt; $options,
        ])-&gt;unique(function ($file) {
            return $file['name'].$file['disk'].$file['path'];
        })-&gt;all();

        return $this;
    }

    /**
     * Attach in-memory data as an attachment.
     *
     * @param  string  $data
     * @param  string  $name
     * @param  array  $options
     * @return $this
     */
    public function attachData($data, $name, array $options = [])
    {
        $this-&gt;rawAttachments = collect($this-&gt;rawAttachments)
                -&gt;push(compact('data', 'name', 'options'))
                -&gt;unique(function ($file) {
                    return $file['name'].$file['data'];
                })-&gt;all();

        return $this;
    }

    /**
     * Assert that the given text is present in the HTML email body.
     *
     * @param  string  $string
     * @return $this
     */
    public function assertSeeInHtml($string)
    {
        [$html, $text] = $this-&gt;renderForAssertions();

        PHPUnit::assertTrue(
            Str::contains($html, $string),
            &quot;Did not see expected text [{$string}] within email body.&quot;
        );

        return $this;
    }

    /**
     * Assert that the given text is not present in the HTML email body.
     *
     * @param  string  $string
     * @return $this
     */
    public function assertDontSeeInHtml($string)
    {
        [$html, $text] = $this-&gt;renderForAssertions();

        PHPUnit::assertFalse(
            Str::contains($html, $string),
            &quot;Saw unexpected text [{$string}] within email body.&quot;
        );

        return $this;
    }

    /**
     * Assert that the given text is present in the plain-text email body.
     *
     * @param  string  $string
     * @return $this
     */
    public function assertSeeInText($string)
    {
        [$html, $text] = $this-&gt;renderForAssertions();

        PHPUnit::assertTrue(
            Str::contains($text, $string),
            &quot;Did not see expected text [{$string}] within text email body.&quot;
        );

        return $this;
    }

    /**
     * Assert that the given text is not present in the plain-text email body.
     *
     * @param  string  $string
     * @return $this
     */
    public function assertDontSeeInText($string)
    {
        [$html, $text] = $this-&gt;renderForAssertions();

        PHPUnit::assertFalse(
            Str::contains($text, $string),
            &quot;Saw unexpected text [{$string}] within text email body.&quot;
        );

        return $this;
    }

    /**
     * Render the HTML and plain-text version of the mailable into views for assertions.
     *
     * @return array
     *
     * @throws \ReflectionException
     */
    protected function renderForAssertions()
    {
        if ($this-&gt;assertionableRenderStrings) {
            return $this-&gt;assertionableRenderStrings;
        }

        return $this-&gt;assertionableRenderStrings = $this-&gt;withLocale($this-&gt;locale, function () {
            Container::getInstance()-&gt;call([$this, 'build']);

            $html = Container::getInstance()-&gt;make('mailer')-&gt;render(
                $view = $this-&gt;buildView(), $this-&gt;buildViewData()
            );

            if (is_array($view) &amp;&amp; isset($view[1])) {
                $text = $view[1];
            }

            $text = $text ?? $view['text'] ?? '';

            if (! empty($text) &amp;&amp; ! $text instanceof Htmlable) {
                $text = Container::getInstance()-&gt;make('mailer')-&gt;render(
                    $text, $this-&gt;buildViewData()
                );
            }

            return [(string) $html, (string) $text];
        });
    }

    /**
     * Set the name of the mailer that should send the message.
     *
     * @param  string  $mailer
     * @return $this
     */
    public function mailer($mailer)
    {
        $this-&gt;mailer = $mailer;

        return $this;
    }

    /**
     * Register a callback to be called with the Swift message instance.
     *
     * @param  callable  $callback
     * @return $this
     */
    public function withSwiftMessage($callback)
    {
        $this-&gt;callbacks[] = $callback;

        return $this;
    }

    /**
     * Register a callback to be called while building the view data.
     *
     * @param  callable  $callback
     * @return void
     */
    public static function buildViewDataUsing(callable $callback)
    {
        static::$viewDataCallback = $callback;
    }

    /**
     * Dynamically bind parameters to the message.
     *
     * @param  string  $method
     * @param  array  $parameters
     * @return $this
     *
     * @throws \BadMethodCallException
     */
    public function __call($method, $parameters)
    {
        if (Str::startsWith($method, 'with')) {
            return $this-&gt;with(Str::camel(substr($method, 4)), $parameters[0]);
        }

        static::throwBadMethodCallException($method);
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>