8889841chtml/readme.md 0000644 00000001553 15052151542 0007273 0 ustar 00 
[](https://travis-ci.org/LaravelCollective/html)
[](https://packagist.org/packages/laravelcollective/html)
[](https://packagist.org/packages/laravelcollective/html)
[](https://packagist.org/packages/laravelcollective/html)
[](https://packagist.org/packages/laravelcollective/html)
Official documentation for Forms & Html for The Laravel Framework can be found at the [LaravelCollective](https://laravelcollective.com/docs) website.
html/src/Componentable.php 0000644 00000005103 15052151542 0011575 0 ustar 00 getComponentData($component['signature'], $arguments);
return new HtmlString(
$this->view->make($component['view'], $data)->render()
);
}
/**
* Prepare the component data, while respecting provided defaults.
*
* @param array $signature
* @param array $arguments
*
* @return array
*/
protected function getComponentData(array $signature, array $arguments)
{
$data = [];
$i = 0;
foreach ($signature as $variable => $default) {
// If the "variable" value is actually a numeric key, we can assume that
// no default had been specified for the component argument and we'll
// just use null instead, so that we can treat them all the same.
if (is_numeric($variable)) {
$variable = $default;
$default = null;
}
$data[$variable] = Arr::get($arguments, $i, $default);
$i++;
}
return $data;
}
/**
* Dynamically handle calls to the class.
*
* @param string $method
* @param array $parameters
*
* @return \Illuminate\Contracts\View\View|mixed
*
* @throws \BadMethodCallException
*/
public function __call($method, $parameters)
{
if (static::hasComponent($method)) {
return $this->renderComponent($method, $parameters);
}
throw new BadMethodCallException("Method {$method} does not exist.");
}
}
html/src/FormBuilder.php 0000644 00000116035 15052151542 0011230 0 ustar 00 url = $url;
$this->html = $html;
$this->view = $view;
$this->csrfToken = $csrfToken;
$this->request = $request;
}
/**
* 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);
$attributes['action'] = $this->getAction($options);
$attributes['accept-charset'] = 'UTF-8';
// 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);
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, Arr::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);
return $this->toHtmlString('' . $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->model = $model;
return $this->open($options);
}
/**
* Set the model instance on the form builder.
*
* @param mixed $model
*
* @return void
*/
public function setModel($model)
{
$this->model = $model;
}
/**
* Get the current model instance on the form builder.
*
* @return mixed $model
*/
public function getModel()
{
return $this->model;
}
/**
* Close the current form.
*
* @return string
*/
public function close()
{
$this->labels = [];
$this->model = null;
return $this->toHtmlString('');
}
/**
* Generate a hidden field with the current CSRF token.
*
* @return string
*/
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 $escape_html
*
* @return \Illuminate\Support\HtmlString
*/
public function label($name, $value = null, $options = [], $escape_html = true)
{
$this->labels[] = $name;
$options = $this->html->attributes($options);
$value = $this->formatLabel($name, $value);
if ($escape_html) {
$value = $this->html->entities($value);
}
return $this->toHtmlString('');
}
/**
* Format the label value.
*
* @param string $name
* @param string|null $value
*
* @return string
*/
protected function formatLabel($name, $value)
{
return $value ?: ucwords(str_replace('_', ' ', $name));
}
/**
* 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, $options = [])
{
$this->type = $type;
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.
$merge = compact('type', 'value', 'id');
$options = array_merge($options, $merge);
return $this->toHtmlString('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, $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, $options = [])
{
return $this->input('password', $name, '', $options);
}
/**
* Create a range input field.
*
* @param string $name
* @param string $value
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function range($name, $value = null, $options = [])
{
return $this->input('range', $name, $value, $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, $options = [])
{
return $this->input('hidden', $name, $value, $options);
}
/**
* Create a search input field.
*
* @param string $name
* @param string $value
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function search($name, $value = null, $options = [])
{
return $this->input('search', $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, $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, $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, $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, $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, $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, $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, $options = [])
{
if ($value instanceof DateTime) {
$value = $value->format('H:i');
}
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, $options = [])
{
return $this->input('url', $name, $value, $options);
}
/**
* Create a week input field.
*
* @param string $name
* @param string $value
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function week($name, $value = null, $options = [])
{
if ($value instanceof DateTime) {
$value = $value->format('Y-\WW');
}
return $this->input('week', $name, $value, $options);
}
/**
* Create a file input field.
*
* @param string $name
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function file($name, $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, $options = [])
{
$this->type = 'textarea';
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('' . e($value, false). '');
}
/**
* Set the text area size on the attributes.
*
* @param array $options
*
* @return array
*/
protected function setTextAreaSize($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($options)
{
$segments = explode('x', $options['size']);
return array_merge($options, ['cols' => $segments[0], 'rows' => $segments[1]]);
}
/**
* Create a select box field.
*
* @param string $name
* @param array $list
* @param string|bool $selected
* @param array $selectAttributes
* @param array $optionsAttributes
* @param array $optgroupsAttributes
*
* @return \Illuminate\Support\HtmlString
*/
public function select(
$name,
$list = [],
$selected = null,
array $selectAttributes = [],
array $optionsAttributes = [],
array $optgroupsAttributes = []
) {
$this->type = 'select';
// 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);
$selectAttributes['id'] = $this->getIdAttribute($name, $selectAttributes);
if (! isset($selectAttributes['name'])) {
$selectAttributes['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($selectAttributes['placeholder'])) {
$html[] = $this->placeholderOption($selectAttributes['placeholder'], $selected);
unset($selectAttributes['placeholder']);
}
foreach ($list as $value => $display) {
$optionAttributes = $optionsAttributes[$value] ?? [];
$optgroupAttributes = $optgroupsAttributes[$value] ?? [];
$html[] = $this->getSelectOption($display, $value, $selected, $optionAttributes, $optgroupAttributes);
}
// 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.
$selectAttributes = $this->html->attributes($selectAttributes);
$list = implode('', $html);
return $this->toHtmlString("{$list}");
}
/**
* 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, $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 mixed
*/
public function selectYear()
{
return call_user_func_array([$this, 'selectRange'], func_get_args());
}
/**
* 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, $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
* @param array $optgroupAttributes
*
* @return \Illuminate\Support\HtmlString
*/
public function getSelectOption($display, $value, $selected, array $attributes = [], array $optgroupAttributes = [])
{
if (is_iterable($display)) {
return $this->optionGroup($display, $value, $selected, $optgroupAttributes, $attributes);
}
return $this->option($display, $value, $selected, $attributes);
}
/**
* Create an option group form element.
*
* @param array $list
* @param string $label
* @param string $selected
* @param array $attributes
* @param array $optionsAttributes
* @param integer $level
*
* @return \Illuminate\Support\HtmlString
*/
protected function optionGroup($list, $label, $selected, array $attributes = [], array $optionsAttributes = [], $level = 0)
{
$html = [];
$space = str_repeat(" ", $level);
foreach ($list as $value => $display) {
$optionAttributes = $optionsAttributes[$value] ?? [];
if (is_iterable($display)) {
$html[] = $this->optionGroup($display, $value, $selected, $attributes, $optionAttributes, $level+5);
} else {
$html[] = $this->option($space.$display, $value, $selected, $optionAttributes);
}
}
return $this->toHtmlString('');
}
/**
* Create a select element option.
*
* @param string $display
* @param string $value
* @param string $selected
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString
*/
protected function option($display, $value, $selected, array $attributes = [])
{
$selected = $this->getSelectedValue($value, $selected);
$options = array_merge(['value' => $value, 'selected' => $selected], $attributes);
$string = 'html->attributes($options) . '>';
if ($display !== null) {
$string .= e($display, false) . '';
}
return $this->toHtmlString($string);
}
/**
* Create a placeholder select element option.
*
* @param $display
* @param $selected
*
* @return \Illuminate\Support\HtmlString
*/
protected function placeholderOption($display, $selected)
{
$selected = $this->getSelectedValue(null, $selected);
$options = [
'selected' => $selected,
'value' => '',
];
return $this->toHtmlString('html->attributes($options) . '>' . e($display, false) . '');
}
/**
* Determine if the value is selected.
*
* @param string $value
* @param string $selected
*
* @return null|string
*/
protected function getSelectedValue($value, $selected)
{
if (is_array($selected)) {
return in_array($value, $selected, true) || in_array((string) $value, $selected, true) ? 'selected' : null;
} elseif ($selected instanceof Collection) {
return $selected->contains($value) ? 'selected' : null;
}
if (is_int($value) && is_bool($selected)) {
return (bool)$value === $selected;
}
return ((string) $value === (string) $selected) ? 'selected' : null;
}
/**
* Create a checkbox input field.
*
* @param string $name
* @param mixed $value
* @param bool $checked
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function checkbox($name, $value = 1, $checked = null, $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, $options = [])
{
if (is_null($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 $checked
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
protected function checkable($type, $name, $value, $checked, $options)
{
$this->type = $type;
$checked = $this->getCheckedState($type, $name, $value, $checked);
if ($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 $checked
*
* @return bool
*/
protected 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->compareValues($name, $value);
}
}
/**
* Get the check state for a checkbox input.
*
* @param string $name
* @param mixed $value
* @param bool $checked
*
* @return bool
*/
protected function getCheckboxCheckedState($name, $value, $checked)
{
$request = $this->request($name);
if (isset($this->session) && ! $this->oldInputIsEmpty() && is_null($this->old($name)) && !$request) {
return false;
}
if ($this->missingOldAndModel($name) && is_null($request)) {
return $checked;
}
$posted = $this->getValueAttribute($name, $checked);
if (is_array($posted)) {
return in_array($value, $posted);
} elseif ($posted instanceof Collection) {
return $posted->contains('id', $value);
} else {
return (bool) $posted;
}
}
/**
* Get the check state for a radio input.
*
* @param string $name
* @param mixed $value
* @param bool $checked
*
* @return bool
*/
protected function getRadioCheckedState($name, $value, $checked)
{
$request = $this->request($name);
if ($this->missingOldAndModel($name) && !$request) {
return $checked;
}
return $this->compareValues($name, $value);
}
/**
* Determine if the provide value loosely compares to the value assigned to the field.
* Use loose comparison because Laravel model casting may be in affect and therefore
* 1 == true and 0 == false.
*
* @param string $name
* @param string $value
* @return bool
*/
protected function compareValues($name, $value)
{
return $this->getValueAttribute($name) == $value;
}
/**
* Determine if old input or model input exists for a key.
*
* @param string $name
*
* @return bool
*/
protected 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, $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, $attributes = [])
{
$attributes['src'] = $this->url->asset($url);
return $this->input('image', $name, null, $attributes);
}
/**
* Create a month input field.
*
* @param string $name
* @param string $value
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function month($name, $value = null, $options = [])
{
if ($value instanceof DateTime) {
$value = $value->format('Y-m');
}
return $this->input('month', $name, $value, $options);
}
/**
* Create a color input field.
*
* @param string $name
* @param string $value
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function color($name, $value = null, $options = [])
{
return $this->input('color', $name, $value, $options);
}
/**
* Create a submit button element.
*
* @param string $value
* @param array $options
*
* @return \Illuminate\Support\HtmlString
*/
public function submit($value = null, $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, $options = [])
{
if (! array_key_exists('type', $options)) {
$options['type'] = 'button';
}
return $this->toHtmlString('html->attributes($options) . '>' . $value . '');
}
/**
* Create a datalist box field.
*
* @param string $id
* @param array $list
*
* @return \Illuminate\Support\HtmlString
*/
public function datalist($id, $list = [])
{
$this->type = 'datalist';
$attributes['id'] = $id;
$html = [];
if ($this->isAssociativeArray($list)) {
foreach ($list as $value => $display) {
$html[] = $this->option($display, $value, null, []);
}
} else {
foreach ($list as $value) {
$html[] = $this->option($value, $value, null, []);
}
}
$attributes = $this->html->attributes($attributes);
$list = implode('', $html);
return $this->toHtmlString("{$list}");
}
/**
* Determine if an array is associative.
*
* @param array $array
* @return bool
*/
protected function isAssociativeArray($array)
{
return (array_values($array) !== $array);
}
/**
* Parse the form action method.
*
* @param string $method
*
* @return string
*/
protected function getMethod($method)
{
$method = strtoupper($method);
return $method !== 'GET' ? 'POST' : $method;
}
/**
* Get the form action from the options.
*
* @param array $options
*
* @return string
*/
protected 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']);
}
if (isset($options['route'])) {
return $this->getRouteAction($options['route']);
}
// 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.
elseif (isset($options['action'])) {
return $this->getControllerAction($options['action']);
}
return $this->url->current();
}
/**
* Get the action for a "url" option.
*
* @param array|string $options
*
* @return string
*/
protected function getUrlAction($options)
{
if (is_array($options)) {
return $this->url->to($options[0], array_slice($options, 1));
}
return $this->url->to($options);
}
/**
* Get the action for a "route" option.
*
* @param array|string $options
*
* @return string
*/
protected function getRouteAction($options)
{
if (is_array($options)) {
$parameters = array_slice($options, 1);
if (array_keys($options) === [0, 1]) {
$parameters = head($parameters);
}
return $this->url->route($options[0], $parameters);
}
return $this->url->route($options);
}
/**
* Get the action for an "action" option.
*
* @param array|string $options
*
* @return string
*/
protected function getControllerAction($options)
{
if (is_array($options)) {
return $this->url->action($options[0], array_slice($options, 1));
}
return $this->url->action($options);
}
/**
* Get the form appendage for the given method.
*
* @param string $method
*
* @return string
*/
protected 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;
}
/**
* Get the ID attribute for a field name.
*
* @param string $name
* @param array $attributes
*
* @return string
*/
public function getIdAttribute($name, $attributes)
{
if (array_key_exists('id', $attributes)) {
return $attributes['id'];
}
if (in_array($name, $this->labels)) {
return $name;
}
}
/**
* Get the value that should be assigned to the field.
*
* @param string $name
* @param string $value
*
* @return mixed
*/
public function getValueAttribute($name, $value = null)
{
if (is_null($name)) {
return $value;
}
$old = $this->old($name);
if (! is_null($old) && $name !== '_method') {
return $old;
}
if (function_exists('app')) {
$hasNullMiddleware = app("Illuminate\Contracts\Http\Kernel")
->hasMiddleware(ConvertEmptyStringsToNull::class);
if ($hasNullMiddleware
&& is_null($old)
&& is_null($value)
&& !is_null($this->view->shared('errors'))
&& count(is_countable($this->view->shared('errors')) ? $this->view->shared('errors') : []) > 0
) {
return null;
}
}
$request = $this->request($name);
if (! is_null($request) && $name != '_method') {
return $request;
}
if (! is_null($value)) {
return $value;
}
if (isset($this->model)) {
return $this->getModelValueAttribute($name);
}
}
/**
* Take Request in fill process
* @param bool $consider
*/
public function considerRequest($consider = true)
{
$this->considerRequest = $consider;
}
/**
* Get value from current Request
* @param $name
* @return array|null|string
*/
protected function request($name)
{
if (!$this->considerRequest) {
return null;
}
if (!isset($this->request)) {
return null;
}
return $this->request->input($this->transformKey($name));
}
/**
* Get the model value that should be assigned to the field.
*
* @param string $name
*
* @return mixed
*/
protected function getModelValueAttribute($name)
{
$key = $this->transformKey($name);
if ((is_string($this->model) || is_object($this->model)) && method_exists($this->model, 'getFormValue')) {
return $this->model->getFormValue($key);
}
return data_get($this->model, $key);
}
/**
* Get a value from the session's old input.
*
* @param string $name
*
* @return mixed
*/
public function old($name)
{
if (isset($this->session)) {
$key = $this->transformKey($name);
$payload = $this->session->getOldInput($key);
if (!is_array($payload)) {
return $payload;
}
if (!in_array($this->type, ['select', 'checkbox'])) {
if (!isset($this->payload[$key])) {
$this->payload[$key] = collect($payload);
}
if (!empty($this->payload[$key])) {
$value = $this->payload[$key]->shift();
return $value;
}
}
return $payload;
}
}
/**
* Determine if the old input is empty.
*
* @return bool
*/
public function oldInputIsEmpty()
{
return (isset($this->session) && count((array) $this->session->getOldInput()) === 0);
}
/**
* Transform key from array to dot syntax.
*
* @param string $key
*
* @return mixed
*/
protected function transformKey($key)
{
return str_replace(['.', '[]', '[', ']'], ['_', '', '.', ''], $key);
}
/**
* Transform the string to an Html serializable object
*
* @param $html
*
* @return \Illuminate\Support\HtmlString
*/
protected function toHtmlString($html)
{
return new HtmlString($html);
}
/**
* Get the session store implementation.
*
* @return \Illuminate\Contracts\Session\Session $session
*/
public function getSessionStore()
{
return $this->session;
}
/**
* Set the session store implementation.
*
* @param \Illuminate\Contracts\Session\Session $session
*
* @return $this
*/
public function setSessionStore(Session $session)
{
$this->session = $session;
return $this;
}
/**
* Dynamically handle calls to the class.
*
* @param string $method
* @param array $parameters
*
* @return \Illuminate\Contracts\View\View|mixed
*
* @throws \BadMethodCallException
*/
public function __call($method, $parameters)
{
if (static::hasComponent($method)) {
return $this->componentCall($method, $parameters);
}
if (static::hasMacro($method)) {
return $this->macroCall($method, $parameters);
}
throw new BadMethodCallException("Method {$method} does not exist.");
}
}
html/src/HtmlServiceProvider.php 0000644 00000006073 15052151542 0012756 0 ustar 00 registerHtmlBuilder();
$this->registerFormBuilder();
$this->app->alias('html', HtmlBuilder::class);
$this->app->alias('form', FormBuilder::class);
$this->registerBladeDirectives();
}
/**
* Register the HTML builder instance.
*
* @return void
*/
protected function registerHtmlBuilder()
{
$this->app->singleton('html', function ($app) {
return new HtmlBuilder($app['url'], $app['view']);
});
}
/**
* Register the form builder instance.
*
* @return void
*/
protected function registerFormBuilder()
{
$this->app->singleton('form', function ($app) {
$form = new FormBuilder($app['html'], $app['url'], $app['view'], $app['session.store']->token(), $app['request']);
return $form->setSessionStore($app['session.store']);
});
}
/**
* Register Blade directives.
*
* @return void
*/
protected function registerBladeDirectives()
{
$this->app->afterResolving('blade.compiler', function (BladeCompiler $bladeCompiler) {
$namespaces = [
'Html' => get_class_methods(HtmlBuilder::class),
'Form' => get_class_methods(FormBuilder::class),
];
foreach ($namespaces as $namespace => $methods) {
foreach ($methods as $method) {
if (in_array($method, $this->directives)) {
$snakeMethod = Str::snake($method);
$directive = strtolower($namespace).'_'.$snakeMethod;
$bladeCompiler->directive($directive, function ($expression) use ($namespace, $method) {
return "";
});
}
}
}
});
}
/**
* Get the services provided by the provider.
*
* @return array
*/
public function provides()
{
return ['html', 'form', HtmlBuilder::class, FormBuilder::class];
}
}
html/src/FormFacade.php 0000644 00000000520 15052151542 0010774 0 ustar 00 getAttributeFromArray($key);
// If the attribute is listed as a date, we will convert it to a DateTime
// instance on retrieval, which makes it quite convenient to work with
// date fields without having to create a mutator for each property.
if (in_array($key, $this->getDates())) {
if (! is_null($value)) {
$value = $this->asDateTime($value);
}
}
// If the attribute has a get mutator, we will call that then return what
// it returns as the value, which is useful for transforming values on
// retrieval from the model to a form that is more useful for usage.
if ($this->hasFormMutator($key)) {
return $this->mutateFormAttribute($key, $value);
}
$keys = explode('.', $key);
if ($this->isNestedModel($keys[0])) {
$relatedModel = $this->getRelation($keys[0]);
unset($keys[0]);
$key = implode('.', $keys);
if (method_exists($relatedModel, 'hasFormMutator') && $key !== '' && $relatedModel->hasFormMutator($key)) {
return $relatedModel->getFormValue($key);
}
return data_get($relatedModel, empty($key)? null: $key);
}
// No form mutator, let the model resolve this
return data_get($this, $key);
}
/**
* Check for a nested model.
*
* @param string $key
*
* @return bool
*/
public function isNestedModel($key)
{
return in_array($key, array_keys($this->getRelations()));
}
/**
* @param $key
*
* @return bool
*/
public function hasFormMutator($key)
{
$methods = $this->getReflection()->getMethods(ReflectionMethod::IS_PUBLIC);
$mutator = collect($methods)
->first(function (ReflectionMethod $method) use ($key) {
return $method->getName() === 'form' . Str::studly($key) . 'Attribute';
});
return (bool) $mutator;
}
/**
* @param $key
* @param $value
*
* @return mixed
*/
private function mutateFormAttribute($key, $value)
{
return $this->{'form' . Str::studly($key) . 'Attribute'}($value);
}
/**
* Get a ReflectionClass Instance
* @return ReflectionClass
*/
protected function getReflection()
{
if (! $this->reflection) {
$this->reflection = new ReflectionClass($this);
}
return $this->reflection;
}
}
html/src/HtmlFacade.php 0000644 00000000520 15052151542 0010775 0 ustar 00 link($url, $title, $attributes, $secure, $escape);
}
}
if (! function_exists('link_to_asset')) {
/**
* Generate a HTML link to an asset.
*
* @param string $url
* @param string $title
* @param array $attributes
* @param bool $secure
*
* @return \Illuminate\Support\HtmlString
*/
function link_to_asset($url, $title = null, $attributes = [], $secure = null)
{
return app('html')->linkAsset($url, $title, $attributes, $secure);
}
}
if (! function_exists('link_to_route')) {
/**
* Generate a HTML link to a named route.
*
* @param string $name
* @param string $title
* @param array $parameters
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString
*/
function link_to_route($name, $title = null, $parameters = [], $attributes = [])
{
return app('html')->linkRoute($name, $title, $parameters, $attributes);
}
}
if (! function_exists('link_to_action')) {
/**
* Generate a HTML link to a controller action.
*
* @param string $action
* @param string $title
* @param array $parameters
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString
*/
function link_to_action($action, $title = null, $parameters = [], $attributes = [])
{
return app('html')->linkAction($action, $title, $parameters, $attributes);
}
}
html/src/HtmlBuilder.php 0000644 00000035456 15052151542 0011240 0 ustar 00 url = $url;
$this->view = $view;
}
/**
* Convert an HTML string to entities.
*
* @param string $value
*
* @return string
*/
public function entities($value)
{
return htmlentities($value, ENT_QUOTES, 'UTF-8', false);
}
/**
* Convert entities to HTML characters.
*
* @param string $value
*
* @return string
*/
public function decode($value)
{
return html_entity_decode($value, ENT_QUOTES, 'UTF-8');
}
/**
* Generate a link to a JavaScript file.
*
* @param string $url
* @param array $attributes
* @param bool $secure
*
* @return \Illuminate\Support\HtmlString
*/
public function script($url, $attributes = [], $secure = null)
{
$attributes['src'] = $this->url->asset($url, $secure);
return $this->toHtmlString('attributes($attributes) . '>');
}
/**
* Generate a link to a CSS file.
*
* @param string $url
* @param array $attributes
* @param bool $secure
*
* @return \Illuminate\Support\HtmlString
*/
public function style($url, $attributes = [], $secure = null)
{
$defaults = ['media' => 'all', 'type' => 'text/css', 'rel' => 'stylesheet'];
$attributes = array_merge($defaults, $attributes);
$attributes['href'] = $this->url->asset($url, $secure);
return $this->toHtmlString('attributes($attributes) . '>');
}
/**
* Generate an HTML image element.
*
* @param string $url
* @param string $alt
* @param array $attributes
* @param bool $secure
*
* @return \Illuminate\Support\HtmlString
*/
public function image($url, $alt = null, $attributes = [], $secure = null)
{
$attributes['alt'] = $alt;
return $this->toHtmlString(' . ')
attributes($attributes) . '>');
}
/**
* Generate a link to a Favicon file.
*
* @param string $url
* @param array $attributes
* @param bool $secure
*
* @return \Illuminate\Support\HtmlString
*/
public function favicon($url, $attributes = [], $secure = null)
{
$defaults = ['rel' => 'shortcut icon', 'type' => 'image/x-icon'];
$attributes = array_merge($defaults, $attributes);
$attributes['href'] = $this->url->asset($url, $secure);
return $this->toHtmlString('attributes($attributes) . '>');
}
/**
* Generate a HTML link.
*
* @param string $url
* @param string $title
* @param array $attributes
* @param bool $secure
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function link($url, $title = null, $attributes = [], $secure = null, $escape = true)
{
$url = $this->url->to($url, [], $secure);
if (is_null($title) || $title === false) {
$title = $url;
}
if ($escape) {
$title = $this->entities($title);
}
return $this->toHtmlString('attributes($attributes) . '>' . $title . '');
}
/**
* Generate a HTTPS HTML link.
*
* @param string $url
* @param string $title
* @param array $attributes
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function secureLink($url, $title = null, $attributes = [], $escape = true)
{
return $this->link($url, $title, $attributes, true, $escape);
}
/**
* Generate a HTML link to an asset.
*
* @param string $url
* @param string $title
* @param array $attributes
* @param bool $secure
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function linkAsset($url, $title = null, $attributes = [], $secure = null, $escape = true)
{
$url = $this->url->asset($url, $secure);
return $this->link($url, $title ?: $url, $attributes, $secure, $escape);
}
/**
* Generate a HTTPS HTML link to an asset.
*
* @param string $url
* @param string $title
* @param array $attributes
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function linkSecureAsset($url, $title = null, $attributes = [], $escape = true)
{
return $this->linkAsset($url, $title, $attributes, true, $escape);
}
/**
* Generate a HTML link to a named route.
*
* @param string $name
* @param string $title
* @param array $parameters
* @param array $attributes
* @param bool $secure
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function linkRoute($name, $title = null, $parameters = [], $attributes = [], $secure = null, $escape = true)
{
return $this->link($this->url->route($name, $parameters), $title, $attributes, $secure, $escape);
}
/**
* Generate a HTML link to a controller action.
*
* @param string $action
* @param string $title
* @param array $parameters
* @param array $attributes
* @param bool $secure
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function linkAction($action, $title = null, $parameters = [], $attributes = [], $secure = null, $escape = true)
{
return $this->link($this->url->action($action, $parameters), $title, $attributes, $secure, $escape);
}
/**
* Generate a HTML link to an email address.
*
* @param string $email
* @param string $title
* @param array $attributes
* @param bool $escape
*
* @return \Illuminate\Support\HtmlString
*/
public function mailto($email, $title = null, $attributes = [], $escape = true)
{
$email = $this->email($email);
$title = $title ?: $email;
if ($escape) {
$title = $this->entities($title);
}
$email = $this->obfuscate('mailto:') . $email;
return $this->toHtmlString('attributes($attributes) . '>' . $title . '');
}
/**
* Obfuscate an e-mail address to prevent spam-bots from sniffing it.
*
* @param string $email
*
* @return string
*/
public function email($email)
{
return str_replace('@', '@', $this->obfuscate($email));
}
/**
* Generates non-breaking space entities based on number supplied.
*
* @param int $num
*
* @return string
*/
public function nbsp($num = 1)
{
return str_repeat(' ', $num);
}
/**
* Generate an ordered list of items.
*
* @param array $list
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString|string
*/
public function ol($list, $attributes = [])
{
return $this->listing('ol', $list, $attributes);
}
/**
* Generate an un-ordered list of items.
*
* @param array $list
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString|string
*/
public function ul($list, $attributes = [])
{
return $this->listing('ul', $list, $attributes);
}
/**
* Generate a description list of items.
*
* @param array $list
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString
*/
public function dl(array $list, array $attributes = [])
{
$attributes = $this->attributes($attributes);
$html = "";
foreach ($list as $key => $value) {
$value = (array) $value;
$html .= "$key";
foreach ($value as $v_key => $v_value) {
$html .= "$v_value";
}
}
$html .= '';
return $this->toHtmlString($html);
}
/**
* Create a listing HTML element.
*
* @param string $type
* @param array $list
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString|string
*/
protected function listing($type, $list, $attributes = [])
{
$html = '';
if (count($list) === 0) {
return $html;
}
// Essentially we will just spin through the list and build the list of the HTML
// elements from the array. We will also handled nested lists in case that is
// present in the array. Then we will build out the final listing elements.
foreach ($list as $key => $value) {
$html .= $this->listingElement($key, $type, $value);
}
$attributes = $this->attributes($attributes);
return $this->toHtmlString("<{$type}{$attributes}>{$html}");
}
/**
* Create the HTML for a listing element.
*
* @param mixed $key
* @param string $type
* @param mixed $value
*
* @return string
*/
protected function listingElement($key, $type, $value)
{
if (is_array($value)) {
return $this->nestedListing($key, $type, $value);
} else {
return '' . e($value, false) . '';
}
}
/**
* Create the HTML for a nested listing attribute.
*
* @param mixed $key
* @param string $type
* @param mixed $value
*
* @return string
*/
protected function nestedListing($key, $type, $value)
{
if (is_int($key)) {
return $this->listing($type, $value);
} else {
return '' . $key . $this->listing($type, $value) . '';
}
}
/**
* Build an HTML attribute string from an array.
*
* @param array $attributes
*
* @return string
*/
public function attributes($attributes)
{
$html = [];
foreach ((array) $attributes as $key => $value) {
$element = $this->attributeElement($key, $value);
if (! is_null($element)) {
$html[] = $element;
}
}
return count($html) > 0 ? ' ' . implode(' ', $html) : '';
}
/**
* Build a single attribute element.
*
* @param string $key
* @param string $value
*
* @return string
*/
protected function attributeElement($key, $value)
{
// For numeric keys we will assume that the value is a boolean attribute
// where the presence of the attribute represents a true value and the
// absence represents a false value.
// This will convert HTML attributes such as "required" to a correct
// form instead of using incorrect numerics.
if (is_numeric($key)) {
return $value;
}
// Treat boolean attributes as HTML properties
if (is_bool($value) && $key !== 'value') {
return $value ? $key : '';
}
if (is_array($value) && $key === 'class') {
return 'class="' . implode(' ', $value) . '"';
}
if (! is_null($value)) {
return $key . '="' . e($value, false) . '"';
}
}
/**
* Obfuscate a string to prevent spam-bots from sniffing it.
*
* @param string $value
*
* @return string
*/
public function obfuscate($value)
{
$safe = '';
foreach (str_split($value) as $letter) {
if (ord($letter) > 128) {
return $letter;
}
// To properly obfuscate the value, we will randomly convert each letter to
// its entity or hexadecimal representation, keeping a bot from sniffing
// the randomly obfuscated letters out of the string on the responses.
switch (rand(1, 3)) {
case 1:
$safe .= '&#' . ord($letter) . ';';
break;
case 2:
$safe .= '&#x' . dechex(ord($letter)) . ';';
break;
case 3:
$safe .= $letter;
}
}
return $safe;
}
/**
* Generate a meta tag.
*
* @param string $name
* @param string $content
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString
*/
public function meta($name, $content, array $attributes = [])
{
$defaults = compact('name', 'content');
$attributes = array_merge($defaults, $attributes);
return $this->toHtmlString('attributes($attributes) . '>');
}
/**
* Generate an html tag.
*
* @param string $tag
* @param mixed $content
* @param array $attributes
*
* @return \Illuminate\Support\HtmlString
*/
public function tag($tag, $content, array $attributes = [])
{
$content = is_array($content) ? implode('', $content) : $content;
return $this->toHtmlString('<' . $tag . $this->attributes($attributes) . '>' . $this->toHtmlString($content) . '');
}
/**
* Transform the string to an Html serializable object
*
* @param $html
*
* @return \Illuminate\Support\HtmlString
*/
protected function toHtmlString($html)
{
return new HtmlString($html);
}
/**
* Dynamically handle calls to the class.
*
* @param string $method
* @param array $parameters
*
* @return \Illuminate\Contracts\View\View|mixed
*
* @throws \BadMethodCallException
*/
public function __call($method, $parameters)
{
if (static::hasComponent($method)) {
return $this->componentCall($method, $parameters);
}
if (static::hasMacro($method)) {
return $this->macroCall($method, $parameters);
}
throw new BadMethodCallException("Method {$method} does not exist.");
}
}
html/LICENSE.txt 0000644 00000002070 15052151542 0007332 0 ustar 00 The MIT License (MIT)
Copyright (c)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
html/composer.json 0000644 00000003072 15052151542 0010234 0 ustar 00 {
"name": "laravelcollective/html",
"description": "HTML and Form Builders for the Laravel Framework",
"license": "MIT",
"homepage": "https://laravelcollective.com",
"support": {
"issues": "https://github.com/LaravelCollective/html/issues",
"source": "https://github.com/LaravelCollective/html"
},
"authors": [
{
"name": "Adam Engebretson",
"email": "adam@laravelcollective.com"
},
{
"name": "Taylor Otwell",
"email": "taylorotwell@gmail.com"
}
],
"require": {
"php": ">=7.2.5",
"illuminate/http": "^6.0|^7.0|^8.0",
"illuminate/routing": "^6.0|^7.0|^8.0",
"illuminate/session": "^6.0|^7.0|^8.0",
"illuminate/support": "^6.0|^7.0|^8.0",
"illuminate/view": "^6.0|^7.0|^8.0"
},
"require-dev": {
"illuminate/database": "^6.0|^7.0|^8.0",
"mockery/mockery": "~1.0",
"phpunit/phpunit": "~8.5"
},
"autoload": {
"psr-4": {
"Collective\\Html\\": "src/"
},
"files": [
"src/helpers.php"
]
},
"extra": {
"branch-alias": {
"dev-master": "6.x-dev"
},
"laravel": {
"providers": [
"Collective\\Html\\HtmlServiceProvider"
],
"aliases": {
"Form": "Collective\\Html\\FormFacade",
"Html": "Collective\\Html\\HtmlFacade"
}
}
},
"minimum-stability": "dev",
"prefer-stable": true
}
html/CONTRIBUTING.md 0000644 00000000410 15052151542 0007734 0 ustar 00 # Laravel Contribution Guide
Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the [Laravel documentation](http://laravel.com/docs/contributions). Please review the entire guide before sending a pull request.
html/readme-ptbr.md 0000644 00000001557 15052151542 0010244 0 ustar 00 
[](https://travis-ci.org/LaravelCollective/html)
[](https://packagist.org/packages/laravelcollective/html)
[](https://packagist.org/packages/laravelcollective/html)
[](https://packagist.org/packages/laravelcollective/html)
[](https://packagist.org/packages/laravelcollective/html)
A documentação oficial para Forms & Html para o framework Laravel podem ser encontrados no site [LaravelCollective](https://laravelcollective.com/docs).