effective_form_inputs 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a2f34fb4c7efed49d6f2b2aac5242d655f91d08
-  data.tar.gz: 312fffd9da431e7fed5fe47f6ae14b7570345e2c
+  metadata.gz: c4569c203c0939b4299583c21b84cdbb8899f0a1
+  data.tar.gz: 6b96dd9835ce3866ed6d5fd174ab7eee5e463e7b
 SHA512:
-  metadata.gz: 9a64355e4aabd335e02726b7424d908ed7e1f04509929e37a96962d1473fc03636feaa202588f88787c9cf9adfed46f0062338191d6c797ef6367c4d0fb8a481
-  data.tar.gz: ed317c875b0962897e4a2cfcce3eba331ea8afac0f0d0cc55ee78f4225104901f5ebb32730e341cadd7f3b720648ceafd8c1afce5be3033e6adcfd15cdfc5b66
+  metadata.gz: 7684f263fbbaa59b318d5c6c790045d487480d2074d3d0ad58a5685b4a5f7440c61fc15b83f666ba56afa9ce7b100f097c12b642671e07324b7784eafc40bdd7
+  data.tar.gz: 1acda55bd40537351041c4400cba4a1ebfef0013205549806a8cd6302d230fa83aea0d0a71ffa80e787df03ff7cbec422eedabaa4b0b05270f83265d05d88574

data/README.md

@@ -271,12 +271,35 @@ Passing `:multiple => true` will allow multiple selections to be made.
 
 Passing `:multiple => true, :tags => true` will allow multiple selections to be made, and new value options to be created.  This will allow you to both select existing tags and create new tags in the same form control.
 
-Passing `:grouped => true` will enable optgroup support.  When in this mode, the collection should be a Hash of Array of Arrays
+Passing `:grouped => true` will enable optgroup support.  When in this mode, the collection should be a Hash of ActiveRecord Relations or Array of Arrays
 
 ```ruby
+:collection => {'Active' => Post.active, 'Past' => Post.past}
 :collection => {'Active' => [['Post A', 1], ['Post B', 2]], 'Past' => [['Post C', 3], ['Post D', 4]]}
 ```
 
+Passing `:polymorphic => true` will enable polymorphic support.  In this mode, an additional 2 hidden input fields are created alongside the select field.
+
+So calling
+
+```ruby
+= f.input :primary_contact, :polymorphic => true, :collection => User.all.to_a + Member.all.to_a
+```
+
+will internally translate the collection into:
+
+```ruby
+[['User 1', 'User_1'], ['User 2', 'User_2'], ['Member 100', 'Member_100']]
+```
+
+and instead of posting to the server with the parameter `:primary_contact`, it will intead post `{:primary_contact_id => 2, :primary_contact_type => 'User'}`.
+
+Using both `:polymorphic => true` and `:grouped => true` is recommended.  In this case the expected collection is as follows:
+
+```ruby
+= f.input :primary_contact, :polymorphic => true, :grouped => true, :collection => {'Users' => User.all, 'Members' => 'Member.all'}
+```
+
 ### Options
 
 The default `:input_js => options` used to initialize this form input are as follows:

data/app/assets/javascripts/effective_select/initialize.js.coffee

@@ -10,3 +10,11 @@ initialize = ->
 $ -> initialize()
 $(document).on 'page:change', -> initialize()
 $(document).on 'cocoon:after-insert', -> initialize()
+
+# If we're working with a polymorphic select, split out the ID and assign the hidden _type and _id fields
+$(document).on 'change', "select.effective_select.polymorphic", (event) ->
+  $select = $(event.target)
+  value = $select.val() || ''
+
+  $select.siblings("input[type='hidden'][name$='_type]']").val(value.split('_')[0] || '')
+  $select.siblings("input[type='hidden'][name$='_id]']").val(value.split('_')[1] || '')

data/app/models/inputs/effective_select/input.rb

@@ -1,10 +1,10 @@
 module Inputs
   module EffectiveSelect
     class Input < Effective::FormInput
-      delegate :collection_select, :grouped_collection_select, :to => :@template
+      delegate :collection_select, :grouped_collection_select, :hidden_field, :to => :@template
 
       def default_options
-        {label_method: :to_s, value_method: :to_s, group_method: :second, group_label_method: :first, option_key_method: :second, option_value_method: :first}
+        {label_method: :to_s, value_method: :to_s, group_label_method: :first, group_method: :last, option_value_method: :first, option_key_method: :second }
       end
 
       def default_input_js
@@ -16,32 +16,103 @@ module Inputs
       end
 
       def to_html
-        if options[:grouped]
+        html = if options[:grouped] && options[:polymorphic]
+          grouped_collection_select(@object_name, polymorphic_id_method, collection, options[:group_method], options[:group_label_method], options[:option_key_method], options[:option_value_method], options, tag_options)
+        elsif options[:grouped]
           grouped_collection_select(@object_name, @method, collection, options[:group_method], options[:group_label_method], options[:option_key_method], options[:option_value_method], options, tag_options)
+        elsif options[:polymorphic]
+          collection_select(@object_name, polymorphic_id_method, collection, :second, :first, options, tag_options)
         else
           collection_select(@object_name, @method, collection, options[:value_method], options[:label_method], options, tag_options)
         end
+
+        if options[:polymorphic]
+          html += hidden_field(@object_name, polymorphic_type_method, value: polymorphic_type_value)
+          html += hidden_field(@object_name, polymorphic_id_method, value: polymorphic_id_value)
+        end
+
+        html
       end
 
+      # This is a grouped polymorphic collection
+      # [["Clinics", [["Clinc 50", "Clinic_50"], ["Clinic 43", "Clinic_43"]]], ["Contacts", [["Contact 544", "Contact_544"]]]]
       def collection
         @collection ||= begin
-          collection = options.delete(:collection)
+          collection = options.delete(:collection) || []
+          grouped = collection[0].kind_of?(Array) && collection[0][0].kind_of?(String) && collection[0][1].respond_to?(:to_a) # Array or ActiveRecord_Relation
+
+          if options[:grouped] && !grouped
+            raise "Grouped collection expecting a Hash {'Posts' => Post.all, 'Events' => Event.all} or a Hash {'Posts' => [['Post A', 1], ['Post B', 2]], 'Events' => [['Event A', 1], ['Event B', 2]]}"
+          end
+
+          if grouped
+            collection.each_with_index do |(name, group), index|
+              collection[index][1] = group.respond_to?(:call) ? group.call : group.to_a
+            end
+          else
+            collection = collection.respond_to?(:call) ? collection.call : collection.to_a
+          end
+
+          if options[:polymorphic]
+            if grouped
+              collection.each { |_, group| polymorphize_collection!(group) }
+            else
+              polymorphize_collection!(collection)
+            end
+          end
+
           collection.respond_to?(:call) ? collection.call : collection.to_a
         end
       end
 
+      # Translate our Collection into a polymorphic collection
+      def polymorphize_collection!(collection)
+        unless options[:grouped] || collection[0].kind_of?(ActiveRecord::Base) || (collection[0].kind_of?(Array) && collection[0].length >= 2)
+          raise "Polymorphic collection expecting a flat Array of mixed ActiveRecord::Base objects, or an Array of Arrays like [['Post A', 'Post_1'], ['Event B', 'Event_2']]"
+        end
+
+        collection.each_with_index do |obj, index|
+          if obj.kind_of?(ActiveRecord::Base)
+            collection[index] = [obj.public_send(options[:label_method]), "#{obj.model_name}_#{obj.to_param}"]
+          end
+        end
+      end
+
+      def polymorphic_type_method
+        @method.to_s.sub('_id', '') + '_type'
+      end
+
+      def polymorphic_id_method
+        @method.to_s.sub('_id', '') + '_id'
+      end
+
+      def polymorphic_value
+        "#{value.model_name}_#{value.to_param}" if value.present?
+      end
+
+      def polymorphic_type_value
+        value.try(:model_name)
+      end
+
+      def polymorphic_id_value
+        value.try(:to_param)
+      end
+
       def options
         super().tap do |options|
           options[:selected] = value if value
 
           options[:multiple] = true if (options[:tags] == true)
           options[:include_blank] = (options[:multiple] != true)
+          options[:selected] = polymorphic_value if options[:polymorphic]
         end
       end
 
       def html_options
         super().tap do |html_options|
           html_options[:multiple] = options[:multiple]
+          html_options[:class] << 'polymorphic' if options[:polymorphic]
+          html_options[:class] << 'grouped' if options[:grouped]
         end
       end
 

data/app/models/inputs/effective_select_input.rb

@@ -8,8 +8,8 @@ if defined?(SimpleForm)
       label_method, value_method = detect_collection_methods
 
       options[:collection] = collection
-      options[:label_method] = label_method
-      options[:value_method] = value_method
+      options[:label_method] = label_method unless options[:polymorphic]
+      options[:value_method] = value_method unless options[:polymorphic]
 
       Inputs::EffectiveSelect::Input.new(object, object_name, template, attribute_name, input_options, (merge_wrapper_options(input_html_options, wrapper_options) || {})).to_html
     end

data/lib/effective_form_inputs/version.rb

@@ -1,3 +1,3 @@
 module EffectiveFormInputs
-  VERSION = '0.7.3'.freeze
+  VERSION = '0.7.4'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_form_inputs
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-04 00:00:00.000000000 Z
+date: 2015-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails