padrino-helpers 0.12.0 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abf7a7c5e2a12e941b018c62e94e24b47f1b9bf6
-  data.tar.gz: c59d6ed08223958df60c85512571fa3b063e46af
+  metadata.gz: 9de9c68240b6a030c87053b1f781ef7152ef5bfc
+  data.tar.gz: a9a5d042cd4ed7d6dd52d9977b4421c0a40389e2
 SHA512:
-  metadata.gz: b75a79d145a6a8027674b75713c11afa14fd727b02d6f60754bda869ded0c925f47c1f408158d4186f8ee70ee72826c829e92e4309708521b1fcba3f6d854e68
-  data.tar.gz: 3be7c0827d6f9750bf536b41abb358745c474cbd5429c54e7e11619c2973a3aecb8583793f7dbbed8c96f888e28a58a30b8ac7e721c72806c59bfa7ee60eb3f3
+  metadata.gz: f0d72f6b0c05eaae7fb28d4fd7c85d7d76a9e2e7a7ef719f42040b0148cdbfb19ccdd3f790ef592328ec341edaf15acf74cda7b6e24b21aa4ce25beaa2af44fa
+  data.tar.gz: 97eb607b9c2caf7c9242c39afa18ceac5f63e7306d46c0e01d3041e93bf3008fef4e0a7b7f03bfc5ba9624b3cb6a7bd2fc9520e63cc9a85396af7d52c621e347

data/lib/padrino-helpers.rb

@@ -1,4 +1,4 @@
-require 'padrino-core/support_lite' unless defined?(SupportLite)
+require 'padrino-support'
 require 'i18n'
 require 'enumerator'
 require 'active_support/time_with_zone'               # next extension depends on this
@@ -6,6 +6,8 @@ require 'active_support/core_ext/string/conversions'  # to_date
 require 'active_support/option_merger'                # with_options
 require 'active_support/core_ext/object/with_options' # with_options
 require 'active_support/inflector'                    # humanize
+require 'active_support/core_ext/hash/except'         # Hash#except
+require 'padrino/rendering'
 
 FileSet.glob_require('padrino-helpers/**/*.rb', __FILE__)
 I18n.load_path += Dir["#{File.dirname(__FILE__)}/padrino-helpers/locale/*.yml"]
@@ -41,6 +43,7 @@ module Padrino
       #   end
       #
       def registered(app)
+        app.register Padrino::Rendering
         app.set :default_builder, 'StandardFormBuilder'
         app.helpers Padrino::Helpers::OutputHelpers
         app.helpers Padrino::Helpers::TagHelpers

data/lib/padrino-helpers/asset_tag_helpers.rb

@@ -32,11 +32,11 @@ module Padrino
       def flash_tag(*args)
         options = args.extract_options!
         bootstrap = options.delete(:bootstrap) if options[:bootstrap]
-        args.inject(''.html_safe) do |html,kind|
-          flash_text = flash[kind]
+        args.inject(ActiveSupport::SafeBuffer.new) do |html,kind|
+          flash_text = ActiveSupport::SafeBuffer.new << flash[kind]
           next html if flash_text.blank?
-          flash_text << safe_content_tag(:button, "&times;", {:type => :button, :class => :close, :'data-dismiss' => :alert}) if bootstrap
-          html << safe_content_tag(:div, flash_text, options.reverse_merge(:class => kind))
+          flash_text << content_tag(:button, '&times;'.html_safe, {:type => :button, :class => :close, :'data-dismiss' => :alert}) if bootstrap
+          html << content_tag(:div, flash_text, { :class => kind }.update(options))
         end
       end
 
@@ -230,11 +230,13 @@ module Padrino
       #
       # @api public.
       def stylesheet_link_tag(*sources)
-        options = sources.extract_options!.symbolize_keys
-        options.reverse_merge!(:media => 'screen', :rel => 'stylesheet', :type => 'text/css')
-        sources.flatten.map { |source|
-          tag(:link, options.reverse_merge(:href => asset_path(:css, source)))
-        }.join("\n").html_safe
+        options = {
+          :rel => 'stylesheet',
+          :type => 'text/css'
+        }.update(sources.extract_options!.symbolize_keys)
+        sources.flatten.inject(ActiveSupport::SafeBuffer.new) do |all,source|
+          all << tag(:link, { :href => asset_path(:css, source) }.update(options))
+        end
       end
 
       ##
@@ -252,11 +254,12 @@ module Padrino
       #   javascript_include_tag 'application', :extjs
       #
       def javascript_include_tag(*sources)
-        options = sources.extract_options!.symbolize_keys
-        options.reverse_merge!(:type => 'text/javascript')
-        sources.flatten.map { |source|
-          content_tag(:script, nil, options.reverse_merge(:src => asset_path(:js, source)))
-        }.join("\n").html_safe
+        options = {
+          :type => 'text/javascript'
+        }.update(sources.extract_options!.symbolize_keys)
+        sources.flatten.inject(ActiveSupport::SafeBuffer.new) do |all,source|
+          all << content_tag(:script, nil, { :src => asset_path(:js, source) }.update(options))
+        end
       end
 
       ##

data/lib/padrino-helpers/breadcrumb_helpers.rb

@@ -143,7 +143,7 @@ module Padrino
       #  # </ul>
       #
       def breadcrumbs(breadcrumbs, bootstrap = false, active = "active", options = {})
-        content = ""
+        content = ActiveSupport::SafeBuffer.new
         breadcrumbs.items[0..-2].each do |item|
           content << render_item(item, bootstrap)
         end
@@ -156,8 +156,8 @@ module Padrino
         classes[1] << active if active
         options[:class], last_options[:class] = classes.map { |class_name| class_name * " " }
 
-        content << safe_content_tag(:li, last, last_options)
-        safe_content_tag(:ul, content, options)
+        content << content_tag(:li, last, last_options)
+        content_tag(:ul, content, options)
       end
 
       private
@@ -173,10 +173,10 @@ module Padrino
       # @return [String] List item with breadcrumb
       #
       def render_item(item, bootstrap)
-        content = ""
+        content = ActiveSupport::SafeBuffer.new
         content << link_to(item[:caption], item[:url])
-        content << safe_content_tag(:span, "/", :class => "divider") if bootstrap
-        safe_content_tag(:li, content, item[:options])
+        content << content_tag(:span, "/", :class => "divider") if bootstrap
+        content_tag(:li, content, item[:options])
       end
     end
   end

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

@@ -1,129 +1,119 @@
+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
-          @object   = build_object(object)
-          @options  = options
-          raise "FormBuilder template must be initialized!" unless template
-          raise "FormBuilder object must not be a nil value. If there's no object, use a symbol instead! (i.e :user)" unless object
+          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)
-          params.unshift object
-          @template.error_messages_for(*params)
+          @template.error_messages_for object, *params
         end
 
         def error_message_on(field, options={})
-          @template.error_message_on(object, field, options)
+          @template.error_message_on object, field, options
         end
 
         def label(field, options={}, &block)
-          options.reverse_merge!(:caption => "#{field_human_name(field)}: ")
-          @template.label_tag(field_id(field), options, &block)
+          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={})
-          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
-          @template.hidden_field_tag field_name(field), options
+          @template.hidden_field_tag field_name(field), default_options(field, options)
         end
 
         def text_field(field, options={})
-          merge_default_options!(field, options)
-          @template.text_field_tag field_name(field), options
+          @template.text_field_tag field_name(field), default_options(field, options)
         end
 
         def number_field(field, options={})
-          merge_default_options!(field, options)
-          @template.number_field_tag field_name(field), options
+          @template.number_field_tag field_name(field), default_options(field, options)
         end
 
         def telephone_field(field, options={})
-          merge_default_options!(field, options)
-          @template.telephone_field_tag field_name(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={})
-          merge_default_options!(field, options)
-          @template.email_field_tag field_name(field), options
+          @template.email_field_tag field_name(field), default_options(field, options)
         end
 
         def search_field(field, options={})
-          merge_default_options!(field, options)
-          @template.search_field_tag field_name(field), options
+          @template.search_field_tag field_name(field), default_options(field, options)
         end
 
         def url_field(field, options={})
-          merge_default_options!(field, options)
-          @template.url_field_tag field_name(field), options
+          @template.url_field_tag field_name(field), default_options(field, options)
         end
 
         def text_area(field, options={})
-          merge_default_options!(field, options)
-          @template.text_area_tag field_name(field), options
+          @template.text_area_tag field_name(field), default_options(field, options)
         end
 
         def password_field(field, options={})
-          merge_default_options!(field, options)
-          @template.password_field_tag field_name(field), options
+          @template.password_field_tag field_name(field), default_options(field, options)
         end
 
         def select(field, options={})
-          options.reverse_merge!(:id => field_id(field), :selected => field_value(field))
-          options.merge!(:class => field_error(field, options))
-          @template.select_tag field_name(field), options
+          @template.select_tag field_name(field), default_options(field, options)
         end
 
         def check_box_group(field, options={})
-          selected_values = Array(options[:selected] || field_value(field))
-          if options[:collection]
-            fields = options[:fields] || [:name, :id]
-            selected_values = selected_values.map{ |v| (v.respond_to?(fields[0]) ? v.send(fields[1]) : v).to_s }
-          end
-          labeled_group( field, options ) do |variant|
-            @template.check_box_tag( field_name(field)+'[]', :value => variant[1], :id => variant[2], :checked => selected_values.include?(variant[1]) )
+          labeled_group(field, options) do |attributes|
+            @template.check_box_tag(field_name(field)+'[]', attributes)
           end
         end
 
         def radio_button_group(field, options={})
-          fields = options[:fields] || [:name, :id]
-          selected_value = options[:selected] || field_value(field)
-          selected_value = selected_value.send(fields[1])  if selected_value.respond_to?(fields[0])
-          labeled_group( field, options ) do |variant|
-            @template.radio_button_tag( field_name(field), :value => variant[1], :id => variant[2], :checked => variant[1] == selected_value.to_s )
+          labeled_group(field, options) do |attributes|
+            @template.radio_button_tag(field_name(field), attributes)
           end
         end
 
         def check_box(field, options={})
-          html = ActiveSupport::SafeBuffer.new
-          unchecked_value = options.delete(:uncheck_value) || '0'
-          options.reverse_merge!(:id => field_id(field), :value => '1')
-          options.reverse_merge!(:checked => true) if values_matches_field?(field, options[:value])
-          html << @template.hidden_field_tag(options[:name] || field_name(field), :value => unchecked_value, :id => nil)
-          html << @template.check_box_tag(field_name(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.reverse_merge!(:id => field_id(field, options[:value]))
-          options.reverse_merge!(:checked => true) if values_matches_field?(field, options[:value])
+          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
-          options.reverse_merge!(:id => field_id(field))
-          options.merge!(:class => field_error(field, options))
-          @template.file_field_tag field_name(field), options
+          @template.file_field_tag field_name(field), default_options(field, options).except(:value)
         end
 
         def submit(*args)
-          options = args[-1].is_a?(Hash) ? args.pop : {}
-          caption = args.length >= 1 ? args.shift : "Submit"
-          @template.submit_tag caption, options
+          @template.submit_tag *args
         end
 
         def image_submit(source, options={})
@@ -136,24 +126,16 @@ module Padrino
         # f.fields_for :addresses, address
         # f.fields_for :addresses, @addresses
         # f.fields_for :addresses, address, index: i
-        def fields_for(child_association, instance_or_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)
-          custom_index = options.has_key?(:index)
 
           nested_options = { :parent => self, :association => child_association }
-          nested_objects = instance_or_collection ? Array(instance_or_collection) : Array(default_collection)
-          nested_objects.each_with_index.map do |child_instance, index|
-            if custom_index
-              nested_options[:index] = options[:index]
-            elsif include_index
-              nested_options[:index] = index
-            else
-              nested_options[:index] = nil
-            end
-            @template.fields_for(child_instance,  { :nested => nested_options }, &block)
-          end.join("\n").html_safe
+          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 }, &block) << "\n"
+          end
         end
 
         def csrf_token_field
@@ -161,43 +143,21 @@ module Padrino
         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 true if the value matches the value in the field.
-        # field_has_value?(:gender, 'male')
-        def values_matches_field?(field, value)
-          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)
-          error = @object.errors[field] rescue nil
-          error.blank? ? options[:class] : [options[:class], :invalid].flatten.compact.join(" ")
-        end
-
-        ##
-        # Returns the human name of the field. Look that use builtin I18n.
-        #
-        def field_human_name(field)
-          I18n.translate("#{object_model_name}.attributes.#{field}", :count => 1, :default => field.to_s.humanize, :scope => :models)
-        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_result
-          result << field_name_fragment if nested_form?
+          result = field_name_fragment
           result << "[#{field}]" unless field.blank?
-          result.flatten.join
+          result
         end
 
         ##
@@ -207,118 +167,114 @@ module Padrino
         # field_name(:number) => "user_telephone_attributes_number"
         # field_name(:street) => "user_addresses_attributes_0_street"
         def field_id(field=nil, value=nil)
-          result = []
-          result << "#{@options[:namespace]}_" if @options[:namespace] && root_form?
-          result << field_result
-          result << field_id_fragment if nested_form?
+          result = (namespace && !is_nested) ? "#{namespace}_" : ''
+          result << field_id_fragment
           result << "_#{field}" unless field.blank?
           result << "_#{value}" unless value.blank?
-          result.flatten.join
+          result
         end
 
         ##
         # Returns the child object if it exists.
         #
         def nested_object_id
-          nested_form? && object.respond_to?(:new_record?) && !object.new_record? && object.id
-        end
-
-        ##
-        # Returns true if this form object is nested in a parent form.
-        #
-        def nested_form?
-          @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 the value for the object's field.
         #
         def field_value(field)
-          @object && @object.respond_to?(field) ? @object.send(field) : ""
+          @object.respond_to?(field) ? @object.send(field) : ''
         end
 
         ##
-        # Returns a new record of the type specified in the object
+        # Returns a record from template instance or create a record of specified class.
         #
-        def build_object(object_or_symbol)
-          object_or_symbol.is_a?(Symbol) ? @template.instance_variable_get("@#{object_or_symbol}") || object_class(object_or_symbol).new : object_or_symbol
+        def build_object(symbol)
+          @template.instance_variable_get("@#{symbol}") || symbol.to_s.camelize.constantize.new
         end
 
         ##
-        # Returns the object's models name.
+        # Builds a group of labels for radios or checkboxes.
         #
-        def object_model_name(explicit_object=object)
-          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(/\//, '_')
+        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
 
-        ##
-        # Returns the class type for the given object.
-        #
-        def object_class(explicit_object)
-          explicit_object.is_a?(Symbol) ? explicit_object.to_s.camelize.constantize : explicit_object.class
-        end
+        private
 
-        ##
-        # Returns true if this form is the top-level (not nested).
-        #
-        def root_form?
-          !nested_form?
+        def is_checked?(field, options)
+          !options.has_key?(:checked) && [options[:value].to_s, 'true'].include?(field_value(field).to_s)
         end
 
-        ##
-        # Builds a group of labels for radios or checkboxes.
-        #
-        def labeled_group(field, options={})
-          options.reverse_merge!(:id => field_id(field), :selected => field_value(field))
-          options.merge!(:class => field_error(field, options))
-          variants = case
-          when options[:options]
-            options[:options].map{ |caption, value| [caption.to_s, (value||caption).to_s] }
-          when options[:collection]
-            fields = options[:fields] || [:name, :id]
-            options[:collection].map{ |variant| [variant.send(fields.first).to_s, variant.send(fields.last).to_s] }
+        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
-          variants.inject(''.html_safe) do |html, variant|
-            variant[2] = "#{field_id(field)}_#{variant[1]}"
-            caption = yield(variant) << ' ' << variant[0]
-            html << @template.label_tag("#{field_name(field)}[]", :for => variant[2], :caption => caption)
+        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
 
-        private
+        def field_methods(options)
+          options[:fields] || [:name, :id]
+        end
 
-        def field_result
-          result = []
-          result << object_model_name if root_form?
-          result
+        def field_values(object, options)
+          field_methods(options).map{ |field| object.send(field).to_s }
         end
 
         def field_name_fragment
-          fragment = [result_options[:parent_form].field_name, "[#{result_options[:attributes_name]}", "]"]
-          fragment.insert(2, "][#{result_options[:nested_index]}") if result_options[:nested_index]
-          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
-          fragment = [result_options[:parent_form].field_id, "_#{result_options[:attributes_name]}"]
-          fragment.push("_#{result_options[:nested_index]}") if result_options[:nested_index]
-          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 result_options
-          {
-            :parent_form  => @options[:nested][:parent],
-            :nested_index => @options[:nested][:index],
-            :attributes_name => "#{@options[:nested][:association]}_attributes"
-          }
+        def error_class(field)
+          error = @object.errors[field] if @object.respond_to?(:errors)
+          error.blank? ? {} : { :class => 'invalid' }
         end
 
-        def merge_default_options!(field, options)
-          options.reverse_merge!(:value => field_value(field), :id => field_id(field))
-          options.merge!(:class => field_error(field, options))
+        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