padrino-helpers 0.16.0.pre4 → 0.16.0

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

@@ -6,16 +6,16 @@ module Padrino
         attr_accessor :template, :object, :multipart
         attr_reader :namespace, :is_nested, :parent_form, :nested_index, :attributes_name, :model_name
 
-        def initialize(template, object, options={})
+        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
+          raise 'FormBuilder template must be initialized' unless template
+          @object = object.is_a?(Symbol) ? build_object(object) : object
+          raise "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] || Inflections.underscore(@object.class).tr('/', '_')
           nested = options[:nested]
-          if @is_nested = nested && (nested_parent = nested[:parent]) && nested_parent.respond_to?(:object)
+          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"
@@ -26,120 +26,122 @@ module Padrino
           @template.error_messages_for object, *params
         end
 
-        def error_message_on(field, options={})
+        def error_message_on(field, options = {})
           @template.error_message_on object, field, options
         end
 
-        def label(field, options={}, &block)
-          @template.label_tag(field_id(field), { :caption => "#{field_human_name(field)}: " }.update(options), &block)
+        def label(field, options = {}, &block)
+          @template.label_tag(field_id(field), { caption: "#{field_human_name(field)}: " }.update(options), &block)
         end
 
-        def hidden_field(field, options={})
+        def hidden_field(field, options = {})
           @template.hidden_field_tag field_name(field), default_options(field, options)
         end
 
-        def text_field(field, options={})
+        def text_field(field, options = {})
           @template.text_field_tag field_name(field), default_options(field, options)
         end
 
-        def number_field(field, options={})
+        def number_field(field, options = {})
           @template.number_field_tag field_name(field), default_options(field, options)
         end
 
-        def telephone_field(field, options={})
+        def telephone_field(field, options = {})
           @template.telephone_field_tag field_name(field), default_options(field, options)
         end
-        alias_method :phone_field, :telephone_field
+        alias phone_field telephone_field
 
-        def email_field(field, options={})
+        def email_field(field, options = {})
           @template.email_field_tag field_name(field), default_options(field, options)
         end
 
-        def search_field(field, options={})
+        def search_field(field, options = {})
           @template.search_field_tag field_name(field), default_options(field, options)
         end
 
-        def url_field(field, options={})
+        def url_field(field, options = {})
           @template.url_field_tag field_name(field), default_options(field, options)
         end
 
-        def text_area(field, options={})
+        def text_area(field, options = {})
           @template.text_area_tag field_name(field), default_options(field, options)
         end
 
-        def password_field(field, options={})
+        def password_field(field, options = {})
           @template.password_field_tag field_name(field), default_options(field, options)
         end
 
-        def select(field, options={})
+        def select(field, options = {})
           @template.select_tag field_name(field), default_options(field, options)
         end
 
-        def check_box_group(field, options={})
+        def check_box_group(field, options = {})
           labeled_group(field, options) do |attributes|
-            @template.check_box_tag(field_name(field)+'[]', attributes)
+            @template.check_box_tag("#{field_name(field)}[]", attributes)
           end
         end
 
-        def radio_button_group(field, options={})
+        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')
+        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.hidden_field_tag(name, value: options.delete(:uncheck_value) || '0')
           html << @template.check_box_tag(name, options)
         end
 
-        def radio_button(field, options={})
+        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={})
+        def file_field(field, options = {})
           self.multipart = true
-          @template.file_field_tag field_name(field), default_options(field, options).reject{ |key, _| key == :value }
+          options = default_options(field, options)
+          options.delete(:value)
+          @template.file_field_tag field_name(field), options
         end
 
         def submit(*args)
           @template.submit_tag(*args)
         end
 
-        def image_submit(source, options={})
+        def image_submit(source, options = {})
           @template.image_submit_tag source, options
         end
 
-        def datetime_field(field, options={})
+        def datetime_field(field, options = {})
           @template.datetime_field_tag field_name(field), default_options(field, options)
         end
 
-        def datetime_local_field(field, options={})
+        def datetime_local_field(field, options = {})
           @template.datetime_local_field_tag field_name(field), default_options(field, options)
         end
 
-        def date_field(field, options={})
+        def date_field(field, options = {})
           @template.date_field_tag field_name(field), default_options(field, options)
         end
 
-        def month_field(field, options={})
+        def month_field(field, options = {})
           @template.month_field_tag field_name(field), default_options(field, options)
         end
 
-        def week_field(field, options={})
+        def week_field(field, options = {})
           @template.week_field_tag field_name(field), default_options(field, options)
         end
 
-        def time_field(field, options={})
+        def time_field(field, options = {})
           @template.time_field_tag field_name(field), default_options(field, options)
         end
 
-        def color_field(field, options={})
+        def color_field(field, options = {})
           @template.color_field_tag field_name(field), default_options(field, options)
         end
 
@@ -149,15 +151,15 @@ module Padrino
         # 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)
+        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(SafeBuffer.new) do |all,(child_instance,index)|
+          nested_options = { parent: self, association: child_association }
+          Array(collection).each_with_index.inject(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"
+            all << @template.fields_for(child_instance, { nested: nested_options, builder: self.class }, &block) << "\n"
           end
         end
 
@@ -169,9 +171,10 @@ module Padrino
 
         # 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,
-            :number_field, :telephone_field, :email_field, :search_field, :url_field,
-            :datetime_field, :datetime_local_field, :date_field, :month_field, :week_field, :time_field, :color_field,
+          %i[
+            hidden_field text_field text_area password_field file_field radio_button check_box select
+            number_field telephone_field email_field search_field url_field
+            datetime_field datetime_local_field date_field month_field week_field time_field color_field
           ]
         end
 
@@ -179,14 +182,14 @@ module Padrino
         # Returns the human name of the field. Look that use builtin I18n.
         #
         def field_human_name(field)
-          I18n.translate("#{model_name}.attributes.#{field}", :count => 1, :default => Inflections.humanize(field), :scope => :models)
+          I18n.translate("#{model_name}.attributes.#{field}", count: 1, default: Inflections.humanize(field), scope: :models)
         end
 
         ##
         # Returns the object's models name.
         #
-        def object_model_name(explicit_object=object)
-          explicit_object.is_a?(Symbol) ? explicit_object : explicit_object.class.to_s.underscore.gsub(/\//, '_')
+        def object_model_name(explicit_object = object)
+          explicit_object.is_a?(Symbol) ? explicit_object : explicit_object.class.to_s.underscore.gsub('/', '_')
         end
 
         ##
@@ -194,7 +197,7 @@ module Padrino
         # 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)
+        def field_name(field = nil)
           result = field_name_fragment
           result << "[#{field}]" if field
           result
@@ -206,8 +209,8 @@ module Padrino
         # 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}_" : ''
+        def field_id(field = nil, value = nil)
+          result = namespace && !is_nested ? "#{namespace}_" : ''
           result << field_id_fragment
           result << "_#{field}" if field
           result << "_#{value}" if value
@@ -238,29 +241,29 @@ module Padrino
         ##
         # 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(' ') }
+        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(SafeBuffer.new) do |html, (caption,value)|
+          variants_for_group(options).inject(SafeBuffer.new) do |html, (caption, value)|
             variant_id = "#{options[:id]}_#{value}"
-            attributes = { :value => value, :id => variant_id, :checked => selected_values.include?(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)
+            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)
+          !options.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) }
+          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
@@ -279,20 +282,20 @@ module Padrino
         end
 
         def field_methods(options)
-          options[:fields] || [:name, :id]
+          options[:fields] || %i[name id]
         end
 
         def field_values(object, options)
-          field_methods(options).map{ |field| object.send(field).to_s }
+          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 << "]"
+            fragment << ']'
           else
-            "#{model_name}"
+            model_name.to_s.dup
           end
         end
 
@@ -302,19 +305,20 @@ module Padrino
             fragment << "_#{nested_index}" if nested_index
             fragment
           else
-            "#{model_name}"
+            model_name.to_s.dup
           end
         end
 
         def error_class(field)
           error = @object.errors[field] if @object.respond_to?(:errors)
-          error.nil? || error.empty? ? {} : { :class => 'invalid' }
+          error.nil? || error.empty? ? {} : { 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(' ') }
+        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

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

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/abstract_form_builder') unless defined?(AbstractFormBuilder)
+require_relative 'abstract_form_builder' unless defined?(AbstractFormBuilder)
 
 module Padrino
   module Helpers
@@ -7,33 +7,33 @@ module Padrino
         ##
         # 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'])
+        #   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={})
-            if options[:caption]
-              options = options.dup
-              label_options = { :caption => options.delete(:caption) }.update(label_options)
+        (self.field_types - %i[hidden_field radio_button]).each do |field_type|
+          class_eval <<~RUBY, __FILE__, __LINE__ + 1
+            def #{field_type}_block(field, options={}, label_options={})
+              if options[:caption]
+                options = options.dup
+                label_options = { caption: options.delete(:caption) }.update(label_options)
+              end
+              field_html = label(field, label_options)
+              field_html << #{field_type}(field, options)
+              @template.content_tag(:p, field_html)
             end
-            field_html = label(field, label_options)
-            field_html << #{field_type}(field, options)
-            @template.content_tag(:p, field_html)
-          end
-          EOF
+          RUBY
         end
 
-        def submit_block(caption, options={})
+        def submit_block(caption, options = {})
           submit_html = self.submit(caption, options)
           @template.content_tag(:p, submit_html)
         end
 
-        def image_submit_block(source, options={})
+        def image_submit_block(source, options = {})
           submit_html = self.image_submit(source, options)
           @template.content_tag(:p, submit_html)
         end

data/lib/padrino-helpers/form_helpers/errors.rb

@@ -38,8 +38,8 @@ module Padrino
         #
         def error_messages_for(*objects)
           options = objects.last.is_a?(Hash) ? Utils.symbolize_keys(objects.pop) : {}
-          objects = objects.map{ |obj| resolve_object(obj) }.compact
-          count   = objects.inject(0){ |sum, object| sum + object.errors.count }
+          objects = objects.map { |obj| resolve_object(obj) }.compact
+          count   = objects.inject(0) { |sum, object| sum + object.errors.count }
           return SafeBuffer.new if count.zero?
 
           content_tag(:div, error_contents(objects, count, options), error_html_attributes(options))
@@ -68,27 +68,27 @@ module Padrino
         #   error_message_on @post, :title
         #
         #   # => <div class="custom" style="border:1px solid red">can't be blank</div>
-        #   error_message_on :post, :title, :tag => :id, :class => :custom, :style => "border:1px solid red"
+        #   error_message_on :post, :title, tag: :id, class: :custom, style: 'border:1px solid red'
         #
         #   # => <div class="error">This title can't be blank (or it won't work)</div>
-        #   error_message_on :post, :title, :prepend => "This title", :append => "(or it won't work)"
+        #   error_message_on :post, :title, prepend: 'This title', append: "(or it won't work)"
         #
         # @return [String] The html display of an error for a particular +object+ and +field+.
         #
         # @api public
-        def error_message_on(object, field, options={})
+        def error_message_on(object, field, options = {})
           error = Array(resolve_object(object).errors[field]).first
           return SafeBuffer.new unless error
-          options = { :tag => :span, :class => :error }.update(options)
+          options = { tag: :span, class: :error }.update(options)
           tag   = options.delete(:tag)
-          error = [options.delete(:prepend), error, options.delete(:append)].compact.join(" ")
+          error = [options.delete(:prepend), error, options.delete(:append)].compact.join(' ')
           content_tag(tag, error, options)
         end
 
         private
 
         def error_contents(objects, count, options)
-          object_name = options[:object_name] || Inflections.underscore(objects.first.class).gsub(/\//, ' ')
+          object_name = options[:object_name] || Inflections.underscore(objects.first.class).gsub('/', ' ')
 
           contents = SafeBuffer.new
           contents << error_header_tag(options, object_name, count)
@@ -97,9 +97,9 @@ module Padrino
         end
 
         def error_list_tag(objects, object_name)
-          errors = objects.inject({}){ |all,object| all.update(object.errors) }
+          errors = objects.inject({}) { |all, object| all.update(object.errors) }
           error_messages = errors.inject(SafeBuffer.new) do |all, (field, message)|
-            field_name = I18n.t(field, :default => Inflections.humanize(field), :scope => [:models, object_name, :attributes])
+            field_name = I18n.t(field, default: Inflections.humanize(field), scope: [:models, object_name, :attributes])
             all << content_tag(:li, "#{field_name} #{message}")
           end
           content_tag(:ul, error_messages)
@@ -107,19 +107,19 @@ module Padrino
 
         def error_header_tag(options, object_name, count)
           header_message = options[:header_message] || begin
-            model_name = I18n.t(:name, :default => Inflections.humanize(object_name), :scope => [:models, object_name], :count => 1)
-            I18n.t :header, :count => count, :model => model_name, :locale => options[:locale], :scope => [:models, :errors, :template]
+            model_name = I18n.t(:name, default: Inflections.humanize(object_name), scope: [:models, object_name], count: 1)
+            I18n.t :header, count: count, model: model_name, locale: options[:locale], scope: %i[models errors template]
           end
           content_tag(options[:header_tag] || :h2, header_message) unless header_message.empty?
         end
 
         def error_body_tag(options)
-          body_message = options[:message] || I18n.t(:body, :locale => options[:locale], :scope => [:models, :errors, :template])
+          body_message = options[:message] || I18n.t(:body, locale: options[:locale], scope: %i[models errors template])
           content_tag(:p, body_message) unless body_message.empty?
         end
 
         def error_html_attributes(options)
-          [:id, :class, :style].each_with_object({}) do |key,all|
+          %i[id class style].each_with_object({}) do |key, all|
             if options.include?(key)
               value = options[key]
               all[key] = value if value

data/lib/padrino-helpers/form_helpers/options.rb

@@ -7,12 +7,14 @@ module Padrino
       module Options
         def extract_option_tags!(options)
           state = extract_option_state!(options)
-          option_tags = if options[:grouped_options]
-            grouped_options_for_select(options.delete(:grouped_options), state)
-          else
-            options_for_select(extract_option_items!(options), state)
-          end
-          if prompt = options.delete(:include_blank)
+          option_tags =
+            if options[:grouped_options]
+              grouped_options_for_select(options.delete(:grouped_options), state)
+            else
+              options_for_select(extract_option_items!(options), state)
+            end
+
+          if (prompt = options.delete(:include_blank))
             option_tags.unshift(blank_option(prompt))
           end
           option_tags
@@ -28,11 +30,11 @@ module Padrino
           when nil, false
             nil
           when String
-            content_tag(:option, prompt,       :value => '')
+            content_tag(:option, prompt,       value: '')
           when Array
-            content_tag(:option, prompt.first, :value => prompt.last)
+            content_tag(:option, prompt.first, value: prompt.last)
           else
-            content_tag(:option, '',           :value => '')
+            content_tag(:option, '',           value: '')
           end
         end
 
@@ -40,24 +42,23 @@ module Padrino
         # Returns whether the option should be selected or not.
         #
         # @example
-        #   option_is_selected?("red", "Red", ["red", "blue"])   => true
-        #   option_is_selected?("red", "Red", ["green", "blue"]) => false
+        #   option_is_selected?('red', 'Red', ['red', 'blue'])   => true
+        #   option_is_selected?('red', 'Red', ['green', 'blue']) => false
         #
         def option_is_selected?(value, caption, selected_values)
-          Array(selected_values).any? do |selected|
-            value ?
-              value.to_s == selected.to_s :
-              caption.to_s == selected.to_s
-          end
+          check_value = (value || caption).to_s
+
+          Array(selected_values).any? { |selected| check_value == selected.to_s }
         end
 
         ##
         # Returns the options tags for a select based on the given option items.
         #
         def options_for_select(option_items, state = {})
-          return [] if option_items.count == 0
+          return [] if option_items.none?
+
           option_items.map do |caption, value, attributes|
-            html_attributes = { :value => value || caption }.merge(attributes||{})
+            html_attributes = { value: value || caption }.merge(attributes || {})
             html_attributes[:selected] ||= option_is_selected?(html_attributes[:value], caption, state[:selected])
             html_attributes[:disabled] ||= option_is_selected?(html_attributes[:value], caption, state[:disabled])
             content_tag(:option, caption, html_attributes)
@@ -70,18 +71,18 @@ module Padrino
         def grouped_options_for_select(collection, state = {})
           collection.map do |item|
             caption = item.shift
-            attributes = item.last.kind_of?(Hash) ? item.pop : {}
+            attributes = item.last.is_a?(Hash) ? item.pop : {}
             value = item.flatten(1)
-            attributes = value.pop if value.last.kind_of?(Hash)
-            html_attributes = { :label => caption }.merge(attributes||{})
+            attributes = value.pop if value.last.is_a?(Hash)
+            html_attributes = { label: caption }.merge(attributes || {})
             content_tag(:optgroup, options_for_select(value, state), html_attributes)
           end
         end
 
         def extract_option_state!(options)
           {
-            :selected => Array(options.delete(:value))|Array(options.delete(:selected))|Array(options.delete(:selected_options)),
-            :disabled => Array(options.delete(:disabled_options))
+            selected: Array(options.delete(:value)) | Array(options.delete(:selected)) | Array(options.delete(:selected_options)),
+            disabled: Array(options.delete(:disabled_options))
           }
         end
 
@@ -89,7 +90,7 @@ module Padrino
           if options[:collection]
             fields = options.delete(:fields)
             collection = options.delete(:collection)
-            collection.map{ |item| [ item.send(fields.first), item.send(fields.last) ] }
+            collection.map { |item| [item.send(fields.first), item.send(fields.last)] }
           else
             options.delete(:options) || []
           end

data/lib/padrino-helpers/form_helpers/security.rb

@@ -19,7 +19,7 @@ module Padrino
         #   csrf_token_field
         #
         def csrf_token_field
-          hidden_field_tag csrf_param, :value => csrf_token
+          hidden_field_tag csrf_param, value: csrf_token
         end
 
         ##
@@ -32,10 +32,10 @@ module Padrino
         #   csrf_meta_tags
         #
         def csrf_meta_tags
-          if is_protected_from_csrf?
-            meta_tag(csrf_param, :name => 'csrf-param') <<
-            meta_tag(csrf_token, :name => 'csrf-token')
-          end
+          return unless is_protected_from_csrf?
+
+          meta_tag(csrf_param, name: 'csrf-param') <<
+            meta_tag(csrf_token, name: 'csrf-token')
         end
 
         protected