formtastic 1.2.4 → 3.1.5

data/lib/formtastic/i18n.rb

@@ -1,16 +1,18 @@
 # encoding: utf-8
 
 module Formtastic
+  # @private
   module I18n
 
     DEFAULT_SCOPE = [:formtastic].freeze
     DEFAULT_VALUES = YAML.load_file(File.expand_path("../../locale/en.yml", __FILE__))["en"]["formtastic"].freeze
     SCOPES = [
         '%{model}.%{nested_model}.%{action}.%{attribute}',
-        '%{model}.%{action}.%{attribute}',
         '%{model}.%{nested_model}.%{attribute}',
-        '%{model}.%{attribute}',
+        '%{nested_model}.%{action}.%{attribute}',
         '%{nested_model}.%{attribute}',
+        '%{model}.%{action}.%{attribute}',
+        '%{model}.%{attribute}',
         '%{attribute}'
       ]
 

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.rb

@@ -0,0 +1,39 @@
+module Formtastic
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Basic
+    autoload :BooleanInput
+    autoload :CheckBoxesInput
+    autoload :ColorInput
+    autoload :CountryInput
+    autoload :DatalistInput
+    autoload :DateInput
+    autoload :DatePickerInput
+    autoload :DatetimePickerInput
+    autoload :DateSelectInput
+    autoload :DatetimeInput
+    autoload :DatetimeSelectInput
+    autoload :EmailInput
+    autoload :FileInput
+    autoload :HiddenInput
+    autoload :NumberInput
+    autoload :NumericInput
+    autoload :PasswordInput
+    autoload :PhoneInput
+    autoload :RadioInput
+    autoload :RangeInput
+    autoload :SearchInput
+    autoload :SelectInput
+    autoload :StringInput
+    autoload :TextInput
+    autoload :TimeInput
+    autoload :TimePickerInput
+    autoload :TimeSelectInput
+    autoload :TimeZoneInput
+    autoload :Timeish
+    autoload :UrlInput
+  end
+end
+

data/lib/formtastic/inputs/base.rb

@@ -0,0 +1,76 @@
+module Formtastic
+  module Inputs
+    module Base
+
+      attr_accessor :builder, :template, :object, :object_name, :method, :options
+
+      def initialize(builder, template, object, object_name, method, options)
+        @builder = builder
+        @template = template
+        @object = object
+        @object_name = object_name
+        @method = method
+        @options = options.dup
+
+        # Deprecate :member_label and :member_value, remove v4.0
+        member_deprecation_message = "passing an Array of label/value pairs like [['Justin', 2], ['Kate', 3]] into :collection directly (consider building the array in your model using Model.pluck)"
+        warn_deprecated_option!(:member_label, member_deprecation_message)
+        warn_deprecated_option!(:member_value, member_deprecation_message)
+      end
+
+      # Usefull for deprecating options.
+      def warn_and_correct_option!(old_option_name, new_option_name)
+        if options.key?(old_option_name)
+          ::ActiveSupport::Deprecation.warn("The :#{old_option_name} option is deprecated in favour of :#{new_option_name} and will be removed from Formtastic in the next version", caller(6))
+          options[new_option_name] = options.delete(old_option_name)
+        end
+      end
+
+      # Usefull for deprecating options.
+      def warn_deprecated_option!(old_option_name, instructions)
+        if options.key?(old_option_name)
+          ::ActiveSupport::Deprecation.warn("The :#{old_option_name} option is deprecated in favour of `#{instructions}`. :#{old_option_name} will be removed in the next version", caller(6))
+        end
+      end
+
+      # Usefull for raising an error on previously supported option.
+      def removed_option!(old_option_name)
+        raise ArgumentError, ":#{old_option_name} is no longer available" if options.key?(old_option_name)
+      end
+
+      extend ActiveSupport::Autoload
+
+      autoload :DatetimePickerish
+      autoload :Associations
+      autoload :Collections
+      autoload :Choices
+      autoload :Database
+      autoload :Errors
+      autoload :Fileish
+      autoload :Hints
+      autoload :Html
+      autoload :Labelling
+      autoload :Naming
+      autoload :Numeric
+      autoload :Options
+      autoload :Placeholder
+      autoload :Stringish
+      autoload :Timeish
+      autoload :Validations
+      autoload :Wrapping
+
+      include Html
+      include Options
+      include Database
+      include Errors
+      include Hints
+      include Naming
+      include Validations
+      include Fileish
+      include Associations
+      include Labelling
+      include Wrapping
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Associations
+        include Formtastic::Helpers::Reflection
+
+        # :belongs_to, etc
+        def association
+          @association ||= association_macro_for_method(method)
+        end
+
+        def reflection
+          @reflection ||= reflection_for(method)
+        end
+
+        def belongs_to?
+          association == :belongs_to
+        end
+
+        def has_many?
+          association == :has_many
+        end
+
+        def association_primary_key
+          association_primary_key_for_method(method)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Choices
+
+        def choices_wrapping(&block)
+          template.content_tag(:fieldset,
+            template.capture(&block),
+            choices_wrapping_html_options
+          )
+        end
+
+        def choices_wrapping_html_options
+          { :class => "choices" }
+        end
+
+        def choices_group_wrapping(&block)
+          template.content_tag(:ol,
+            template.capture(&block),
+            choices_group_wrapping_html_options
+          )
+        end
+
+        def choices_group_wrapping_html_options
+          { :class => "choices-group" }
+        end
+
+        def choice_wrapping(html_options, &block)
+          template.content_tag(:li,
+            template.capture(&block),
+            html_options
+          )
+        end
+
+        def choice_wrapping_html_options(choice)
+          classes = ['choice']
+          classes << "#{sanitized_method_name.singularize}_#{choice_html_safe_value(choice)}" if value_as_class?
+
+          { :class => classes.join(" ") }
+        end
+
+        def choice_html(choice)
+          raise "choice_html() needs to be implemented when including Formtastic::Inputs::Base::Choices"
+        end
+
+        def choice_label(choice)
+          if choice.is_a?(Array)
+            choice.first
+          else
+            choice
+          end.to_s
+        end
+
+        def choice_value(choice)
+          choice.is_a?(Array) ? choice[1] : choice
+        end
+
+        def choice_html_options(choice)
+          custom_choice_html_options(choice).merge(default_choice_html_options(choice))
+        end
+
+        def default_choice_html_options(choice)
+          { :id => choice_input_dom_id(choice) }
+        end
+
+        def custom_choice_html_options(choice)
+          (choice.is_a?(Array) && choice.size > 2) ? choice[-1] : {}
+        end
+
+        def choice_html_safe_value(choice)
+          choice_value(choice).to_s.gsub(/\s/, '_').gsub(/[^\w-]/, '').downcase
+        end
+
+        def choice_input_dom_id(choice)
+          [
+            builder.dom_id_namespace,
+            sanitized_object_name,
+            builder.options[:index],
+            association_primary_key || method,
+            choice_html_safe_value(choice)
+          ].compact.reject { |i| i.blank? }.join("_")
+        end
+
+        def value_as_class?
+          options[:value_as_class]
+        end
+
+        def legend_html
+          if render_label?
+            template.content_tag(:legend,
+              template.content_tag(:label, label_text),
+              label_html_options.merge(:class => "label")
+            )
+          else
+            "".html_safe
+          end
+        end
+
+        # Override to remove the for attribute since this isn't associated with any element, as it's
+        # nested inside the legend.
+        def label_html_options
+          super.merge(:for => nil)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Collections
+
+        def label_method
+          @label_method ||= (label_method_from_options || label_and_value_method.first)
+        end
+
+        def label_method_from_options
+          options[:member_label]
+        end
+
+        def value_method
+          @value_method ||= (value_method_from_options || label_and_value_method[-1])
+        end
+
+        def value_method_from_options
+          options[:member_value]
+        end
+
+        def label_and_value_method
+          @label_and_value_method ||= label_and_value_method_from_collection(raw_collection)
+        end
+
+        def label_and_value_method_from_collection(_collection)
+          sample = _collection.first || _collection[-1]
+
+          case sample
+          when Array
+            label, value = :first, :last
+          when Integer
+            label, value = :to_s, :to_i
+          when Symbol, String, NilClass
+            label, value = :to_s, :to_s
+          end
+
+          # Order of preference: user supplied method, class defaults, auto-detect
+          label ||= builder.collection_label_methods.find { |m| sample.respond_to?(m) }
+          value ||= builder.collection_value_methods.find { |m| sample.respond_to?(m) }
+
+          [label, value]
+        end
+
+        def raw_collection
+          @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.is_a?(String)
+
+          # 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, 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)] }
+        end
+
+        def collection_from_options
+          items = options[:collection]
+          case items
+          when Hash
+            items.to_a
+          when Range
+            items.to_a.collect{ |c| [c.to_s, c] }
+          else
+            items
+          end
+        end
+
+        def collection_from_association
+          if reflection
+            if reflection.respond_to?(:options)
+              raise PolymorphicInputWithoutCollectionError.new(
+                        "A collection must be supplied for #{method} input. Collections cannot be guessed for polymorphic associations."
+                    ) if reflection.options[:polymorphic] == true
+            end
+
+            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}
+            where_conditions = (scope_conditions && scope_conditions[:conditions]) || {}
+
+            if Util.rails3?
+              reflection.klass.scoped(scope_conditions).where({}) # where is uneccessary, but keeps the stubbing simpler while we support rails3
+            else
+              reflection.klass.where(where_conditions)
+            end
+          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)
+
+          # TODO options[:value_as_class] = true unless options.key?(:value_as_class)
+
+          [ [true_text, true], [false_text, false] ]
+        end
+
+        def send_or_call(duck, object)
+          if duck.respond_to?(:call)
+            duck.call(object)
+          elsif object.respond_to? duck.to_sym
+            object.send(duck)
+          end
+        end
+
+        # 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) || object.is_a?(Integer) || object.is_a?(Symbol) # TODO what about other classes etc?
+          send_or_call(duck, object)
+        end
+
+      end
+    end
+  end
+end