simple_form 2.0.0 → 2.1.0

data/README.md

@@ -1,49 +1,48 @@
 # SimpleForm - Rails forms made easy.
-[![Build Status](https://secure.travis-ci.org/plataformatec/simple_form.png)](http://travis-ci.org/plataformatec/simple_form)
+[![Build Status](https://secure.travis-ci.org/plataformatec/simple_form.png?branch=master)](http://travis-ci.org/plataformatec/simple_form)
 
 **SimpleForm** aims to be as flexible as possible while helping you with powerful components to create
 your forms. The basic goal of SimpleForm is to not touch your way of defining the layout, letting
 you find the better design for your eyes. Most of the DSL was inherited from Formtastic,
 which we are thankful for and should make you feel right at home.
 
-INFO: This README is [also available in a friendly navigable format](http://simple-form.plataformatec.com.br/)
-and refers to **SimpleForm** 2.0. If you are using **SimpleForm** in the versions 1.x, you should
-check this branch:
-
-https://github.com/plataformatec/simple_form/tree/v1.5
+INFO: This README refers to **SimpleForm** 2.1. For older releases, check the related branch for your version.
 
 ## Installation
 
 Add it to your Gemfile:
 
-`gem 'simple_form'`
+```ruby
+gem 'simple_form'
+```
 
 Run the following command to install it:
 
-`bundle install`
+```console
+bundle install
+```
 
 Run the generator:
 
-`rails generate simple_form:install`
+```console
+rails generate simple_form:install
+```
 
 Also, if you want to use the country select, you will need the
 [country_select gem](https://rubygems.org/gems/country_select), add it to your Gemfile:
 
-`gem 'country_select'`
-
-## Configuration
-
-**SimpleForm** has several configuration options. You can read and change them in the initializer
-created by **SimpleForm**, so if you haven't executed the command below yet, please do:
-
-`rails generate simple_form:install`
+```ruby
+gem 'country_select'
+```
 
 ### Twitter Bootstrap
 
 **SimpleForm** 2.0 can be easily integrated to the [Twitter Bootstrap](http://twitter.github.com/bootstrap).
 To do that you have to use the `bootstrap` option in the install generator, like this:
 
-`rails generate simple_form:install --bootstrap`
+```console
+rails generate simple_form:install --bootstrap
+```
 
 You have to be sure that you added a copy of the [Twitter Bootstrap](http://twitter.github.com/bootstrap)
 assets on your application.
@@ -54,116 +53,17 @@ For more information see the generator output, our
 
 **NOTE**: **SimpleForm** integration requires Twitter Bootstrap version 2.0 or higher.
 
-### The wrappers API
-
-With **SimpleForm** you can configure how your components will be rendered using the wrappers API.
-The syntax looks like this:
+### Zurb Foundation 3
 
-```ruby
-config.wrappers :tag => :div, :class => :input,
-                :error_class => :field_with_errors do |b|
-
-  # Form extensions
-  b.use :html5
-  b.optional :pattern
-  b.use :maxlength
-  b.use :placeholder
-  b.use :readonly
+To generate wrappers that are compatible with [Zurb Foundation 3](http://foundation.zurb.com/), pass the `foundation` option to the generator, like this:
 
-  # Form components
-  b.use :label_input
-  b.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
-  b.use :error, :wrap_with => { :tag => :span, :class => :error }
-end
+```console
+rails generate simple_form:install --foundation
 ```
 
-The _Form components_ will generate the form tags like labels, inputs, hints or errors contents.
+Please note that the Foundation wrapper does not support the `:hint` option by default. In order to enable hints, please uncomment the appropriate line in `config/initializers/simple_form_foundation.rb`. You will need to provide your own CSS styles for hints.
 
-The _Form extensions_ are used to generate some attributes or perform some lookups on the model to
-add extra information to your components.
-
-You can create new _Form components_ using the wrappers API as in the following example:
-
-```ruby
-config.wrappers do |b|
-  b.use :placeholder
-  b.use :label_input
-  b.wrapper :tag => :div, :class => 'separator' do |component|
-    component.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
-    component.use :error, :wrap_with => { :tag => :span, :class => :error }
-  end
-end
-```
-
-this will wrap the hint and error components within a `div` tag using the class `'separator'`.
-
-If you want to customize the custom _Form components_ on demand you can give it a name like this:
-
-```ruby
-config.wrappers do |b|
-  b.use :placeholder
-  b.use :label_input
-  b.wrapper :my_wrapper, :tag => :div, :class => 'separator' do |component|
-    component.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
-    component.use :error, :wrap_with => { :tag => :span, :class => :error }
-  end
-end
-```
-
-and now you can pass options to your `input` calls to customize the `:my_wrapper` _Form component_.
-
-```ruby
-# Completely turns off the custom wrapper
-f.input :name, :my_wrapper => false
-
-# Configure the html
-f.input :name, :my_wrapper_html => { :id => 'special_id' }
-
-# Configure the tag
-f.input :name, :my_wrapper_tag => :p
-```
-
-You can also define more than one wrapper and pick one to render in a specific form or input.
-To define another wrapper you have to give it a name, as the follow:
-
-```ruby
-config.wrappers :small do |b|
-  b.use :placeholder
-  b.use :label_input
-end
-```
-
-and use it in this way:
-
-```ruby
-# Specifying to whole form
-simple_form_for @user, :wrapper => :small do |f|
-  f.input :name
-end
-
-# Specifying to one input
-simple_form_for @user do |f|
-  f.input :name, :wrapper => :small
-end
-```
-
-**SimpleForm** also allows you to use optional elements. For instance, let's suppose you want to use
-hints or placeholders, but you don't want them to be generated automatically. You can set their
-default values to `false` or use the `optional` method. Is preferible to use the `optional` syntax:
-
-```ruby
-config.wrappers :placeholder => false do |b|
-  b.use :placeholder
-  b.use :label_input
-  b.wrapper :tag => :div, :class => 'separator' do |component|
-    component.optional :hint, :wrap_with => { :tag => :span, :class => :hint }
-    component.use :error, :wrap_with => { :tag => :span, :class => :error }
-  end
-end
-```
-
-By setting it as `optional`, a hint will only be generated when `:hint => true` is explicitly used.
-The same for placehold.
+Please see the [instructions on how to install Foundation in a Rails app](http://foundation.zurb.com/docs/rails.php).
 
 ## Usage
 
@@ -171,7 +71,7 @@ The same for placehold.
 are invoked to create a complete html input for you, which by default contains label, hints, errors
 and the input itself. It does not aim to create a lot of different logic from the default Rails
 form helpers, as they do a great work by themselves. Instead, **SimpleForm** acts as a DSL and just
-maps your input type (retrieved from the column definition in the database) to an specific helper method.
+maps your input type (retrieved from the column definition in the database) to a specific helper method.
 
 To start using **SimpleForm** you just have to use the helper it provides:
 
@@ -187,13 +87,14 @@ This will generate an entire form with labels for user name and password as well
 by default when you render the form with invalid data (after submitting for example).
 
 You can overwrite the default label by passing it to the input method. You can also add a hint or
-even a placeholder:
+even a placeholder. For boolean inputs, you can add an inline label as well:
 
 ```erb
 <%= simple_form_for @user do |f| %>
   <%= f.input :username, :label => 'Your username please' %>
   <%= f.input :password, :hint => 'No special characters.' %>
   <%= f.input :email, :placeholder => 'user@domain.com' %>
+  <%= f.input :remember_me, :inline_label => 'Yes, remember me' %>
   <%= f.button :submit %>
 <% end %>
 ```
@@ -247,8 +148,11 @@ any html attribute to that wrapper as well using the `:wrapper_html` option, lik
 <% end %>
 ```
 
-By default all inputs are required, which means an * is prepended to the label, but you can disable
-it in any input you want:
+Required fields are marked with an * prepended to their labels.
+
+By default all inputs are required. When the form object has `presence` validations attached to its fields, **SimpleForm** tells required and optional fields apart. For performance reasons, this detection is skipped on validations that make use of conditional options, such as `:if` and `:unless`.
+
+And of course, the `required` property of any input can be overwritten as needed:
 
 ```erb
 <%= simple_form_for @user do |f| %>
@@ -383,26 +287,7 @@ drop down then you may use the `:collection` option:
 f.input :shipping_country, :priority => [ "Brazil" ], :collection => [ "Australia", "Brazil", "New Zealand"]
 ```
 
-### Wrapper
-
-**SimpleForm** allows you to add a wrapper which contains the label, error, hint and input.
-The first step is to configure a wrapper tag:
-
-```ruby
-SimpleForm.wrapper_tag = :p
-```
-
-And now, you no longer need to wrap your `f.input` calls anymore:
-
-```erb
-<%= simple_form_for @user do |f| %>
-  <%= f.input :username %>
-  <%= f.input :password %>
-  <%= f.button :submit %>
-<% end %>
-```
-
-## Associations
+### Associations
 
 To deal with associations, **SimpleForm** can generate select inputs, a series of radios buttons or check boxes.
 Lets see how it works: imagine you have a user model that belongs to a company and has_and_belongs_to_many
@@ -451,7 +336,13 @@ the collection by hand, all together with the prompt:
 f.association :company, :collection => Company.active.all(:order => 'name'), :prompt => "Choose a Company"
 ```
 
-## Buttons
+In case you want to declare different labels and values:
+
+```ruby
+f.association :company, :label_method => :company_name, :value_method => :id, :include_blank => false
+```
+
+### Buttons
 
 All web forms need buttons, right? **SimpleForm** wraps them in the DSL, acting like a proxy:
 
@@ -464,7 +355,7 @@ All web forms need buttons, right? **SimpleForm** wraps them in the DSL, acting
 
 The above will simply call submit. You choose to use it or not, it's just a question of taste.
 
-## Wrapping Rails Form Helpers
+### Wrapping Rails Form Helpers
 
 Say you wanted to use a rails form helper but still wrap it in **SimpleForm** goodness? You can, by
 calling input with a block like so:
@@ -478,14 +369,15 @@ calling input with a block like so:
 In the above example, we're taking advantage of Rails 3's select method that allows us to pass in a
 hash of additional attributes for each option.
 
-## Extra helpers
+### Extra helpers
 
 **SimpleForm** also comes with some extra helpers you can use inside rails default forms without relying
 on `simple_form_for` helper. They are listed below.
 
-### Simple Fields For
+#### Simple Fields For
 
-Wrapper to use SimpleForm inside a default rails form
+Wrapper to use **SimpleForm** inside a default rails form. It works in the same way that the `field_for`
+Rails helper, but change the builder to use the `SimpleForm::FormBuilder`.
 
 ```ruby
 form_for @user do |f|
@@ -496,7 +388,8 @@ form_for @user do |f|
 end
 ```
 
-### Collection Radio Buttons
+
+#### Collection Radio Buttons
 
 Creates a collection of radio inputs with labels associated (same API as `collection_select`):
 
@@ -513,7 +406,7 @@ end
 <label class="collection_radio_buttons" for="user_options_false">No</label>
 ```
 
-### Collection Check Boxes
+#### Collection Check Boxes
 
 Creates a collection of check boxes with labels associated (same API as `collection_select`):
 
@@ -544,7 +437,7 @@ end
 
 **SimpleForm** comes with a lot of default mappings:
 
-```
+```text
 Mapping               Input                         Column Type
 
 boolean               check box                     boolean
@@ -598,7 +491,18 @@ instance, if you want to wrap date/time/datetime in a div, you can do:
 # app/inputs/date_time_input.rb
 class DateTimeInput < SimpleForm::Inputs::DateTimeInput
   def input
-    "<div>#{super}</div>".html_safe
+    template.content_tag(:div, super)
+  end
+end
+```
+
+Or if you want to add a class to all the select fields you can do:
+
+```ruby
+# app/inputs/collection_select_input.rb
+class CollectionSelectInput < SimpleForm::Inputs::CollectionSelectInput
+  def input_html_classes
+    super.push('chosen')
   end
 end
 ```
@@ -691,7 +595,7 @@ en:
 ```
 
 **SimpleForm** will always look for a default attribute translation under the "defaults" key if no
-specific is found inside the model key.Note that this syntax is different from 1.x. To migrate to
+specific is found inside the model key. Note that this syntax is different from 1.x. To migrate to
 the new syntax, just move "labels.#{attribute}" to "labels.defaults.#{attribute}".
 
 In addition, **SimpleForm** will fallback to default human_attribute_name from Rails when no other
@@ -716,7 +620,7 @@ en:
       user:
         gender:
           male: 'Male'
-          female: "Female'
+          female: 'Female'
 ```
 
 You can also use the `defaults` key as you would do with labels, hints and placeholders. It is
@@ -738,6 +642,163 @@ There are other options that can be configured through I18n API, such as require
 Be sure to check our locale file or the one copied to your application after you run
 `rails generate simple_form:install`.
 
+It should be noted that translations for labels, hints and placeholders for a namespaced model, e.g.
+`Admin::User`, should be placed under `admin_user`, not under `admin/user`. This is different from
+how translations for namespaced model and attribute names are defined:
+
+```yaml
+en:
+  activerecord:
+    models:
+        admin/user: User
+    attributes:
+        admin/user:
+            name: Name
+```
+
+They should be placed under `admin/user`. Form labels, hints and placeholders for those attributes,
+though, should be placed under `admin_user`:
+
+```yaml
+en:
+  simple_form:
+    labels:
+        admin_user:
+            name: Name
+```
+
+This difference exists because **SimpleForm** relies on `object_name` provided by Rails'
+FormBuilder to determine the translation path for a given object instead of `i18n_key` from the
+object itself. Thus, similarly, if a form for an `Admin::User` object is defined by calling
+`simple_form_for @admin_user, :as => :some_user`, **SimpleForm** will look for translations
+under `some_user` instead of `admin_user`.
+
+## Configuration
+
+**SimpleForm** has several configuration options. You can read and change them in the initializer
+created by **SimpleForm**, so if you haven't executed the command below yet, please do:
+
+`rails generate simple_form:install`
+
+### The wrappers API
+
+With **SimpleForm** you can configure how your components will be rendered using the wrappers API.
+The syntax looks like this:
+
+```ruby
+config.wrappers :tag => :div, :class => :input,
+                :error_class => :field_with_errors do |b|
+
+  # Form extensions
+  b.use :html5
+  b.optional :pattern
+  b.use :maxlength
+  b.use :placeholder
+  b.use :readonly
+
+  # Form components
+  b.use :label_input
+  b.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
+  b.use :error, :wrap_with => { :tag => :span, :class => :error }
+end
+```
+
+The _Form components_ will generate the form tags like labels, inputs, hints or errors contents. The available components are:
+
+```ruby
+:label         # The <label> tag alone
+:input         # The <input> tag alone
+:label_input   # The <label> and the <input> tags
+:hint          # The hint for the input
+:error         # The error for the input
+```
+
+The _Form extensions_ are used to generate some attributes or perform some lookups on the model to
+add extra information to your components.
+
+You can create new _Form components_ using the wrappers API as in the following example:
+
+```ruby
+config.wrappers do |b|
+  b.use :placeholder
+  b.use :label_input
+  b.wrapper :tag => :div, :class => 'separator' do |component|
+    component.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
+    component.use :error, :wrap_with => { :tag => :span, :class => :error }
+  end
+end
+```
+
+this will wrap the hint and error components within a `div` tag using the class `'separator'`.
+
+If you want to customize the custom _Form components_ on demand you can give it a name like this:
+
+```ruby
+config.wrappers do |b|
+  b.use :placeholder
+  b.use :label_input
+  b.wrapper :my_wrapper, :tag => :div, :class => 'separator' do |component|
+    component.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
+    component.use :error, :wrap_with => { :tag => :span, :class => :error }
+  end
+end
+```
+
+and now you can pass options to your `input` calls to customize the `:my_wrapper` _Form component_.
+
+```ruby
+# Completely turns off the custom wrapper
+f.input :name, :my_wrapper => false
+
+# Configure the html
+f.input :name, :my_wrapper_html => { :id => 'special_id' }
+
+# Configure the tag
+f.input :name, :my_wrapper_tag => :p
+```
+
+You can also define more than one wrapper and pick one to render in a specific form or input.
+To define another wrapper you have to give it a name, as the follow:
+
+```ruby
+config.wrappers :small do |b|
+  b.use :placeholder
+  b.use :label_input
+end
+```
+
+and use it in this way:
+
+```ruby
+# Specifying to whole form
+simple_form_for @user, :wrapper => :small do |f|
+  f.input :name
+end
+
+# Specifying to one input
+simple_form_for @user do |f|
+  f.input :name, :wrapper => :small
+end
+```
+
+**SimpleForm** also allows you to use optional elements. For instance, let's suppose you want to use
+hints or placeholders, but you don't want them to be generated automatically. You can set their
+default values to `false` or use the `optional` method. Is preferible to use the `optional` syntax:
+
+```ruby
+config.wrappers :placeholder => false do |b|
+  b.use :placeholder
+  b.use :label_input
+  b.wrapper :tag => :div, :class => 'separator' do |component|
+    component.optional :hint, :wrap_with => { :tag => :span, :class => :hint }
+    component.use :error, :wrap_with => { :tag => :span, :class => :error }
+  end
+end
+```
+
+By setting it as `optional`, a hint will only be generated when `:hint => true` is explicitly used.
+The same for placehold.
+
 ## HTML 5 Notice
 
 By default, **SimpleForm** will generate input field types and attributes that are supported in HTML5,
@@ -810,7 +871,8 @@ https://github.com/plataformatec/simple_form/issues
 * José Valim (https://github.com/josevalim)
 * Carlos Antonio da Silva (https://github.com/carlosantoniodasilva)
 * Rafael Mendonça França (https://github.com/rafaelfranca)
+* Vasiliy Ermolovich (https://github.com/nashby)
 
 ## License
 
-MIT License. Copyright 2012 Plataforma Tecnologia. http://blog.plataformatec.com.br
+MIT License. Copyright 2009-2013 Plataformatec. http://plataformatec.com.br

data/lib/generators/simple_form/install_generator.rb

@@ -5,16 +5,25 @@ module SimpleForm
       source_root File.expand_path('../templates', __FILE__)
       class_option :template_engine, :desc => 'Template engine to be invoked (erb, haml or slim).'
       class_option :bootstrap, :type => :boolean, :desc => 'Add the Twitter Bootstrap wrappers to the SimpleForm initializer.'
+      class_option :foundation, :type => :boolean, :desc => 'Add the Zurb Foundation 3 wrappers to the SimpleForm initializer.'
 
       def info_bootstrap
-        return if options.bootstrap?
-        puts "SimpleForm 2 supports Twitter bootstrap. In case you want to " \
-          "generate bootstrap configuration, please re-run this " \
-          "generator passing --bootstrap as option."
+        return if options.bootstrap? || options.foundation?
+        puts "SimpleForm 2 supports Twitter Bootstrap and Zurb Foundation 3. 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
 
       def copy_config
-        directory '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
 
       def copy_scaffold_template

data/lib/generators/simple_form/templates/config/initializers/{simple_form.rb.tt → simple_form.rb}

@@ -44,50 +44,10 @@ SimpleForm.setup do |config|
     b.use :hint,  :wrap_with => { :tag => :span, :class => :hint }
     b.use :error, :wrap_with => { :tag => :span, :class => :error }
   end
-<% if options.bootstrap? %>
-  config.wrappers :bootstrap, :tag => 'div', :class => 'control-group', :error_class => 'error' do |b|
-    b.use :placeholder
-    b.use :label
-    b.wrapper :tag => 'div', :class => 'controls' do |ba|
-      ba.use :input
-      ba.use :error, :wrap_with => { :tag => 'span', :class => 'help-inline' }
-      ba.use :hint,  :wrap_with => { :tag => 'p', :class => 'help-block' }
-    end
-  end
-
-  config.wrappers :prepend, :tag => 'div', :class => "control-group", :error_class => 'error' do |b|
-    b.use :placeholder
-    b.use :label
-    b.wrapper :tag => 'div', :class => 'controls' do |input|
-      input.wrapper :tag => 'div', :class => 'input-prepend' do |prepend|
-        prepend.use :input
-      end
-      input.use :hint,  :wrap_with => { :tag => 'span', :class => 'help-block' }
-      input.use :error, :wrap_with => { :tag => 'span', :class => 'help-inline' }
-    end
-  end
 
-  config.wrappers :append, :tag => 'div', :class => "control-group", :error_class => 'error' do |b|
-    b.use :placeholder
-    b.use :label
-    b.wrapper :tag => 'div', :class => 'controls' do |input|
-      input.wrapper :tag => 'div', :class => 'input-append' do |append|
-        append.use :input
-      end
-      input.use :hint,  :wrap_with => { :tag => 'span', :class => 'help-block' }
-      input.use :error, :wrap_with => { :tag => 'span', :class => 'help-inline' }
-    end
-  end
-
-  # Wrappers for forms and inputs using the Twitter Bootstrap toolkit.
-  # Check the Bootstrap docs (http://twitter.github.com/bootstrap)
-  # to learn about the different styles for forms and inputs,
-  # buttons and other elements.
-  config.default_wrapper = :bootstrap
-<% else %>
   # The default wrapper to be used by the FormBuilder.
   config.default_wrapper = :default
-<% end %>
+
   # Define the way to render check boxes / radio buttons with labels.
   # Defaults to :nested for bootstrap config.
   #   :inline => input + label
@@ -97,7 +57,9 @@ SimpleForm.setup do |config|
   # Default class for buttons
   config.button_class = 'btn'
 
-  # Method used to tidy up errors.
+  # Method used to tidy up errors. Specify any Rails Array method.
+  # :first lists the first message for each field.
+  # Use :to_sentence to list all errors for each field.
   # config.error_method = :first
 
   # Default tag used for error notification helper.
@@ -156,6 +118,10 @@ SimpleForm.setup do |config|
   # matches the regexp as value.
   # config.input_mappings = { /count/ => :integer }
 
+  # Custom wrappers for input types. This should be a hash containing an input
+  # type as key and the wrapper that will be used for all inputs with specified type.
+  # config.wrapper_mappings = { :string => :prepend }
+
   # Default priority for time_zone inputs.
   # config.time_zone_priority = nil
 

data/lib/generators/simple_form/templates/config/initializers/simple_form_bootstrap.rb

@@ -0,0 +1,45 @@
+# Use this setup block to configure all options available in SimpleForm.
+SimpleForm.setup do |config|
+  config.wrappers :bootstrap, :tag => 'div', :class => 'control-group', :error_class => 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.wrapper :tag => 'div', :class => 'controls' do |ba|
+      ba.use :input
+      ba.use :error, :wrap_with => { :tag => 'span', :class => 'help-inline' }
+      ba.use :hint,  :wrap_with => { :tag => 'p', :class => 'help-block' }
+    end
+  end
+
+  config.wrappers :prepend, :tag => 'div', :class => "control-group", :error_class => 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.wrapper :tag => 'div', :class => 'controls' do |input|
+      input.wrapper :tag => 'div', :class => 'input-prepend' do |prepend|
+        prepend.use :input
+      end
+      input.use :hint,  :wrap_with => { :tag => 'span', :class => 'help-block' }
+      input.use :error, :wrap_with => { :tag => 'span', :class => 'help-inline' }
+    end
+  end
+
+  config.wrappers :append, :tag => 'div', :class => "control-group", :error_class => 'error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label
+    b.wrapper :tag => 'div', :class => 'controls' do |input|
+      input.wrapper :tag => 'div', :class => 'input-append' do |append|
+        append.use :input
+      end
+      input.use :hint,  :wrap_with => { :tag => 'span', :class => 'help-block' }
+      input.use :error, :wrap_with => { :tag => 'span', :class => 'help-inline' }
+    end
+  end
+
+  # Wrappers for forms and inputs using the Twitter Bootstrap toolkit.
+  # Check the Bootstrap docs (http://twitter.github.com/bootstrap)
+  # to learn about the different styles for forms and inputs,
+  # buttons and other elements.
+  config.default_wrapper = :bootstrap
+end