simple_form 0.5 → 1.0.0

data/lib/simple_form/i18n_cache.rb

@@ -0,0 +1,22 @@
+module SimpleForm
+  # A lot of configuration values are retrived from I18n,
+  # like boolean collection, required string. This module provides
+  # caching facility to speed up form construction.
+  module I18nCache
+    def i18n_cache(key)
+      get_i18n_cache(key)[I18n.locale] ||= yield.freeze
+    end
+
+    def get_i18n_cache(key)
+      if class_variable_defined?(:"@@#{key}")
+        class_variable_get(:"@@#{key}")
+      else
+        reset_i18n_cache(key)
+      end
+    end
+
+    def reset_i18n_cache(key)
+      class_variable_set(:"@@#{key}", {})
+    end
+  end
+end

data/lib/simple_form/inputs.rb

@@ -0,0 +1,12 @@
+module SimpleForm
+  module Inputs
+    autoload :Base,            'simple_form/inputs/base'
+    autoload :BlockInput,      'simple_form/inputs/block_input'
+    autoload :CollectionInput, 'simple_form/inputs/collection_input'
+    autoload :DateTimeInput,   'simple_form/inputs/date_time_input'
+    autoload :HiddenInput,     'simple_form/inputs/hidden_input'
+    autoload :MappingInput,    'simple_form/inputs/mapping_input'
+    autoload :PriorityInput,   'simple_form/inputs/priority_input'
+    autoload :TextFieldInput,  'simple_form/inputs/text_field_input'
+  end
+end

data/lib/simple_form/inputs/base.rb

@@ -0,0 +1,107 @@
+module SimpleForm
+  module Inputs
+    class Base
+      extend I18nCache
+
+      # When action is create or update, we still should use new and edit
+      ACTIONS = {
+        :create => :new,
+        :update => :edit
+      }
+
+      include SimpleForm::Components::Errors
+      include SimpleForm::Components::Hints
+      include SimpleForm::Components::Labels
+      include SimpleForm::Components::Wrapper
+
+      delegate :template, :object, :object_name, :attribute_name, :column,
+               :reflection, :input_type, :options, :to => :@builder
+
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def input
+        raise NotImplementedError
+      end
+
+      def input_options
+        options
+      end
+
+      def input_html_options
+        html_options_for(:input, input_type, required_class)
+      end
+
+      def render
+        content = SimpleForm.components.map do |component|
+          next if options[component] == false
+          send(component)
+        end
+        content.compact!
+        wrap(content.join).html_safe!
+      end
+
+    protected
+
+      def attribute_required?
+        options[:required] != false
+      end
+
+      def required_class
+        attribute_required? ? :required : :optional
+      end
+
+      # Find reflection name when available, otherwise use attribute
+      def reflection_or_attribute_name
+        reflection ? reflection.name : attribute_name
+      end
+
+      # Retrieve options for the given namespace from the options hash
+      def html_options_for(namespace, *extra)
+        html_options = options[:"#{namespace}_html"] || {}
+        html_options[:class] = (extra << html_options[:class]).join(' ').strip if extra.present?
+        html_options
+      end
+
+      # Lookup translations for the given namespace using I18n, based on object name,
+      # actual action and attribute name. Lookup priority as follows:
+      #
+      #   simple_form.{namespace}.{model}.{action}.{attribute}
+      #   simple_form.{namespace}.{model}.{attribute}
+      #   simple_form.{namespace}.{attribute}
+      #
+      #  Namespace is used for :labels and :hints.
+      #
+      #  Model is the actual object name, for a @user object you'll have :user.
+      #  Action is the action being rendered, usually :new or :edit.
+      #  And attribute is the attribute itself, :name for example.
+      #
+      #  Example:
+      #
+      #    simple_form:
+      #      labels:
+      #        user:
+      #          new:
+      #            email: 'E-mail para efetuar o sign in.'
+      #          edit:
+      #            email: 'E-mail.'
+      #
+      #  Take a look at our locale example file.
+      def translate(namespace, default='')
+        lookups = []
+        lookups << :"#{object_name}.#{lookup_action}.#{reflection_or_attribute_name}"
+        lookups << :"#{object_name}.#{reflection_or_attribute_name}"
+        lookups << :"#{reflection_or_attribute_name}"
+        lookups << default
+        I18n.t(lookups.shift, :scope => :"simple_form.#{namespace}", :default => lookups)
+      end
+
+      # The action to be used in lookup.
+      def lookup_action
+        action = template.controller.action_name.to_sym
+        ACTIONS[action] || action
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/block_input.rb

@@ -0,0 +1,13 @@
+module SimpleForm
+  module Inputs
+    class BlockInput < Base
+      def initialize(builder, block)
+        @builder, @block = builder, block
+      end
+
+      def input
+        template.capture(&@block)
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/collection_input.rb

@@ -0,0 +1,58 @@
+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
+        collection = (options[:collection] || self.class.boolean_collection).to_a
+        detect_collection_methods(collection, options)
+        @builder.send(:"collection_#{input_type}", attribute_name, collection, options[:value_method],
+                      options[:label_method], input_options, input_html_options)
+      end
+
+      def input_options
+        options = super
+        options[:include_blank] = true unless skip_include_blank?
+        options
+      end
+
+    protected
+
+      # Check if :include_blank must be included by default.
+      def skip_include_blank?
+        (options.keys & [:prompt, :include_blank, :default, :selected]).any? ||
+          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(collection, options)
+        sample = collection.first || collection.last
+
+        case sample
+          when Array
+            label, value = :first, :last
+          when Integer
+            label, value = :to_s, :to_i
+          when String, NilClass
+            label, value = :to_s, :to_s
+        end
+
+        options[:label_method] ||= label || SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) }
+        options[:value_method] ||= value || SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) }
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/date_time_input.rb

@@ -0,0 +1,18 @@
+module SimpleForm
+  module Inputs
+    class DateTimeInput < Base
+      def input
+        @builder.send(:"#{input_type}_select", attribute_name, input_options, input_html_options)
+      end
+
+      def label_target
+        case input_type
+          when :date, :datetime
+            "#{attribute_name}_1i"
+          when :time
+            "#{attribute_name}_4i"
+        end
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/hidden_input.rb

@@ -0,0 +1,11 @@
+module SimpleForm
+  module Inputs
+    # Handles hidden input.
+    class HiddenInput < Base
+      def render
+        @builder.hidden_field(attribute_name, input_html_options)
+      end
+      alias :input :render
+    end
+  end
+end

data/lib/simple_form/inputs/mapping_input.rb

@@ -0,0 +1,23 @@
+module SimpleForm
+  module Inputs
+    # Uses MapType to handle basic input types.
+    class MappingInput < Base
+      extend MapType
+
+      map_type :boolean,  :to => :check_box
+      map_type :password, :to => :password_field
+      map_type :text,     :to => :text_area
+      map_type :file,     :to => :file_field
+
+      def input
+        @builder.send(input_method, attribute_name, input_html_options)
+      end
+
+      def input_method
+        method = self.class.mappings[input_type]
+        raise "Could not find method for #{input_type.inspect}" unless method
+        method
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/priority_input.rb

@@ -0,0 +1,20 @@
+module SimpleForm
+  module Inputs
+    class PriorityInput < CollectionInput
+      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 skip_include_blank?
+        super || input_priority.present?
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/text_field_input.rb

@@ -0,0 +1,16 @@
+module SimpleForm
+  module Inputs
+    # Handles common text field inputs, as String, Numeric, Float and Decimal.
+    class TextFieldInput < Base
+      def input
+        @builder.text_field(attribute_name, input_html_options)
+      end
+
+      def input_html_options
+        input_options = super
+        input_options[:maxlength] ||= column.limit if column
+        input_options
+      end
+    end
+  end
+end

data/lib/simple_form/locale/en.yml

@@ -0,0 +1,14 @@
+en:
+  simple_form:
+    "yes": 'Yes'
+    "no": 'No'
+    buttons:
+      create: 'Create {{model}}'
+      update: 'Update {{model}}'
+      submit: 'Submit {{model}}'
+    required:
+      text: 'required'
+      mark: '*'
+      # You can uncomment the line below if you need to overwrite the whole required html.
+      # When using html, text and mark won't be used.
+      # html: '<abbr title="required">*</abbr>'

data/lib/simple_form/map_type.rb

@@ -0,0 +1,13 @@
+module SimpleForm
+  module MapType
+    def mappings
+      @mappings ||= {}
+    end
+
+    def map_type(*types)
+      options = types.extract_options!
+      raise ArgumentError, "You need to give :to as option to map_type" unless options[:to]
+      types.each { |t| mappings[t] = options[:to] }
+    end
+  end
+end

data/lib/simple_form/version.rb

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

data/test/action_view_extensions/builder_test.rb

@@ -0,0 +1,172 @@
+require 'test_helper'
+
+class BuilderTest < ActionView::TestCase
+  # COLLECTION RADIO
+  test 'collection radio accepts a collection and generate inputs from value method' do
+    form_for @user do |f|
+      concat f.collection_radio :active, [true, false], :to_s, :to_s
+    end
+
+    assert_select 'form input[type=radio][value=true]#user_active_true'
+    assert_select 'form input[type=radio][value=false]#user_active_false'
+  end
+
+  test 'collection radio accepts a collection and generate inputs from label method' do
+    form_for @user do |f|
+      concat f.collection_radio :active, [true, false], :to_s, :to_s
+    end
+
+    assert_select 'form label.collection_radio[for=user_active_true]', 'true'
+    assert_select 'form label.collection_radio[for=user_active_false]', 'false'
+  end
+
+  test 'collection radio accepts checked item' do
+    form_for @user do |f|
+      concat f.collection_radio :active, [[1, true], [0, false]], :last, :first, :checked => true
+    end
+
+    assert_select 'form input[type=radio][value=true][checked=checked]'
+    assert_no_select 'form input[type=radio][value=false][checked=checked]'
+  end
+
+  test 'collection radio accepts multiple disabled items' do
+    collection = [[1, true], [0, false], [2, 'other']]
+    form_for @user do |f|
+      concat f.collection_radio :active, collection, :last, :first, :disabled => [true, false]
+    end
+
+    assert_select 'form input[type=radio][value=true][disabled=disabled]'
+    assert_select 'form input[type=radio][value=false][disabled=disabled]'
+    assert_no_select 'form input[type=radio][value=other][disabled=disabled]'
+  end
+
+  test 'collection radio accepts single disable item' do
+    collection = [[1, true], [0, false]]
+    form_for @user do |f|
+      concat f.collection_radio :active, collection, :last, :first, :disabled => true
+    end
+
+    assert_select 'form input[type=radio][value=true][disabled=disabled]'
+    assert_no_select 'form input[type=radio][value=false][disabled=disabled]'
+  end
+
+  test 'collection radio accepts html options as input' do
+    form_for @user do |f|
+      concat f.collection_radio :active, [[1, true], [0, false]], :last, :first, {}, :class => 'radio'
+    end
+
+    assert_select 'form input[type=radio][value=true].radio#user_active_true'
+    assert_select 'form input[type=radio][value=false].radio#user_active_false'
+  end
+
+  # COLLECTION CHECK BOX
+  test 'collection check box accepts a collection and generate a serie of checkboxes for value method' do
+    collection = [Tag.new(1, 'Tag 1'), Tag.new(2, 'Tag 2')]
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :id, :name
+    end
+
+    assert_select "form input[type=hidden][name='user[tag_ids][]'][value=]"
+    assert_select 'form input#user_tag_ids_1[type=checkbox][value=1]'
+    assert_select 'form input#user_tag_ids_2[type=checkbox][value=2]'
+  end
+
+  test 'collection check box accepts a collection and generate a serie of checkboxes with labels for label method' do
+    collection = [Tag.new(1, 'Tag 1'), Tag.new(2, 'Tag 2')]
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :id, :name
+    end
+
+    assert_select 'form label.collection_check_boxes[for=user_tag_ids_1]', 'Tag 1'
+    assert_select 'form label.collection_check_boxes[for=user_tag_ids_2]', 'Tag 2'
+  end
+
+  test 'collection check box accepts selected values as :checked option' do
+    collection = (1..3).map{|i| [i, "Tag #{i}"] }
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :first, :last, :checked => [1, 3]
+    end
+
+    assert_select 'form input[type=checkbox][value=1][checked=checked]'
+    assert_select 'form input[type=checkbox][value=3][checked=checked]'
+    assert_no_select 'form input[type=checkbox][value=2][checked=checked]'
+  end
+
+  test 'collection check box accepts a single checked value' do
+    collection = (1..3).map{|i| [i, "Tag #{i}"] }
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :first, :last, :checked => 3
+    end
+
+    assert_select 'form input[type=checkbox][value=3][checked=checked]'
+    assert_no_select 'form input[type=checkbox][value=1][checked=checked]'
+    assert_no_select 'form input[type=checkbox][value=2][checked=checked]'
+  end
+
+  test 'collection check box accepts multiple disabled items' do
+    collection = (1..3).map{|i| [i, "Tag #{i}"] }
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :first, :last, :disabled => [1, 3]
+    end
+
+    assert_select 'form input[type=checkbox][value=1][disabled=disabled]'
+    assert_select 'form input[type=checkbox][value=3][disabled=disabled]'
+    assert_no_select 'form input[type=checkbox][value=2][disabled=disabled]'
+  end
+
+  test 'collection check box accepts single disable item' do
+    collection = (1..3).map{|i| [i, "Tag #{i}"] }
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :first, :last, :disabled => 1
+    end
+
+    assert_select 'form input[type=checkbox][value=1][disabled=disabled]'
+    assert_no_select 'form input[type=checkbox][value=3][disabled=disabled]'
+    assert_no_select 'form input[type=checkbox][value=2][disabled=disabled]'
+  end
+
+  test 'collection check box accepts a proc to disabled items' do
+    collection = (1..3).map{|i| [i, "Tag #{i}"] }
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :first, :last, :disabled => proc { |i| i.first == 1 }
+    end
+
+    assert_select 'form input[type=checkbox][value=1][disabled=disabled]'
+    assert_no_select 'form input[type=checkbox][value=3][disabled=disabled]'
+    assert_no_select 'form input[type=checkbox][value=2][disabled=disabled]'
+  end
+
+  test 'collection check box accepts html options' do
+    collection = [[1, 'Tag 1'], [2, 'Tag 2']]
+    form_for @user do |f|
+      concat f.collection_check_boxes :tag_ids, collection, :first, :last, {}, :class => 'check'
+    end
+
+    assert_select 'form input.check[type=checkbox][value=1]'
+    assert_select 'form input.check[type=checkbox][value=2]'
+  end
+
+  test 'collection check box with fields for' do
+    collection = [Tag.new(1, 'Tag 1'), Tag.new(2, 'Tag 2')]
+    form_for @user do |f|
+      f.fields_for :post do |p|
+        concat p.collection_check_boxes :tag_ids, collection, :id, :name
+      end
+    end
+
+    assert_select 'form input#user_post_tag_ids_1[type=checkbox][value=1]'
+    assert_select 'form input#user_post_tag_ids_2[type=checkbox][value=2]'
+
+    assert_select 'form label.collection_check_boxes[for=user_post_tag_ids_1]', 'Tag 1'
+    assert_select 'form label.collection_check_boxes[for=user_post_tag_ids_2]', 'Tag 2'
+  end
+
+  # SIMPLE FIELDS
+  test 'simple fields for is available and yields an instance of FormBuilder' do
+    form_for @user do |f|
+      f.simple_fields_for :posts do |posts_form|
+        assert posts_form.instance_of?(SimpleForm::FormBuilder)
+      end
+    end
+  end
+end