effective_form_inputs 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f903f343a6b2612545534ce9a86fa00e953bb50
-  data.tar.gz: 81bafa3159d6e521f38dca2b5f31f3970b638ce5
+  metadata.gz: 792d97f3b56394922bae94e8a202d9b92d0ac664
+  data.tar.gz: ec1a60a1d46296341d949c28efa63a1bc56f7c0d
 SHA512:
-  metadata.gz: 2d09274264261dcb884eaccb193926de684985ebac1bbc20c34948dbfd7ee95bca244d36eb72b764672c106dba726cfd1cb4e7a15b2a6003cf5be230fbfeb353
-  data.tar.gz: d29abe9f25363244106b176a81be578f86c4b11563276a84f28a165073b405c87110d2847abfc2d7e7bb365412fcea4d1fbee5a8e673abdfcc39afaeb5d25270
+  metadata.gz: c2f35c124ce855d1e71305d1e2a0bfd335e03b661b9d006e3d1904bcc5994e22fe6f0ee2b3ba3a487477e2d7ddee5acce99f47d8e78e725e4f1706ab2c52217b
+  data.tar.gz: 3cec8f1c61b3540f748b8ca422f90965009c72a9373355b164d36ef10c29a4aa2aea2514dc058aaead4804a0934fd09ddf78ba02aabd5136057b44f5c8abc340

data/README.md

@@ -77,19 +77,26 @@ As a Rails Form Helper input:
   = f.effective_date_time_picker :updated_at
 ```
 
-and as a SimpleForm input:
+As a SimpleForm input:
 
 ```ruby
 = simple_form_for @user do |f|
   = f.input :updated_at, :as => :effective_date_time_picker
 ```
 
+As a SimpleForm input without the input group (calendar glyphicon)
+
+```ruby
+= simple_form_for @user do |f|
+  = f.input :updated_at, :as => :effective_date_time_picker, :input_group => false
+```
+
 ### Options
 
 The default options used to initialize this form input are as follows:
 
 ```ruby
-:format => 'YYYY-MM-DD h:mm A', :sideBySide => true
+:input_js => {:format => 'YYYY-MM-DD h:mm A', :sideBySide => true}
 ```
 
 For a full list of options, please refer to:
@@ -129,19 +136,26 @@ As a Rails Form Helper input:
   = f.effective_date_picker :started_on
 ```
 
-and as a SimpleForm input:
+As a SimpleForm input:
 
 ```ruby
 = simple_form_for @user do |f|
   = f.input :started_on, :as => :effective_date_picker
 ```
 
+As a SimpleForm input without the input group (calendar glyphicon)
+
+```ruby
+= simple_form_for @user do |f|
+  = f.input :updated_at, :as => :effective_date_picker, :input_group => false
+```
+
 ### Options
 
 The default options used to initialize this form input are as follows:
 
 ```ruby
-:format => 'YYYY-MM-DD'
+:input_js => {:format => 'YYYY-MM-DD'}
 ```
 
 For a full list of options, please refer to:
@@ -168,7 +182,7 @@ As a Rails Form Helper input:
   = f.effective_static_control :member_id
 ```
 
-and as a SimpleForm input:
+As a SimpleForm input:
 
 ```ruby
 = simple_form_for @user do |f|
@@ -180,7 +194,6 @@ and as a SimpleForm input:
 There are no options for this form input
 
 
-
 ## Effective Select
 
 This custom form input is based on the following awesome project:
@@ -212,7 +225,7 @@ As a Rails Form Helper input:
 = form_for @user do |f|
   = f.effective_select :category, 10.times.map { |x| "Category #{x}"}
   = f.effective_select :categories, 10.times.map { |x| "Category #{x}"}, :multiple => true
-  = f.effective_select :categories, 10.times.map { |x| "Category #{x}"}, :multiple => true, :tags => true
+  = f.effective_select :categories, 10.times.map { |x| "Category #{x}"}, :tags => true
 ```
 
 and as a SimpleForm input:
@@ -221,7 +234,7 @@ and as a SimpleForm input:
 = simple_form_for @user do |f|
   = f.input :category, :as => :effective_select, :collection => 10.times.map { |x| "Category #{x}"}
   = f.input :categories, :as => :effective_select, :collection => 10.times.map { |x| "Category #{x}"}, :multiple => true
-  = f.input :categories, :as => :effective_select, :collection => 10.times.map { |x| "Category #{x}"}, :multiple => true, :tags => true
+  = f.input :categories, :as => :effective_select, :collection => 10.times.map { |x| "Category #{x}"}, :tags => true
 ```
 
 ### Modes
@@ -235,11 +248,15 @@ Passing `:multiple => true, :tags => true` will allow multiple selections to be
 
 ### Options
 
-The default options used to initialize this form input are as follows:
+The default `:input_js => options` used to initialize this form input are as follows:
 
 ```ruby
-:allowClear => !(options[:multiple])  # Only display the Clear 'x' on a single selection box
+:theme => 'bootstrap'
+:minimumResultsForSearch => 6
 :tokenSeparators => [',', ' ']
+:width => 'style'
+:placeholder => 'Please choose'
+:allowClear => !(options[:multiple])  # Only display the Clear 'x' on a single selection box
 ```
 
 ### Interesting Available Options
@@ -250,7 +267,7 @@ To limit the number of items that can be selected in a multiple select box:
 :maximumSelectionLength => 2
 ```
 
-To hide the search box:
+To hide the search box entirely:
 
 ```ruby
 :minimumResultsForSearch => 'Infinity'
@@ -268,20 +285,20 @@ There is currently no support for using AJAX to load remote data.  This feature
 
 ## Passing Options to JavaScript
 
-All appropriate options passed to any effective_form_input will be used to initialize the Javascript library
+All `:input_js => options` passed to any effective_form_input will be used to initialize the Javascript library
 
 For example:
 
 ```ruby
 = form_for @user do |f|
-  = f.effective_date_time_picker :updated_at, :format => 'dddd, MMMM Do YYYY', :showTodayButton => true
+  = f.effective_date_time_picker :updated_at, :input_js => {:format => 'dddd, MMMM Do YYYY', :showTodayButton => true}
 ```
 
 or
 
 ```ruby
 = simple_form_for @user do |f|
-  = f.input :updated_at, :as => :effective_date_time_picker, :format => 'dddd, MMMM Do YYYY', :showTodayButton => true
+  = f.input :updated_at, :as => :effective_date_time_picker, :input_js => {:format => 'dddd, MMMM Do YYYY', :showTodayButton => true}
 ```
 
 will result in the following call to the Javascript library:

data/app/models/effective/form_builder_inputs.rb

@@ -1,32 +1,22 @@
 module Effective
   module FormBuilderInputs
     def effective_date_time_picker(method, options = {})
-      Inputs::EffectiveDateTimePicker::Input.new(@object, @object_name, @template, method, merged_input_js_options(options)).to_html
+      Inputs::EffectiveDateTimePicker::Input.new(@object, @object_name, @template, method, options, options).to_html
     end
 
     def effective_date_picker(method, options = {})
-      Inputs::EffectiveDatePicker::Input.new(@object, @object_name, @template, method, merged_input_js_options(options)).to_html
+      Inputs::EffectiveDatePicker::Input.new(@object, @object_name, @template, method, options, options).to_html
     end
 
     def effective_static_control(method, options = {})
-      Inputs::EffectiveStaticControl::Input.new(@object, @object_name, @template, method, merged_input_js_options(options)).to_html
+      Inputs::EffectiveStaticControl::Input.new(@object, @object_name, @template, method, options, options).to_html
     end
 
-    def effective_select(method, options_tag = nil, options = {})
+    def effective_select(method, options_tag = nil, options = {}, html_options = {})
       options[:collection] = options_tag
-      options[:label_method] = :to_s
-      options[:value_method] = :to_s
-      Inputs::EffectiveSelect::Input.new(@object, @object_name, @template, method, merged_input_js_options(options)).to_html
-    end
-
-    private
-
-    def merged_input_js_options(options)
-      (options || {}).tap do |opts|
-        js_options = opts.reject { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) }
-        opts.reject! { |k, _| js_options.include?(k) }
-        opts['data-input-js-options'] = js_options if js_options.present?
-      end
+      options[:label_method] = :to_s if options[:label_method].nil?
+      options[:value_method] = :to_s if options[:value_method].nil?
+      Inputs::EffectiveSelect::Input.new(@object, @object_name, @template, method, options, html_options).to_html
     end
   end
 end

data/app/models/effective/form_input.rb

@@ -1,12 +1,35 @@
 module Effective
   class FormInput
 
-    def initialize(object, object_name, template, method, opts)
+    def initialize(object, object_name, template, method, opts, html_opts = {})
       @object = object
       @object_name = object_name
       @template = template
       @method = method
-      @opts = opts
+
+      # Initialize 3 options Hashes:  @opts, @html_opts, and @js_opts
+      @js_opts = opts.delete(:input_js).presence || {}
+      @html_opts = html_opts.presence || opts.delete(:input_html) || {}
+      @opts = opts.presence || {}
+
+      # Copy the following keys from options to html_options
+      # To deal with SimpleForm being simple
+      [:class, :readonly, :pattern, :disabled, :maxlength].each do |key|
+        if !html_opts.key?(key) && @opts.key?(key)
+          @html_opts[key] = @opts[:key] if @opts[:key]
+        end
+      end
+
+      # Reverse merge in the defaults, so the current values take precedence over defaults
+      @js_opts.reverse_merge!((default_input_js || {}))
+      @html_opts.reverse_merge!((default_input_html || {}).except(:class))
+      @opts.reverse_merge!((default_options || {}))
+
+      # Take special procedure to ensure that @html_opts[:class] is an Array, and the proper merged values
+      @html_opts[:class] = (arrayize_html_class_key(@html_opts[:class]) + arrayize_html_class_key(default_input_html)).compact.uniq
+
+      # Set the value to avoid options craziness
+      @value = (@opts.delete(:value) || @html_opts.delete(:value) || (@object.send(@method) if @object.respond_to?(@method)))
     end
 
     def field_name
@@ -14,43 +37,49 @@ module Effective
     end
 
     def value
-      options[:value] || (@object.send(@method) if @object.respond_to?(@method))
+      @value
     end
 
-    def default_input_js_options; {} end
-    def default_input_classes; [] end
+    # Override these methods to change any options around
+    # tag_options reads html_options and js_options
+    def options; @opts end              # All options passed to the FormInput, merged with defaults
+    def html_options; @html_opts end    # All :input_html => options, merged with defaults.  Could be everything (same as options) if coming from FormBuilder.
+    def js_options; @js_opts end        # All :input_js => options, merged with defaults
 
-    def options(&block)
-      @form_field_options ||= (
-        (@opts || {}).tap do |options|
-          options['data-input-js-options'] = {} unless options['data-input-js-options'].kind_of?(Hash)
-          merge_class_options!(options)
+    protected
 
-          yield(options) if block_given?
+    # Hook methods for an inheritting class to apply defaults
+    def default_options; {} end         # All options passed to FormInput
+    def default_input_html; {} end    # To merge with any :input_html => options
+    def default_input_js; {} end      # to merge with any :input_js => options
 
-          merge_input_js_options!(options)
-          options.delete('data-input-js-options') if options['data-input-js-options'] == '{}'
-        end
-      )
+    # This is what we want to send to a content_tag, text_area_tag, or whatever actual input we use
+    # It serializes any js_options into JSON format
+    # And turns html_options[:class] back into a string
+    def tag_options
+      html_options().tap do |html_options|
+        html_options['data-input-js-options'] = (JSON.generate(js_options) rescue {})
+        html_options[:class] = html_options[:class].join(' ')
+      end
     end
 
     private
 
-    def merge_class_options!(options)
-      (default_input_classes || []).each do |c|
-        if options[:class].blank?
-          options[:class] = c.to_s
-        elsif options[:class].kind_of?(Array)
-          options[:class] << c unless options[:class].include?(c)
-        elsif options[:class].kind_of?(String)
-          options[:class] << (' ' + c.to_s) unless options[:class].include?(c.to_s)
-        end
+    # I'm passed something...I don't know what it is, but it needs to be an Array
+    def arrayize_html_class_key(something)
+      case something
+      when Hash
+        arrayize_html_class_key(something[:class])
+      when Array
+        something.compact.map(&:to_s)
+      when String
+        something.split(' ')
+      when Symbol
+        [something.to_s]
+      else
+        []
       end
     end
 
-    def merge_input_js_options!(options)
-      options['data-input-js-options'] = JSON.generate((default_input_js_options || {}).merge(options['data-input-js-options'] || {})) rescue {}
-    end
-
   end
 end

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

@@ -3,35 +3,34 @@ module Inputs
     class Input < Effective::FormInput
       delegate :content_tag, :text_field_tag, :to => :@template
 
-      def default_input_js_options
+      def default_input_js
         {:format => 'YYYY-MM-DD'}
       end
 
-      def default_input_classes
-        [:effective_date_picker, :date]
+      def default_input_html
+        {class: 'effective_date_picker date'}
       end
 
       def to_html
-        if options.delete(:input_group) == false
-          return text_field_tag(field_name, value, options)
+        if options[:input_group] == false
+          return text_field_tag(field_name, value, tag_options)
         end
 
         content_tag(:div, :class => 'input-group') do
           content_tag(:span, :class => 'input-group-addon') do
             content_tag(:i, '', :class => 'glyphicon glyphicon-calendar').html_safe
           end +
-          text_field_tag(field_name, value, options)
+          text_field_tag(field_name, value, tag_options)
         end
       end
 
-      def options
-        super do |options|
-          unless options['data-input-js-options'][:format].present?
-            options[:pattern] = '\d{4}-\d{2}-\d{2}'
+      def html_options
+        super.tap do |html_options|
+          if js_options[:format] == default_input_js[:format] # Unless someone changed from the default
+            html_options[:pattern] = '\d{4}-\d{2}-\d{2}' # Match default pattern defined above
           end
         end
       end
-
     end
   end
 end

data/app/models/inputs/effective_date_picker_input.rb

@@ -5,11 +5,7 @@ if defined?(SimpleForm)
 
   class EffectiveDatePickerInput < SimpleForm::Inputs::StringInput
     def input(wrapper_options = nil)
-      options = merge_wrapper_options(input_html_options, wrapper_options) || {}
-      options.merge!(input_options.select { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) })
-      options['data-input-js-options'] = input_options.reject { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) }
-
-      Inputs::EffectiveDatePicker::Input.new(object, object_name, template, attribute_name, options).to_html
+      Inputs::EffectiveDatePicker::Input.new(object, object_name, template, attribute_name, input_options, (merge_wrapper_options(input_html_options, wrapper_options) || {})).to_html
     end
   end
 

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

@@ -3,35 +3,34 @@ module Inputs
     class Input < Effective::FormInput
       delegate :content_tag, :text_field_tag, :to => :@template
 
-      def default_input_js_options
+      def default_input_js
         {:format => 'YYYY-MM-DD h:mm A', :sideBySide => true}
       end
 
-      def default_input_classes
-        [:effective_date_time_picker, :datetime]
+      def default_input_html
+        {class: 'effective_date_time_picker datetime'}
       end
 
       def to_html
-        if options.delete(:input_group) == false
-          return text_field_tag(field_name, value, options)
+        if options[:input_group] == false
+          return text_field_tag(field_name, value, tag_options)
         end
 
         content_tag(:div, :class => 'input-group') do
           content_tag(:span, :class => 'input-group-addon') do
             content_tag(:i, '', :class => 'glyphicon glyphicon-calendar').html_safe
           end +
-          text_field_tag(field_name, value, options)
+          text_field_tag(field_name, value, tag_options)
         end
       end
 
-      def options
-        super do |options|
-          unless options['data-input-js-options'][:format].present?
-            options[:pattern] = '\d{4}-\d{2}-\d{2} \d+:\d{2} [A-Z]{2}'
+      def html_options
+        super.tap do |html_options|
+          if js_options[:format] == default_input_js[:format] # Unless someone changed from the default
+            html_options[:pattern] = '\d{4}-\d{2}-\d{2} \d+:\d{2} [A-Z]{2}' # Match default pattern defined above
           end
         end
       end
-
     end
   end
 end

data/app/models/inputs/effective_date_time_picker_input.rb

@@ -5,11 +5,7 @@ if defined?(SimpleForm)
 
   class EffectiveDateTimePickerInput < SimpleForm::Inputs::StringInput
     def input(wrapper_options = nil)
-      options = merge_wrapper_options(input_html_options, wrapper_options) || {}
-      options.merge!(input_options.select { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) })
-      options['data-input-js-options'] = input_options.reject { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) }
-
-      Inputs::EffectiveDateTimePicker::Input.new(object, object_name, template, attribute_name, options).to_html
+      Inputs::EffectiveDateTimePicker::Input.new(object, object_name, template, attribute_name, input_options, (merge_wrapper_options(input_html_options, wrapper_options) || {})).to_html
     end
   end
 

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

@@ -3,28 +3,43 @@ module Inputs
     class Input < Effective::FormInput
       delegate :collection_select, :to => :@template
 
-      def default_input_js_options
-        {:theme => 'bootstrap', :minimumResultsForSearch => 6, :tokenSeparators => [',', ' '], :width => 'style'}
+      def default_options
+        {:label_method => :to_s, :value_method => :to_s}
       end
 
-      def default_input_classes
-        [:effective_select]
+      def default_input_js
+        {theme: 'bootstrap', minimumResultsForSearch: 6, tokenSeparators: [',', ' '], width: 'style', placeholder: 'Please choose'}
+      end
+
+      def default_input_html
+        {class: 'effective_select', placeholder: 'Please choose'}
       end
 
       def to_html
-        collection_select(@object_name, @method, options.delete(:collection), options.delete(:label_method), options.delete(:value_method), options.merge({:selected => value}), options)
+        collection_select(@object_name, @method, options[:collection], options[:label_method], options[:value_method], options, tag_options)
       end
 
       def options
-        super do |options|
-          options[:multiple] = true if options[:tags]
+        super().tap do |options|
+          options[:selected] = value if value
+
+          options[:multiple] = true if (options[:tags] == true)
+          options[:include_blank] = (options[:multiple] != true)
+        end
+      end
 
-          # If multiple...
-          options['data-input-js-options'][:allowClear] = (!options[:multiple])
-          options[:include_blank] = false if options[:multiple]
+      def html_options
+        super().tap do |html_options|
+          html_options[:multiple] = options[:multiple]
+        end
+      end
+
+      def js_options
+        super().tap do |js_options|
+          js_options[:allowClear] = (options[:multiple] != true)
+          js_options[:tags] = (options[:tags] == true)
         end
       end
     end
   end
 end
-

data/app/models/inputs/effective_select_input.rb

@@ -7,14 +7,11 @@ if defined?(SimpleForm)
     def input(wrapper_options = nil)
       label_method, value_method = detect_collection_methods
 
-      options = merge_wrapper_options(input_html_options, wrapper_options) || {}
-      options.merge!(input_options.select { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) })
-      options['data-input-js-options'] = input_options.reject { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) }
-
       options[:collection] = collection
       options[:label_method] = label_method
       options[:value_method] = value_method
-      Inputs::EffectiveSelect::Input.new(object, object_name, template, attribute_name, options).to_html
+
+      Inputs::EffectiveSelect::Input.new(object, object_name, template, attribute_name, input_options, (merge_wrapper_options(input_html_options, wrapper_options) || {})).to_html
     end
   end
 

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

@@ -3,18 +3,17 @@ module Inputs
     class Input < Effective::FormInput
       delegate :content_tag, :to => :@template
 
-      def default_input_classes
-        ['form-control-static']
+      def default_input_html
+        {class: 'form-control-static'}
       end
 
       def to_html
-        content_tag(:p, value, options)
+        content_tag(:p, value, tag_options)
       end
 
-      def options
-        super do |options|
-          options[:class].delete('form-control') if options[:class].kind_of?(Array)
-          options[:class].delete!('form-control') if options[:class].kind_of?(String)
+      def html_options
+        super.tap do |html_options|
+          html_options[:class].delete('form-control')
         end
       end
 

data/app/models/inputs/effective_static_control_input.rb

@@ -5,11 +5,7 @@ if defined?(SimpleForm)
 
   class EffectiveStaticControlInput < SimpleForm::Inputs::StringInput
     def input(wrapper_options = nil)
-      options = merge_wrapper_options(input_html_options, wrapper_options) || {}
-      options.merge!(input_options.select { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) })
-      options['data-input-js-options'] = input_options.reject { |k, _| EffectiveFormInputs::REJECTED_INPUT_JS_OPTIONS.include?(k) }
-
-      Inputs::EffectiveStaticControl::Input.new(object, object_name, template, attribute_name, options).to_html
+      Inputs::EffectiveStaticControl::Input.new(object, object_name, template, attribute_name, input_options, (merge_wrapper_options(input_html_options, wrapper_options) || {})).to_html
     end
   end
 

data/app/views/effective/style_guide/_form_default.html.haml

@@ -1,7 +1,24 @@
 / this gives me a mechanism to test the inputs easily on a site with effective style_guide installed
 
 = form_for Effective::StyleGuide.new(:category => 'Category 2'), :url => '/' do |f|
-  = f.effective_date_time_picker :updated_at
-  = f.effective_date_picker :updated_at
-  = f.select :category, 10.times.map { |x| "Category #{x}"}, :include_blank => true
-  = f.effective_select :category, 10.times.map { |x| "Category #{x}"}, :include_blank => false, :placeholder => 'Pleze chooze', :input_group => false
+  / = f.date_field :updated_at, :class => 'my-class'
+  / = f.effective_date_picker :updated_at, :class => 'my-class'
+  / %hr
+  / = f.datetime_field :updated_at
+  / = f.effective_date_time_picker :updated_at
+  / %hr
+  / = f.select :category, 10.times.map { |x| "Category #{x}"}, {:include_blank => true}, {:class => 'my-class'}
+  / = f.effective_select :category, 10.times.map { |x| "Category #{x}"}, {:include_blank => true}, {:class => 'my-class'}
+  / %hr
+  / = f.select :category, 10.times.map { |x| "Category #{x}"}, {:multiple => true}, {:class => 'my-class'}
+  / = f.effective_select :category, 10.times.map { |x| "Category #{x}"}, {:multiple => true}, {:class => 'my-class'}
+  / %hr
+  / = f.effective_static_control :static_text, :value => 'this is static control value', :class => 'my-class'
+
+
+  /= f.text_field :title, :class => 'my-text-field'
+  /= f.datetime_field :updated_at, :class => 'my-updated-at-class', :something => 'cool'
+  /= f.effective_date_time_picker :updated_at, :class => 'my-updated-at-class', :something => 'cool'
+
+  /= f.select :category, 10.times.map { |x| "Category #{x}"}, {:include_blank => true}, {:class => 'myclass'}
+  /= f.effective_select :category, 10.times.map { |x| "Category #{x}"}, {:include_blank => false}, {:class => 'myclass'}

data/lib/effective_form_inputs.rb

@@ -2,5 +2,4 @@ require "effective_form_inputs/engine"
 require "effective_form_inputs/version"
 
 module EffectiveFormInputs
-  REJECTED_INPUT_JS_OPTIONS = [:as, :hint, :error, :readonly, :disabled, :required, :label, :inline_label, :prompt, :min_max, :maxlength, :pattern, :input_html, :wrapper_html, :error_html, :id, :wrapper, :collection, :multiple, :include_blank, :label_method, :value_method, :input_group]
 end

data/lib/effective_form_inputs/version.rb

@@ -1,3 +1,3 @@
 module EffectiveFormInputs
-  VERSION = '0.4.2'.freeze
+  VERSION = '0.5.0'.freeze
 end

metadata

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