rails4_client_side_validations 0.0.2 → 0.0.3

data/README.md

@@ -0,0 +1 @@
+It's modifed version of [client_side_validations](https://github.com/bcardarella/client_side_validations.git), which supports Rails 4

data/lib/generators/rails4_client_side_validations/copy_assets_generator.rb

@@ -0,0 +1,58 @@
+module Rails4ClientSideValidations
+  module Generators
+    class CopyAssetsGenerator < Rails::Generators::Base
+
+      def copy_javascript_asset
+        if self.class == CopyAssetsGenerator || !asset_pipeline_enabled?
+          assets.each do |asset|
+            source_paths << asset[:path]
+            copy_file asset[:file], "#{asset_directory}/#{asset[:file]}"
+          end
+        end
+      end
+
+      private
+
+      def self.asset_directory
+        if asset_pipeline_enabled?
+          "app#{Rails.configuration.assets.prefix}/javascripts"
+        else
+          'public/javascripts'
+        end
+      end
+
+      def asset_directory
+        CopyAssetsGenerator.asset_directory
+      end
+
+      def self.assets
+        Assets
+      end
+
+      def assets
+        CopyAssetsGenerator.assets
+      end
+
+      def self.asset_file_names
+        assets.map { |asset| asset[:file] }.join(', ')
+      end
+
+      def self.asset_pipeline_enabled?
+        if Rails.application
+          (Rails.configuration.respond_to?(:assets) ? (Rails.configuration.assets || {}) : {})[:enabled]
+        end
+      end
+
+      def asset_pipeline_enabled?
+        self.class.asset_pipeline_enabled?
+      end
+
+      def self.installation_message
+        "Copies #{asset_file_names} to #{asset_directory}"
+      end
+
+      desc installation_message
+    end
+  end
+end
+

data/lib/generators/rails4_client_side_validations/install_generator.rb

@@ -0,0 +1,22 @@
+require 'generators/rails4_client_side_validations/copy_assets_generator'
+
+module Rails4ClientSideValidations
+  module Generators
+    class InstallGenerator < CopyAssetsGenerator
+
+      def copy_initializer
+        source_paths << File.expand_path('../../templates/rails4_client_side_validations', __FILE__)
+        copy_file 'initializer.rb', 'config/initializers/rails4_client_side_validations.rb'
+      end
+
+      private
+
+      def self.installation_message
+        "Copies initializer into config/initializers and #{super.downcase}"
+      end
+
+      desc installation_message
+    end
+  end
+end
+

data/lib/generators/templates/client_side_validations/initializer.rb

@@ -0,0 +1,20 @@
+# ClientSideValidations Initializer
+
+# Uncomment to disable uniqueness validator, possible security issue
+# ClientSideValidations::Config.disabled_validators = [:uniqueness]
+
+# Uncomment to validate number format with current I18n locale
+# ClientSideValidations::Config.number_format_with_locale = true
+
+# Uncomment to set a custom application scope
+# ClientSideValidations::Config.root_path = '/your/application/scope'
+
+# Uncomment the following block if you want each input field to have the validation messages attached.
+# ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+#   unless html_tag =~ /^<label/
+#     %{<div class="field_with_errors">#{html_tag}<label for="#{instance.send(:tag_id)}" class="message">#{instance.error_message.first}</label></div>}.html_safe
+#   else
+#     %{<div class="field_with_errors">#{html_tag}</div>}.html_safe
+#   end
+# end
+

data/lib/rails4_client_side_validations.rb

@@ -0,0 +1,13 @@
+module Rails4ClientSideValidations
+end
+
+require 'rails4_client_side_validations/config'
+require 'rails4_client_side_validations/active_model'  if defined?(::ActiveModel)
+require 'rails4_client_side_validations/active_record' if defined?(::ActiveRecord)
+require 'rails4_client_side_validations/action_view'   if defined?(::ActionView)
+if defined?(::Rails)
+  require 'rails4_client_side_validations/generators'
+  require 'rails4_client_side_validations/middleware'
+  require 'rails4_client_side_validations/engine'
+end
+

data/lib/rails4_client_side_validations/action_view.rb

@@ -0,0 +1,14 @@
+module Rails4ClientSideValidations::ActionView
+  module Helpers
+  end
+end
+
+require 'rails4_client_side_validations/core_ext'
+require 'rails4_client_side_validations/action_view/form_helper'
+require 'rails4_client_side_validations/action_view/form_tag_helper'
+require 'rails4_client_side_validations/action_view/form_builder'
+
+ActionView::Base.send(:include, Rails4ClientSideValidations::ActionView::Helpers::FormHelper)
+ActionView::Base.send(:include, Rails4ClientSideValidations::ActionView::Helpers::FormTagHelper)
+ActionView::Helpers::FormBuilder.send(:include, Rails4ClientSideValidations::ActionView::Helpers::FormBuilder)
+

data/lib/rails4_client_side_validations/action_view/form_builder.rb

@@ -0,0 +1,105 @@
+module Rails4ClientSideValidations::ActionView::Helpers
+  module FormBuilder
+
+    def self.included(base)
+      (base.field_helpers.map(&:to_s) - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
+        base.class_eval <<-RUBY_EVAL
+          def #{selector}_with_rails4_client_side_validations(method, options = {})
+            build_validation_options(method, options)
+            options.delete(:validate)
+            #{selector}_without_rails4_client_side_validations(method, options)
+          end
+        RUBY_EVAL
+
+        base.class_eval { alias_method_chain selector, :rails4_client_side_validations }
+      end
+
+      base.class_eval do
+        alias_method_chain :initialize,                :rails4_client_side_validations
+        alias_method_chain :fields_for,                :rails4_client_side_validations
+        alias_method_chain :check_box,                 :rails4_client_side_validations
+        alias_method_chain :radio_button,              :rails4_client_side_validations
+        alias_method_chain :select,                    :rails4_client_side_validations
+        alias_method_chain :collection_select,         :rails4_client_side_validations
+        alias_method_chain :grouped_collection_select, :rails4_client_side_validations
+        alias_method_chain :time_zone_select,          :rails4_client_side_validations
+
+        def client_side_form_settings(options, form_helper)
+          {
+            :type => self.class.to_s,
+            :input_tag => form_helper.class.field_error_proc.call(%{<span id="input_tag" />},  Struct.new(:error_message, :tag_id).new([], "")),
+            :label_tag => form_helper.class.field_error_proc.call(%{<label id="label_tag" />}, Struct.new(:error_message, :tag_id).new([], ""))
+          }
+        end
+      end
+    end
+
+    def validate(*attrs)
+      options = attrs.pop if attrs.last.is_a?(Hash)
+      (attrs.present? ? attrs : @object._validators.keys).each do |attr|
+        build_validation_options(attr, :validate => options)
+      end
+      nil
+    end
+
+    def initialize_with_rails4_client_side_validations(object_name, object, template, options, proc=nil)
+      initialize_without_rails4_client_side_validations(object_name, object, template, options, proc)
+      @options[:validators] = { object => {} }
+    end
+
+    def fields_for_with_rails4_client_side_validations(record_or_name_or_array, *args, &block)
+      options = args.extract_options!
+      options[:validate] ||= @options[:validate] if @options[:validate] && !options.key?(:validate)
+      fields_for_without_rails4_client_side_validations(record_or_name_or_array, *(args << options), &block)
+    end
+
+    def check_box_with_rails4_client_side_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
+      build_validation_options(method, options)
+      options.delete(:validate)
+      check_box_without_rails4_client_side_validations(method, options, checked_value, unchecked_value)
+    end
+
+    def radio_button_with_rails4_client_side_validations(method, tag_value, options = {})
+      build_validation_options(method, options)
+      options.delete(:validate)
+      radio_button_without_rails4_client_side_validations(method, tag_value, options)
+    end
+
+    def select_with_rails4_client_side_validations(method, choices, options = {}, html_options = {})
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
+      select_without_rails4_client_side_validations(method, choices, options, html_options)
+    end
+
+    def collection_select_with_rails4_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {})
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
+      collection_select_without_rails4_client_side_validations(method, collection, value_method, text_method, options, html_options)
+    end
+
+    def grouped_collection_select_with_rails4_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
+      grouped_collection_select_without_rails4_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+    end
+
+    def time_zone_select_with_rails4_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
+      time_zone_select_without_rails4_client_side_validations(method, priority_zones, options, html_options)
+    end
+
+    private
+
+    def build_validation_options(method, options = {})
+      if @options[:validate]
+        index = @default_options[:index].present? ? "[#{@default_options[:index]}]" : ''
+        name = options[:name] || "#{@object_name}#{index}[#{method}]"
+        child_index = @options[:child_index] ? "(\\d+|#{Regexp.escape(@options[:child_index].to_s)})" : "\\d+"
+        name = name.to_s.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
+        name = "#{name}#{options[:multiple] ? "[]" : nil}"
+        @options[:validators][@object][method] = { :name => name, :options => options[:validate] }
+      end
+    end
+  end
+end

data/lib/rails4_client_side_validations/action_view/form_helper.rb

@@ -0,0 +1,139 @@
+module Rails4ClientSideValidations::ActionView::Helpers
+  module FormHelper
+    class Error < StandardError; end
+
+    def form_for(record, *args, &block)
+      raise ArgumentError, "Missing block" unless block_given?
+      options = args.extract_options!
+      if options[:validate]
+
+        # Always turn off HTML5 Validations
+        options[:html] ||= {}
+        options[:html][:novalidate] = 'novalidate'
+
+        case record
+        when String, Symbol
+          raise Rails4ClientSideValidations::ActionView::Helpers::FormHelper::Error, 'Using form_for(:name, @resource) is not supported with ClientSideValidations. Please use form_for(@resource, :as => :name) instead.'
+        else
+          object = record.is_a?(Array) ? record.last : record
+          object_name = options[:as] || model_name_from_record_or_class(object).param_key
+        end
+      end
+
+      @validators = {}
+
+      # Order matters here. Rails mutates the options object
+      html_id = options[:html][:id] if options[:html]
+      form = super(record, *(args << options), &block)
+      options[:id] = html_id if html_id
+
+      process_validators options
+      builder = instantiate_builder(object_name, object, options) if object_name and object
+
+      script = client_side_form_settings(object, options, builder)
+
+      # Because of the load order requirement above this sub is necessary
+      # Would be nice to not do this
+      script = insert_validators_into_script(script)
+
+      if assign_script_to_content_for(options[:validate], script)
+        form.html_safe
+      else
+        "#{form}#{script}".html_safe
+      end
+    end
+
+    def assign_script_to_content_for(name, script)
+      if name && name != true
+        content_for(name) { script.html_safe }
+        true
+      end
+    end
+
+    def apply_form_for_options!(object_or_array, object, options)
+      super
+      options[:html][:validate] = true if options[:validate]
+    end
+
+    def fields_for(record_or_name_or_array, record_object = nil, options = {}, &block)
+      output = super
+      process_validators options
+      output
+    end
+
+    private
+
+    def process_validators(options)
+      if @validators
+        options[:validators].each do |key, value|
+          if @validators.key?(key)
+            @validators[key].merge! value
+          else
+            @validators[key] = value
+          end
+        end
+      end
+    end
+
+    def insert_validators_into_script(script)
+      # There is probably a more performant way of doing this
+      # But using String#sub has some issues. Undocumented "features"
+      if script
+        script = script.split(/"validator_hash"/)
+        script = "#{script[0]}#{construct_validators.to_json}#{script[1]}"
+      end
+
+      script
+    end
+
+    def construct_validators
+      @validators.inject({}) do |validator_hash, object_opts|
+        option_hash = object_opts[1].inject({}) do |option_hash, attr|
+          option_hash.merge!(attr[0] => attr[1][:options])
+        end
+
+        if object_opts[0].respond_to?(:client_side_validation_hash)
+          validation_hash = object_opts[0].client_side_validation_hash(option_hash)
+        else
+          validation_hash = {}
+        end
+
+        option_hash.each_key do |attr|
+          if validation_hash[attr]
+            validator_hash.merge!(object_opts[1][attr][:name] => validation_hash[attr])
+          end
+        end
+
+        validator_hash
+      end
+    end
+
+    def client_side_form_settings(object, options, builder)
+      if options[:validate]
+        if options[:id]
+          var_name = options[:id]
+        else
+          var_name = if object.respond_to?(:persisted?) && object.persisted?
+            options[:as] ? "edit_#{options[:as]}" : [options[:namespace], dom_id(object, :edit)].compact.join("_")
+          else
+            options[:as] ? "new_#{options[:as]}" : [options[:namespace], dom_id(object)].compact.join("_")
+          end
+        end
+
+        if Rails4ClientSideValidations::Config.number_format_with_locale and defined?(I18n)
+          number_format = I18n.t("number.format").slice(:separator, :delimiter)
+        else
+          number_format = {:separator=>".", :delimiter=>","}
+        end
+        patterns = {:numericality=>"/^(-|\\+)?(?:\\d+|\\d{1,3}(?:\\#{number_format[:delimiter]}\\d{3})+)(?:\\#{number_format[:separator]}\\d*)?$/"}
+
+
+        content_tag(:script) do
+          "//<![CDATA[\nif(window.Rails4ClientSideValidations===undefined)window.Rails4ClientSideValidations={};window.Rails4ClientSideValidations.disabled_validators=#{Rails4ClientSideValidations::Config.disabled_validators.to_json};window.Rails4ClientSideValidations.number_format=#{number_format.to_json};if(window.Rails4ClientSideValidations.patterns===undefined)window.Rails4ClientSideValidations.patterns = {};window.Rails4ClientSideValidations.patterns.numericality=#{patterns[:numericality]};if(window.Rails4ClientSideValidations.remote_validators_prefix===undefined)window.Rails4ClientSideValidations.remote_validators_prefix='#{(Rails4ClientSideValidations::Config.root_path||"").sub(/\/+\Z/,'')}';if(window.Rails4ClientSideValidations.forms===undefined)window.Rails4ClientSideValidations.forms={};window.Rails4ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};\n//]]>".html_safe
+        end
+      end
+    end
+
+  end
+end
+

data/lib/rails4_client_side_validations/action_view/form_tag_helper.rb

@@ -0,0 +1,12 @@
+module Rails4ClientSideValidations::ActionView::Helpers
+  module FormTagHelper
+    private
+      def html_options_for_form(url_for_options, options, *parameters_for_url)
+        options.stringify_keys!
+        html_options = {}
+        html_options['data-validate'] = options.delete('validate') if options['validate']
+        html_options.merge!(super(url_for_options, options, *parameters_for_url))
+      end
+  end
+end
+

data/lib/rails4_client_side_validations/active_model.rb

@@ -0,0 +1,143 @@
+require 'rails4_client_side_validations/core_ext'
+
+module Rails4ClientSideValidations::ActiveModel
+  module Validator
+
+    def client_side_hash(model, attribute, force = nil)
+      build_client_side_hash(model, attribute, self.options.dup)
+    end
+
+    def copy_conditional_attributes(to, from)
+      [:if, :unless].each { |key| to[key] = from[key] if from[key].present? }
+    end
+
+    private
+
+    def build_client_side_hash(model, attribute, options)
+      { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
+    end
+
+    def message_type
+      kind
+    end
+  end
+
+  module Validations
+    def client_side_validation_hash(force = nil)
+      _validators.inject({}) do |attr_hash, attr|
+        unless [nil, :block].include?(attr[0])
+
+          validator_hash = attr[1].inject(Hash.new { |h,k| h[k] = []}) do |kind_hash, validator|
+            if can_use_for_client_side_validation?(attr[0], validator, force)
+              if client_side_hash = validator.client_side_hash(self, attr[0], extract_force_option(attr[0], force))
+                kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
+              end
+            end
+
+            kind_hash
+          end
+
+          if validator_hash.present?
+            attr_hash.merge!(attr[0] => validator_hash)
+          else
+            attr_hash
+          end
+        else
+          attr_hash
+        end
+      end
+    end
+
+    private
+
+    def extract_force_option(attr, force)
+      case force
+      when FalseClass, TrueClass, NilClass
+        force
+      when Hash
+        extract_force_option(nil, force[attr])
+      else
+        nil
+      end
+    end
+
+    def can_use_for_client_side_validation?(attr, validator, force)
+      if validator_turned_off?(attr, validator, force)
+        result = false
+      else
+        # Yeah yeah, #new_record? is not part of ActiveModel :p
+        result = ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?)
+        result = result && validator.kind != :block
+
+        if validator.options[:if] || validator.options[:unless]
+          if validator.options[:if] && validator.options[:if] =~ /changed\?/
+            result = true
+          else result = can_force_validator?(attr, validator, force)
+            if validator.options[:if]
+              result = result && run_conditional(validator.options[:if])
+            end
+            if validator.options[:unless]
+              result = result && !run_conditional(validator.options[:unless])
+            end
+          end
+        end
+      end
+
+      result
+    end
+
+    def run_conditional(method_name_value_or_proc)
+      if method_name_value_or_proc.respond_to?(:call)
+        method_name_value_or_proc.call(self)
+      else
+        self.send(method_name_value_or_proc)
+      end
+    end
+
+    def validator_turned_off?(attr, validator, force)
+      case force
+      when FalseClass
+        true
+      when Hash
+        case force[attr]
+        when FalseClass
+          true
+        when Hash
+          force[attr][validator.kind] == false
+        else
+          false
+        end
+      else
+        ::Rails4ClientSideValidations::Config.disabled_validators.include?(validator.kind)
+      end
+    end
+
+    def can_force_validator?(attr, validator, force)
+      case force
+      when TrueClass
+        true
+      when Hash
+        case force[attr]
+        when TrueClass
+          true
+        when Hash
+          force[attr][validator.kind]
+        else
+          false
+        end
+      else
+        false
+      end
+    end
+  end
+end
+
+ActiveModel::Validator.send(:include, Rails4ClientSideValidations::ActiveModel::Validator)
+ActiveModel::Validations.send(:include, Rails4ClientSideValidations::ActiveModel::Validations)
+
+%w{absence acceptance exclusion inclusion length format numericality presence}.each do |validator|
+  require "rails4_client_side_validations/active_model/#{validator}"
+  validator.capitalize!
+  eval "ActiveModel::Validations::#{validator}Validator.send(:include, Rails4ClientSideValidations::ActiveModel::#{validator})"
+end
+