formtastic 2.1.0 → 4.0.0

data/lib/formtastic/helpers/inputs_helper.rb

@@ -47,10 +47,6 @@ module Formtastic
       include Formtastic::Helpers::FieldsetWrapper
       include Formtastic::LocalizedString
 
-      # Which columns to skip when automatically rendering a form without any fields specified.
-      SKIPPED_COLUMNS = [:created_at, :updated_at, :created_on, :updated_on, :lock_version, :version]
-
-
       # {#inputs} creates an input fieldset and ol tag wrapping for use around a set of inputs.  It can be
       # called either with a block (in which you can do the usual Rails form stuff, HTML, ERB, etc),
       # or with a list of fields (accepting all default arguments and options). These two examples
@@ -136,7 +132,7 @@ module Formtastic
       #       <% end %>
       #     <% end %>
       #
-      # {#inputs} also provides a DSL similar to `fields_for` / `semantic_fields_for` to reduce the 
+      # {#inputs} also provides a DSL similar to `fields_for` / `semantic_fields_for` to reduce the
       # lines of code a little:
       #
       #     <% semantic_form_for @user do |f| %>
@@ -162,7 +158,7 @@ module Formtastic
       # All options except `:name`, `:title` and `:for` will be passed down to the fieldset as HTML
       # attributes (id, class, style, etc).
       #
-      # When nesting `inputs()` inside another `inputs()` block, the nested content will 
+      # When nesting `inputs()` inside another `inputs()` block, the nested content will
       # automatically be wrapped in an `<li>` tag to preserve the HTML validity (a `<fieldset>`
       # cannot be a direct descendant of an `<ol>`.
       #
@@ -182,9 +178,13 @@ module Formtastic
       #     <%= f.inputs %>
       #   <% end %>
       #
+      # @example Quick form: Skip one or more fields
+      #   <%= f.inputs :except => [:featured, :something_for_admin_only] %>
+      #   <%= f.inputs :except => :featured %>
+      #
       # @example Short hand: Render inputs for a named set of attributes and simple associations on the model, with all default arguments and options
       #   <% semantic_form_for @post do |form| %>
-      #     <%= f.inputs, :title, :body, :user, :categories %>
+      #     <%= f.inputs :title, :body, :user, :categories %>
       #   <% end %>
       #
       # @example Block: Render inputs for attributes and simple associations with full control over arguments and options
@@ -215,7 +215,7 @@ module Formtastic
       #       <%= f.input :title ... %>
       #       <%= f.input :body ... %>
       #     <% end %>
-      #     <%= f.inputs do :name => 'Advanced options:' do %>
+      #     <%= f.inputs :name => 'Advanced options:' do %>
       #       <%= f.input :user ... %>
       #       <%= f.input :categories ... %>
       #     <% end %>
@@ -279,11 +279,12 @@ module Formtastic
       def inputs(*args, &block)
         wrap_it = @already_in_an_inputs_block ? true : false
         @already_in_an_inputs_block = true
-        
+
         title = field_set_title_from_args(*args)
         html_options = args.extract_options!
         html_options[:class] ||= "inputs"
         html_options[:name] = title
+        skipped_args = Array.wrap html_options.delete(:except)
 
         out = begin
           if html_options[:for] # Nested form
@@ -292,27 +293,27 @@ module Formtastic
             field_set_and_list_wrapping(*(args << html_options), &block)
           else
             legend = args.shift if args.first.is_a?(::String)
-            args = default_columns_for_object if @object && args.empty?
+            args = default_columns_for_object - skipped_args if @object && args.empty?
             contents = fieldset_contents_from_column_list(args)
             args.unshift(legend) if legend.present?
             field_set_and_list_wrapping(*((args << html_options) << contents))
           end
         end
-        
+
         out = template.content_tag(:li, out, :class => "input") if wrap_it
         @already_in_an_inputs_block = wrap_it
         out
       end
 
       protected
-      
+
       def default_columns_for_object
         cols  = association_columns(:belongs_to)
         cols += content_columns
-        cols -= SKIPPED_COLUMNS
+        cols -= skipped_columns
         cols.compact
       end
-      
+
       def fieldset_contents_from_column_list(columns)
         columns.collect do |method|
           if @object
@@ -323,22 +324,22 @@ module Formtastic
             elsif @object.class.respond_to?(:associations)
               if (@object.class.associations[method.to_sym] && @object.class.associations[method.to_sym].options[:polymorphic] == true)
                 raise PolymorphicInputWithoutCollectionError.new("Please provide a collection for :#{method} input (you'll need to use block form syntax). Inputs for polymorphic associations can only be used when an explicit :collection is provided.")
-              end            
-            end            
+              end
+            end
           end
           input(method.to_sym)
         end
       end
-      
+
       # Collects association columns (relation columns) for the current form object class. Skips
       # polymorphic associations because we can't guess which class to use for an automatically
       # generated input.
-      def association_columns(*by_associations) #:nodoc:
+      def association_columns(*by_associations) # @private
         if @object.present? && @object.class.respond_to?(:reflections)
           @object.class.reflections.collect do |name, association_reflection|
             if by_associations.present?
               if by_associations.include?(association_reflection.macro) && association_reflection.options[:polymorphic] != true
-                name 
+                name
               end
             else
               name
@@ -349,12 +350,21 @@ module Formtastic
         end
       end
 
+      # Collects all foreign key columns
+      def foreign_key_columns # @private
+        if @object.present? && @object.class.respond_to?(:reflect_on_all_associations)
+          @object.class.reflect_on_all_associations(:belongs_to).map{ |reflection| reflection.foreign_key.to_sym }
+        else
+          []
+        end
+      end
+
       # Collects content columns (non-relation columns) for the current form object class.
-      def content_columns #:nodoc:
+      def content_columns # @private
         # TODO: NameError is raised by Inflector.constantize. Consider checking if it exists instead.
         begin klass = model_name.constantize; rescue NameError; return [] end
         return [] unless klass.respond_to?(:content_columns)
-        klass.content_columns.collect { |c| c.name.to_sym }.compact
+        klass.content_columns.collect { |c| c.name.to_sym }.compact - foreign_key_columns
       end
 
       # Deals with :for option when it's supplied to inputs methods. Additional
@@ -362,7 +372,7 @@ module Formtastic
       # key.
       #
       # It should raise an error if a block with arity zero is given.
-      def inputs_for_nested_attributes(*args, &block) #:nodoc:
+      def inputs_for_nested_attributes(*args, &block) # @private
         options = args.extract_options!
         args << options.merge!(:parent => { :builder => self, :for => options[:for] })
 
@@ -372,10 +382,10 @@ module Formtastic
           lambda do |f|
             contents = f.inputs(*args) do
               if block.arity == 1  # for backwards compatibility with REE & Ruby 1.8.x
-                block.call(f)
+                yield(f)
               else
                 index = parent_child_index(options[:parent]) if options[:parent]
-                block.call(f, index)
+                yield(f, index)
               end
             end
             template.concat(contents)
@@ -391,7 +401,7 @@ module Formtastic
         fields_for(*fields_for_args, &fields_for_block)
       end
 
-      def field_set_title_from_args(*args) #:nodoc:
+      def field_set_title_from_args(*args) # @private
         options = args.extract_options!
         options[:name] ||= options.delete(:title)
         title = options[:name]

data/lib/formtastic/helpers/reflection.rb

@@ -4,20 +4,20 @@ module Formtastic
     module Reflection
       # If an association method is passed in (f.input :author) try to find the
       # reflection object.
-      def reflection_for(method) #:nodoc:
+      def reflection_for(method) # @private
         if @object.class.respond_to?(:reflect_on_association)
-          @object.class.reflect_on_association(method) 
+          @object.class.reflect_on_association(method)
         elsif @object.class.respond_to?(:associations) # MongoMapper uses the 'associations(method)' instead
           @object.class.associations[method]
         end
       end
 
-      def association_macro_for_method(method) #:nodoc:
+      def association_macro_for_method(method) # @private
         reflection = reflection_for(method)
         reflection.macro if reflection
       end
 
-      def association_primary_key_for_method(method) #:nodoc:
+      def association_primary_key_for_method(method) # @private
         reflection = reflection_for(method)
         if reflection
           case association_macro_for_method(method)

data/lib/formtastic/helpers.rb

@@ -1,5 +1,4 @@
 module Formtastic
-  # @private
   module Helpers
     autoload :ButtonsHelper, 'formtastic/helpers/buttons_helper'
     autoload :ActionHelper, 'formtastic/helpers/action_helper'
@@ -10,8 +9,8 @@ module Formtastic
     autoload :FormHelper, 'formtastic/helpers/form_helper'
     autoload :InputHelper, 'formtastic/helpers/input_helper'
     autoload :InputsHelper, 'formtastic/helpers/inputs_helper'
-    autoload :LabelHelper, 'formtastic/helpers/label_helper'
     autoload :Reflection, 'formtastic/helpers/reflection'
+    autoload :Enum, 'formtastic/helpers/enum'
   end
 end
 

data/lib/formtastic/html_attributes.rb

@@ -1,6 +1,17 @@
 module Formtastic
   # @private
   module HtmlAttributes
+    # Returns a namespace passed by option or inherited from parent builders / class configuration
+    def dom_id_namespace
+      namespace = options[:custom_namespace]
+      parent = options[:parent_builder]
+
+      case
+        when namespace then namespace
+        when parent && parent != self then parent.dom_id_namespace
+        else custom_namespace
+      end
+    end
 
     protected
 
@@ -18,4 +29,4 @@ module Formtastic
     end
 
   end
-end
+end

data/lib/formtastic/i18n.rb

@@ -23,7 +23,7 @@ module Formtastic
         options = args.extract_options!
         options.reverse_merge!(:default => DEFAULT_VALUES[key])
         options[:scope] = [DEFAULT_SCOPE, options[:scope]].flatten.compact
-        ::I18n.translate(key, *(args << options))
+        ::I18n.translate(key, *args, **options)
       end
       alias :t :translate
 

data/lib/formtastic/input_class_finder.rb

@@ -0,0 +1,18 @@
+module Formtastic
+
+  # Uses the {Formtastic::NamespacedClassFinder} to look up input class names.
+  #
+  # See {Formtastic::FormBuilder#namespaced_input_class} for details.
+  #
+  class InputClassFinder < NamespacedClassFinder
+
+    # @param builder [FormBuilder]
+    def initialize(builder)
+      super builder.input_namespaces
+    end
+
+    def class_name(as)
+      "#{super}Input"
+    end
+  end
+end

data/lib/formtastic/inputs/base/choices.rb

@@ -64,7 +64,7 @@ module Formtastic
         end
 
         def custom_choice_html_options(choice)
-          (choice.is_a?(Array) && choice.size > 2) ? choice.last : {}
+          (choice.is_a?(Array) && choice.size > 2) ? choice[-1] : {}
         end
 
         def choice_html_safe_value(choice)
@@ -73,7 +73,7 @@ module Formtastic
 
         def choice_input_dom_id(choice)
           [
-            builder.custom_namespace,
+            builder.dom_id_namespace,
             sanitized_object_name,
             builder.options[:index],
             association_primary_key || method,

data/lib/formtastic/inputs/base/collections.rb

@@ -12,7 +12,7 @@ module Formtastic
         end
 
         def value_method
-          @value_method ||= (value_method_from_options || label_and_value_method.last)
+          @value_method ||= (value_method_from_options || label_and_value_method[-1])
         end
 
         def value_method_from_options
@@ -24,7 +24,7 @@ module Formtastic
         end
 
         def label_and_value_method_from_collection(_collection)
-          sample = _collection.first || _collection.last
+          sample = _collection.first || _collection[-1]
 
           case sample
           when Array
@@ -43,16 +43,16 @@ module Formtastic
         end
 
         def raw_collection
-          @raw_collection ||= (collection_from_options || collection_from_association || collection_for_boolean)
+          @raw_collection ||= (collection_from_options || collection_from_enum || collection_from_association || collection_for_boolean)
         end
 
         def collection
           # Return if we have a plain string
-          return raw_collection if raw_collection.instance_of?(String) || raw_collection.instance_of?(ActiveSupport::SafeBuffer)
+          return raw_collection if raw_collection.is_a?(String)
 
-          # Return if we have an Array of strings, fixnums or arrays
+          # Return if we have an Array of strings, integers or arrays
           return raw_collection if (raw_collection.instance_of?(Array) || raw_collection.instance_of?(Range)) &&
-                               [Array, Fixnum, String].include?(raw_collection.first.class) &&
+                               ([Array, String].include?(raw_collection.first.class) || raw_collection.first.is_a?(Integer)) &&
                                !(options.include?(:member_label) || options.include?(:member_value))
 
           raw_collection.map { |o| [send_or_call(label_method, o), send_or_call(value_method, o)] }
@@ -78,21 +78,53 @@ module Formtastic
                     ) if reflection.options[:polymorphic] == true
             end
 
-            find_options_from_options = options[:find_options] || {}
-            conditions_from_options = find_options_from_options[:conditions] || {}
             conditions_from_reflection = (reflection.respond_to?(:options) && reflection.options[:conditions]) || {}
             conditions_from_reflection = conditions_from_reflection.call if conditions_from_reflection.is_a?(Proc)
 
             scope_conditions = conditions_from_reflection.empty? ? nil : {:conditions => conditions_from_reflection}
-            if conditions_from_options.any?
-              reflection.klass.scoped(scope_conditions).where(conditions_from_options)
-            else
-              find_options_from_options.merge!(:include => group_by) if self.respond_to?(:group_by) && group_by
-              reflection.klass.scoped(scope_conditions).where(find_options_from_options)
+            where_conditions = (scope_conditions && scope_conditions[:conditions]) || {}
+
+            reflection.klass.where(where_conditions)
+          end
+        end
+
+        # Assuming the following model:
+        #
+        # class Post < ActiveRecord::Base
+        #   enum :status => [ :active, :archived ]
+        # end
+        #
+        # We would end up with a collection like this:
+        #
+        # [["Active", "active"], ["Archived", "archived"]
+        #
+        # The first element in each array uses String#humanize, but I18n
+        # translations are available too. Set them with the following structure.
+        #
+        # en:
+        #   activerecord:
+        #     attributes:
+        #       post:
+        #         statuses:
+        #           active: Custom Active Label Here
+        #           archived: Custom Archived Label Here
+        def collection_from_enum
+          if collection_from_enum?
+            method_name = method.to_s
+
+            enum_options_hash = object.defined_enums[method_name]
+            enum_options_hash.map do |name, value|
+              key = "activerecord.attributes.#{object_name}.#{method_name.pluralize}.#{name}"
+              label = ::I18n.translate(key, :default => name.humanize)
+              [label, name]
             end
           end
         end
 
+        def collection_from_enum?
+          object.respond_to?(:defined_enums) && object.defined_enums.has_key?(method.to_s)
+        end
+
         def collection_for_boolean
           true_text = options[:true] || Formtastic::I18n.t(:yes)
           false_text = options[:false] || Formtastic::I18n.t(:no)
@@ -113,7 +145,7 @@ module Formtastic
         # Avoids an issue where `send_or_call` can be a String and duck can be something simple like
         # `:first`, which obviously String responds to.
         def send_or_call_or_object(duck, object)
-          return object if object.is_a?(String) # TODO what about other classes etc?
+          return object if object.is_a?(String) || object.is_a?(Integer) || object.is_a?(Symbol) # TODO what about other classes etc?
           send_or_call(duck, object)
         end
 

data/lib/formtastic/inputs/base/database.rb

@@ -4,7 +4,12 @@ module Formtastic
       module Database
         
         def column
-          object.column_for_attribute(method) if object.respond_to?(:column_for_attribute)
+          if object.respond_to?(:column_for_attribute)
+            # Remove deprecation wrapper & review after Rails 5.0 ships
+            ActiveSupport::Deprecation.silence do
+              object.column_for_attribute(method)
+            end
+          end
         end
         
         def column?
@@ -14,4 +19,4 @@ module Formtastic
       end
     end
   end
-end
+end

data/lib/formtastic/inputs/base/datetime_pickerish.rb

@@ -0,0 +1,85 @@
+module Formtastic
+  module Inputs
+    module Base
+      module DatetimePickerish
+        include Base::Placeholder
+      
+        def html_input_type
+          raise NotImplementedError
+        end
+      
+        def default_size
+          raise NotImplementedError
+        end
+        
+        def value
+          raise NotImplementedError
+        end
+      
+        def input_html_options
+          super.merge(extra_input_html_options)
+        end
+      
+        def extra_input_html_options
+          {
+            :type => html_input_type, 
+            :size => size, 
+            :maxlength => maxlength, 
+            :step => step,
+            :value => value
+          }
+        end
+      
+        def size
+          return options[:size] if options.key?(:size)
+          return options[:input_html][:size] if options[:input_html] && options[:input_html].key?(:size)
+          default_size
+        end
+      
+        def step
+          return step_from_macro(options[:input_html][:step]) if options[:input_html] && options[:input_html][:step] && options[:input_html][:step].is_a?(Symbol)
+          return options[:input_html][:step] if options[:input_html] && options[:input_html].key?(:step)
+          default_step
+        end
+      
+        def maxlength
+          return options[:maxlength] if options.key?(:maxlength)
+          return options[:input_html][:maxlength] if options[:input_html] && options[:input_html].key?(:maxlength)
+          default_size
+        end
+      
+        def default_maxlength
+          default_size
+        end
+      
+        def default_step
+          1
+        end
+        
+        protected
+        
+        def step_from_macro(sym)
+          case sym
+
+            # date
+            when :day then "1"
+            when :seven_days, :week then "7"
+            when :two_weeks, :fortnight then "14"
+            when :four_weeks then "28"
+            when :thirty_days then "30"
+
+            # time
+            when :second then "1"
+            when :minute then "60"
+            when :fifteen_minutes, :quarter_hour then "900"
+            when :thirty_minutes, :half_hour then "1800"
+            when :sixty_minutes, :hour then "3600"            
+
+            else sym
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/errors.rb

@@ -8,22 +8,22 @@ module Formtastic
         end
         
         def error_sentence_html
-          error_class = options[:error_class] || builder.default_inline_error_class
-          template.content_tag(:p, Formtastic::Util.html_safe(errors.to_sentence.html_safe), :class => error_class)
+          error_class = builder.default_inline_error_class
+          template.content_tag(:p, errors.to_sentence, :class => error_class)
         end
                 
         def error_list_html
-          error_class = options[:error_class] || builder.default_error_list_class
+          error_class = builder.default_error_list_class
           list_elements = []
           errors.each do |error|
-            list_elements << template.content_tag(:li, Formtastic::Util.html_safe(error.html_safe))
+            list_elements << template.content_tag(:li, error.html_safe)
           end
-          template.content_tag(:ul, Formtastic::Util.html_safe(list_elements.join("\n")), :class => error_class)
+          template.content_tag(:ul, list_elements.join("\n").html_safe, :class => error_class)
         end
         
         def error_first_html
-          error_class = options[:error_class] || builder.default_inline_error_class
-          template.content_tag(:p, Formtastic::Util.html_safe(errors.first.untaint), :class => error_class)
+          error_class = builder.default_inline_error_class
+          template.content_tag(:p, errors.first.untaint.html_safe, :class => error_class)
         end
         
         def error_none_html

data/lib/formtastic/inputs/base/hints.rb

@@ -7,8 +7,8 @@ module Formtastic
           if hint?
             template.content_tag(
               :p, 
-              Formtastic::Util.html_safe(hint_text), 
-              :class => (options[:hint_class] || builder.default_hint_class)
+              hint_text.html_safe, 
+              :class => builder.default_hint_class
             )
           end
         end

data/lib/formtastic/inputs/base/html.rb

@@ -2,7 +2,7 @@ module Formtastic
   module Inputs
     module Base
       module Html
-        
+
         # Defines how the instance of an input should be rendered to a HTML string.
         #
         # @abstract Implement this method in your input class to describe how the input should render itself.
@@ -17,24 +17,25 @@ module Formtastic
         def to_html
           raise NotImplementedError
         end
-        
+
         def input_html_options
-          { 
+          {
             :id => dom_id,
             :required => required_attribute?,
-            :autofocus => autofocus?
+            :autofocus => autofocus?,
+            :readonly => readonly?
           }.merge(options[:input_html] || {})
         end
-        
+
         def dom_id
           [
-            builder.custom_namespace, 
-            sanitized_object_name, 
-            dom_index, 
+            builder.dom_id_namespace,
+            sanitized_object_name,
+            dom_index,
             association_primary_key || sanitized_method_name
           ].reject { |x| x.blank? }.join('_')
         end
-        
+
         def dom_index
           if builder.options.has_key?(:index)
             builder.options[:index]

data/lib/formtastic/inputs/base/labelling.rb

@@ -10,17 +10,14 @@ module Formtastic
         end
         
         def label_html_options
-          # opts = options_for_label(options) # TODO
-          opts = {}
-          opts[:for] ||= input_html_options[:id]
-          opts[:class] = [opts[:class]]
-          opts[:class] << 'label'
-          
-          opts
+          {
+            :for => input_html_options[:id],
+            :class => ['label'],
+          }
         end
         
         def label_text
-          ((localized_label || humanized_method_name) << requirement_text).html_safe
+          ((localized_label || humanized_method_name) + requirement_text).html_safe
         end
         
         # TODO: why does this need to be memoized in order to make the inputs_spec tests pass? 

data/lib/formtastic/inputs/base/naming.rb

@@ -4,9 +4,9 @@ module Formtastic
       module Naming
 
         def as
-          self.class.name.split("::").last.underscore.gsub(/_input$/, '')
+          self.class.name.split("::")[-1].underscore.gsub(/_input$/, '')
         end
-        
+
         def sanitized_object_name
           object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
         end
@@ -18,7 +18,7 @@ module Formtastic
         def attributized_method_name
           method.to_s.gsub(/_id$/, '').to_sym
         end
-        
+
         def humanized_method_name
           if builder.label_str_method != :humanize
             # Special case where label_str_method should trump the human_attribute_name
@@ -39,4 +39,4 @@ module Formtastic
       end
     end
   end
-end
+end

data/lib/formtastic/inputs/base/numeric.rb

@@ -5,7 +5,7 @@ module Formtastic
         def input_html_options
           defaults = super
 
-          # override rails default size - not valid on numeric inputs
+          # override rails default size - does not apply to numeric inputs
           #@todo document/spec
           defaults[:size] = nil