FormBuilder::getModel() - Code Metrics - Inspection of "Updating the package to support Laravel 5.6" - ARCANEDEV/LaravelHtml - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#21)

by ARCANEDEV
created 2018-02-08 16:22 UTC
FormBuilder::getModel() A

↳ Parent: FormBuilder
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	1
CRAP Score	1
Importance

Changes
Metric	Value
c	0
b	0
f	0
dl	0
loc	4
ccs	1
cts	1
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	1
<?php namespace Arcanedev\LaravelHtml;

use Arcanedev\LaravelHtml\Bases\Builder;
use Arcanedev\LaravelHtml\Contracts\FormBuilder as FormBuilderContract;
use DateTime;
use Illuminate\Contracts\Routing\UrlGenerator;
use Illuminate\Contracts\Session\Session;
use Illuminate\Support\Arr;
use Illuminate\Support\Collection;

/**
 * Class     FormBuilder
 *
 * @package  Arcanedev\LaravelHtml
 * @author   ARCANEDEV <[email protected]>
 */
class FormBuilder extends Builder implements FormBuilderContract
{
    /* -----------------------------------------------------------------
     |  Properties
     | -----------------------------------------------------------------
     */

    /**
    * The HTML builder instance.
    *
    * @var \Arcanedev\LaravelHtml\Contracts\HtmlBuilder
    */
    protected $html;

    /**
    * The URL generator instance.
    *
    * @var \Illuminate\Contracts\Routing\UrlGenerator
    */
    protected $url;

    /**
    * The CSRF token used by the form builder.
    *
    * @var string
    */
    protected $csrfToken;

    /**
    * The session store implementation.
    *
    * @var \Illuminate\Contracts\Session\Session
    */
    protected $session;

    /**
    * The current model instance for the form.
    *
    * @var \Illuminate\Database\Eloquent\Model
    */
    protected $model;

    /**
    * An array of label names we've created.
    *
    * @var array
    */
    protected $labels = [];

    /**
    * The reserved form open attributes.
    *
    * @var array
    */
    protected $reserved = ['method', 'url', 'route', 'action', 'files'];

    /**
    * The form methods that should be spoofed, in uppercase.
    *
    * @var array
    */
    protected $spoofedMethods = ['DELETE', 'PATCH', 'PUT'];

    /**
    * The types of inputs to not fill values on by default.
    *
    * @var array
    */
    protected $skipValueTypes = ['file', 'password', 'checkbox', 'radio'];

    /* -----------------------------------------------------------------
     |  Constructor
     | -----------------------------------------------------------------
     */

    /**
    * Create a new form builder instance.
    *
    * @param  \Arcanedev\LaravelHtml\Contracts\HtmlBuilder  $html
    * @param  \Illuminate\Contracts\Routing\UrlGenerator    $url
    * @param  \Illuminate\Contracts\Session\Session         $session
    */
    public function __construct(
        Contracts\HtmlBuilder $html,
        UrlGenerator $url,
        Session $session
    ) {
        $this->url       = $url;
        $this->html      = $html;
        $this->csrfToken = $session->token();

        $this->setSessionStore($session);
    }

    /* -----------------------------------------------------------------
     |  Getters & Setters
     | -----------------------------------------------------------------
     */

    /**
     * Get the session store implementation.
     *
     * @return  \Illuminate\Contracts\Session\Session
     */
    public function getSessionStore()
    {
        return $this->session;
    }

    /**
     * Set the session store implementation.
     *
     * @param  \Illuminate\Contracts\Session\Session  $session
     *
     * @return self
     */
    public function setSessionStore(Session $session)
    {
        $this->session = $session;

        return $this;
    }

    /**
     * Set the model instance on the form builder.
     *
     * @param  \Illuminate\Database\Eloquent\Model  $model
     *
     * @return self
     */
    public function setModel($model)
    {
        $this->model = $model;

        return $this;
    }

    /**
     * Get the model instance on the form builder.
     *
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function getModel()
    {
        return $this->model;
    }

    /**
     * Get the ID attribute for a field name.
     *
     * @param  string  $name
     * @param  array   $attributes
     *
     * @return string
     */
    public function getIdAttribute($name, array $attributes)
    {
        if (array_key_exists('id', $attributes))
            return $attributes['id'];

        if (in_array($name, $this->labels))
            return $name;

        return null;
    }

    /**
     * Get the value that should be assigned to the field.
     *
     * @param  string  $name
     * @param  mixed   $value
     *
     * @return mixed
     */
    public function getValueAttribute($name, $value = null)
    {
        if (is_null($name))
            return $value;

        if ( ! is_null($this->old($name)) && $name !== '_method')
            return $this->old($name);

        if ( ! is_null($value))
            return $value;

        return isset($this->model)
            ? $this->getModelValueAttribute($name)
            : null;
    }

    /**
     * Get the model value that should be assigned to the field.
     *
     * @param  string                               $name
     * @param  \Illuminate\Database\Eloquent\Model  $model
     *
     * @return mixed
     */
    private function getModelValueAttribute($name, $model = null)
    {
        if (is_null($model)) {
            $model = $this->model;
        }

        $key = $this->transformKey($name);

        if (strpos($key, '.') !== false) {
            $keys = explode('.', $key, 2);

            return $this->getModelValueAttribute($keys[1],
                $this->getModelValueAttribute($keys[0], $model)
            );
        }

        return method_exists($model, 'getFormValue')
            ? $model->getFormValue($key)
            : data_get($model, $key);
    }

    /**
     * Get a value from the session's old input.
     *
     * @param  string  $name
     *
     * @return mixed
     */
    public function old($name)
    {
        return isset($this->session)
            ? $this->session->getOldInput($this->transformKey($name))
            : null;
    }

    /**
     * Transform key from array to dot syntax.
     *
     * @param  string  $key
     *
     * @return string
     */
    private function transformKey($key)
    {
        return str_replace(['.', '[]', '[', ']'], ['_', '', '.', ''], $key);
    }

    /**
     * Determine if the old input is empty.
     *
     * @return bool
     */
    public function oldInputIsEmpty()
    {
        return isset($this->session) && (count($this->session->getOldInput()) == 0);
    }

    /**
     * Parse the form action method.
     *
     * @param  string  $method
     *
     * @return string
     */
    private function getMethod($method)
    {
        $method = strtoupper($method);

        return $method !== 'GET' ? 'POST' : $method;
    }

    /* -----------------------------------------------------------------
     |  Main Methods
     | -----------------------------------------------------------------
     */

    /**
     * Open up a new HTML form.
     *
     * @param  array  $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function open(array $options = [])
    {
        $method = Arr::get($options, 'method', 'post');

        // We need to extract the proper method from the attributes. If the method is
        // something other than GET or POST we'll use POST since we will spoof the
        // actual method since forms don't support the reserved methods in HTML.
        $attributes = [
            'method'         => $this->getMethod($method),
            'action'         => $this->getAction($options),
            'accept-charset' => 'UTF-8',
        ];

        if (isset($options['files']) && $options['files']) {
            $options['enctype'] = 'multipart/form-data';
        }

        // Finally we're ready to create the final form HTML field. We will attribute
        // format the array of attributes. We will also add on the appendage which
        // is used to spoof requests for this PUT, PATCH, etc. methods on forms.
        $attributes = array_merge(
            $attributes, array_except($options, $this->reserved)
        );

        // Finally, we will concatenate all of the attributes into a single string so
        // we can build out the final form open statement. We'll also append on an
        // extra value for the hidden _method field if it's needed for the form.
        $attributes = $this->html->attributes($attributes);

        // If the method is PUT, PATCH or DELETE we will need to add a spoofer hidden
        // field that will instruct the Symfony request to pretend the method is a
        // different method than it actually is, for convenience from the forms.
        $append = $this->getAppendage($method);

        return $this->toHtmlString('<form'.$attributes.'>' . $append);
    }

    /**
     * Create a new model based form builder.
     *
     * @param  mixed  $model
     * @param  array  $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function model($model, array $options = [])
    {
        $this->setModel($model);

        return $this->open($options);
    }

    /**
     * Close the current form.
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function close()
    {
        $this->labels = [];
        $this->setModel(null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return $this->toHtmlString('</form>');
    }

    /**
     * Generate a hidden field with the current CSRF token.
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function token()
    {
        $token = ! empty($this->csrfToken)
            ? $this->csrfToken
            : $this->session->token();

        return $this->hidden('_token', $token);
    }

    /**
     * Create a form label element.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     * @param  bool    $escaped
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function label($name, $value = null, array $options = [], $escaped = true)
    {
        $this->labels[] = $name;

        return $this->toHtmlString(
            Helpers\Label::make($name, $value, $options, $escaped)
        );
    }

    /**
     * Create a form input field.
     *
     * @param  string  $type
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function input($type, $name, $value = null, array $options = [])
    {
        if ( ! isset($options['name'])) {
            $options['name'] = $name;
        }

        // We will get the appropriate value for the given field. We will look for the
        // value in the session for the value in the old input data then we'll look
        // in the model instance if one is set. Otherwise we will just use empty.
        $id = $this->getIdAttribute($name, $options);

        if ( ! in_array($type, $this->skipValueTypes)) {
            $value = $this->getValueAttribute($name, $value);
        }

        // Once we have the type, value, and ID we can merge them into the rest of the
        // attributes array so we can convert them into their HTML attribute format
        // when creating the HTML element. Then, we will return the entire input.
        $options = array_merge($options, compact('type', 'value', 'id'));

        return $this->toHtmlString('<input'.$this->html->attributes($options).'>');
    }

    /**
     * Create a text input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function text($name, $value = null, array $options = [])
    {
        return $this->input('text', $name, $value, $options);
    }

    /**
     * Create a password input field.
     *
     * @param  string  $name
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function password($name, array $options = [])
    {
        return $this->input('password', $name, '', $options);
    }

    /**
     * Create a hidden input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function hidden($name, $value = null, array $options = [])
    {
        return $this->input('hidden', $name, $value, $options);
    }

    /**
     * Create an e-mail input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function email($name, $value = null, array $options = [])
    {
        return $this->input('email', $name, $value, $options);
    }

    /**
     * Create a tel input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function tel($name, $value = null, array $options = [])
    {
        return $this->input('tel', $name, $value, $options);
    }

    /**
     * Create a number input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function number($name, $value = null, array $options = [])
    {
        return $this->input('number', $name, $value, $options);
    }

    /**
     * Create a date input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function date($name, $value = null, array $options = [])
    {
        if ($value instanceof DateTime) {
            $value = $value->format('Y-m-d');
        }

        return $this->input('date', $name, $value, $options);
    }

    /**
     * Create a datetime input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function datetime($name, $value = null, array $options = [])
    {
        if ($value instanceof DateTime) {
            $value = $value->format(DateTime::RFC3339);
        }

        return $this->input('datetime', $name, $value, $options);
    }

    /**
     * Create a datetime-local input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function datetimeLocal($name, $value = null, array $options = [])
    {
        if ($value instanceof DateTime) {
            $value = $value->format('Y-m-d\TH:i');
        }

        return $this->input('datetime-local', $name, $value, $options);
    }

    /**
     * Create a time input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function time($name, $value = null, array $options = [])
    {
        return $this->input('time', $name, $value, $options);
    }

    /**
     * Create a url input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function url($name, $value = null, array $options = [])
    {
        return $this->input('url', $name, $value, $options);
    }

    /**
     * Create a file input field.
     *
     * @param  string  $name
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function file($name, array $options = [])
    {
        return $this->input('file', $name, null, $options);
    }

    /**
     * Create a textarea input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function textarea($name, $value = null, array $options = [])
    {
        if ( ! isset($options['name'])) {
            $options['name'] = $name;
        }

        // Next we will look for the rows and cols attributes, as each of these are put
        // on the textarea element definition. If they are not present, we will just
        // assume some sane default values for these attributes for the developer.
        $options       = $this->setTextAreaSize($options);
        $options['id'] = $this->getIdAttribute($name, $options);
        $value         = (string) $this->getValueAttribute($name, $value);

        unset($options['size']);

        // Next we will convert the attributes into a string form. Also we have removed
        // the size attribute, as it was merely a short-cut for the rows and cols on
        // the element. Then we'll create the final textarea elements HTML for us.
        $options = $this->html->attributes($options);

        return $this->toHtmlString('<textarea'.$options.'>'.$this->html->escape($value).'</textarea>');
    }

    /**
     * Set the text area size on the attributes.
     *
     * @param  array  $options
     *
     * @return array
     */
    private function setTextAreaSize(array $options)
    {
        if (isset($options['size'])) {
            return $this->setQuickTextAreaSize($options);
        }

        // If the "size" attribute was not specified, we will just look for the regular
        // columns and rows attributes, using sane defaults if these do not exist on
        // the attributes array. We'll then return this entire options array back.
        $cols = Arr::get($options, 'cols', 50);
        $rows = Arr::get($options, 'rows', 10);

        return array_merge($options, compact('cols', 'rows'));
    }

    /**
     * Set the text area size using the quick "size" attribute.
     *
     * @param  array  $options
     *
     * @return array
     */
    protected function setQuickTextAreaSize(array $options)
    {
        list($cols, $rows) = explode('x', $options['size']);

        return array_merge($options, compact('cols', 'rows'));
    }

    /**
     * Create a select box field.
     *
     * @param  string                                $name
     * @param  array|\Illuminate\Support\Collection  $list
     * @param  string                                $selected
     * @param  array                                 $attributes
     * @param  array                                 $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function select($name, $list = [], $selected = null, array $attributes = [], array $options = [])
    {
        // When building a select box the "value" attribute is really the selected one
        // so we will use that when checking the model or session for a value which
        // should provide a convenient method of re-populating the forms on post.
        $selected = $this->getValueAttribute($name, $selected);

        // Transform to array if it is a collection
        if ($selected instanceof Collection) {
            $selected = $selected->all();
        }

        $attributes['id'] = $this->getIdAttribute($name, $attributes);

        if ( ! isset($attributes['name'])) {
            $attributes['name'] = $name;
        }

        // We will simply loop through the options and build an HTML value for each of
        // them until we have an array of HTML declarations. Then we will join them
        // all together into one single HTML element that can be put on the form.
        $html = [];

        if (isset($attributes['placeholder'])) {
            $html[] = $this->placeholderOption($attributes['placeholder'], $selected);
            unset($attributes['placeholder']);
        }

        foreach($list as $value => $display) {
            $html[] = $this->getSelectOption(
                $display, $value, $selected, isset($options[$value]) ? $options[$value] : []
            );
        }

        // Once we have all of this HTML, we can join this into a single element after
        // formatting the attributes into an HTML "attributes" string, then we will
        // build out a final select statement, which will contain all the values.
        $attributes = $this->html->attributes($attributes);

        return $this->toHtmlString("<select{$attributes}>".implode('', $html).'</select>');
    }

    /**
     * Create a select range field.
     *
     * @param  string  $name
     * @param  string  $begin
     * @param  string  $end
     * @param  string  $selected
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function selectRange($name, $begin, $end, $selected = null, array $options = [])
    {
        $range = array_combine($range = range($begin, $end), $range);

        return $this->select($name, $range, $selected, $options);
    }

    /**
     * Create a select year field.
     *
     * @param  string  $name
     * @param  string  $begin
     * @param  string  $end
     * @param  string  $selected
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function selectYear($name, $begin, $end, $selected = null, array $options = [])
    {
        return call_user_func_array(
            [$this, 'selectRange'],
            compact('name', 'begin', 'end', 'selected', 'options')
        );
    }

    /**
     * Create a select month field.
     *
     * @param  string  $name
     * @param  string  $selected
     * @param  array   $options
     * @param  string  $format
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function selectMonth($name, $selected = null, array $options = [], $format = '%B')
    {
        $months = [];

        foreach(range(1, 12) as $month) {
            $months[$month] = strftime($format, mktime(0, 0, 0, $month, 1));
        }

        return $this->select($name, $months, $selected, $options);
    }

    /**
     * Get the select option for the given value.
     *
     * @param  string  $display
     * @param  string  $value
     * @param  string  $selected
     * @param  array   $attributes
     *
     * @return string
     */
    private function getSelectOption($display, $value, $selected, array $attributes = [])
    {
        return is_array($display)
            ? $this->optionGroup($display, $value, $selected, $attributes)
            : $this->option($display, $value, $selected, $attributes);
    }

    /**
     * Create an option group form element.
     *
     * @param  array   $list
     * @param  string  $label
     * @param  string  $selected
     * @param  array   $attributes
     *
     * @return string
     */
    private function optionGroup(array $list, $label, $selected, array $attributes = [])
    {
        $html = [];

        foreach($list as $value => $display) {
            $html[] = $this->option($display, $value, $selected, $attributes);
        }

        return '<optgroup label="'.$this->html->escape($label).'">'.implode('', $html).'</optgroup>';
    }

    /**
     * Create a select element option.
     *
     * @param  string  $display
     * @param  string  $value
     * @param  string  $selected
     * @param  array   $attributes
     *
     * @return string
     */
    private function option($display, $value, $selected, array $attributes = [])
    {
        $selected = $this->getSelectedValue($value, $selected);
        $options  = array_merge(compact('value', 'selected'), $attributes);

        return '<option'.$this->html->attributes($options).'>'.$this->html->escape($display).'</option>';
    }

    /**
     * Create a placeholder select element option.
     *
     * @param  string  $display
     * @param  string  $selected
     *
     * @return string
     */
    private function placeholderOption($display, $selected)
    {
        $selected = $this->getSelectedValue(null, $selected);
        $options  = array_merge(compact('selected'), ['value' => '']);

        return '<option'.$this->html->attributes($options).'>'.$this->html->escape($display).'</option>';
    }

    /**
     * Determine if the value is selected.
     *
     * @param  string  $value
     * @param  string  $selected
     *
     * @return string|null
     */
    private function getSelectedValue($value, $selected)
    {
        if (is_array($selected)) {
            return in_array($value, $selected) ? 'selected' : null;
        }

        return ((string) $value === (string) $selected) ? 'selected' : null;
    }

    /**
     * Create a checkbox input field.
     *
     * @param  string     $name
     * @param  mixed      $value
     * @param  bool|null  $checked
     * @param  array      $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function checkbox($name, $value = 1, $checked = null, array $options = [])
    {
        return $this->checkable('checkbox', $name, $value, $checked, $options);
    }

    /**
     * Create a radio button input field.
     *
     * @param  string  $name
     * @param  mixed   $value
     * @param  bool    $checked
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function radio($name, $value = null, $checked = null, array $options = [])
    {
        $value = $value ?? $name;

        return $this->checkable('radio', $name, $value, $checked, $options);
    }

    /**
     * Create a checkable input field.
     *
     * @param  string     $type
     * @param  string     $name
     * @param  mixed      $value
     * @param  bool|null  $checked
     * @param  array      $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    protected function checkable($type, $name, $value, $checked, array $options)
    {
        $checked = $this->getCheckedState($type, $name, $value, $checked);

        if ( ! is_null($checked) && $checked) {
            $options['checked'] = 'checked';
        }

        return $this->input($type, $name, $value, $options);
    }

    /**
     * Get the check state for a checkable input.
     *
     * @param  string     $type
     * @param  string     $name
     * @param  mixed      $value
     * @param  bool|null  $checked
     *
     * @return bool
     */
    private function getCheckedState($type, $name, $value, $checked)
    {
        switch($type) {
            case 'checkbox':
                return $this->getCheckboxCheckedState($name, $value, $checked);

            case 'radio':
                return $this->getRadioCheckedState($name, $value, $checked);

            default:
                return $this->getValueAttribute($name) === $value;
        }
    }

    /**
     * Get the check state for a checkbox input.
     *
     * @param  string     $name
     * @param  mixed      $value
     * @param  bool|null  $checked
     *
     * @return bool
     */
    private function getCheckboxCheckedState($name, $value, $checked)
    {
        if (isset($this->session) && ! $this->oldInputIsEmpty() && is_null($this->old($name))) {
            return false;
        }

        if ($this->missingOldAndModel($name)) {
            return $checked;
        }

        $posted = $this->getValueAttribute($name, $checked);

        if (is_array($posted)) {
            return in_array($value, $posted);
        }

        if ($posted instanceof Collection) {
            return $posted->contains('id', $value);
        }

        return (bool) $posted;
    }

    /**
     * Get the check state for a radio input.
     *
     * @param  string     $name
     * @param  mixed      $value
     * @param  bool|null  $checked
     *
     * @return bool
     */
    private function getRadioCheckedState($name, $value, $checked)
    {
        return $this->missingOldAndModel($name)
            ? $checked
            : $this->getValueAttribute($name) === $value;
    }

    /**
     * Determine if old input or model input exists for a key.
     *
     * @param  string  $name
     *
     * @return bool
     */
    private function missingOldAndModel($name)
    {
        return (is_null($this->old($name)) && is_null($this->getModelValueAttribute($name)));
    }

    /**
     * Create a HTML reset input element.
     *
     * @param  string  $value
     * @param  array   $attributes
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function reset($value, array $attributes = [])
    {
        return $this->input('reset', null, $value, $attributes);
    }

    /**
    * Create a HTML image input element.
    *
    * @param  string  $url
    * @param  string  $name
    * @param  array   $attributes
    *
     * @return \Illuminate\Support\HtmlString
    */
    public function image($url, $name = null, array $attributes = [])
    {
        $attributes['src'] = $this->url->asset($url);

        return $this->input('image', $name, null, $attributes);
    }

    /**
     * Create a submit button element.
     *
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function submit($value = null, array $options = [])
    {
        return $this->input('submit', null, $value, $options);
    }

    /**
     * Create a button element.
     *
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function button($value = null, array $options = [])
    {
        if ( ! array_key_exists('type', $options)) {
            $options['type'] = 'button';
        }

        return $this->toHtmlString(
            '<button'.$this->html->attributes($options).'>'.$value.'</button>'
        );
    }

    /**
     * Create a color input field.
     *
     * @param  string  $name
     * @param  string  $value
     * @param  array   $options
     *
     * @return \Illuminate\Support\HtmlString
     */
    public function color($name, $value = null, array $options = [])
    {
        return $this->input('color', $name, $value, $options);
    }

    /* -----------------------------------------------------------------
     |  Other Methods
     | -----------------------------------------------------------------
     */

    /**
     * Get the form action from the options.
     *
     * @param  array  $options
     *
     * @return string
     */
    private function getAction(array $options)
    {
        // We will also check for a "route" or "action" parameter on the array so that
        // developers can easily specify a route or controller action when creating
        // a form providing a convenient interface for creating the form actions.
        if (isset($options['url'])) {
            return $this->getUrlAction($options['url']);
        }
        elseif (isset($options['route'])) {
            return $this->getRouteAction($options['route']);
        }
        elseif (isset($options['action'])) {
            // If an action is available, we are attempting to open a form to a controller
            // action route. So, we will use the URL generator to get the path to these
            // actions and return them from the method. Otherwise, we'll use current.
            return $this->getControllerAction($options['action']);
        }

        return $this->url->current();
    }

    /**
     * Get the action for a "url" option.
     *
     * @param  array|string  $options
     *
     * @return string
     */
    private function getUrlAction($options)
    {
        return is_array($options)
            ? $this->url->to($options[0], array_slice($options, 1))
            : $this->url->to($options);
    }

    /**
     * Get the action for a "route" option.
     *
     * @param  array|string  $options
     *
     * @return string
     */
    private function getRouteAction($options)
    {
        return is_array($options)
            ? $this->url->route($options[0], array_slice($options, 1))
            : $this->url->route($options);
    }

    /**
     * Get the action for an "action" option.
     *
     * @param  array|string  $options
     *
     * @return string
     */
    private function getControllerAction($options)
    {
        return is_array($options)
            ? $this->url->action($options[0], array_slice($options, 1))
            : $this->url->action($options);
    }

    /**
     * Get the form appendage for the given method.
     *
     * @param  string  $method
     *
     * @return string
     */
    private function getAppendage($method)
    {
        list($method, $appendage) = [strtoupper($method), ''];

        // If the HTTP method is in this list of spoofed methods, we will attach the
        // method spoofer hidden input to the form. This allows us to use regular
        // form to initiate PUT and DELETE requests in addition to the typical.
        if (in_array($method, $this->spoofedMethods)) {
            $appendage .= $this->hidden('_method', $method);
        }

        // If the method is something other than GET we will go ahead and attach the
        // CSRF token to the form, as this can't hurt and is convenient to simply
        // always have available on every form the developers creates for them.
        if ($method !== 'GET') {
            $appendage .= $this->token();
        }

        return $appendage;
    }
}

ARCANEDEV / LaravelHtml

Pull Request — master (#21)

FormBuilder::getModel() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
