ehoch_simple_form 2.0.2.dev

data/lib/simple_form/inputs/collection_input.rb

@@ -0,0 +1,101 @@
+module SimpleForm
+  module Inputs
+    class CollectionInput < Base
+      # Default boolean collection for use with selects/radios when no
+      # collection is given. Always fallback to this boolean collection.
+      # Texts can be translated using i18n in "simple_form.yes" and
+      # "simple_form.no" keys. See the example locale file.
+      def self.boolean_collection
+        i18n_cache :boolean_collection do
+          [ [I18n.t(:"simple_form.yes", :default => 'Yes'), true],
+            [I18n.t(:"simple_form.no", :default => 'No'), false] ]
+        end
+      end
+
+      def input
+        raise NotImplementedError,
+          "input should be implemented by classes inheriting from CollectionInput"
+      end
+
+      def input_options
+        options = super
+        options[:include_blank] = true unless skip_include_blank?
+        options
+      end
+
+      private
+
+      def collection
+        @collection ||= begin
+          collection = options.delete(:collection) || self.class.boolean_collection
+          collection.respond_to?(:call) ? collection.call : collection.to_a
+        end
+      end
+
+      def has_required?
+        super && (input_options[:include_blank] || multiple?)
+      end
+
+      # Check if :include_blank must be included by default.
+      def skip_include_blank?
+        (options.keys & [:prompt, :include_blank, :default, :selected]).any? || multiple?
+      end
+
+      def multiple?
+        !!options[:input_html].try(:[], :multiple)
+      end
+
+      # Detect the right method to find the label and value for a collection.
+      # If no label or value method are defined, will attempt to find them based
+      # on default label and value methods that can be configured through
+      # SimpleForm.collection_label_methods and
+      # SimpleForm.collection_value_methods.
+      def detect_collection_methods
+        label, value = options.delete(:label_method), options.delete(:value_method)
+
+        unless label && value
+          common_method_for = detect_common_display_methods
+          label ||= common_method_for[:label]
+          value ||= common_method_for[:value]
+        end
+
+        [label, value]
+      end
+
+      def detect_common_display_methods(collection_classes = detect_collection_classes)
+        collection_translated = translate_collection if collection_classes == [Symbol]
+
+        if collection_translated || collection_classes.include?(Array)
+          { :label => :first, :value => :last }
+        elsif collection_includes_basic_objects?(collection_classes)
+          { :label => :to_s, :value => :to_s }
+        else
+          sample = collection.first || collection.last
+
+          { :label => SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) },
+            :value => SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) } }
+        end
+      end
+
+      def detect_collection_classes(some_collection = collection)
+        some_collection.map { |e| e.class }.uniq
+      end
+
+      def collection_includes_basic_objects?(collection_classes)
+        (collection_classes & [
+          String, Integer, Fixnum, Bignum, Float, NilClass, Symbol, TrueClass, FalseClass
+        ]).any?
+      end
+
+      def translate_collection
+        if translated_collection = translate(:options)
+          @collection = collection.map do |key|
+            [translated_collection[key] || key, key]
+          end
+          true
+        end
+      end
+    end
+  end
+end
+

data/lib/simple_form/inputs/collection_radio_buttons_input.rb

@@ -0,0 +1,63 @@
+module SimpleForm
+  module Inputs
+    class CollectionRadioButtonsInput < CollectionInput
+      def input
+        label_method, value_method = detect_collection_methods
+
+        @builder.send("collection_#{input_type}",
+          attribute_name, collection, value_method, label_method,
+          input_options, input_html_options, &collection_block_for_nested_boolean_style
+        )
+      end
+
+      def input_options
+        options = super
+        apply_default_collection_options!(options)
+        apply_nested_boolean_collection_options!(options) if nested_boolean_style?
+        options
+      end
+
+      protected
+
+      def apply_default_collection_options!(options)
+        options[:item_wrapper_tag] ||= options.fetch(:item_wrapper_tag, SimpleForm.item_wrapper_tag)
+        options[:item_wrapper_class] = [
+          item_wrapper_class, options[:item_wrapper_class], SimpleForm.item_wrapper_class
+        ].compact.presence
+
+        options[:collection_wrapper_tag] ||= options.fetch(:collection_wrapper_tag, SimpleForm.collection_wrapper_tag)
+        options[:collection_wrapper_class] = [
+          options[:collection_wrapper_class], SimpleForm.collection_wrapper_class
+        ].compact.presence
+      end
+
+      # Force item wrapper to be a label when using nested boolean, to support
+      # configuring classes through :item_wrapper_class, and to maintain
+      # compatibility with :inline style and default :item_wrapper_tag.
+      def apply_nested_boolean_collection_options!(options)
+        options[:item_wrapper_tag] = :label
+      end
+
+      def collection_block_for_nested_boolean_style
+        return unless nested_boolean_style?
+
+        proc { |builder| build_nested_boolean_style_item_tag(builder) }
+      end
+
+      def build_nested_boolean_style_item_tag(collection_builder)
+        collection_builder.radio_button + collection_builder.text
+      end
+
+      def item_wrapper_class
+        "radio"
+      end
+
+      # Do not attempt to generate label[for] attributes by default, unless an
+      # explicit html option is given. This avoids generating labels pointing to
+      # non existent fields.
+      def generate_label_for_attribute?
+        false
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/collection_select_input.rb

@@ -0,0 +1,14 @@
+module SimpleForm
+  module Inputs
+    class CollectionSelectInput < CollectionInput
+      def input
+        label_method, value_method = detect_collection_methods
+
+        @builder.collection_select(
+          attribute_name, collection, value_method, label_method,
+          input_options, input_html_options
+        )
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/date_time_input.rb

@@ -0,0 +1,28 @@
+module SimpleForm
+  module Inputs
+    class DateTimeInput < Base
+      def input
+        @builder.send(:"#{input_type}_select", attribute_name, input_options, input_html_options)
+      end
+
+      def has_required?
+        false
+      end
+
+      private
+
+      def label_target
+        position = case input_type
+        when :date, :datetime
+          date_order = input_options[:order] || I18n.t('date.order')
+          date_order.first
+        else
+          :hour
+        end
+
+        position = ActionView::Helpers::DateTimeSelector::POSITION[position]
+        "#{attribute_name}_#{position}i"
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/file_input.rb

@@ -0,0 +1,9 @@
+module SimpleForm
+  module Inputs
+    class FileInput < Base
+      def input
+        @builder.file_field(attribute_name, input_html_options)
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/grouped_collection_select_input.rb

@@ -0,0 +1,41 @@
+module SimpleForm
+  module Inputs
+    class GroupedCollectionSelectInput < CollectionInput
+      def input
+        label_method, value_method = detect_collection_methods
+        @builder.grouped_collection_select(attribute_name, grouped_collection,
+                      group_method, group_label_method, value_method, label_method,
+                      input_options, input_html_options)
+      end
+
+      private
+
+      def grouped_collection
+        @grouped_collection ||= begin
+          grouped_collection = options.delete(:collection)
+          grouped_collection.respond_to?(:call) ? grouped_collection.call : grouped_collection.to_a
+        end
+      end
+
+      # Sample collection
+      def collection
+        @collection ||= grouped_collection.first.try(:send, group_method) || []
+      end
+
+      def group_method
+        @group_method ||= options.delete(:group_method)
+      end
+
+      def group_label_method
+        label = options.delete(:group_label_method)
+
+        unless label
+          common_method_for = detect_common_display_methods(detect_collection_classes(grouped_collection))
+          label = common_method_for[:label]
+        end
+
+        label
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/hidden_input.rb

@@ -0,0 +1,17 @@
+module SimpleForm
+  module Inputs
+    class HiddenInput < Base
+      disable :label, :errors, :hint, :required
+
+      def input
+        @builder.hidden_field(attribute_name, input_html_options)
+      end
+
+      private
+
+      def required_class
+        nil
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/numeric_input.rb

@@ -0,0 +1,24 @@
+module SimpleForm
+  module Inputs
+    class NumericInput < Base
+      enable :placeholder, :min_max
+
+      def input
+        add_size!
+        input_html_classes.unshift("numeric")
+        if html5?
+          input_html_options[:type] ||= "number"
+          input_html_options[:step] ||= integer? ? 1 : "any"
+        end
+        @builder.text_field(attribute_name, input_html_options)
+      end
+
+      private
+
+      # Rails adds the size attr by default, if the :size key does not exist.
+      def add_size!
+        input_html_options[:size] ||= nil
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/password_input.rb

@@ -0,0 +1,12 @@
+module SimpleForm
+  module Inputs
+    class PasswordInput < Base
+      enable :placeholder, :maxlength
+
+      def input
+        add_size!
+        @builder.password_field(attribute_name, input_html_options)
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/priority_input.rb

@@ -0,0 +1,24 @@
+module SimpleForm
+  module Inputs
+    class PriorityInput < CollectionSelectInput
+      def input
+        @builder.send(:"#{input_type}_select", attribute_name, input_priority,
+                      input_options, input_html_options)
+      end
+
+      def input_priority
+        options[:priority] || SimpleForm.send(:"#{input_type}_priority")
+      end
+
+      protected
+
+      def has_required?
+        false
+      end
+
+      def skip_include_blank?
+        super || input_priority.present?
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/range_input.rb

@@ -0,0 +1,14 @@
+module SimpleForm
+  module Inputs
+    class RangeInput < NumericInput
+      def input
+        if html5?
+          input_html_options[:type] ||= "range"
+          input_html_options[:step] ||= 1
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/string_input.rb

@@ -0,0 +1,23 @@
+module SimpleForm
+  module Inputs
+    class StringInput < Base
+      enable :placeholder, :maxlength, :pattern
+
+      def input
+        unless string?
+          input_html_classes.unshift("string")
+          input_html_options[:type] ||= input_type if html5?
+        end
+
+        add_size!
+        @builder.text_field(attribute_name, input_html_options)
+      end
+
+      private
+
+      def string?
+        input_type == :string
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/text_input.rb

@@ -0,0 +1,11 @@
+module SimpleForm
+  module Inputs
+    class TextInput < Base
+      enable :placeholder, :maxlength
+
+      def input
+        @builder.text_area(attribute_name, input_html_options)
+      end
+    end
+  end
+end

data/lib/simple_form/map_type.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/class/attribute'
+
+module SimpleForm
+  module MapType
+    def self.extended(base)
+      base.class_attribute :mappings
+      base.mappings = {}
+    end
+
+    def map_type(*types)
+      map_to = types.extract_options![:to]
+      raise ArgumentError, "You need to give :to as option to map_type" unless map_to
+      self.mappings = mappings.merge types.each_with_object({}) { |t, m| m[t] = map_to }
+    end
+  end
+end

data/lib/simple_form/version.rb

@@ -0,0 +1,3 @@
+module SimpleForm
+  VERSION = "2.0.2.dev".freeze
+end

data/lib/simple_form/wrappers.rb

@@ -0,0 +1,8 @@
+module SimpleForm
+  module Wrappers
+    autoload :Builder, 'simple_form/wrappers/builder'
+    autoload :Many,    'simple_form/wrappers/many'
+    autoload :Root,    'simple_form/wrappers/root'
+    autoload :Single,  'simple_form/wrappers/single'
+  end
+end

data/lib/simple_form/wrappers/builder.rb

@@ -0,0 +1,103 @@
+module SimpleForm
+  module Wrappers
+    # Provides the builder syntax for components. The builder provides
+    # three methods `use`, `optional` and `wrapper` and they allow the following invocations:
+    #
+    #     config.wrappers do |b|
+    #       # Use a single component
+    #       b.use :html5
+    #
+    #       # Use the component, but do not automatically lookup. It will only be triggered when
+    #       # :placeholder is explicitly set.
+    #       b.optional :placeholder
+    #
+    #       # Use a component with specific wrapper options
+    #       b.use :error, :wrap_with => { :tag => "span", :class => "error" }
+    #
+    #       # Use a set of components by wrapping them in a tag+class.
+    #       b.wrapper :tag => "div", :class => "another" do |ba|
+    #         ba.use :label
+    #         ba.use :input
+    #       end
+    #
+    #       # Use a set of components by wrapping them in a tag+class.
+    #       # This wrapper is identified by :label_input, which means it can
+    #       # be turned off on demand with `f.input :name, :label_input => false`
+    #       b.wrapper :label_input, :tag => "div", :class => "another" do |ba|
+    #         ba.use :label
+    #         ba.use :input
+    #       end
+    #     end
+    #
+    # The builder also accepts default options at the root level. This is usually
+    # used if you want a component to be disabled by default:
+    #
+    #     config.wrappers :hint => false do |b|
+    #       b.use :hint
+    #       b.use :label_input
+    #     end
+    #
+    # In the example above, hint defaults to false, which means it won't automatically
+    # do the lookup anymore. It will only be triggered when :hint is explicitly set.
+    class Builder
+      def initialize(options)
+        @options    = options
+        @components = []
+      end
+
+      def use(name, options=nil, &block)
+        if block_given?
+          ActiveSupport::Deprecation.warn "Passing a block to use is deprecated. " \
+            "Please use wrapper instead of use."
+          return wrapper(name, options, &block)
+        end
+
+        if options && options.keys != [:wrap_with]
+          ActiveSupport::Deprecation.warn "Passing :tag, :class and others to use is deprecated. " \
+            "Please invoke b.use #{name.inspect}, :wrap_with => #{options.inspect} instead."
+          options = { :wrap_with => options }
+        end
+
+        if options && wrapper = options[:wrap_with]
+          @components << Single.new(name, wrapper)
+        else
+          @components << name
+        end
+      end
+
+      def optional(name, options=nil, &block)
+        if block_given?
+          ActiveSupport::Deprecation.warn "Passing a block to optional is deprecated. " \
+            "Please use wrapper instead of optional."
+          return wrapper(name, options, &block)
+        end
+
+        if options && options.keys != [:wrap_with]
+          ActiveSupport::Deprecation.warn "Passing :tag, :class and others to optional is deprecated. " \
+            "Please invoke b.optional #{name.inspect}, :wrap_with => #{options.inspect} instead."
+          options = { :wrap_with => options }
+        end
+
+        @options[name] = false
+        use(name, options, &block)
+      end
+
+      def wrapper(name, options=nil)
+        if block_given?
+          name, options = nil, name if name.is_a?(Hash)
+          builder = self.class.new(@options)
+          options ||= {}
+          options[:tag] = :div if options[:tag].nil?
+          yield builder
+          @components << Many.new(name, builder.to_a, options)
+        else
+          raise ArgumentError, "A block is required as argument to wrapper"
+        end
+      end
+
+      def to_a
+        @components
+      end
+    end
+  end
+end