padrino-helpers-cj 0.12.2

data/lib/padrino-helpers/form_builder/abstract_form_builder.rb

@@ -0,0 +1,283 @@
+require 'padrino-helpers/form_builder/deprecated_builder_methods'
+
+module Padrino
+  module Helpers
+    module FormBuilder
+      # Base class for Padrino Form Builder
+      class AbstractFormBuilder
+        attr_accessor :template, :object, :multipart
+        attr_reader :namespace, :is_nested, :parent_form, :nested_index, :attributes_name, :model_name
+
+        include DeprecatedBuilderMethods
+
+        def initialize(template, object, options={})
+          @template = template
+          fail "FormBuilder template must be initialized" unless template
+          @object = object.kind_of?(Symbol) ? build_object(object) : object
+          fail "FormBuilder object must be present. If there's no object, use a symbol instead (i.e. :user)" unless object
+          @options = options
+          @namespace = options[:namespace]
+          @model_name = options[:as] || @object.class.to_s.underscore.gsub(/\//, '_')
+          nested = options[:nested]
+          if @is_nested = nested && (nested_parent = nested[:parent]) && nested_parent.respond_to?(:object)
+            @parent_form = nested_parent
+            @nested_index = nested[:index]
+            @attributes_name = "#{nested[:association]}_attributes"
+          end
+        end
+
+        def error_messages(*params)
+          @template.error_messages_for object, *params
+        end
+
+        def error_message_on(field, options={})
+          @template.error_message_on object, field, options
+        end
+
+        def label(field, options={}, &block)
+          options[:id] ||= nil
+          options[:caption] ||= I18n.t("#{model_name}.attributes.#{field}", :count => 1, :default => field.to_s.humanize, :scope => :models) + ': '
+          @template.label_tag(field_id(field), default_options(field, options), &block)
+        end
+
+        def hidden_field(field, options={})
+          @template.hidden_field_tag field_name(field), default_options(field, options)
+        end
+
+        def text_field(field, options={})
+          @template.text_field_tag field_name(field), default_options(field, options)
+        end
+
+        def number_field(field, options={})
+          @template.number_field_tag field_name(field), default_options(field, options)
+        end
+
+        def telephone_field(field, options={})
+          @template.telephone_field_tag field_name(field), default_options(field, options)
+        end
+        alias_method :phone_field, :telephone_field
+
+        def email_field(field, options={})
+          @template.email_field_tag field_name(field), default_options(field, options)
+        end
+
+        def search_field(field, options={})
+          @template.search_field_tag field_name(field), default_options(field, options)
+        end
+
+        def url_field(field, options={})
+          @template.url_field_tag field_name(field), default_options(field, options)
+        end
+
+        def text_area(field, options={})
+          @template.text_area_tag field_name(field), default_options(field, options)
+        end
+
+        def password_field(field, options={})
+          @template.password_field_tag field_name(field), default_options(field, options)
+        end
+
+        def select(field, options={})
+          @template.select_tag field_name(field), default_options(field, options)
+        end
+
+        def check_box_group(field, options={})
+          labeled_group(field, options) do |attributes|
+            @template.check_box_tag(field_name(field)+'[]', attributes)
+          end
+        end
+
+        def radio_button_group(field, options={})
+          labeled_group(field, options) do |attributes|
+            @template.radio_button_tag(field_name(field), attributes)
+          end
+        end
+
+        def check_box(field, options={})
+          options = default_options(field, options, :value => '1')
+          options[:checked] = true if is_checked?(field, options)
+          name = field_name(field)
+          html = @template.hidden_field_tag(name, :value => options.delete(:uncheck_value) || '0')
+          html << @template.check_box_tag(name, options)
+        end
+
+        def radio_button(field, options={})
+          options = default_options(field, options)
+          options[:checked] = true if is_checked?(field, options)
+          options[:id] = field_id(field, options[:value])
+          @template.radio_button_tag field_name(field), options
+        end
+
+        def file_field(field, options={})
+          self.multipart = true
+          @template.file_field_tag field_name(field), default_options(field, options).except(:value)
+        end
+
+        def submit(*args)
+          @template.submit_tag *args
+        end
+
+        def image_submit(source, options={})
+          @template.image_submit_tag source, options
+        end
+
+        ##
+        # Supports nested fields for a child model within a form.
+        # f.fields_for :addresses
+        # f.fields_for :addresses, address
+        # f.fields_for :addresses, @addresses
+        # f.fields_for :addresses, address, index: i
+        def fields_for(child_association, collection=nil, options={}, &block)
+          default_collection = self.object.send(child_association)
+          collection ||= default_collection
+          include_index = default_collection.respond_to?(:each)
+
+          nested_options = { :parent => self, :association => child_association }
+          Array(collection).each_with_index.inject(ActiveSupport::SafeBuffer.new) do |all,(child_instance,index)|
+            nested_options[:index] = options[:index] || (include_index ? index : nil)
+            all << @template.fields_for(child_instance,  { :nested => nested_options, :builder => self.class }, &block) << "\n"
+          end
+        end
+
+        def csrf_token_field
+          @template.csrf_token_field
+        end
+
+        protected
+
+        # Returns the known field types for a Formbuilder.
+        def self.field_types
+          [:hidden_field, :text_field, :text_area, :password_field, :file_field, :radio_button, :check_box, :select]
+        end
+
+        ##
+        # Returns the name for the given field.
+        # field_name(:username) => "user[username]"
+        # field_name(:number) => "user[telephone_attributes][number]"
+        # field_name(:street) => "user[addresses_attributes][0][street]"
+        def field_name(field=nil)
+          result = field_name_fragment
+          result << "[#{field}]" unless field.blank?
+          result
+        end
+
+        ##
+        # Returns the id for the given field.
+        # field_id(:username) => "user_username"
+        # field_id(:gender, :male) => "user_gender_male"
+        # field_name(:number) => "user_telephone_attributes_number"
+        # field_name(:street) => "user_addresses_attributes_0_street"
+        def field_id(field=nil, value=nil)
+          result = (namespace && !is_nested) ? "#{namespace}_" : ''
+          result << field_id_fragment
+          result << "_#{field}" unless field.blank?
+          result << "_#{value}" unless value.blank?
+          result
+        end
+
+        ##
+        # Returns the child object if it exists.
+        #
+        def nested_object_id
+          is_nested && object.respond_to?(:new_record?) && !object.new_record? && object.id
+        end
+
+        ##
+        # Returns the value for the object's field.
+        #
+        def field_value(field)
+          @object.respond_to?(field) ? @object.send(field) : ''
+        end
+
+        ##
+        # Returns a record from template instance or create a record of specified class.
+        #
+        def build_object(symbol)
+          @template.instance_variable_get("@#{symbol}") || symbol.to_s.camelize.constantize.new
+        end
+
+        ##
+        # Builds a group of labels for radios or checkboxes.
+        #
+        def labeled_group(field, options={})
+          options = { :id => field_id(field), :selected => field_value(field) }.update(options)
+          options.update(error_class(field)){ |_,*values| values.compact.join(' ') }
+          selected_values = resolve_checked_values(field, options)
+          variants_for_group(options).inject(ActiveSupport::SafeBuffer.new) do |html, (caption,value)|
+            variant_id = "#{options[:id]}_#{value}"
+            attributes = { :value => value, :id => variant_id, :checked => selected_values.include?(value) }
+            caption = yield(attributes) << ' ' << caption
+            html << @template.label_tag("#{field_name(field)}[]", :for => variant_id, :caption => caption)
+          end
+        end
+
+        private
+
+        def is_checked?(field, options)
+          !options.has_key?(:checked) && [options[:value].to_s, 'true'].include?(field_value(field).to_s)
+        end
+
+        def variants_for_group(options)
+          if variants = options[:options]
+            variants.map{ |caption, value| [caption.to_s, (value||caption).to_s] }
+          elsif collection = options[:collection]
+            collection.map{ |variant| field_values(variant, options) }
+          else
+            []
+          end
+        end
+
+        def resolve_checked_values(field, options)
+          selected_values = Array(options[:selected] || field_value(field))
+          if options[:collection]
+            _, id_method = *field_methods(options)
+            selected_values.map do |value|
+              (value.respond_to?(id_method) ? value.send(id_method) : value).to_s
+            end
+          else
+            selected_values
+          end
+        end
+
+        def field_methods(options)
+          options[:fields] || [:name, :id]
+        end
+
+        def field_values(object, options)
+          field_methods(options).map{ |field| object.send(field).to_s }
+        end
+
+        def field_name_fragment
+          if is_nested
+            fragment = parent_form.field_name.dup << "[#{attributes_name}"
+            fragment << "][#{nested_index}" if nested_index
+            fragment << "]"
+          else
+            "#{model_name}"
+          end
+        end
+
+        def field_id_fragment
+          if is_nested
+            fragment = parent_form.field_id.dup << "_#{attributes_name}"
+            fragment << "_#{nested_index}" if nested_index
+            fragment
+          else
+            "#{model_name}"
+          end
+        end
+
+        def error_class(field)
+          error = @object.errors[field] if @object.respond_to?(:errors)
+          error.blank? ? {} : { :class => 'invalid' }
+        end
+
+        def default_options(field, options, defaults={})
+          { :value => field_value(field),
+            :id => field_id(field)
+          }.update(defaults).update(options).update(error_class(field)){ |_,*values| values.compact.join(' ') }
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_builder/deprecated_builder_methods.rb

@@ -0,0 +1,92 @@
+module Padrino
+  module Helpers
+    module FormBuilder
+      module DeprecatedBuilderMethods
+        ##
+        # Returns true if the value matches the value in the field.
+        # field_has_value?(:gender, 'male')
+        def values_matches_field?(field, value)
+          logger.warn "##{__method__} is deprecated"
+          value.present? && (field_value(field).to_s == value.to_s || field_value(field).to_s == 'true')
+        end
+
+        ##
+        # Add a :invalid css class to the field if it contain an error.
+        #
+        def field_error(field, options)
+          logger.warn "##{__method__} is deprecated"
+          error = @object.errors[field] rescue nil
+          error.blank? ? options[:class] : [options[:class], :invalid].flatten.compact.join(" ")
+        end
+
+        def nested_form?
+          logger.warn "##{__method__} is deprecated"
+          @options[:nested] && @options[:nested][:parent] && @options[:nested][:parent].respond_to?(:object)
+          is_nested && object.respond_to?(:new_record?) && !object.new_record? && object.id
+        end
+
+        ##
+        # Returns a new record of the type specified in the object
+        #
+        def build_object(object_or_symbol)
+          logger.warn "##{__method__} is deprecated"
+          object_or_symbol.is_a?(Symbol) ? @template.instance_variable_get("@#{object_or_symbol}") || object_class(object_or_symbol).new : object_or
+        end
+
+        ##
+        # Returns the object's models name.
+        #
+        def object_model_name(explicit_object=object)
+          logger.warn "##{__method__} is deprecated"
+          return @options[:as] if root_form? && @options[:as].is_a?(Symbol)
+          explicit_object.is_a?(Symbol) ? explicit_object : explicit_object.class.to_s.underscore.gsub(/\//, '_')
+        end
+
+        ##
+        # Returns the class type for the given object.
+        #
+        def object_class(explicit_object)
+          logger.warn "##{__method__} is deprecated"
+          explicit_object.is_a?(Symbol) ? explicit_object.to_s.camelize.constantize : explicit_object.class
+          @object.respond_to?(field) ? @object.send(field) : ''
+        end
+
+        ##
+        # Returns true if this form is the top-level (not nested).
+        # Returns a record from template instance or create a record of specified class.
+        #
+        def root_form?
+          logger.warn "##{__method__} is deprecated"
+          !nested_form?
+        end
+
+        def build_object(symbol)
+          logger.warn "##{__method__} is deprecated"
+          @template.instance_variable_get("@#{symbol}") || symbol.to_s.camelize.constantize.new
+        end
+
+        def field_result
+          logger.warn "##{__method__} is deprecated"
+          result = []
+          result << object_model_name if root_form?
+          result
+        end
+
+        def merge_default_options!(field, options)
+          logger.warn "##{__method__} is deprecated"
+          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
+          options.merge!(:class => field_error(field, options))
+        end
+
+        def result_options
+          logger.warn "##{__method__} is deprecated"
+          {
+            :parent_form  => @options[:nested][:parent],
+            :nested_index => @options[:nested][:index],
+            :attributes_name => "#{@options[:nested][:association]}_attributes"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_builder/standard_form_builder.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/abstract_form_builder') unless defined?(AbstractFormBuilder)
+
+module Padrino
+  module Helpers
+    module FormBuilder
+      class StandardFormBuilder < AbstractFormBuilder
+        ##
+        # StandardFormBuilder
+        #
+        #   text_field_block(:username, { :class => 'long' }, { :class => 'wide-label' })
+        #   text_area_block(:summary, { :class => 'long' }, { :class => 'wide-label' })
+        #   password_field_block(:password, { :class => 'long' }, { :class => 'wide-label' })
+        #   file_field_block(:photo, { :class => 'long' }, { :class => 'wide-label' })
+        #   check_box_block(:remember_me, { :class => 'long' }, { :class => 'wide-label' })
+        #   select_block(:color, :options => ['green', 'black'])
+        #
+        (self.field_types - [ :hidden_field, :radio_button ]).each do |field_type|
+          class_eval <<-EOF
+          def #{field_type}_block(field, options={}, label_options={})
+            label_options.reverse_merge!(:caption => options.delete(:caption)) if options[:caption]
+            field_html = label(field, label_options)
+            field_html << #{field_type}(field, options)
+            @template.content_tag(:p, field_html)
+          end
+          EOF
+        end
+
+        def submit_block(caption, options={})
+          submit_html = self.submit(caption, options)
+          @template.content_tag(:p, submit_html)
+        end
+
+        def image_submit_block(source, options={})
+          submit_html = self.image_submit(source, options)
+          @template.content_tag(:p, submit_html)
+        end
+      end
+    end
+  end
+end

data/lib/padrino-helpers/form_helpers.rb

@@ -0,0 +1,633 @@
+require 'padrino-helpers/form_helpers/errors'
+require 'padrino-helpers/form_helpers/options'
+require 'padrino-helpers/form_helpers/security'
+
+module Padrino
+  module Helpers
+    ##
+    # Helpers related to producing form related tags and inputs into templates.
+    #
+    module FormHelpers
+      def self.included(base)
+        base.send(:include, FormHelpers::Errors)
+        base.send(:include, FormHelpers::Options)
+        base.send(:include, FormHelpers::Security)
+      end
+
+      ##
+      # Constructs a form for object using given or default form_builder.
+      #
+      # @param [Object] object
+      #   The object for which the form is being built.
+      # @param [String] URL
+      #   The url this form will submit to.
+      # @param [Hash] options
+      #   The settings associated with this form.
+      #   Accepts a :namespace option that will be prepended to the id attributes of the form's elements.
+      #   Also accepts HTML options.
+      # @option settings [String] :builder ("StandardFormBuilder")
+      #   The FormBuilder class to use such as StandardFormBuilder.
+      # @option settings [Symbol] :as
+      #   Sets custom form object name.
+      # @param [Proc] block
+      #   The fields and content inside this form.
+      #
+      # @yield [AbstractFormBuilder] The form builder used to compose fields.
+      #
+      # @return [String] The html object-backed form with the specified options and input fields.
+      #
+      # @example
+      #   form_for :user, '/register' do |f| ... end
+      #   form_for @user, '/register', :id => 'register' do |f| ... end
+      #   form_for @user, '/register', :as => :customer do |f| ... end
+      #
+      def form_for(object, url, options={}, &block)
+        instance = builder_instance(object, options)
+        # this can erect instance.multipart flag if the block calls instance.file_field
+        html = capture_html(instance, &block)
+        options = { :multipart => instance.multipart }.update(options.except(:namespace, :as))
+        form_tag(url, options) { html }
+      end
+
+      ##
+      # Constructs form fields for an object using given or default form_builder.
+      # Used within an existing form to allow alternate objects within one form.
+      #
+      # @param [Object] object
+      #   The object for which the fields are being built.
+      # @param [Hash] options
+      #   The settings associated with these fields. Accepts HTML options.
+      # @param [Proc] block
+      #   The content inside this set of fields.
+      #
+      # @return [String] The html fields with the specified options.
+      #
+      # @example
+      #   fields_for @user.assignment do |assignment| ... end
+      #   fields_for :assignment do |assigment| ... end
+      #
+      def fields_for(object, options={}, &block)
+        instance = builder_instance(object, options)
+        fields_html = capture_html(instance, &block)
+        fields_html << instance.hidden_field(:id) if instance.send(:nested_object_id)
+        concat_content fields_html
+      end
+
+      ##
+      # Constructs a form without object based on options.
+      #
+      # @param [String] url
+      #   The URL this form will submit to.
+      # @param [Hash] options
+      #   The html options associated with this form.
+      # @param [Proc] block
+      #   The fields and content inside this form.
+      #
+      # @return [String] The HTML form with the specified options and input fields.
+      #
+      # @example
+      #   form_tag '/register', :class => "registration_form" do ... end
+      #
+      def form_tag(url, options={}, &block)
+        options = {
+          :action => url,
+          :protect_from_csrf => is_protected_from_csrf?,
+          'accept-charset' => 'UTF-8'
+        }.update(options)
+        options[:enctype] = 'multipart/form-data' if options.delete(:multipart)
+
+        if (desired_method = options[:method]) =~ /get/i
+          options.delete(:protect_from_csrf)
+        else
+          options[:method] = 'post'
+        end
+        inner_form_html = hidden_form_method_field(desired_method)
+        inner_form_html << csrf_token_field if options.delete(:protect_from_csrf)
+        concat_content content_tag(:form, inner_form_html << capture_html(&block), options)
+      end
+
+      ##
+      # Returns the hidden method field for 'put' and 'delete' forms.
+      # Only 'get' and 'post' are allowed within browsers;
+      # 'put' and 'delete' are just specified using hidden fields with form action still 'put'.
+      #
+      # @param [String] desired_method
+      #   The method this hidden field represents (i.e put or delete).
+      #
+      # @return [String] The hidden field representing the +desired_method+ for the form.
+      #
+      # @example
+      #   # Generate: <input name="_method" value="delete" />
+      #   hidden_form_method_field('delete')
+      #
+      def hidden_form_method_field(desired_method)
+        return ActiveSupport::SafeBuffer.new if desired_method.blank? || desired_method.to_s =~ /get|post/i
+        hidden_field_tag(:_method, :value => desired_method)
+      end
+
+      ##
+      # Constructs a field_set to group fields with given options.
+      #
+      # @overload field_set_tag(legend=nil, options={}, &block)
+      #   @param [String] legend  The legend caption for the fieldset
+      #   @param [Hash]   options The html options for the fieldset.
+      #   @param [Proc]   block   The content inside the fieldset.
+      # @overload field_set_tag(options={}, &block)
+      #   @param [Hash]   options The html options for the fieldset.
+      #   @param [Proc]   block   The content inside the fieldset.
+      #
+      # @return [String] The html for the fieldset tag based on given +options+.
+      #
+      # @example
+      #   field_set_tag(:class => "office-set") { }
+      #   field_set_tag("Office", :class => 'office-set') { }
+      #
+      def field_set_tag(*args, &block)
+        options = args.extract_options!
+        legend_text = args.first
+        legend_html = legend_text.blank? ? ActiveSupport::SafeBuffer.new : content_tag(:legend, legend_text)
+        concat_content content_tag(:fieldset, legend_html << capture_html(&block), options)
+      end
+
+      ##
+      # Constructs a label tag from the given options.
+      #
+      # @param [String] name
+      #   The name of the field to label.
+      # @param [Hash] options
+      #   The html options for this label.
+      # @option options :caption
+      #   The caption for this label.
+      # @param [Proc] block
+      #   The content to be inserted into the label.
+      #
+      # @return [String] The html for this label with the given +options+.
+      #
+      # @example
+      #   label_tag :username, :class => 'long-label'
+      #   label_tag :username, :class => 'long-label' do ... end
+      #
+      def label_tag(name, options={}, &block)
+        options = { :caption => "#{name.to_s.humanize}: ", :for => name }.update(options)
+        caption_text = ActiveSupport::SafeBuffer.new << options.delete(:caption)
+        caption_text << "<span class='required'>*</span> ".html_safe if options.delete(:required)
+
+        if block_given?
+          concat_content content_tag(:label, caption_text << capture_html(&block), options)
+        else
+          content_tag(:label, caption_text, options)
+        end
+      end
+
+      ##
+      # Creates a text field input with the given name and options.
+      #
+      # @macro [new] text_field
+      #   @param [Symbol] name
+      #     The name of the input to create.
+      #   @param [Hash] options
+      #     The HTML options to include in this field.
+      #
+      #   @option options [String] :id
+      #     Specifies a unique identifier for the field.
+      #   @option options [String] :class
+      #     Specifies the stylesheet class of the field.
+      #   @option options [String] :name
+      #     Specifies the name of the field.
+      #   @option options [String] :accesskey
+      #     Specifies a shortcut key to access the field.
+      #   @option options [Integer] :tabindex
+      #     Specifies the tab order of the field.
+      #   @option options [Integer] :maxlength
+      #     Specifies the maximum length, in characters, of the field.
+      #   @option options [Integer] :size
+      #     Specifies the width, in characters, of the field.
+      #   @option options [String] :placeholder
+      #     Specifies a short hint that describes the expected value of the field.
+      #   @option options [Boolean] :hidden
+      #     Specifies whether or not the field is hidden from view.
+      #   @option options [Boolean] :spellcheck
+      #     Specifies whether or not the field should have it's spelling and grammar checked for errors.
+      #   @option options [Boolean] :draggable
+      #     Specifies whether or not the field is draggable. (true, false, :auto).
+      #   @option options [String] :pattern
+      #     Specifies the regular expression pattern that the field's value is checked against.
+      #   @option options [Symbol] :autocomplete
+      #     Specifies whether or not the field should have autocomplete enabled. (:on, :off).
+      #   @option options [Boolean] :autofocus
+      #     Specifies whether or not the field should automatically get focus when the page loads.
+      #   @option options [Boolean] :required
+      #     Specifies whether or not the field is required to be completed before the form is submitted.
+      #   @option options [Boolean] :readonly
+      #     Specifies whether or not the field is read only.
+      #   @option options [Boolean] :disabled
+      #     Specifies whether or not the field is disabled.
+      #
+      #   @return [String]
+      #     Generated HTML with specified +options+.
+      #
+      # @example
+      #   text_field_tag :first_name, :maxlength => 40, :required => true
+      #   # => <input name="first_name" maxlength="40" required type="text" />
+      #
+      #   text_field_tag :last_name, :class => 'string', :size => 40
+      #   # => <input name="last_name" class="string" size="40" type="text" />
+      #
+      #   text_field_tag :username, :placeholder => 'Your Username'
+      #   # => <input name="username" placeholder="Your Username" type="text" />
+      #
+      def text_field_tag(name, options={})
+        input_tag(:text, { :name => name }.update(options))
+      end
+
+      ##
+      # Creates a number field input with the given name and options.
+      #
+      # @macro [new] number_field
+      #   @param [Symbol] name
+      #     The name of the input to create.
+      #   @param [Hash] options
+      #     The HTML options to include in this field.
+      #
+      #   @option options [String] :id
+      #     Specifies a unique identifier for the field.
+      #   @option options [String] :class
+      #     Specifies the stylesheet class of the field.
+      #   @option options [String] :name
+      #     Specifies the name of the field.
+      #   @option options [String] :accesskey
+      #     Specifies a shortcut key to access the field.
+      #   @option options [Integer] :tabindex
+      #     Specifies the tab order of the field.
+      #   @option options [Integer] :min
+      #     Specifies the minimum value of the field.
+      #   @option options [Integer] :max
+      #     Specifies the maximum value of the field.
+      #   @option options [Integer] :step
+      #     Specifies the legal number intervals of the field.
+      #   @option options [Boolean] :hidden
+      #     Specifies whether or not the field is hidden from view.
+      #   @option options [Boolean] :spellcheck
+      #     Specifies whether or not the field should have it's spelling and grammar checked for errors.
+      #   @option options [Boolean] :draggable
+      #     Specifies whether or not the field is draggable. (true, false, :auto).
+      #   @option options [String] :pattern
+      #     Specifies the regular expression pattern that the field's value is checked against.
+      #   @option options [Symbol] :autocomplete
+      #     Specifies whether or not the field should have autocomplete enabled. (:on, :off).
+      #   @option options [Boolean] :autofocus
+      #     Specifies whether or not the field should automatically get focus when the page loads.
+      #   @option options [Boolean] :required
+      #     Specifies whether or not the field is required to be completeled before the form is submitted.
+      #   @option options [Boolean] :readonly
+      #     Specifies whether or not the field is read only.
+      #   @option options [Boolean] :disabled
+      #     Specifies whether or not the field is disabled.
+      #
+      #   @return [String]
+      #     Generated HTML with specified +options+.
+      #
+      # @example
+      #   number_field_tag :quantity, :class => 'numeric'
+      #   # => <input name="quantity" class="numeric" type="number" />
+      #
+      #   number_field_tag :zip_code, :pattern => /[0-9]{5}/
+      #   # => <input name="zip_code" pattern="[0-9]{5}" type="number" />
+      #
+      #   number_field_tag :credit_card, :autocomplete => :off
+      #   # => <input name="credit_card" autocomplete="off" type="number" />
+      #
+      #   number_field_tag :age, :min => 18, :max => 120, :step => 1
+      #   # => <input name="age" min="18" max="120" step="1" type="number" />
+      #
+      def number_field_tag(name, options={})
+        input_tag(:number, { :name => name }.update(options))
+      end
+
+      ##
+      # Creates a telephone field input with the given name and options.
+      #
+      # @macro text_field
+      #
+      # @example
+      #   telephone_field_tag :phone_number, :class => 'string'
+      #   # => <input name="phone_number" class="string" type="tel" />
+      #
+      #  telephone_field_tag :cell_phone, :tabindex => 1
+      #  telephone_field_tag :work_phone, :tabindex => 2
+      #  telephone_field_tag :home_phone, :tabindex => 3
+      #
+      #  # => <input name="cell_phone" tabindex="1" type="tel" />
+      #  # => <input name="work_phone" tabindex="2" type="tel" />
+      #  # => <input name="home_phone" tabindex="3" type="tel" />
+      #
+      def telephone_field_tag(name, options={})
+        input_tag(:tel, { :name => name }.update(options))
+      end
+      alias_method :phone_field_tag, :telephone_field_tag
+
+      ##
+      # Creates an email field input with the given name and options.
+      #
+      # @macro text_field
+      #
+      # @example
+      #   email_field_tag :email, :placeholder => 'you@example.com'
+      #   # => <input name="email" placeholder="you@example.com" type="email" />
+      #
+      #   email_field_tag :email, :value => 'padrinorb@gmail.com', :readonly => true
+      #   # => <input name="email" value="padrinorb@gmail.com" readonly type="email" />
+      #
+      def email_field_tag(name, options={})
+        input_tag(:email, { :name => name }.update(options))
+      end
+
+      ##
+      # Creates a search field input with the given name and options.
+      #
+      # @macro text_field
+      #
+      # @example
+      #  search_field_tag :search, :placeholder => 'Search this website...'
+      #  # => <input name="search" placeholder="Search this website..." type="search" />
+      #
+      #  search_field_tag :search, :maxlength => 15, :class => ['search', 'string']
+      #  # => <input name="search" maxlength="15" class="search string" />
+      #
+      #  search_field_tag :search, :id => 'search'
+      #  # => <input name="search" id="search" type="search" />
+      #
+      #  search_field_tag :search, :autofocus => true
+      #  # => <input name="search" autofocus type="search" />
+      #
+      def search_field_tag(name, options={})
+        input_tag(:search, { :name => name }.update(options))
+      end
+
+      ##
+      # Creates a URL field input with the given name and options.
+      #
+      # @macro text_field
+      #
+      # @example
+      #  url_field_tag :favorite_website, :placeholder => 'http://padrinorb.com'
+      #  <input name="favorite_website" placeholder="http://padrinorb.com." type="url" />
+      #
+      #  url_field_tag :home_page, :class => 'string url'
+      #  <input name="home_page" class="string url", type="url" />
+      #
+      def url_field_tag(name, options={})
+        input_tag(:url, { :name => name }.update(options))
+      end
+
+      ##
+      # Constructs a hidden field input from the given options.
+      #
+      # @example
+      #   hidden_field_tag :session_key, :value => "__secret__"
+      #
+      def hidden_field_tag(name, options={})
+        input_tag(:hidden, { :name => name }.update(options))
+      end
+
+      ##
+      # Constructs a text area input from the given options.
+      #
+      # @example
+      #   text_area_tag :username, :class => 'long', :value => "Demo?"
+      #
+      def text_area_tag(name, options={})
+        inner_html = "\n#{options.delete(:value)}"
+        options = { :name => name, :rows => "", :cols => "" }.update(options)
+        content_tag(:textarea, inner_html, options)
+      end
+
+      ##
+      # Constructs a password field input from the given options.
+      #
+      # @example
+      #   password_field_tag :password, :class => 'long'
+      #
+      # @api public
+      def password_field_tag(name, options={})
+        input_tag(:password, { :name => name }.update(options))
+      end
+
+      ##
+      # Constructs a check_box from the given options.
+      #
+      # @example
+      #   check_box_tag :remember_me, :value => 'Yes'
+      #
+      def check_box_tag(name, options={})
+        input_tag(:checkbox, { :name => name, :value => '1' }.update(options))
+      end
+
+      ##
+      # Constructs a radio_button from the given options.
+      #
+      # @example
+      #   radio_button_tag :remember_me, :value => 'true'
+      #
+      def radio_button_tag(name, options={})
+        input_tag(:radio, { :name => name }.update(options))
+      end
+
+      ##
+      # Constructs a file field input from the given options.
+      #
+      # @example
+      #   file_field_tag :photo, :class => 'long'
+      #
+      # @api public
+      def file_field_tag(name, options={})
+        name = "#{name}[]" if options[:multiple]
+        input_tag(:file, { :name => name }.update(options))
+      end
+
+      ##
+      # Constructs a select from the given options.
+      #
+      # @example
+      #   options = [['caption', 'value'], ['Green', 'green1'], ['Blue', 'blue1'], ['Black', "black1"]]
+      #   options = ['option', 'red', 'yellow' ]
+      #   select_tag(:favorite_color, :options => ['red', 'yellow'], :selected => 'green1')
+      #   select_tag(:country, :collection => @countries, :fields => [:name, :code], :include_blank => 'None')
+      #
+      #   # Optgroups can be generated using :grouped_options => (Hash or nested Array)
+      #   grouped_options = [['Friends',['Yoda',['Obiwan',1]]],['Enemies',['Palpatine',['Darth Vader',3]]]]
+      #   grouped_options = {'Friends' => ['Yoda',['Obiwan',1]],'Enemies' => ['Palpatine',['Darth Vader',3]]}
+      #   select_tag(:color, :grouped_options => [['warm',['red','yellow']],['cool',['blue', 'purple']]])
+      #
+      #   # Optgroups can be generated using the rails-style attribute hash.
+      #   grouped_options = {
+      #     "Friends" => ["Yoda", ["Obiwan", 2, {:magister => 'no'}], {:lame => 'yes'}],
+      #     "Enemies" => [["Palpatine", "Palpatine", {:scary => 'yes', :old => 'yes'}], ["Darth Vader", 3, {:disabled => true}]]
+      #   }
+      #   select_tag(:name, :grouped_options => grouped_options)
+      #
+      # @param [String] name
+      #   The name of the input field.
+      # @param [Hash] options
+      #   The html options for the input field.
+      # @option options [Array<String, Array>] :options
+      #  Explicit options to display in the select. Can be strings or string tuples.
+      # @option options [Array<Array>] :grouped_options
+      #   List of options for each group in the select. See examples for details.
+      # @option options [Array<Object>] :collection
+      #   Collection of objects used as options in the select.
+      # @option options [Array<Symbol>] :fields
+      #   The attributes used as "label" and "value" for each +collection+ object.
+      # @option options [String] :selected (nil)
+      #   The option value initially selected.
+      # @option options [Boolean] :include_blank (false)
+      #   Include a blank option in the select.
+      # @option options [Boolean] :multiple (false)
+      #   Allow multiple options to be selected at once.
+      #
+      # @return [String] The HTML input field based on the +options+ specified.
+      #
+      def select_tag(name, options={})
+        options = { :name => name }.merge(options)
+        options[:name] = "#{options[:name]}[]" if options[:multiple]
+        content_tag(:select, extract_option_tags!(options), options)
+      end
+
+      ##
+      # Constructs a button input from the given options.
+      #
+      # @param [String] caption
+      #   The caption for the button.
+      # @param [Hash] options
+      #   The html options for the input field.
+      #
+      # @return [String] The html button based on the +options+ specified.
+      #
+      # @example
+      #   button_tag "Cancel", :class => 'clear'
+      #
+      def button_tag(caption, options = {})
+        input_tag(:button, { :value => caption }.update(options))
+      end
+
+      ##
+      # Constructs a submit button from the given options.
+      #
+      # @param [String] caption (defaults to: +Submit+)
+      #   The caption for the submit button.
+      # @param [Hash] options
+      #   The html options for the input field.
+      #
+      # @return [String] The html submit button based on the +options+ specified.
+      #
+      # @example
+      #   submit_tag "Create", :class => 'success'
+      #   submit_tag :class => 'btn'
+      #
+      def submit_tag(*args)
+        options = args.extract_options!
+        caption = args.length >= 1 ? args.first : "Submit"
+        input_tag(:submit, { :value => caption }.merge(options))
+      end
+
+      ##
+      # Constructs a submit button from the given options.
+      #
+      # @param [String] source
+      #   The source image path for the button.
+      # @param [Hash] options
+      #   The html options for the input field.
+      #
+      # @return [String] The html image button based on the +options+ specified.
+      #
+      # @example
+      #   image_submit_tag 'form/submit.png'
+      #
+      def image_submit_tag(source, options={})
+        input_tag(:image, { :src => image_path(source) }.update(options))
+      end
+
+      ##
+      # Creates a form containing a single button that submits to the URL.
+      #
+      # @overload button_to(name, url, options={})
+      #   @param [String]  caption  The text caption.
+      #   @param [String]  url      The url href.
+      #   @param [Hash]    options  The html options.
+      # @overload button_to(name, options={}, &block)
+      #   @param [String]  url      The url href.
+      #   @param [Hash]    options  The html options.
+      #   @param [Proc]    block    The button content.
+      #
+      # @option options [Boolean] :multipart
+      #   If true, this form will support multipart encoding.
+      # @option options [String] :remote
+      #   Instructs ujs handler to handle the submit as ajax.
+      # @option options [Symbol] :method
+      #   Instructs ujs handler to use different http method (i.e :post, :delete).
+      # @option options [Hash] :submit_options
+      #   Hash of any options, that you want to pass to submit_tag (i.e :id, :class)
+      #
+      # @return [String] Form and button html with specified +options+.
+      #
+      # @example
+      #   button_to 'Delete', url(:accounts_destroy, :id => account), :method => :delete, :class => :form
+      #   # Generates:
+      #   # <form class="form" action="/admin/accounts/destroy/2" method="post">
+      #   #   <input type="hidden" value="delete" name="_method" />
+      #   #   <input type="submit" value="Delete" />
+      #   # </form>
+      #
+      def button_to(*args, &block)
+        options   = args.extract_options!.dup
+        name, url = *args
+        options['data-remote'] = 'true' if options.delete(:remote)
+        submit_options = options.delete(:submit_options) || {}
+        block ||= proc { submit_tag(name, submit_options) }
+        form_tag(url || name, options, &block)
+      end
+
+      ##
+      # Constructs a range tag from the given options.
+      #
+      # @example
+      #   range_field_tag('ranger_with_min_max', :min => 1, :max => 50)
+      #   range_field_tag('ranger_with_range', :range => 1..5)
+      #
+      # @param [String] name
+      #   The name of the range field.
+      # @param [Hash] options
+      #   The html options for the range field.
+      # @option options [Integer] :min
+      #  The min range of the range field.
+      # @option options [Integer] :max
+      #  The max range of the range field.
+      # @option options [range] :range
+      #  The range, in lieu of :min and :max.  See examples for details.
+      # @return [String] The html range field
+      #
+      def range_field_tag(name, options = {})
+        options = { :name => name }.update(options)
+        if range = options.delete(:range)
+          options[:min], options[:max] = range.min, range.max
+        end
+        input_tag(:range, options)
+      end
+
+      private
+
+      ##
+      # Returns an initialized builder instance for the given object and settings.
+      #
+      # @example
+      #   builder_instance(@account, :nested => { ... }) => <FormBuilder>
+      #
+      def builder_instance(object, options={})
+        default_builder = respond_to?(:settings) && settings.default_builder || 'StandardFormBuilder'
+        builder_class = options.delete(:builder) || default_builder
+        builder_class = "Padrino::Helpers::FormBuilder::#{builder_class}".constantize if builder_class.is_a?(String)
+        builder_class.new(self, object, options)
+      end
+    end
+  end
+end