Simple Form

https://www.rubydoc.info/gems/simple_form
Admin
Simple Form is a Ruby on Rails gem that simplifies form building by providing helper methods and...
Tokens:46,335
Snippets:446
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Setup Simple Form

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm

Initializes the Simple Form configuration block.

```ruby
# File 'lib/simple_form.rb', line 291

def self.setup
  @@configured = true
  yield self
end
```

--------------------------------

### Configure Simple Form via setup

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.setup

The setup method yields the SimpleForm module to a block, allowing for configuration settings to be applied. It sets the internal configured flag to true upon execution.

```ruby
def self.setup
  @@configured = true
  yield self
end
```

--------------------------------

### Using the input helper

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Example of using the input helper within a simple_form_for block.

```ruby
# Imagine @user has error "can't be blank" on name
simple_form_for @user do |f|
f.input :name, hint: 'My hint'
end
```

--------------------------------

### Input helper HTML output

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

The resulting HTML generated by the input helper example.

```html
<label class="string required" for="user_name">
  <abbr title="required">*</abbr> Super User Name!
</label>
<input class="string required" id="user_name" maxlength="100"
   name="user[name]" type="text" value="Carlos" />
<span class="hint">My hint</span>
<span class="error">can't be blank</span>
```

--------------------------------

### Basic Usage of simple_form_for

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/ActionViewExtensions/FormHelper

Example of initializing a form using simple_form_for with a model instance.

```ruby
simple_form_for @user do |f|
f.input :name, hint: 'My hint'
end
```

--------------------------------

### SimpleForm FormBuilder#label Examples

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Alabel

Demonstrates various ways to use the `label` method for generating form labels. This includes I18n lookups, providing custom label text, and passing HTML options.

```ruby
f.label :name                     # Do I18n lookup
```

```ruby
f.label :name, "Name"             # Same behavior as Rails, do not add required tag
```

```ruby
f.label :name, label: "Name"      # Same as above, but adds required tag
```

```ruby
f.label :name, required: false
```

```ruby
f.label :name, id: "cool_label"
```

--------------------------------

### Create Hint Tag with I18n Lookup and HTML Options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ahint

This example shows how to create a hint tag for an attribute using I18n lookup and also provides HTML options, such as an ID, for the hint tag.

```ruby
f.hint :name, id: "cool_hint"
```

--------------------------------

### Create a button with SimpleForm

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Abutton_button

Usage example for creating a submit button within a form_for block.

```ruby
form_for @user do |f|
f.button :submit
end
```

--------------------------------

### Create a button with form_for

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Example of creating a submit button within a form_for block.

```ruby
form_for @user do |f|
f.button :submit
end

```

--------------------------------

### Basic association usage

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Aassociation

Examples of using the association helper to generate inputs for model associations.

```ruby
simple_form_for @user do |f|
f.association :company          # Company.all
end

f.association :company, collection: Company.all(order: 'name')
# Same as using :order option, but overriding collection
```

--------------------------------

### Using a custom component in a form

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm

Example of applying a custom wrapper to a Simple Form builder instance.

```erb
<%= simple_form_for @blog, wrapper: input_group do |f| %>
 <%= f.input :title, prepend: true %>
<% end %>
```

--------------------------------

### Get Input Options in SimpleForm

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base%3Ainput_options

This method returns the options associated with an input. It's a fundamental part of how Simple Form handles input configurations.

```ruby
def input_options
  options
end
```

--------------------------------

### SimpleForm.setup

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.setup

Configures the Simple Form library by yielding the configuration object to a block.

```APIDOC
## SimpleForm.setup

### Description
Default way to setup Simple Form. This method is typically called within a Rails initializer file (e.g., config/initializers/simple_form.rb) to configure global settings.

### Signature
`SimpleForm.setup { |config| ... }`

### Yields
- **config** (SimpleForm) - The configuration object used to set library options.

### Usage Example
```ruby
SimpleForm.setup do |config|
  config.boolean_style = :nested
  config.default_wrapper = :default
end
```
```

--------------------------------

### Get Reflection Information

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base%3Areflection

Returns the value of the attribute reflection. This is a readonly attribute.

```ruby
def reflection
  @reflection
end
```

--------------------------------

### Using the hint helper

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Demonstrates various ways to use the hint method, including I18n lookups and custom HTML attributes.

```ruby
f.hint :name # Do I18n lookup
f.hint :name, id: "cool_hint"
f.hint "Don't forget to accept this"
```

--------------------------------

### InstallGenerator#show_readme Method

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Generators/InstallGenerator%3Ashow_readme

This method checks if the generator is being invoked and if Bootstrap options are selected. If both conditions are true, it displays the README file.

```ruby
def show_readme
  if behavior == :invoke && options.bootstrap?
    readme "README"
  end
end
```

--------------------------------

### Registering and Using a Custom Component

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.include_component

Shows how to define a custom component module, register it in the SimpleForm configuration, and use it within a form.

```ruby
# The application needs to tell where the components will be.
Dir[Rails.root.join('lib/components/**/*.rb')].each { |f| require f }

# Create a custom component in the path specified above.
# lib/components/input_group_component.rb
module InputGroupComponent
 def prepend
   ...
 end

 def append
   ...
 end
end

SimpleForm.setup do |config|
 # Create a wrapper using the custom component.
 config.wrappers :input_group, tag: :div, error_class: :error do |b|
   b.use :label
   b.optional :prepend
   b.use :input
   b.use :append
 end
end

# Using the custom component in the form.
<%= simple_form_for @blog, wrapper: input_group do |f| %>
 <%= f.input :title, prepend: true %>
<% end %>
```

--------------------------------

### SimpleForm::Wrappers::Root#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Root%3Ainitialize

Initializes a new instance of the Root wrapper. It calls the superclass initializer with ':wrapper' and any provided arguments, then sets up internal options based on defaults, excluding specific keys.

```APIDOC
## SimpleForm::Wrappers::Root#initialize

### Description
Initializes a new instance of the Root wrapper. It calls the superclass initializer with ':wrapper' and any provided arguments, then sets up internal options based on defaults, excluding specific keys.

### Method
initialize(*args)

### Parameters
*args - Arguments passed to the initializer.

### Request Example
```ruby
SimpleForm::Wrappers::Root.new(options)
```

### Response
Returns a new instance of Root.
```

--------------------------------

### Instance Methods

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base

Methods for managing input classes and rendering logic.

```ruby
# File 'lib/simple_form/inputs/base.rb', line 94

def additional_classes
  @additional_classes ||= [input_type, required_class, readonly_class, disabled_class].compact
end
```

```ruby
# File 'lib/simple_form/inputs/base.rb', line 86

def input(wrapper_options = nil)
  raise NotImplementedError
end
```

```ruby
# File 'lib/simple_form/inputs/base.rb', line 98

def input_class
  "#{lookup_model_names.join('_')}_#{reflection_or_attribute_name}"
end
```

```ruby
# File 'lib/simple_form/inputs/base.rb', line 90

def input_options
  options
end
```

--------------------------------

### Configure form wrappers

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder

Demonstrates the DSL for defining components, optional elements, and nested wrappers within a configuration block.

```ruby
config.wrappers do |b|
  # Use a single component
  b.use :html5

  # Use the component, but do not automatically lookup. It will only be triggered when
  # :placeholder is explicitly set.
  b.optional :placeholder

  # Use a component with specific wrapper options
  b.use :error, wrap_with: { tag: "span", class: "error" }

  # Use a set of components by wrapping them in a tag+class.
  b.wrapper tag: "div", class: "another" do |ba|
    ba.use :label
    ba.use :input
  end

  # Use a set of components by wrapping them in a tag+class.
  # This wrapper is identified by :label_input, which means it can
  # be turned off on demand with `f.input :name, label_input: false`
  b.wrapper :label_input, tag: "div", class: "another" do |ba|
    ba.use :label
    ba.use :input
  end
end
```

--------------------------------

### SimpleForm::Wrappers::Root#options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Root

Returns the options associated with the Root wrapper instance.

```APIDOC
## SimpleForm::Wrappers::Root#options

### Description
Returns the options associated with the Root wrapper instance.

### Returns
* `Object`: The value of the options attribute.

### Source Code
```ruby
def options
  @options
end
```
```

--------------------------------

### SimpleForm::Components::HTML5#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/HTML5

Initializes the HTML5 component, setting the @html5 flag to false by default.

```APIDOC
## initialize

### Description
Initializes the HTML5 component. By default, the `@html5` flag is set to `false`.

### Method
`initialize(*)`

### Source
```ruby
def initialize(*)
  @html5 = false
end
```
```

--------------------------------

### Get FormBuilder Template

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Atemplate

Returns the value of the template attribute. This is used internally by SimpleForm to manage template-related data.

```Ruby
def template
  @template
end
```

--------------------------------

### Usage examples for FormBuilder#error

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Aerror

Basic usage of the error method to display validation messages for a form attribute.

```ruby
f.error :name
f.error :name, id: "cool_error"
```

--------------------------------

### Initialize SimpleForm::Wrappers::Root

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Root

Initializes a new instance of Root, setting up default options and merging them with provided arguments. It specifically excludes certain default options like tag, class, error_class, and hint_class.

```ruby
def initialize(*args)
  super(:wrapper, *args)
  @options = @defaults.except(:tag, :class, :error_class, :hint_class)
end
```

--------------------------------

### Get Components in SimpleForm::Wrappers::Many

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Many%3Acomponents

Returns the value of the components attribute. This method is part of the SimpleForm::Wrappers::Many class.

```ruby
def components
  @components
end
```

--------------------------------

### Get html_classes Attribute - Ruby

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base%3Ahtml_classes

This method returns the value of the @html_classes instance variable. It is used to retrieve the HTML classes associated with an input.

```ruby
def html_classes
  @html_classes
end
```

--------------------------------

### Inform User About Framework Support

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Generators/InstallGenerator

Provides guidance to the user if they haven't specified Bootstrap or Foundation, suggesting how to re-run the generator with framework options for better compatibility.

```ruby
def info_bootstrap
  return if options.bootstrap? || options.foundation?
  puts "SimpleForm supports Bootstrap 5 and Zurb Foundation 5. If you want "\
    "a configuration that is compatible with one of these frameworks, then please " \
    "re-run this generator with --bootstrap or --foundation as an option."
end
```

--------------------------------

### Get input_html_options - Ruby

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base%3Ainput_html_options

Retrieves the value of the `input_html_options` attribute. This is typically used internally by Simple Form to access HTML attributes for input elements.

```ruby
def input_html_options
  @input_html_options
end
```

--------------------------------

### use(name, options = {})

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder

Registers a component to be used in the wrapper. If :wrap_with options are provided, it wraps the component; otherwise, it adds it as a leaf component.

```APIDOC
## use(name, options = {})

### Description
Registers a component to be used in the wrapper. If :wrap_with options are provided, it wraps the component; otherwise, it adds it as a leaf component.

### Parameters
- **name** (Symbol) - Required - The name of the component to use.
- **options** (Hash) - Optional - Configuration options for the component, including :wrap_with for custom tag wrapping.
```

--------------------------------

### Use component

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder

Registers a component, optionally wrapping it if the :wrap_with option is provided.

```ruby
# File 'lib/simple_form/wrappers/builder.rb', line 49

def use(name, options = {})
  if options && wrapper = options[:wrap_with]
    @components << Single.new(name, wrapper, options.except(:wrap_with))
  else
    @components << Leaf.new(name, options)
  end
end
```

--------------------------------

### Get Associated Object - SimpleForm::FormBuilder

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Aobject

Returns the value of the associated object. This is typically used internally by SimpleForm to access the model instance for form generation.

```ruby
def object
  @object
end
```

--------------------------------

### SimpleForm::Tags::CollectionCheckBoxes#render

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Tags/CollectionCheckBoxes%3Arender

The `render` method is responsible for rendering the collection of checkboxes. It calls the `super` method to get the default rendering and then wraps the result using `wrap_rendered_collection`.

```APIDOC
## SimpleForm::Tags::CollectionCheckBoxes#render

### Description

Renders the collection of checkboxes. This method calls the parent class's `render` method and then applies a wrapper to the output.

### Method

`render`

### Returns

`Object` - The rendered HTML for the collection of checkboxes, wrapped appropriately.

### Source Code

```ruby
def render
  wrap_rendered_collection(super)
end
```
```

--------------------------------

### Display Bootstrap/Foundation configuration info

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Generators/InstallGenerator%3Ainfo_bootstrap

This method checks if bootstrap or foundation options are set and outputs a message if neither is present.

```ruby
def info_bootstrap
  return if options.bootstrap? || options.foundation?
  puts "SimpleForm supports Bootstrap 5 and Zurb Foundation 5. If you want "\
    "a configuration that is compatible with one of these frameworks, then please " \
    "re-run this generator with --bootstrap or --foundation as an option."
end
```

--------------------------------

### Initialize HTML5 Component

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/HTML5%3Ainitialize

This method initializes the HTML5 component. It sets the internal @html5 flag to false by default, indicating that HTML5 specific inputs are not enabled until configured otherwise.

```ruby
def initialize(*)
  @html5 = false
end
```

--------------------------------

### BlockInput#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/BlockInput

Initializes a new instance of BlockInput. It accepts arguments and a block, storing the block for later use.

```APIDOC
## initialize(*args, &block)

### Description
Returns a new instance of BlockInput.

### Method
initialize

### Parameters
* `args`: Arguments passed to the initializer.
* `block`: A block of code to be executed for the input.

### Returns
A new instance of BlockInput.
```

--------------------------------

### SimpleForm::Wrappers::Single#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Single%3Ainitialize

Initializes a new instance of the Single wrapper. This method takes a name, optional wrapper options, and additional options to configure the wrapper.

```APIDOC
## SimpleForm::Wrappers::Single#initialize

### Description
Returns a new instance of Single.

### Method
initialize(name, wrapper_options = {}, options = {})

### Parameters
- **name** (String) - The name of the wrapper.
- **wrapper_options** (Hash) - Optional. Options for the wrapper.
- **options** (Hash) - Optional. Additional options.

### Request Example
```ruby
SimpleForm::Wrappers::Single.new(:my_wrapper, { class: 'my-class' }, { data: { tooltip: 'some info' } })
```

### Response
- **Single** - A new instance of the Single wrapper.
```

--------------------------------

### input(attribute_name, options = {}, &block)

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Creates a full input wrapper for the given attribute, including labels, hints, and errors based on the configured wrapper.

```APIDOC
## input(attribute_name, options = {}, &block)

### Description
Creates a full input wrapper for the given attribute, including labels, hints, and errors based on the configured wrapper.

### Parameters
- **attribute_name** (Symbol) - Required - The name of the attribute to create the input for.
- **options** (Hash) - Optional - Configuration options for the input, such as :include_blank, :collection, :label_method, :value_method, or :priority.
```

--------------------------------

### Initialize FormBuilder

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Constructor for the FormBuilder class, setting up the object, defaults, and wrapper.

```ruby
def initialize(*) #:nodoc:
  super
  @object   = convert_to_model(@object)
  @defaults = options[:defaults]
  @wrapper  = SimpleForm.wrapper(options[:wrapper] || SimpleForm.default_wrapper)
end
```

--------------------------------

### Initialize Leaf instance

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Leaf

Constructor for creating a new Leaf instance with a namespace and options.

```ruby
# File 'lib/simple_form/wrappers/leaf.rb', line 7

def initialize(namespace, options = {})
  @namespace = namespace
  @options = options
end
```

--------------------------------

### Initialize Builder

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder

Constructor for the Builder class.

```ruby
# File 'lib/simple_form/wrappers/builder.rb', line 44

def initialize(options)
  @options    = options
  @components = []
end
```

--------------------------------

### Build a new SimpleForm wrapper

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.build

Initializes a wrapper with the provided options and yields a builder instance to define the structure.

```ruby
def self.build(options = {})
  options[:tag] = :div if options[:tag].nil?
  builder = SimpleForm::Wrappers::Builder.new(options)
  yield builder
  SimpleForm::Wrappers::Root.new(builder.to_a, options)
end
```

--------------------------------

### Initialize SimpleForm::Wrappers::Leaf

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Leaf%3Ainitialize

Constructor for the Leaf class that stores the namespace and options configuration.

```ruby
def initialize(namespace, options = {})
  @namespace = namespace
  @options = options
end
```

--------------------------------

### Set default options for wrappers

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder

Shows how to pass default options to the wrapper builder, such as disabling a component by default.

```ruby
config.wrappers hint: false do |b|
  b.use :hint
  b.use :label_input
end
```

--------------------------------

### Implementation of simple_fields_for

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/ActionViewExtensions/Builder%3Asimple_fields_for

The source implementation of the simple_fields_for method, showing how it handles options and builder assignment.

```ruby
def simple_fields_for(*args, &block)
  options = args.extract_options!
  options[:wrapper] = self.options[:wrapper] if options[:wrapper].nil?
  options[:defaults] ||= self.options[:defaults]
  options[:wrapper_mappings] ||= self.options[:wrapper_mappings]

  if self.class < ActionView::Helpers::FormBuilder
    options[:builder] ||= self.class
  else
    options[:builder] ||= SimpleForm::FormBuilder
  end
  fields_for(*args, options, &block)
end
```

--------------------------------

### Initialize SimpleForm Input Base

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base%3Ainitialize

Initializes a new input instance by setting up builder, attribute, column, and input options. It also calculates required status and prepares HTML classes for the input element.

```ruby
def initialize(builder, attribute_name, column, input_type, options = {})
  super

  options         = options.dup
  @builder        = builder
  @attribute_name = attribute_name
  @column         = column
  @input_type     = input_type
  @reflection     = options.delete(:reflection)
  @options        = options.reverse_merge!(self.class.default_options)
  @required       = calculate_required

  # Notice that html_options_for receives a reference to input_html_classes.
  # This means that classes added dynamically to input_html_classes will
  # still propagate to input_html_options.
  @html_classes = SimpleForm.additional_classes_for(:input) { additional_classes }

  @input_html_classes = @html_classes.dup

  input_html_classes = self.input_html_classes

  if SimpleForm.input_class && input_html_classes.any?
    input_html_classes << SimpleForm.input_class
  end

  @input_html_options = html_options_for(:input, input_html_classes).tap do |o|
    o[:readonly]  = true if has_readonly?
    o[:disabled]  = true if has_disabled?
    o[:autofocus] = true if has_autofocus?
  end
end
```

--------------------------------

### SimpleForm::Inputs::BlockInput#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/BlockInput%3Ainitialize

Initializes a new instance of BlockInput. It accepts arguments and a block, storing the block for later use.

```APIDOC
## initialize(*args, &block)

### Description
Returns a new instance of BlockInput.

### Method
initialize

### Parameters
* `*args`: Variable number of arguments passed to the initializer.
* `&block`: A block of code to be associated with the input.

### Returns
* `BlockInput`: A new instance of the BlockInput class.
```

--------------------------------

### Find component by name

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Leaf

Returns the current instance if the provided name matches the namespace.

```ruby
# File 'lib/simple_form/wrappers/leaf.rb', line 24

def find(name)
  self if @namespace == name
end
```

--------------------------------

### FormBuilder#hint Method Implementation

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ahint

The source code for the FormBuilder#hint method, demonstrating how it handles attribute names, options, and renders the hint tag.

```ruby
def hint(attribute_name, options = {})
  options = options.dup

  options[:hint_html] = options.except(:hint_tag, :hint)
  if attribute_name.is_a?(String)
    options[:hint] = attribute_name
    attribute_name, column, input_type = nil, nil, nil
  else
    column      = find_attribute_column(attribute_name)
    input_type  = default_input_type(attribute_name, column, options)
  end

  wrapper.find(:hint).
    render(SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options))
end
```

--------------------------------

### Copy SimpleForm configuration files

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Generators/InstallGenerator%3Acopy_config

This method copies the base initializer and conditional framework-specific templates, followed by the locales directory.

```ruby
def copy_config
  template "config/initializers/simple_form.rb"

  if options[:bootstrap]
    template "config/initializers/simple_form_bootstrap.rb"
  elsif options[:foundation]
    template "config/initializers/simple_form_foundation.rb"
  end

  directory 'config/locales'
end
```

--------------------------------

### Initialize SimpleForm::Wrappers::Single

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Single%3Ainitialize

Initializes a new instance of the Single wrapper. It takes a name, optional wrapper options, and other options to configure the component.

```ruby
def initialize(name, wrapper_options = {}, options = {})
  @component = Leaf.new(name, options)

  super(name, [@component], wrapper_options)
end
```

--------------------------------

### Initialize BlockInput with a block

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/BlockInput%3Ainitialize

This method initializes a new BlockInput instance and stores the provided block for later execution. It calls the superclass's initialize method first.

```ruby
def initialize(*args, &block)
  super
  @block = block
end
```

--------------------------------

### Initialize SimpleForm::Wrappers::Builder

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder%3Ainitialize

Initializes a new instance of the Builder class, setting up options and an empty components array.

```ruby
def initialize(options)
  @options    = options
  @components = []
end
```

--------------------------------

### SimpleForm::ErrorNotification#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/ErrorNotification%3Ainitialize

Initializes a new instance of ErrorNotification with a builder and options.

```APIDOC
## SimpleForm::ErrorNotification#initialize

### Description
Initializes a new instance of ErrorNotification.

### Method
initialize(builder, options)

### Parameters
- **builder**: The form builder instance.
- **options**: A hash of options. `:message` can be deleted from here.

### Request Example
```ruby
ErrorNotification.new(builder, { message: 'Error occurred', other_option: 'value' })
```

### Response
Returns a new instance of `ErrorNotification`.
```

--------------------------------

### Render Single Wrapper

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Single

Renders the single component if the namespace option is not set to false.

```ruby
def render(input)
  options = input.options
  if options[namespace] != false
    content = @component.render(input)
    wrap(input, options, content) if content
  end
end
```

--------------------------------

### Retrieve priority configuration

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/PriorityInput%3Ainput_priority

Fetches the priority setting from the options hash or defaults to the global configuration based on the input type.

```ruby
def input_priority
  options[:priority] || SimpleForm.send(:"#{input_type}_priority")
end
```

--------------------------------

### Hint Component Implementation

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/Hints%3Ahint

This method generates the HTML for a hint. It prioritizes string hints provided in options, otherwise it attempts to translate a hint from the namespace. Use this when you need to customize hint generation or integrate custom translation logic.

```ruby
def hint(wrapper_options = nil)
  @hint ||= begin
    hint = options[:hint]

    if hint.is_a?(String)
      html_escape(hint)
    else
      content = translate_from_namespace(:hints)
      content.html_safe if content
    end
  end
end
```

--------------------------------

### Create Hint Tag with Direct String

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ahint

Use this to create a hint tag by providing the hint text directly as a string. This bypasses I18n lookup.

```ruby
f.hint "Don't forget to accept this"
```

--------------------------------

### Configuration Methods

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base

Class methods to enable or disable specific input options.

```ruby
# File 'lib/simple_form/inputs/base.rb', line 42

def self.disable(*keys)
  options = self.default_options.dup
  keys.each { |key| options[key] = false }
  self.default_options = options
end
```

```ruby
# File 'lib/simple_form/inputs/base.rb', line 36

def self.enable(*keys)
  options = self.default_options.dup
  keys.each { |key| options.delete(key) }
  self.default_options = options
end
```

--------------------------------

### SimpleForm::FormBuilder#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ainitialize

Initializes a new FormBuilder instance. It converts the object to a model, sets default options, and configures the wrapper based on provided options or the SimpleForm default.

```APIDOC
## SimpleForm::FormBuilder#initialize

### Description
Initializes a new FormBuilder instance. It converts the object to a model, sets default options, and configures the wrapper based on provided options or the SimpleForm default.

### Method
`initialize(*)`

### Parameters
This method accepts a variable number of arguments (`*`). Specific parameters are processed internally:
- `@object`: Converted to a model using `convert_to_model`.
- `options[:defaults]`: Used to set the `@defaults` instance variable.
- `options[:wrapper]` or `SimpleForm.default_wrapper`: Used to configure the `@wrapper` instance variable.

### Source Code
```ruby
def initialize(*)
  super
  @object   = convert_to_model(@object)
  @defaults = options[:defaults]
  @wrapper  = SimpleForm.wrapper(options[:wrapper] || SimpleForm.default_wrapper)
end
```
```

--------------------------------

### Retrieve a wrapper

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm

Fetches a specific wrapper by name or raises a WrapperNotFound error.

```ruby
# File 'lib/simple_form.rb', line 221

def self.wrapper(name)
  @@wrappers[name.to_s] or raise WrapperNotFound, "Couldn't find wrapper with name #{name}"
end
```

--------------------------------

### Define placeholder_text method

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/Placeholders

Retrieves the placeholder text from options or translates it from the namespace.

```ruby
def placeholder_text(wrapper_options = nil)
  placeholder = options[:placeholder]
  placeholder.is_a?(String) ? placeholder : translate_from_namespace(:placeholders)
end
```

--------------------------------

### Configure validation classes

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ainput_field

Setting up validation classes in the SimpleForm initializer to be applied to input fields.

```ruby
# config/initializers/simple_form.rb
SimpleForm.setup do |config|
config.input_field_valid_class = 'is-valid'
config.input_field_error_class = 'is-invalid'
end

simple_form_for @user do |f|
f.input_field :name
end
```

--------------------------------

### Define a Wrapper Component with `use`

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder%3Ause

Use this method to register a new wrapper component. If `wrap_with` is provided in options, it defines a nested wrapper; otherwise, it registers a leaf wrapper.

```ruby
def use(name, options = {})
  if options && wrapper = options[:wrap_with]
    @components << Single.new(name, wrapper, options.except(:wrap_with))
  else
    @components << Leaf.new(name, options)
  end
end
```

--------------------------------

### Initialize SimpleForm::Wrappers::Many

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Many%3Ainitialize

Initializes the wrapper with a namespace, components, and optional defaults. It ensures a default tag of :div is set if not provided and converts the class option into an array.

```ruby
def initialize(namespace, components, defaults = {})
  @namespace  = namespace
  @components = components
  @defaults   = defaults
  @defaults[:tag]   = :div unless @defaults.key?(:tag)
  @defaults[:class] = Array(@defaults[:class])
end
```

--------------------------------

### Render Input with Block

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/BlockInput

Renders the custom input using the block provided during initialization. The block is executed within the template's capture context.

```ruby
def input(wrapper_options = nil)
  template.capture(&@block)
end
```

--------------------------------

### Initialize Single Wrapper

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Single

Constructor for the Single wrapper class, which initializes a single Leaf component.

```ruby
def initialize(name, wrapper_options = {}, options = {})
  @component = Leaf.new(name, options)

  super(name, [@component], wrapper_options)
end
```

--------------------------------

### Including custom components

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm

Registers custom components for use within Simple Form wrappers. Requires loading component files and defining them as modules.

```ruby
# The application needs to tell where the components will be.
Dir[Rails.root.join('lib/components/**/*.rb')].each { |f| require f }

# Create a custom component in the path specified above.
# lib/components/input_group_component.rb
module InputGroupComponent
 def prepend
   ...
 end

 def append
   ...
 end
end

SimpleForm.setup do |config|
 # Create a wrapper using the custom component.
 config.wrappers :input_group, tag: :div, error_class: :error do |b|
   b.use :label
   b.optional :prepend
   b.use :input
   b.use :append
 end
end
```

--------------------------------

### .eager_load!

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm

Eager loads SimpleForm components and inputs.

```APIDOC
## .eager_load!

### Description
Triggers eager loading for SimpleForm::Inputs and SimpleForm::Components.
```

--------------------------------

### SimpleForm::Wrappers::Builder#use

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder%3Ause

Registers a new wrapper component. It can be a `Leaf` component or a `Single` component that wraps another component.

```APIDOC
## SimpleForm::Wrappers::Builder#use

### Description
Registers a new wrapper component. It can be a `Leaf` component or a `Single` component that wraps another component.

### Method
`use(name, options = {})`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```ruby
builder.use(:my_wrapper, wrap_with: :div)
builder.use(:another_wrapper)
```

### Response
#### Success Response (200)
Returns the `Object` that was added to the components list.

#### Response Example
```ruby
# Returns the added component instance
```
```

--------------------------------

### SimpleForm::FormBuilder#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ainitialize

Initializes the FormBuilder instance. It converts the object to a model, sets default options, and configures the wrapper based on provided options or the default wrapper.

```ruby
def initialize(*)
  super
  @object   = convert_to_model(@object)
  @defaults = options[:defaults]
  @wrapper  = SimpleForm.wrapper(options[:wrapper] || SimpleForm.default_wrapper)
end
```

--------------------------------

### Render Label and Input with LabelInput

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/LabelInput

This method renders the label and input components. If the `label` option is explicitly set to false, only the input is rendered. Otherwise, both the label and input are rendered.

```ruby
def label_input(wrapper_options = nil)
  if options[:label] == false
    deprecated_component(:input, wrapper_options)
  else
    deprecated_component(:label, wrapper_options) + deprecated_component(:input, wrapper_options)
  end
end
```

--------------------------------

### input

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/CollectionRadioButtonsInput

Renders the collection of radio buttons.

```APIDOC
## input(wrapper_options = nil)

### Description
Renders the collection of radio buttons.

### Method
This is an instance method of the `SimpleForm::Inputs::CollectionRadioButtonsInput` class.

### Parameters
* `wrapper_options` (Object) - Optional - Options for the wrapper.

### Returns
* Object - The rendered radio button group.
```

--------------------------------

### Retrieve a wrapper by name

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.wrapper

Use this method to access a registered wrapper configuration. It requires the name of the wrapper as a string or symbol.

```ruby
def self.wrapper(name)
  @@wrappers[name.to_s] or raise WrapperNotFound, "Couldn't find wrapper with name #{name}"
end
```

--------------------------------

### SimpleForm.wrappers(*args, &block)

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.wrappers

Defines a new wrapper using SimpleForm::Wrappers::Builder and stores it by name, or returns the collection of all wrappers if no block is provided.

```APIDOC
## SimpleForm.wrappers(*args, &block)

### Description
Define a new wrapper using SimpleForm::Wrappers::Builder and store it in the given name, or retrieve all defined wrappers.

### Parameters
- **args** (Array) - Optional - The name of the wrapper (defaults to :default) and options for the builder.
- **block** (Proc) - Optional - A block used to build the wrapper configuration.

### Returns
- **Object** - Returns the stored wrapper collection or the result of the build process.
```

--------------------------------

### hint(attribute_name, options = {})

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Creates a hint tag for the given attribute.

```APIDOC
## hint(attribute_name, options = {})

### Description
Creates a hint tag for the given attribute. It accepts a symbol for I18n lookup or a string. Options are passed as :hint_html.

### Parameters
- **attribute_name** (Symbol) - Required - The attribute name for the hint.
- **options** (Hash) - Optional - Options passed as :hint_html.
```

--------------------------------

### Retrieve and process collection input options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/CollectionInput%3Ainput_options

This method merges superclass options, sets the include_blank default, and translates prompt and include_blank options.

```ruby
def input_options
  options = super

  options[:include_blank] = true unless skip_include_blank?
  translate_option options, :prompt
  translate_option options, :include_blank

  options
end
```

--------------------------------

### SimpleForm.file_methods=

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.file_methods%3D

Sets the file methods configuration for the SimpleForm library. Note that this method triggers a deprecation warning.

```APIDOC
## SimpleForm.file_methods=

### Description
Sets the file methods configuration for SimpleForm. This method is deprecated and will trigger a warning when called.

### Method
Ruby Class Method

### Signature
SimpleForm.file_methods=(file_methods)

### Parameters
- **file_methods** (Object) - Required - The configuration object or value to set for file methods.
```

--------------------------------

### Input configuration options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ainput

Defines input type and requirement status using the 'as' and 'required' options.

```ruby
as: allows you to define the input type you want, for instance you
     can use it to generate a text field for a date column.

required: defines whether this attribute is required or not. True
          by default.
```

--------------------------------

### FileInput Input Method

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/FileInput

The `input` method is the primary method for rendering a file input field. It merges wrapper options with input HTML options and uses the builder to create a file field.

```APIDOC
## input(wrapper_options = nil)

### Description
Renders a file input field, merging provided wrapper options with the input's HTML options.

### Method
`input`

### Parameters
- **wrapper_options** (Hash) - Optional - Options to be merged with the input HTML options.

### Request Example
```ruby
# Assuming 'f' is a FormBuilder instance and 'attribute_name' is the attribute for the file input
f.input :file_upload, wrapper_options: { class: 'my-custom-wrapper' }
```

### Response
- **Object** - The rendered HTML for the file input field.
```

--------------------------------

### Define a Custom Wrapper with a Block

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder%3Awrapper

Use this method to define a custom wrapper component. A block is required, which receives a builder instance to define the wrapper's structure. If no tag is specified, it defaults to `div`.

```ruby
def wrapper(name, options = nil)
  if block_given?
    name, options = nil, name if name.is_a?(Hash)
    builder = self.class.new(@options)
    options ||= {}
    options[:tag] = :div if options[:tag].nil?
    yield builder
    @components << Many.new(name, builder.to_a, options)
  else
    raise ArgumentError, "A block is required as argument to wrapper"
  end
end
```

--------------------------------

### Define ACTIONS constant

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Maps create and update actions to new and edit respectively.

```ruby
{
  'create' => 'new',
  'update' => 'edit'
}
```

--------------------------------

### Create Hint Tag with I18n Lookup

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ahint

Use this to create a hint tag for an attribute by performing an I18n lookup. The attribute name is passed as a symbol.

```ruby
f.hint :name # Do I18n lookup
```

--------------------------------

### Render input component

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Leaf%3Arender

Executes the input method associated with the namespace, handling options based on the method's arity.

```ruby
def render(input)
  method = input.method(@namespace)

  if method.arity.zero?
    SimpleForm.deprecator.warn(SimpleForm::CUSTOM_INPUT_DEPRECATION_WARN % { name: @namespace })

    method.call
  else
    method.call(@options)
  end
end
```

--------------------------------

### Define or retrieve wrappers

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm

Defines a new wrapper using a builder block or returns the current collection of wrappers.

```ruby
# File 'lib/simple_form.rb', line 231

def self.wrappers(*args, &block)
  if block_given?
    options                 = args.extract_options!
    name                    = args.first || :default
    @@wrappers[name.to_s]   = build(options, &block)
  else
    @@wrappers
  end
end
```

--------------------------------

### Implement minlength component method

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/Minlength

This method sets the minlength attribute in input_html_options by retrieving the minimum length from model validations.

```ruby
def minlength(wrapper_options = nil)
  input_html_options[:minlength] ||= minimum_length_from_validation
  nil
end
```

--------------------------------

### button(type, *args, &block)

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Creates a button element within the form, proxying to the specified button type method.

```APIDOC
## button(type, *args, &block)

### Description
Creates a button in the form. It acts as a proxy to the method name provided (e.g., :submit). It also applies the default SimpleForm button class.

### Parameters
- **type** (Symbol) - Required - The type of button to create (e.g., :submit).
- **args** (Array) - Optional - Additional arguments passed to the button method.
- **block** (Proc) - Optional - A block to be passed to the underlying button method.
```

--------------------------------

### Render method implementation in SimpleForm::Wrappers::Root

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Root%3Arender

This method updates the input options with default values and proceeds with the rendering process.

```ruby
def render(input)
  input.options.reverse_merge!(@options)
  super
end
```

--------------------------------

### Find a wrapper by name

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Root%3Afind

Retrieves a wrapper by name, returning a default Many wrapper with a Leaf if the specified name is not found.

```ruby
def find(name)
  super || SimpleForm::Wrappers::Many.new(name, [Leaf.new(name)])
end
```

--------------------------------

### wrapper(name, options = nil, &block)

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Builder

Defines a group of components wrapped in a specific tag and class.

```APIDOC
## wrapper(name, options = nil, &block)

### Description
Defines a group of components wrapped in a specific tag and class. A block is required to define the components inside the wrapper.

### Parameters
- **name** (Symbol) - Optional - An identifier for the wrapper.
- **options** (Hash) - Optional - Configuration options including :tag and :class.
- **block** (Proc) - Required - A block containing the components to be wrapped.
```

--------------------------------

### SimpleForm.wrapper(name)

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.wrapper

Retrieves a given wrapper by its name. Raises a WrapperNotFound error if the wrapper does not exist.

```APIDOC
## SimpleForm.wrapper(name)

### Description
Retrieves a specific wrapper configuration by its name. This method looks up the wrapper in the internal registry and returns it, or raises a `WrapperNotFound` error if the name is not found.

### Method
`SimpleForm.wrapper(name)`

### Parameters
- **name** (String/Symbol) - Required - The name of the wrapper to retrieve.

### Returns
- **Object** - The requested wrapper object.

### Exceptions
- **WrapperNotFound** - Raised if no wrapper is found with the provided name.
```

--------------------------------

### SimpleForm::Wrappers::Root#render

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Root

Renders the wrapper, merging its options with the input's options before calling the superclass's render method.

```APIDOC
## SimpleForm::Wrappers::Root#render

### Description
Renders the wrapper, merging its options with the input's options before calling the superclass's render method.

### Parameters
* `input`: The input object to render.

### Returns
* `Object`: The result of the rendering process.

### Source Code
```ruby
def render(input)
  input.options.reverse_merge!(@options)
  super
end
```
```

--------------------------------

### SimpleForm::Inputs::Base#input_options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/Base%3Ainput_options

Returns the options for the input. This method is defined in lib/simple_form/inputs/base.rb.

```APIDOC
## SimpleForm::Inputs::Base#input_options

### Description
Returns the options for the input.

### Method
`input_options`

### Returns
`Object` - The options for the input.

### Source
`lib/simple_form/inputs/base.rb`
```

--------------------------------

### SimpleForm.build(options = {})

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.build

Builds a new wrapper using SimpleForm::Wrappers::Builder. This method yields a builder object to the provided block to configure the wrapper.

```APIDOC
## SimpleForm.build(options = {})

### Description
Builds a new wrapper using SimpleForm::Wrappers::Builder. Yields a builder instance to the block for configuration.

### Parameters
- **options** (Hash) - Optional - Configuration options for the wrapper. Defaults :tag to :div if not provided.

### Yields
- **builder** (SimpleForm::Wrappers::Builder) - The builder instance used to define the wrapper structure.

### Returns
- **Object** - A new instance of SimpleForm::Wrappers::Root.
```

--------------------------------

### Render components in SimpleForm::Wrappers::Many

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Wrappers/Many%3Arender

This method iterates over components, checks if they should be rendered based on input options, and wraps the final output.

```ruby
def render(input)
  content = "".html_safe
  options = input.options

  components.each do |component|
    next if options[component.namespace] == false
    rendered = component.render(input)
    content.safe_concat rendered.to_s if rendered
  end

  wrap(input, options, content)
end
```

--------------------------------

### simple_form_for(record, options = {}, &block)

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/ActionViewExtensions/FormHelper

Creates a form for the given record using the SimpleForm::FormBuilder. It automatically configures the form builder and applies default CSS classes and validation settings.

```APIDOC
## simple_form_for(record, options = {}, &block)

### Description
Creates a form for the given record using the SimpleForm::FormBuilder. It automatically configures the form builder and applies default CSS classes and validation settings.

### Parameters
- **record** (Object) - Required - The record object or name for the form.
- **options** (Hash) - Optional - Configuration options for the form.
- **block** (Proc) - Required - The block containing the form fields.
```

--------------------------------

### SimpleForm::Components::HTML5#initialize

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/HTML5%3Ainitialize

Initializes the HTML5 component, setting the internal @html5 flag to false by default. This method is part of the internal workings of SimpleForm for managing HTML5 specific features.

```APIDOC
## initialize

### Description
Initializes the HTML5 component, setting the internal `@html5` flag to `false`.

### Method
`initialize(*)`

### Returns
`Object`

### Source Code
```ruby
def initialize(*)
  @html5 = false
end
```
```

--------------------------------

### SimpleForm::FormBuilder#hint

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder%3Ahint

Creates a hint tag for the given attribute. Accepts a symbol indicating an attribute for I18n lookup or a string. All the given options are sent as :hint_html.

```APIDOC
## SimpleForm::FormBuilder#hint

### Description
Creates a hint tag for the given attribute. Accepts a symbol indicating an attribute for I18n lookup or a string. All the given options are sent as :hint_html.

### Method
Object

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```ruby
f.hint :name # Do I18n lookup
f.hint :name, id: "cool_hint"
f.hint "Don't forget to accept this"
```

### Response
#### Success Response (200)
- **hint_tag** (Object) - The generated hint tag.

#### Response Example
```json
{
  "hint_tag": "<span class=\"hint\">Your hint text here</span>"
}
```
```

--------------------------------

### Define collection radio options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/FormBuilder

Configuration options for customizing the wrapper tags and classes for radio collections.

```text
* checked  => the value that should be checked initially.

* disabled => the value or values that should be disabled. Accepts a single
            item or an array of items.

* collection_wrapper_tag   => the tag to wrap the entire collection.

* collection_wrapper_class => the CSS class to use for collection_wrapper_tag

* item_wrapper_tag         => the tag to wrap each item in the collection.

* item_wrapper_class       => the CSS class to use for item_wrapper_tag

* a block                  => to generate the label + radio or any other component.
```

--------------------------------

### Implementation of include_component

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm.include_component

The internal implementation of the include_component method in lib/simple_form.rb.

```ruby
def self.include_component(component)
  if Module === component
    SimpleForm::Inputs::Base.include(component)
  else
    raise TypeError, "SimpleForm.include_component expects a module but got: #{component.class}"
  end
end
```

--------------------------------

### input_options

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/CollectionRadioButtonsInput

Retrieves and applies default collection options to the input options. This method is crucial for setting up default behaviors for collection inputs.

```APIDOC
## input_options

### Description
Retrieves and applies default collection options to the input options. This method is crucial for setting up default behaviors for collection inputs.

### Method
```ruby
def input_options
  options = super
  apply_default_collection_options!(options)
  options
end
```
```

--------------------------------

### Implement RichTextAreaInput#input

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Inputs/RichTextAreaInput%3Ainput

Renders a rich text area input by merging wrapper options and calling the builder's rich_text_area method.

```ruby
def input(wrapper_options = nil)
  merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)

  @builder.rich_text_area(attribute_name, merged_input_options)
end
```

--------------------------------

### Define placeholder method

Source: https://www.rubydoc.info/gems/simple_form/SimpleForm/Components/Placeholders

Sets the placeholder attribute in input_html_options if not already present.

```ruby
def placeholder(wrapper_options = nil)
  input_html_options[:placeholder] ||= placeholder_text
  nil
end
```
Tokens:
Raw