dry_crud 2.1.1 → 2.1.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzE5OGExYmQyZDhkN2JiNGVmZjNjZGU5NTBlMTliZWU5ZTA5NDVkYw==
+    MWE4YzQzMjYxYmZlZWExOWUzZjczNDE2OWRlMTQwZDM4NDU5OTNlMg==
   data.tar.gz: !binary |-
-    Yzk1Y2M5ZjJlZDk0MWYwZWUzMjA2NTc4YWMwZmUzMTlmYTdlODFjMw==
-!binary "U0hBNTEy":
+    OTUzZWFjODA5NzRlZTVlMGQzYzZiOTMzNGRkNjIxNDM4OWM0OTZlMw==
+SHA512:
   metadata.gz: !binary |-
-    OThmZjNlNTJhZDRkNWI5M2ZhYTBmYzQ1OGFlYTA0ZTVkYjFlZDkxN2U0MWNk
-    OGQzMzViYWU3OWQwY2EzMjE4ZTc4OWNlYWMwNmVjNmRlNjY3N2VjMjY5YzNk
-    ODhiZDAzZjUzYjVkZTMyM2ZmMDljNDNlYzRmZTM3ZDg4MTZiOWE=
+    MWY5NDJlYmQ2NjE1OGJlZjEzMGRlZmE1YmUzM2EzZDQ4Nzk3YjJhYzVhZWI5
+    OGQyNzI5OGJmMDgwYjU1N2Y3OTk5MjA2ZTgyNTU3OGI1NDhjODViNmJjZDVm
+    YWIyODY4YzIzODIxNDk2ZGQ4M2E2ODE4ZDQwOWQ2NmFjYTczYzE=
   data.tar.gz: !binary |-
-    MThmZTk3YTQ5YWY0YWZlNDI5MDFlMmE3ZjAxZDgxNmU2ZDljN2UyNWFlZWI3
-    OTY2NmQxYWUyMzQyYmZhNGZlMDU3NmYyNmVhYTRmMDc5MzhkNDlmOTkzNzFl
-    ZGQ1OGYxNGIyNDgyY2U1ZGE5YzA5OGY0MWQ4ODMzNGJlOGJiNjM=
+    ODc3YTliNjQ5YzZhMGQwMjIxMTMwYzBlMDMzNDhjM2I5MDg0NzEwNGY0YTk0
+    NGRjN2Q2MWVkZjBhZjQzMmYzMTJhMDYyM2MwYzlkZGZmZTk0ZjY0NzVjMTE0
+    OTVmODcyNDNkNzUwNDJlNmIyN2E4NDFlZjhkZjIzZTY3NTRjYzM=

data/VERSION

@@ -1 +1 @@
-2.1.1
+2.1.2

data/app/assets/stylesheets/sample.scss

@@ -224,7 +224,7 @@ a.icon img {
   padding: 4px 0 4px;
 }
 
-.form-group label {
+.form-group > label {
   float: left;
   width: 120px;
   padding-right: 10px;

data/app/controllers/crud_controller.rb

@@ -109,7 +109,7 @@ class CrudController < ListController
 
   # Main accessor method for the handled model entry.
   def entry
-    get_model_ivar || set_model_ivar(params[:id] ? find_entry : build_entry)
+    model_ivar_get || model_ivar_set(params[:id] ? find_entry : build_entry)
   end
 
   # Creates a new model entry.

data/app/controllers/dry_crud/generic_model.rb

@@ -13,23 +13,23 @@ module DryCrud
     included do
       helper_method :model_class, :models_label, :path_args
 
-    private
+      private
 
       delegate :model_class, :models_label, :model_identifier, to: 'self.class'
     end
 
     private
 
-  # The scope where model entries will be listed and created.
-  # This is mainly used for nested models to provide the
-  # required context.
-  def model_scope
-    if Rails.version < '4.0'
-      model_class.scoped
-    else
-      model_class.all
+    # The scope where model entries will be listed and created.
+    # This is mainly used for nested models to provide the
+    # required context.
+    def model_scope
+      if Rails.version < '4.0'
+        model_class.scoped
+      else
+        model_class.all
+      end
     end
-  end
 
     # The path arguments to link to the given model entry.
     # If the controller is nested, this provides the required context.
@@ -37,53 +37,53 @@ module DryCrud
       last
     end
 
-  # Get the instance variable named after the +model_class+.
-  # If the collection variable is required, pass true as the second argument.
-  def get_model_ivar(plural = false)
-    name = ivar_name(model_class)
-    name = name.pluralize if plural
-    instance_variable_get(:"@#{name}")
-  end
-
-  # Sets an instance variable with the underscored class name if the given
-  # value. If the value is a collection, sets the plural name.
-  def set_model_ivar(value)
-    name = if value.respond_to?(:klass) # ActiveRecord::Relation
-             ivar_name(value.klass).pluralize
-           elsif value.respond_to?(:each) # Array
-             ivar_name(value.first.class).pluralize
-           else
-             ivar_name(value.class)
-           end
-    instance_variable_set(:"@#{name}", value)
-  end
+    # Get the instance variable named after the +model_class+.
+    # If the collection variable is required, pass true as the second argument.
+    def model_ivar_get(plural = false)
+      name = ivar_name(model_class)
+      name = name.pluralize if plural
+      instance_variable_get(:"@#{name}")
+    end
 
-  def ivar_name(klass)
-    klass.model_name.param_key
-  end
+    # Sets an instance variable with the underscored class name if the given
+    # value. If the value is a collection, sets the plural name.
+    def model_ivar_set(value)
+      name = if value.respond_to?(:klass) # ActiveRecord::Relation
+               ivar_name(value.klass).pluralize
+             elsif value.respond_to?(:each) # Array
+               ivar_name(value.first.class).pluralize
+             else
+               ivar_name(value.class)
+             end
+      instance_variable_set(:"@#{name}", value)
+    end
 
-  # Class methods from GenericModel.
-  module ClassMethods
-    # The ActiveRecord class of the model.
-    def model_class
-      @model_class ||= controller_name.classify.constantize
+    def ivar_name(klass)
+      klass.model_name.param_key
     end
 
+    # Class methods from GenericModel.
+    module ClassMethods
+      # The ActiveRecord class of the model.
+      def model_class
+        @model_class ||= controller_name.classify.constantize
+      end
+
       # The identifier of the model used for form parameters.
       # I.e., the symbol of the underscored model name.
       def model_identifier
         @model_identifier ||= model_class.model_name.param_key
       end
 
-    # A human readable plural name of the model.
-    def models_label(plural = true)
-      opts = { count: (plural ? 3 : 1) }
-      opts[:default] = model_class.model_name.human.titleize
-      opts[:default] = opts[:default].pluralize if plural
+      # A human readable plural name of the model.
+      def models_label(plural = true)
+        opts = { count: (plural ? 3 : 1) }
+        opts[:default] = model_class.model_name.human.titleize
+        opts[:default] = opts[:default].pluralize if plural
 
-      model_class.model_name.human(opts)
+        model_class.model_name.human(opts)
+      end
     end
-  end
 
   end
 end

data/app/controllers/dry_crud/nestable.rb

@@ -45,7 +45,7 @@ module DryCrud
     # Loads the parent entry for the given ActiveRecord class.
     # By default, performs a find with the class_name_id param.
     def parent_entry(clazz)
-      set_model_ivar(clazz.find(params["#{clazz.name.underscore}_id"]))
+      model_ivar_set(clazz.find(params["#{clazz.name.underscore}_id"]))
     end
 
     # An array of objects used in url_for and related functions.

data/app/controllers/dry_crud/render_callbacks.rb

@@ -37,6 +37,8 @@ module DryCrud
       # Defines before callbacks for the render actions.
       def define_render_callbacks(*actions)
         args = actions.map { |a| :"render_#{a}" }
+        # Rails 4.1 terminator:
+        # ->(ctrl, result) { result == false || ctrl.performed? }
         args << { only: :before,
                   terminator: 'result == false || performed?' }
         define_model_callbacks(*args)

data/app/controllers/dry_crud/responder.rb

@@ -12,11 +12,14 @@ module DryCrud
 
     private
 
+    # rubocop:disable PredicateName
+
     # Check whether the resource has errors. Additionally checks the :success
     # option.
     def has_errors?
       options[:success] == false || super
     end
+    # rubocop:enable PredicateName
 
     # Wraps the resources with the path_args for correct nesting.
     def with_path_args(resources, controller)

data/app/controllers/list_controller.rb

@@ -35,7 +35,7 @@ class ListController < ApplicationController
   # Helper method to access the entries to be displayed in the current index
   # page in an uniform way.
   def entries
-    get_model_ivar(true) || set_model_ivar(list_entries)
+    model_ivar_get(true) || model_ivar_set(list_entries)
   end
 
   # The base relation used to filter the entries.

data/app/helpers/dry_crud/form/builder.rb

@@ -1,314 +1,339 @@
 # encoding: UTF-8
 
-module DryCrud::Form
-
-  # A form builder that automatically selects the corresponding input field
-  # for ActiveRecord column types. Convenience methods for each column type
-  # allow one to customize the different fields.
-  #
-  # All field methods may be prefixed with +labeled_+ in order to render
-  # a standard label, required mark and an optional help block with them.
-  #
-  # Use #labeled_input_field or #input_field to render a input field
-  # corresponding to the given attribute.
-  #
-  # See the Control class for how to customize the html rendered for a
-  # single input field.
-  class Builder < ActionView::Helpers::FormBuilder
-
-    class_attribute :control_class
-    self.control_class = Control
-
-    attr_reader :template
-
-    delegate :association, :column_type, :column_property, :captionize,
-             :ti, :ta, :link_to, :content_tag, :safe_join, :capture,
-             :add_css_class, :assoc_and_id_attr,
-             to: :template
-
-    ### INPUT FIELDS
-
-    # Render multiple input controls together with a label for the given
-    # attributes.
-    def labeled_input_fields(*attrs)
-      options = attrs.extract_options!
-      safe_join(attrs) { |a| labeled_input_field(a, options.dup) }
-    end
+module DryCrud
+  module Form
 
-    # Render a corresponding input control and label for the given attribute.
-    # The input field is chosen based on the ActiveRecord column type.
+    # A form builder that automatically selects the corresponding input field
+    # for ActiveRecord column types. Convenience methods for each column type
+    # allow one to customize the different fields.
     #
-    # The following options may be passed:
-    # * <tt>:addon</tt> - Addon content displayd just after the input field.
-    # * <tt>:help</tt> - A help text displayd below the input field.
-    # * <tt>:span</tt> - Number of columns the input field should span.
-    # * <tt>:caption</tt> - Different caption for the label.
-    # * <tt>:field_method</tt> - Different method to create the input field.
+    # All field methods may be prefixed with +labeled_+ in order to render
+    # a standard label, required mark and an optional help block with them.
     #
-    # Use additional html_options for the input element.
-    def labeled_input_field(attr, html_options = {})
-      control_class.new(self, attr, html_options).render_labeled
-    end
-
-    # Render a corresponding input control for the given attribute.
-    # The input field is chosen based on the ActiveRecord column type.
+    # Use #labeled_input_field or #input_field to render a input field
+    # corresponding to the given attribute.
     #
-    # The following options may be passed:
-    # * <tt>:addon</tt> - Addon content displayd just after the input field.
-    # * <tt>:help</tt> - A help text displayd below the input field.
-    # * <tt>:span</tt> - Number of columns the input field should span.
-    # * <tt>:field_method</tt> - Different method to create the input field.
-    #
-    # Use additional html_options for the input element.
-    def input_field(attr, html_options = {})
-      control_class.new(self, attr, html_options).render_content
-    end
+    # See the Control class for how to customize the html rendered for a
+    # single input field.
+    class Builder < ActionView::Helpers::FormBuilder
 
-    # Render a standard string field with column contraints.
-    def string_field(attr, html_options = {})
-      html_options[:maxlength] ||= column_property(@object, attr, :limit)
-      text_field(attr, html_options)
-    end
+      class_attribute :control_class
+      self.control_class = Control
 
-    # Render a boolean field.
-    def boolean_field(attr, html_options = {})
-      add_css_class(html_options, 'form-control')
-      check_box(attr, html_options)
-    end
+      attr_reader :template
 
-    # Customize the standard text area to have 5 rows by default.
-    def text_area(attr, html_options = {})
-      html_options[:rows] ||= 5
-      super
-    end
+      delegate :association, :column_type, :column_property, :captionize,
+               :ti, :ta, :link_to, :content_tag, :safe_join, :capture,
+               :add_css_class, :assoc_and_id_attr,
+               to: :template
 
-    alias_method :integer_field, :number_field
-    alias_method :float_field, :number_field
-    alias_method :decimal_field, :number_field
+      ### INPUT FIELDS
 
-    if Rails.version < '4.0'
-      # Render a field to select a date. You might want to customize this.
-      def date_field(attr, html_options = {})
-        html_options[:type] = 'date'
-        text_field(attr, html_options)
+      # Render multiple input controls together with a label for the given
+      # attributes.
+      def labeled_input_fields(*attrs)
+        options = attrs.extract_options!
+        safe_join(attrs) { |a| labeled_input_field(a, options.dup) }
       end
 
-      # Render a field to enter a time. You might want to customize this.
-      def time_field(attr, html_options = {})
-        html_options[:type] = 'time'
-        text_field(attr, html_options)
+      # Render a corresponding input control and label for the given attribute.
+      # The input field is chosen based on the ActiveRecord column type.
+      #
+      # The following options may be passed:
+      # * <tt>:addon</tt> - Addon content displayd just after the input field.
+      # * <tt>:help</tt> - A help text displayd below the input field.
+      # * <tt>:span</tt> - Number of columns the input field should span.
+      # * <tt>:caption</tt> - Different caption for the label.
+      # * <tt>:field_method</tt> - Different method to create the input field.
+      #
+      # Use additional html_options for the input element.
+      def labeled_input_field(attr, html_options = {})
+        control_class.new(self, attr, html_options).render_labeled
       end
 
-      # Render a field to enter a date and time.
-      # You might want to customize this.
-      def datetime_field(attr, html_options = {})
-        html_options[:type] = 'datetime'
+      # Render a corresponding input control for the given attribute.
+      # The input field is chosen based on the ActiveRecord column type.
+      #
+      # The following options may be passed:
+      # * <tt>:addon</tt> - Addon content displayd just after the input field.
+      # * <tt>:help</tt> - A help text displayd below the input field.
+      # * <tt>:span</tt> - Number of columns the input field should span.
+      # * <tt>:field_method</tt> - Different method to create the input field.
+      #
+      # Use additional html_options for the input element.
+      def input_field(attr, html_options = {})
+        control_class.new(self, attr, html_options).render_content
+      end
+
+      # Render a standard string field with column contraints.
+      def string_field(attr, html_options = {})
+        html_options[:maxlength] ||= column_property(@object, attr, :limit)
         text_field(attr, html_options)
       end
-    end
 
-    # Render a select element for a :belongs_to association defined by attr.
-    # Use additional html_options for the select element.
-    # To pass a custom element list, specify the list with the :list key or
-    # define an instance variable with the pluralized name of the association.
-    def belongs_to_field(attr, html_options = {})
-      list = association_entries(attr, html_options).to_a
-      if list.present?
-        collection_select(attr, list, :id, :to_s,
-                          select_options(attr, html_options),
-                          html_options)
-      else
-        static_text(ta(:none_available, association(@object, attr)).html_safe)
+      # Render a boolean field.
+      def boolean_field(attr, html_options = {})
+        content_tag(:div, class: 'checkbox') do
+          content_tag(:label) do
+            detail = html_options.delete(:detail) || '&nbsp;'.html_safe
+            safe_join([check_box(attr, html_options), ' ', detail])
+          end
+        end
       end
-    end
 
-    # Render a multi select element for a :has_many or :has_and_belongs_to_many
-    # association defined by attr.
-    # Use additional html_options for the select element.
-    # To pass a custom element list, specify the list with the :list key or
-    # define an instance variable with the pluralized name of the association.
-    def has_many_field(attr, html_options = {})
-      html_options[:multiple] = true
-      add_css_class(html_options, 'multiselect')
-      belongs_to_field(attr, html_options)
-    end
+      # Add form-control class to all input fields.
+      %w(text_field password_field email_field text_area
+         number_fielc date_field time_field datetime_field).each do |method|
+        define_method(method) do |attr, html_options = {}|
+          add_css_class(html_options, 'form-control')
+          super(attr, html_options)
+        end
+      end
 
-    ### VARIOUS FORM ELEMENTS
+      # Customize the standard text area to have 5 rows by default.
+      def text_area(attr, html_options = {})
+        add_css_class(html_options, 'form-control')
+        html_options[:rows] ||= 5
+        super(attr, html_options)
+      end
 
-    # Render the error messages for the current form.
-    def error_messages
-      @template.render('shared/error_messages',
-                       errors: @object.errors,
-                       object: @object)
-    end
+      alias_method :integer_field, :number_field
+      alias_method :float_field, :number_field
+      alias_method :decimal_field, :number_field
+
+      if Rails.version < '4.0'
+        # Render a field to select a date. You might want to customize this.
+        def date_field(attr, html_options = {})
+          html_options[:type] = 'date'
+          text_field(attr, html_options)
+        end
+
+        # Render a field to enter a time. You might want to customize this.
+        def time_field(attr, html_options = {})
+          html_options[:type] = 'time'
+          text_field(attr, html_options)
+        end
 
-    # Renders the given content with an addon.
-    def with_addon(content, addon)
-      content_tag(:div, class: 'input-group') do
-        content + content_tag(:span, addon, class: 'input-group-addon')
+        # Render a field to enter a date and time.
+        # You might want to customize this.
+        def datetime_field(attr, html_options = {})
+          html_options[:type] = 'datetime'
+          text_field(attr, html_options)
+        end
       end
-    end
 
-    # Renders a static text where otherwise form inputs appear.
-    def static_text(text)
-      content_tag(:p, text, class: 'form-control-static')
-    end
+      # Render a select element for a :belongs_to association defined by attr.
+      # Use additional html_options for the select element.
+      # To pass a custom element list, specify the list with the :list key or
+      # define an instance variable with the pluralized name of the
+      # association.
+      def belongs_to_field(attr, html_options = {})
+        list = association_entries(attr, html_options).to_a
+        if list.present?
+          add_css_class(html_options, 'form-control')
+          collection_select(attr, list, :id, :to_s,
+                            select_options(attr, html_options),
+                            html_options)
+        else
+          static_text(
+            ta(:none_available, association(@object, attr)).html_safe)
+        end
+      end
 
-    # Generates a help block for fields
-    def help_block(text)
-      content_tag(:p, text, class: 'help-block')
-    end
+      # rubocop:disable PredicateName
+
+      # Render a multi select element for a :has_many or
+      # :has_and_belongs_to_many association defined by attr.
+      # Use additional html_options for the select element.
+      # To pass a custom element list, specify the list with the :list key or
+      # define an instance variable with the pluralized name of the
+      # association.
+      def has_many_field(attr, html_options = {})
+        html_options[:multiple] = true
+        add_css_class(html_options, 'multiselect')
+        belongs_to_field(attr, html_options)
+      end
+      # rubocop:enable PredicateName
+
+      ### VARIOUS FORM ELEMENTS
 
-    # Render a submit button and a cancel link for this form.
-    def standard_actions(submit_label = ti('button.save'), cancel_url = nil)
-      content_tag(:div, class: 'col-md-offset-2 col-md-8') do
-        safe_join([submit_button(submit_label), cancel_link(cancel_url)], ' ')
+      # Render the error messages for the current form.
+      def error_messages
+        @template.render('shared/error_messages',
+                         errors: @object.errors,
+                         object: @object)
       end
-    end
 
-    # Render a standard submit button with the given label.
-    def submit_button(label = ti('button.save'))
-      button(label, class: 'btn btn-primary', data: { disable_with: label })
-    end
+      # Renders the given content with an addon.
+      def with_addon(content, addon)
+        content_tag(:div, class: 'input-group') do
+          content + content_tag(:span, addon, class: 'input-group-addon')
+        end
+      end
 
-    # Render a cancel link pointing to the given url.
-    def cancel_link(url = nil)
-      url ||= cancel_url
-      link_to(ti('button.cancel'), url, class: 'cancel')
-    end
+      # Renders a static text where otherwise form inputs appear.
+      def static_text(text)
+        content_tag(:p, text, class: 'form-control-static')
+      end
 
-    # Depending if the given attribute must be present, return
-    # only an initial selection prompt or a blank option, respectively.
-    def select_options(attr, options = {})
-      prompt = options.delete(:prompt)
-      blank = options.delete(:include_blank)
-      if options[:multiple]
-        {}
-      elsif prompt
-        { prompt: prompt }
-      elsif blank
-        { include_blank: blank }
-      else
-        assoc = association(@object, attr)
-        if required?(attr)
-          { prompt: ta(:please_select, assoc) }
-        else
-          { include_blank: ta(:no_entry, assoc) }
+      # Generates a help block for fields
+      def help_block(text)
+        content_tag(:p, text, class: 'help-block')
+      end
+
+      # Render a submit button and a cancel link for this form.
+      def standard_actions(submit_label = ti('button.save'), cancel_url = nil)
+        content_tag(:div, class: 'col-md-offset-2 col-md-8') do
+          safe_join([submit_button(submit_label),
+                     cancel_link(cancel_url)],
+                    ' ')
         end
       end
-    end
 
-    # Returns true if the given attribute must be present.
-    def required?(attr)
-      attr, attr_id = assoc_and_id_attr(attr)
-      validators = @object.class.validators_on(attr) +
-                   @object.class.validators_on(attr_id)
-      validators.any? do |v|
-        v.kind == :presence &&
-        !v.options.key?(:if) &&
-        !v.options.key?(:unless)
+      # Render a standard submit button with the given label.
+      def submit_button(label = ti('button.save'))
+        button(label, class: 'btn btn-primary', data: { disable_with: label })
       end
-    end
 
-    # Render a label for the given attribute with the passed content.
-    # The content may be given as an argument or as a block:
-    #   labeled(:attr) { #content }
-    #   labeled(:attr, content)
-    #
-    # The following options may be passed:
-    # * <tt>:span</tt> - Number of columns the content should span.
-    # * <tt>:caption</tt> - Different caption for the label.
-    def labeled(attr, content = {}, options = {}, &block)
-      if block_given?
-        options = content
-        content = capture(&block)
+      # Render a cancel link pointing to the given url.
+      def cancel_link(url = nil)
+        url ||= cancel_url
+        link_to(ti('button.cancel'), url, class: 'cancel')
       end
-      control = control_class.new(self, attr, options)
-      control.render_labeled(content)
-    end
 
-    # Dispatch methods starting with 'labeled_' to render a label and the
-    # corresponding input field.
-    # E.g. labeled_boolean_field(:checked, class: 'bold')
-    # To add an additional help text, use the help option.
-    # E.g. labeled_boolean_field(:checked, help: 'Some Help')
-    def method_missing(name, *args)
-      field_method = labeled_field_method?(name)
-      if field_method
-        build_labeled_field(field_method, *args)
-      else
-        super(name, *args)
+      # Depending if the given attribute must be present, return
+      # only an initial selection prompt or a blank option, respectively.
+      def select_options(attr, options = {})
+        prompt = options.delete(:prompt)
+        blank = options.delete(:include_blank)
+        if options[:multiple]
+          {}
+        elsif prompt
+          { prompt: prompt }
+        elsif blank
+          { include_blank: blank }
+        else
+          assoc = association(@object, attr)
+          if required?(attr)
+            { prompt: ta(:please_select, assoc) }
+          else
+            { include_blank: ta(:no_entry, assoc) }
+          end
+        end
       end
-    end
 
-    # Overriden to fullfill contract with method_missing 'labeled_' methods.
-    def respond_to?(name)
-      labeled_field_method?(name).present? || super(name)
-    end
+      # Returns true if the given attribute must be present.
+      def required?(attr)
+        attr, attr_id = assoc_and_id_attr(attr)
+        validators = @object.class.validators_on(attr) +
+                     @object.class.validators_on(attr_id)
+        validators.any? do |v|
+          v.kind == :presence &&
+          !v.options.key?(:if) &&
+          !v.options.key?(:unless)
+        end
+      end
+
+      # Render a label for the given attribute with the passed content.
+      # The content may be given as an argument or as a block:
+      #   labeled(:attr) { #content }
+      #   labeled(:attr, content)
+      #
+      # The following options may be passed:
+      # * <tt>:span</tt> - Number of columns the content should span.
+      # * <tt>:caption</tt> - Different caption for the label.
+      def labeled(attr, content = {}, options = {}, &block)
+        if block_given?
+          options = content
+          content = capture(&block)
+        end
+        control = control_class.new(self, attr, options)
+        control.render_labeled(content)
+      end
 
-    private
+      # Dispatch methods starting with 'labeled_' to render a label and the
+      # corresponding input field.
+      # E.g. labeled_boolean_field(:checked, class: 'bold')
+      # To add an additional help text, use the help option.
+      # E.g. labeled_boolean_field(:checked, help: 'Some Help')
+      def method_missing(name, *args)
+        field_method = labeled_field_method?(name)
+        if field_method
+          build_labeled_field(field_method, *args)
+        else
+          super(name, *args)
+        end
+      end
 
-    # Checks if the passed name corresponds to a field method with a
-    # 'labeled_' prefix.
-    def labeled_field_method?(name)
-      prefix = 'labeled_'
-      if name.to_s.start_with?(prefix)
-        field_method = name.to_s[prefix.size..-1]
-        field_method if respond_to?(field_method)
+      # Overriden to fullfill contract with method_missing 'labeled_' methods.
+      def respond_to?(name)
+        labeled_field_method?(name).present? || super(name)
       end
-    end
 
-    # Renders the corresponding field together with a label, required mark and
-    # an optional help block.
-    def build_labeled_field(field_method, *args)
-      options = args.extract_options!
-      options[:field_method] = field_method
-      control_class.new(self, *(args << options)).render_labeled
-    end
+      private
 
-    # Returns the list of association entries, either from options[:list] or
-    # the instance variable with the pluralized association name.
-    # Otherwise, if the association defines a #options_list or #list scope,
-    # this is used to load the entries.
-    # As a last resort, all entries from the association class are returned.
-    def association_entries(attr, options)
-      list = options.delete(:list)
-      unless list
-        assoc = association(@object, attr)
-        list = @template.send(:instance_variable_get,
-                              :"@#{assoc.name.to_s.pluralize}")
-        list ||= load_association_entries(assoc)
+      # Checks if the passed name corresponds to a field method with a
+      # 'labeled_' prefix.
+      def labeled_field_method?(name)
+        prefix = 'labeled_'
+        if name.to_s.start_with?(prefix)
+          field_method = name.to_s[prefix.size..-1]
+          field_method if respond_to?(field_method)
+        end
+      end
+
+      # Renders the corresponding field together with a label, required mark
+      # and an optional help block.
+      def build_labeled_field(field_method, *args)
+        options = args.extract_options!
+        options[:field_method] = field_method
+        control_class.new(self, *(args << options)).render_labeled
       end
-      list
-    end
 
-    # Automatically load the entries for the given association.
-    def load_association_entries(assoc)
-      klass = assoc.klass
-      list = if Rails.version >= '4.0'
-               klass.all.merge(assoc.scope)
-             else
-               klass.where(assoc.options[:conditions])
-                    .order(assoc.options[:order])
-             end
-      # Use special scopes if they are defined
-      if klass.respond_to?(:options_list)
-        list.options_list
-      elsif klass.respond_to?(:list)
-        list.list
-      else
+      # Returns the list of association entries, either from options[:list] or
+      # the instance variable with the pluralized association name.
+      # Otherwise, if the association defines a #options_list or #list scope,
+      # this is used to load the entries.
+      # As a last resort, all entries from the association class are returned.
+      def association_entries(attr, options)
+        list = options.delete(:list)
+        unless list
+          assoc = association(@object, attr)
+          list = @template.send(:instance_variable_get,
+                                :"@#{assoc.name.to_s.pluralize}")
+          list ||= load_association_entries(assoc)
+        end
         list
       end
-    end
 
-    # Get the cancel url for the given object considering options:
-    # 1. Use :cancel_url_new or :cancel_url_edit option, if present
-    # 2. Use :cancel_url option, if present
-    def cancel_url
-      url = @object.new_record? ? options[:cancel_url_new] :
-                                  options[:cancel_url_edit]
-      url || options[:cancel_url]
-    end
+      # Automatically load the entries for the given association.
+      def load_association_entries(assoc)
+        klass = assoc.klass
+        list = if Rails.version >= '4.0'
+                 klass.all.merge(assoc.scope)
+               else
+                 klass.where(assoc.options[:conditions])
+                      .order(assoc.options[:order])
+               end
+        # Use special scopes if they are defined
+        if klass.respond_to?(:options_list)
+          list.options_list
+        elsif klass.respond_to?(:list)
+          list.list
+        else
+          list
+        end
+      end
+
+      # Get the cancel url for the given object considering options:
+      # 1. Use :cancel_url_new or :cancel_url_edit option, if present
+      # 2. Use :cancel_url option, if present
+      def cancel_url
+        url = @object.new_record? ? options[:cancel_url_new] :
+                                    options[:cancel_url_edit]
+        url || options[:cancel_url]
+      end
 
+    end
   end
 end