client_side_validations 3.2.5 → 4.2.12

data/lib/client_side_validations/action_view/form_builder.rb

@@ -1,104 +1,122 @@
-module ClientSideValidations::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_client_side_validations(method, options = {})
-            build_validation_options(method, options)
-            options.delete(:validate)
-            #{selector}_without_client_side_validations(method, options)
+module ClientSideValidations
+  module ActionView
+    module 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_client_side_validations(method, options = {})
+                build_validation_options(method, options)
+                options.delete(:validate)
+                #{selector}_without_client_side_validations(method, options)
+              end
+            RUBY_EVAL
+
+            base.class_eval { alias_method_chain selector, :client_side_validations }
           end
-        RUBY_EVAL
 
-        base.class_eval { alias_method_chain selector, :client_side_validations }
-      end
+          base.class_eval do
+            alias_method_chain :initialize,                :client_side_validations
+            alias_method_chain :fields_for,                :client_side_validations
+            alias_method_chain :check_box,                 :client_side_validations
+            alias_method_chain :radio_button,              :client_side_validations
+            alias_method_chain :select,                    :client_side_validations
+            alias_method_chain :collection_select,         :client_side_validations
+            alias_method_chain :collection_check_boxes,    :client_side_validations
+            alias_method_chain :collection_radio_buttons,  :client_side_validations
+            alias_method_chain :grouped_collection_select, :client_side_validations
+            alias_method_chain :time_zone_select,          :client_side_validations
+          end
+        end
 
-      base.class_eval do
-        alias_method_chain :initialize,                :client_side_validations
-        alias_method_chain :fields_for,                :client_side_validations
-        alias_method_chain :check_box,                 :client_side_validations
-        alias_method_chain :radio_button,              :client_side_validations
-        alias_method_chain :select,                    :client_side_validations
-        alias_method_chain :collection_select,         :client_side_validations
-        alias_method_chain :grouped_collection_select, :client_side_validations
-        alias_method_chain :time_zone_select,          :client_side_validations
-
-        def client_side_form_settings(options, form_helper)
+        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([], ""))
+            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 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_client_side_validations(object_name, object, template, options, proc)
-      initialize_without_client_side_validations(object_name, object, template, options, proc)
-      @options[:validators] = { object => {} }
-    end
+        def initialize_with_client_side_validations(object_name, object, template, options)
+          initialize_without_client_side_validations(object_name, object, template, options)
+          @options[:validators] = { object => {} }
+        end
 
-    def fields_for_with_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_client_side_validations(record_or_name_or_array, *(args << options), &block)
-    end
+        def fields_for_with_client_side_validations(record_name, record_object = nil, fields_options = {}, &block)
+          fields_options[:validate] ||= @options[:validate] if @options[:validate] && !fields_options.key?(:validate)
+          fields_for_without_client_side_validations(record_name, record_object, fields_options, &block)
+        end
 
-    def check_box_with_client_side_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
-      build_validation_options(method, options)
-      options.delete(:validate)
-      check_box_without_client_side_validations(method, options, checked_value, unchecked_value)
-    end
+        def check_box_with_client_side_validations(method, options = {}, checked_value = '1', unchecked_value = '0')
+          build_validation_options(method, options)
+          options.delete(:validate)
+          check_box_without_client_side_validations(method, options, checked_value, unchecked_value)
+        end
 
-    def radio_button_with_client_side_validations(method, tag_value, options = {})
-      build_validation_options(method, options)
-      options.delete(:validate)
-      radio_button_without_client_side_validations(method, tag_value, options)
-    end
+        def radio_button_with_client_side_validations(method, tag_value, options = {})
+          build_validation_options(method, options)
+          options.delete(:validate)
+          radio_button_without_client_side_validations(method, tag_value, options)
+        end
 
-    def select_with_client_side_validations(method, choices, options = {}, html_options = {})
-      build_validation_options(method, html_options.merge(:name => options[:name]))
-      html_options.delete(:validate)
-      select_without_client_side_validations(method, choices, options, html_options)
-    end
+        def select_with_client_side_validations(method, choices = nil, options = {}, html_options = {}, &block)
+          build_validation_options(method, html_options.merge(name: options[:name]))
+          html_options.delete(:validate)
+          select_without_client_side_validations(method, choices, options, html_options, &block)
+        end
 
-    def collection_select_with_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_client_side_validations(method, collection, value_method, text_method, options, html_options)
-    end
+        def collection_select_with_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_client_side_validations(method, collection, value_method, text_method, options, html_options)
+        end
 
-    def grouped_collection_select_with_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_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
-    end
+        def collection_check_boxes_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+          build_validation_options(method, html_options.merge(name: options[:name]))
+          html_options.delete(:validate)
+          collection_check_boxes_without_client_side_validations(method, collection, value_method, text_method, options, html_options, &block)
+        end
 
-    def time_zone_select_with_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_client_side_validations(method, priority_zones, options, html_options)
-    end
+        def collection_radio_buttons_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+          build_validation_options(method, html_options.merge(name: options[:name]))
+          html_options.delete(:validate)
+          collection_radio_buttons_without_client_side_validations(method, collection, value_method, text_method, options, html_options, &block)
+        end
 
-  private
+        def grouped_collection_select_with_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_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_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_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])})" : "\\d+"
-        name = name.to_s.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
-        name = "#{name}#{options[:multiple] ? "[]" : nil}"
-        @options[:validators][@object][method] = { :name => name, :options => options[:validate] }
+        def build_validation_options(method, options = {})
+          return unless @options[:validate]
+
+          index       = @default_options[:index].present? ? "[#{@default_options[:index]}]" : ''
+          child_index = @options[:child_index] ? "(\\d+|#{Regexp.escape(@options[:child_index].to_s)})" : '\\d+'
+
+          name = options[:name] || "#{@object_name}#{index}[#{method}]"
+          name = name.to_s.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
+          name << '[]' if options[:multiple]
+
+          @options[:validators][@object][method] = { name: name, options: options[:validate] }
+        end
       end
     end
   end

data/lib/client_side_validations/action_view/form_helper.rb

@@ -1,146 +1,141 @@
-module ClientSideValidations::ActionView::Helpers
-  module FormHelper
-    class Error < StandardError; end
-
-    def form_for(record, *args, &block)
-      options = args.extract_options!
-      if options[:validate]
-
-        # Always turn off HTML5 Validations
-        options[:html] ||= {}
-        options[:html][:novalidate] = 'novalidate'
-
-        case record
-        when String, Symbol
-          raise ClientSideValidations::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
+# frozen_string_literal: true
+module ClientSideValidations
+  module ActionView
+    module Helpers
+      module FormHelper
+        class Error < StandardError
         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)
-      build_bound_validators(options)
-      options[:id] = html_id if html_id
-      script = client_side_form_settings(object, options)
+        def form_for(record, options = {}, &block)
+          raise ArgumentError, 'Missing block' unless block_given?
+          if options[:validate]
 
-      # Because of the load order requirement above this sub is necessary
-      # Would be nice to not do this
-      script = insert_validators_into_script(script)
+            # Always turn off HTML5 Validations
+            options[:html] ||= {}
+            options[:html][:novalidate] = 'novalidate'
 
-      if assign_script_to_content_for(options[:validate], script)
-        form.html_safe
-      else
-        "#{form}#{script}".html_safe
-      end
-    end
+            case record
+            when String, Symbol
+              raise ClientSideValidations::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
 
-    def assign_script_to_content_for(name, script)
-      if name && name != true
-        content_for(name) { script.html_safe }
-        true
-      end
-    end
+          @validators = {}
 
-    def apply_form_for_options!(object_or_array, options)
-      super
-      options[:html][:validate] = true if options[:validate]
-    end
+          # Order matters here. Rails mutates the options object
+          html_id = options[:html][:id] if options[:html]
+          form = super(record, options, &block)
+          options[:id] = html_id if html_id
 
-    def fields_for(record_or_name_or_array, record_object = nil, options = {}, &block)
-      output = super
-      build_bound_validators(options)
-      output
-    end
+          build_bound_validators options
+          builder = instantiate_builder(object_name, object, options) if object_name && object
+          script = client_side_form_settings(object, options, builder)
 
-    private
+          # Because of the load order requirement above this sub is necessary
+          # Would be nice to not do this
+          script = insert_validators_into_script(script)
 
-    def build_bound_validators(options)
-      if @validators
-        options[:validators].each do |key, value|
-          if @validators.key?(key)
-            @validators[key].merge! value
+          # rubocop:disable OutputSafety
+          # TODO: check if html_safe is really needed here
+          if assign_script_to_content_for(options[:validate], script)
+            form.html_safe
           else
-            @validators[key] = value
+            "#{form}#{script}".html_safe
           end
+          # rubocop:enable OutputSafety
         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 assign_script_to_content_for(name, script)
+          # rubocop:disable OutputSafety
+          # TODO: check if html_safe is really needed here
+          return unless name && name != true
+          content_for name, script.html_safe
+          true
+          # rubocop:enable OutputSafety
+        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])
+        def apply_form_for_options!(record, object, options)
+          super
+          options[:html][:validate] = true if options[:validate]
         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 = {}
+        def fields_for(record_or_name_or_array, record_object = nil, options = {}, &block)
+          output = super
+          build_bound_validators options
+          output
         end
 
-        option_hash.each_key do |attr|
-          if validation_hash[attr]
-            validator_hash.merge!(object_opts[1][attr][:name] => validation_hash[attr])
+        private
+
+        def build_bound_validators(options)
+          return unless @validators
+          options[:validators].each do |key, value|
+            if @validators.key?(key)
+              @validators[key].merge! value
+            else
+              @validators[key] = value
+            end
           end
         end
 
-        validator_hash
-      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
 
-    def client_side_form_settings(object, options)
-      if options[:validate]
-        builder = options[:parent_builder]
+          script
+        end
 
-        if options[:id]
-          var_name = options[:id]
-        else
-          if Rails.version >= '3.2.0'
-            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("_")
+        def construct_validators
+          @validators.each_with_object({}) do |object_opts, validator_hash|
+            option_hash = object_opts[1].each_with_object({}) do |attr, result|
+              result[attr[0]] = attr[1][:options]
             end
-          else
-            # This is to maintain backward compatibility with Rails 3.1
-            # see: https://github.com/rails/rails/commit/e29773f885fd500189ffd964550ae20061d745ba#commitcomment-948052
-            var_name = if object.respond_to?(:persisted?) && object.persisted?
-              options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit)
-            else
-              options[:as] ? "#{options[:as]}_new" : dom_id(object)
+
+            validation_hash =
+              if object_opts[0].respond_to?(:client_side_validation_hash)
+                object_opts[0].client_side_validation_hash(option_hash)
+              else
+                {}
+              end
+
+            option_hash.each_key do |attr|
+              if validation_hash[attr]
+                validator_hash.merge!(object_opts[1][attr][:name] => validation_hash[attr])
+              end
             end
           end
         end
 
-        if ClientSideValidations::Config.number_format_with_locale and defined?(I18n)
-          number_format = I18n.t("number.format").extract!(:separator, :delimiter)
-        else
-          number_format = {:separator=>".", :delimiter=>","}
-        end
-        patterns = {:numericality=>"/^(-|\\+)?(?:\\d+|\\d{1,3}(?:\\#{number_format[:delimiter]}\\d{3})+)(?:\\#{number_format[:separator]}\\d*)?$/"}
+        def client_side_form_settings(object, options, builder)
+          return unless options[:validate]
+          var_name =
+            if options[:id]
+              options[:id]
+            elsif object.respond_to?(:persisted?) && object.persisted?
+              options[:as] ? "edit_#{options[:as]}" : [options[:namespace], dom_id(object, :edit)].compact.join('_'.freeze)
+            else
+              options[:as] ? "new_#{options[:as]}" : [options[:namespace], dom_id(object)].compact.join('_'.freeze)
+            end
 
+          number_format =
+            if ClientSideValidations::Config.number_format_with_locale && defined?(I18n)
+              I18n.t('number.format').slice(:separator, :delimiter)
+            else
+              { 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.ClientSideValidations===undefined)window.ClientSideValidations={};window.ClientSideValidations.disabled_validators=#{ClientSideValidations::Config.disabled_validators.to_json};window.ClientSideValidations.number_format=#{number_format.to_json};if(window.ClientSideValidations.patterns===undefined)window.ClientSideValidations.patterns = {};window.ClientSideValidations.patterns.numericality=#{patterns[:numericality]};if(window.ClientSideValidations.remote_validators_prefix===undefined)window.ClientSideValidations.remote_validators_prefix='#{(ClientSideValidations::Config.root_path||"").sub(/\/+\Z/,'')}';if(window.ClientSideValidations.forms===undefined)window.ClientSideValidations.forms={};window.ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};\n//]]>".html_safe
+          javascript_tag "if(window.ClientSideValidations===undefined)window.ClientSideValidations={};window.ClientSideValidations.disabled_validators=#{ClientSideValidations::Config.disabled_validators.to_json};window.ClientSideValidations.number_format=#{number_format.to_json};if(window.ClientSideValidations.patterns===undefined)window.ClientSideValidations.patterns = {};window.ClientSideValidations.patterns.numericality=#{patterns[:numericality]};#{"if(window.ClientSideValidations.remote_validators_prefix===undefined)window.ClientSideValidations.remote_validators_prefix='#{ClientSideValidations::Config.root_path.sub(%r{/+\Z}, '')}';" if ClientSideValidations::Config.root_path.present?}if(window.ClientSideValidations.forms===undefined)window.ClientSideValidations.forms={};window.ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(validators: 'validator_hash').to_json};"
         end
       end
     end
-
   end
 end
-

data/lib/client_side_validations/action_view/form_tag_helper.rb

@@ -1,12 +1,16 @@
-module ClientSideValidations::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))
+module ClientSideValidations
+  module ActionView
+    module Helpers
+      module FormTagHelper
+        private
+
+        def html_options_for_form(url_for_options, options)
+          options.stringify_keys!
+          html_options = {}
+          html_options['data-validate'] = options.delete('validate') if options['validate']
+          html_options.merge!(super(url_for_options, options))
+        end
       end
+    end
   end
 end
-

data/lib/client_side_validations/action_view.rb

@@ -1,5 +1,7 @@
-module ClientSideValidations::ActionView
-  module Helpers
+module ClientSideValidations
+  module ActionView
+    module Helpers
+    end
   end
 end
 
@@ -11,4 +13,3 @@ require 'client_side_validations/action_view/form_builder'
 ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormHelper)
 ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormTagHelper)
 ActionView::Helpers::FormBuilder.send(:include, ClientSideValidations::ActionView::Helpers::FormBuilder)
-

data/lib/client_side_validations/active_model/absence.rb

@@ -0,0 +1,11 @@
+module ClientSideValidations
+  module ActiveModel
+    module Absence
+      private
+
+      def message_type
+        :present
+      end
+    end
+  end
+end

data/lib/client_side_validations/active_model/acceptance.rb

@@ -1,10 +1,11 @@
-module ClientSideValidations::ActiveModel
-  module Acceptance
-    private
+module ClientSideValidations
+  module ActiveModel
+    module Acceptance
+      private
 
-    def message_type
-      :accepted
+      def message_type
+        :accepted
+      end
     end
   end
 end
-

data/lib/client_side_validations/active_model/conditionals.rb

@@ -0,0 +1,41 @@
+module ClientSideValidations
+  module ActiveModel
+    module Conditionals
+      private
+
+      def run_conditionals(conditionals, conditional_type)
+        Array.wrap(conditionals).all? do |conditional|
+          value = run_one_conditional(conditional)
+          if conditional_type == :unless
+            !value
+          else
+            value
+          end
+        end
+      end
+
+      def run_one_conditional(conditional)
+        case conditional
+        when ::Proc
+          case conditional.arity
+          when 0
+            instance_exec(&conditional)
+          when 1
+            instance_exec(self, &conditional)
+          else
+            raise ArgumentError, 'Missing argument'
+          end
+        when String
+          # rubocop:disable Security/Eval'
+          l = eval "lambda { |value| #{conditional} }"
+          # rubocop:enable Security/Eval'
+          instance_exec(nil, &l)
+        when Symbol
+          send conditional
+        else
+          raise ArgumentError, "Unknown conditional #{conditional}. If supported by ActiveModel/ActiveRecord open a bug for client_side_validations gem."
+        end
+      end
+    end
+  end
+end

data/lib/client_side_validations/active_model/exclusion.rb

@@ -1,27 +1,7 @@
-module ClientSideValidations::ActiveModel
-  module Exclusion
-
-    def client_side_hash(model, attribute, force = nil)
-      if options[:in].respond_to?(:call)
-        if force
-          options = self.options.dup
-          options[:in] = options[:in].call(model)
-          hash = build_client_side_hash(model, attribute, options)
-        else
-          return
-        end
-      else
-        hash = build_client_side_hash(model, attribute, self.options.dup)
-      end
-
-      if hash[:in].is_a?(Range)
-        hash[:range] = hash[:in]
-        hash.delete(:in)
-      end
-
-      hash
+module ClientSideValidations
+  module ActiveModel
+    module Exclusion
+      include EnumerableValidator
     end
-
   end
 end
-