client_side_validations 3.2.8 → 4.2.0

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/active_model.rb

@@ -1,40 +1,39 @@
 require 'client_side_validations/core_ext'
 
-module ClientSideValidations::ActiveModel
-  module Validator
+module ClientSideValidations
+  module ActiveModel
+    module Validator
+      def client_side_hash(model, attribute, _force = nil)
+        build_client_side_hash(model, attribute, options.dup)
+      end
 
-    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
 
-    def copy_conditional_attributes(to, from)
-      [:if, :unless].each { |key| to[key] = from[key] if from[key].present? }
-    end
+      private
 
-    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 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]))
+      def message_type
+        kind
+      end
     end
 
-    def message_type
-      kind
-    end
-  end
+    module Validations
+      def client_side_validation_hash(force = nil)
+        _validators.inject({}) do |attr_hash, attr|
+          return attr_hash if [nil, :block].include?(attr[0])
 
-  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].each_with_object(Hash.new { |h, k| h[k] = [] }) do |validator, kind_hash|
+            next unless can_use_for_client_side_validation?(attr[0], validator, force)
 
-          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
+            client_side_hash = validator.client_side_hash(self, attr[0], extract_force_option(attr[0], force))
+            if client_side_hash
+              kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
             end
-
-            kind_hash
           end
 
           if validator_hash.present?
@@ -42,92 +41,109 @@ module ClientSideValidations::ActiveModel
           else
             attr_hash
           end
-        else
-          attr_hash
         end
       end
-    end
 
-    private
+      private
 
-    def extract_force_option(attr, force)
-      case force
-      when FalseClass, TrueClass, NilClass
-        force
-      when Hash
-        extract_force_option(nil, force[attr])
-      else
-        nil
+      def extract_force_option(attr, force)
+        case force
+        when FalseClass, TrueClass, NilClass
+          force
+        when Hash
+          extract_force_option(nil, force[attr])
+        end
       end
-    end
 
-    def can_use_for_client_side_validation?(attr, validator, force)
-      if validator_turned_off?(attr, validator, force)
-        result = false
-      else
+      def can_use_for_client_side_validation?(attr, validator, force)
+        return false if validator_turned_off?(attr, validator, force)
+
         # 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
+        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)
+          else
+            result = can_force_validator?(attr, validator, force)
             if validator.options[:if]
-              result = result && run_conditional(validator.options[:if])
+              result &&= run_conditional(validator.options[:if])
             end
             if validator.options[:unless]
-              result = result && !run_conditional(validator.options[:unless])
+              result &&= !run_conditional(validator.options[:unless])
             end
           end
         end
-      end
 
-      result
-    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)
+      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
+          send method_name_value_or_proc
+        end
       end
-    end
 
-    def validator_turned_off?(attr, validator, force)
-      return true if ::ClientSideValidations::Config.disabled_validators.include?(validator.kind)
-      case force
-      when FalseClass
-        true
-      when Hash
-        case force[attr]
+      def validator_turned_off?(attr, validator, force)
+        case force
         when FalseClass
           true
         when Hash
-          force[attr][validator.kind] == false
+          case force[attr]
+          when FalseClass
+            true
+          when Hash
+            force[attr][validator.kind] == false
+          else
+            false
+          end
         else
-          false
+          ::ClientSideValidations::Config.disabled_validators.include?(validator.kind)
         end
-      else
-        false
       end
-    end
 
-    def can_force_validator?(attr, validator, force)
-      case force
-      when TrueClass
-        true
-      when Hash
-        case force[attr]
+      def can_force_validator?(attr, validator, force)
+        case force
         when TrueClass
           true
         when Hash
-          force[attr][validator.kind]
+          case force[attr]
+          when TrueClass
+            true
+          when Hash
+            force[attr][validator.kind]
+          else
+            false
+          end
         else
           false
         end
-      else
-        false
+      end
+    end
+
+    module EnumerableValidator
+      def client_side_hash(model, attribute, force = nil)
+        options = self.options.dup
+        if options[:in].respond_to?(:call)
+          if force
+            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, options)
+        end
+
+        if hash[:in].is_a?(Range)
+          hash[:range] = hash[:in]
+          hash.delete(:in)
+        end
+
+        hash
       end
     end
   end
@@ -136,9 +152,8 @@ end
 ActiveModel::Validator.send(:include, ClientSideValidations::ActiveModel::Validator)
 ActiveModel::Validations.send(:include, ClientSideValidations::ActiveModel::Validations)
 
-%w{acceptance exclusion inclusion length format numericality presence}.each do |validator|
+%w(absence acceptance exclusion inclusion length format numericality presence).each do |validator|
   require "client_side_validations/active_model/#{validator}"
   validator.capitalize!
-  eval "ActiveModel::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveModel::#{validator})"
+  ActiveModel::Validations.const_get("#{validator}Validator").send :include, ClientSideValidations::ActiveModel.const_get(validator)
 end
-

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/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
-

data/lib/client_side_validations/active_model/format.rb

@@ -1,31 +1,32 @@
-module ClientSideValidations::ActiveModel
-  module Format
-    def client_side_hash(model, attribute, force = nil)
-      options = self.options.dup
-      if options[:with].respond_to?(:call)
-        if force
-          options[:with] = options[:with].call(model)
-          build_client_side_hash(model, attribute, options)
+module ClientSideValidations
+  module ActiveModel
+    module Format
+      def client_side_hash(model, attribute, force = nil)
+        options = self.options.dup
+        if options[:with].respond_to?(:call)
+          if force
+            options[:with] = options[:with].call(model)
+            build_client_side_hash(model, attribute, options)
+          else
+            return
+          end
+        elsif options[:without].respond_to?(:call)
+          if force
+            options[:without] = options[:without].call(model)
+            build_client_side_hash(model, attribute, options)
+          else
+            return
+          end
         else
-          return
+          super
         end
-      elsif options[:without].respond_to?(:call)
-        if force
-          options[:without] = options[:without].call(model)
-          build_client_side_hash(model, attribute, options)
-        else
-          return
-        end
-      else
-        super
       end
-    end
 
-    private
+      private
 
-    def message_type
-      :invalid
+      def message_type
+        :invalid
+      end
     end
   end
 end
-

data/lib/client_side_validations/active_model/inclusion.rb

@@ -1,26 +1,7 @@
-module ClientSideValidations::ActiveModel
-  module Inclusion
-
-    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 Inclusion
+      include EnumerableValidator
     end
-
   end
 end
-

data/lib/client_side_validations/active_model/length.rb

@@ -1,26 +1,26 @@
-module ClientSideValidations::ActiveModel
-  module Length
+module ClientSideValidations
+  module ActiveModel
+    module Length
+      def client_side_hash(model, attribute, _force = nil)
+        options = self.options.dup
+        hash    = { messages: {} }
+        hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
+        hash[:allow_blank]  = true if options[:allow_blank]
 
-    def client_side_hash(model, attribute, force = nil)
-      options = self.options.dup
-      hash    = { :messages => {} }
-      hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
-      hash[:allow_blank]  = true if options[:allow_blank]
+        self.class::MESSAGES.each do |option, message_type|
+          count = options[option]
+          next unless count
 
-      self.class::MESSAGES.each do |option, message_type|
-        if count = options[option]
           options[:message] = options[message_type] if options[message_type].present?
           options.delete(:message) if options[:message].nil?
-          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
+          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(count: count))
           hash[option] = count
         end
-      end
 
-      copy_conditional_attributes(hash, options)
+        copy_conditional_attributes(hash, options)
 
-      hash
+        hash
+      end
     end
-
   end
 end
-