client_side_validations 3.2.5 → 4.2.12

data/lib/client_side_validations/active_model/format.rb

@@ -1,31 +1,26 @@
-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
+module ClientSideValidations
+  module ActiveModel
+    module Format
+      def client_side_hash(model, attribute, force = nil)
+        options = self.options.dup
+        if options[:with].respond_to?(:call)
+          return unless 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
+        elsif options[:without].respond_to?(:call)
+          return unless force
           options[:without] = options[:without].call(model)
           build_client_side_hash(model, attribute, options)
         else
-          return
+          super
         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
-

data/lib/client_side_validations/active_model/numericality.rb

@@ -1,42 +1,40 @@
-module ClientSideValidations::ActiveModel
-  module Numericality
+module ClientSideValidations
+  module ActiveModel
+    module Numericality
+      @@option_map = {}
 
-    OPTION_MAP = {}
+      def self.included(base)
+        @@option_map.merge!(base::CHECKS.keys.inject({}) { |acc, elem| acc.merge!(elem => elem) })
+      end
 
-    def self.included(base)
-      OPTION_MAP.merge!(base::CHECKS.keys.inject({}) { |hash, key| hash.merge!(key => key) })
-    end
+      def client_side_hash(model, attribute, force = nil)
+        options = self.options.dup
+        hash    = { messages: { numericality: model.errors.generate_message(attribute, :not_a_number, options) } }
 
-    def client_side_hash(model, attribute, force = nil)
-      options = self.options.dup
-      hash    = { :messages => { :numericality => model.errors.generate_message(attribute, :not_a_number, options) } }
+        if options[:only_integer]
+          hash[:messages][:only_integer] = model.errors.generate_message(attribute, :not_an_integer, options)
+          hash[:only_integer] = true
+        end
 
-      if options[:only_integer]
-        hash[:messages][:only_integer] = model.errors.generate_message(attribute, :not_an_integer, options)
-        hash[:only_integer] = true
-      end
+        hash[:allow_blank] = true if options[:allow_nil] || options[:allow_blank]
 
-      hash[:allow_blank] = true if options[:allow_nil] || options[:allow_blank]
+        @@option_map.each do |option, message_type|
+          count = options[option]
+          next unless count
 
-      OPTION_MAP.each do |option, message_type|
-        if count = options[option]
           if count.respond_to?(:call)
-            if force
-              count = count.call(model)
-            else
-              next
-            end
+            next unless force
+            count = count.call(model)
           end
-          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
-

data/lib/client_side_validations/active_model/presence.rb

@@ -1,10 +1,11 @@
-module ClientSideValidations::ActiveModel
-  module Presence
-    private
+module ClientSideValidations
+  module ActiveModel
+    module Presence
+      private
 
-    def message_type
-      :blank
+      def message_type
+        :blank
+      end
     end
   end
 end
-

data/lib/client_side_validations/active_model.rb

@@ -1,40 +1,42 @@
 require 'client_side_validations/core_ext'
+require 'client_side_validations/active_model/conditionals'
 
-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
+      include ClientSideValidations::ActiveModel::Conditionals
 
-  module Validations
-    def client_side_validation_hash(force = nil)
-      _validators.inject({}) do |attr_hash, attr|
-        unless [nil, :block].include?(attr[0])
+      def client_side_validation_hash(force = nil)
+        _validators.inject({}) do |attr_hash, attr|
+          return attr_hash if [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
+          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)
 
-            kind_hash
+            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
           end
 
           if validator_hash.present?
@@ -42,91 +44,99 @@ 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 = ((respond_to?(:new_record?) && validator.options[:on] == (new_record? ? :create : :update)) || validator.options[:on].nil?)
+        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_conditionals(validator.options[:if], :if)
             end
             if validator.options[:unless]
-              result = result && !run_conditional(validator.options[:unless])
+              result &&= run_conditionals(validator.options[:unless], :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)
+        result
       end
-    end
 
-    def validator_turned_off?(attr, validator, force)
-      case force
-      when FalseClass
-        true
-      when Hash
-        case force[attr]
+      def validator_turned_off?(attr, validator, force)
+        return true if ::ClientSideValidations::Config.disabled_validators.include?(validator.kind)
+        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
         end
-      else
-        ::ClientSideValidations::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]
+      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)
+          return unless force
+          options[:in] = options[:in].call(model)
+        end
+
+        hash = build_client_side_hash(model, attribute, options)
+
+        if hash[:in].is_a?(Range)
+          hash[:range] = hash[:in]
+          hash.delete(:in)
+        end
+
+        hash
       end
     end
   end
@@ -135,9 +145,7 @@ 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|
-  require "client_side_validations/active_model/#{validator}"
-  validator.capitalize!
-  eval "ActiveModel::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveModel::#{validator})"
+%w(Absence Acceptance Exclusion Format Inclusion Length Numericality Presence).each do |validator|
+  require "client_side_validations/active_model/#{validator.downcase}"
+  ActiveModel::Validations.const_get("#{validator}Validator").send :include, ClientSideValidations::ActiveModel.const_get(validator)
 end
-

data/lib/client_side_validations/active_record/middleware.rb

@@ -1,59 +1,65 @@
-module ClientSideValidations::ActiveRecord
-  class Middleware
+module ClientSideValidations
+  module ActiveRecord
+    class Middleware
+      def self.class?(klass)
+        klass.abstract_class.blank? && klass < ::ActiveRecord::Base
+      end
 
-    def self.is_class?(klass)
-      klass.abstract_class.blank? && klass < ::ActiveRecord::Base
-    end
+      def self.unique?(klass, attribute, value, params)
+        klass  = find_topmost_superclass(klass)
+        column = klass.columns_hash[attribute.to_s]
+        value  = type_cast_value(column, value)
 
-    def self.is_unique?(klass, attribute, value, params)
-      klass = find_topmost_superclass(klass)
-      value = type_cast_value(klass, attribute, value)
-      column = klass.columns_hash[attribute.to_s]
-      value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
+        sql      = sql_statement(klass, attribute, value, params)
+        relation = Arel::Nodes::SqlLiteral.new(sql)
 
-      t = klass.arel_table
+        klass.where(relation).empty?
+      end
 
-      if params[:case_sensitive] == 'true'
-        if t.engine.connection.adapter_name =~ /^mysql/i
-          relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql}")
+      def self.sql_statement(klass, attribute, value, params)
+        sql = []
+        t   = klass.arel_table
+
+        if params[:case_sensitive] == 'true'
+          sql << 'BINARY' if t.engine.connection.adapter_name =~ /^mysql/i
+          sql << t[attribute].eq(value).to_sql
         else
-          relation = t[attribute].eq(value)
+          escaped_value = value.gsub(/[%_]/, '\\\\\0')
+          sql << "#{t[attribute].matches(escaped_value).to_sql} ESCAPE '\\'"
         end
-      else
-        relation = t[attribute].matches(value)
-      end
 
-      if relation.is_a?(Arel::Nodes::SqlLiteral)
-        relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql} AND #{t[klass.primary_key].not_eq(params[:id]).to_sql}")
-      else
-        relation = relation.and(t[klass.primary_key].not_eq(params[:id])) if params[:id]
-      end
+        sql << "AND #{t[klass.primary_key].not_eq(params[:id]).to_sql}" if params[:id]
 
-      (params[:scope] || {}).each do |attribute, value|
-        value    = type_cast_value(klass, attribute, value)
-        if relation.is_a?(Arel::Nodes::SqlLiteral)
-          relation =  Arel::Nodes::SqlLiteral.new("#{relation} AND #{t[attribute].eq(value).to_sql}")
-        else
-          relation = relation.and(t[attribute].eq(value))
+        (params[:scope] || {}).each do |scope_attribute, scope_value|
+          scope_value = type_cast_value(klass.columns_hash[scope_attribute], scope_value)
+          sql << "AND #{t[scope_attribute].eq(scope_value).to_sql}"
         end
-      end
 
-      !klass.where(relation).exists?
-    end
+        sql.join ' '
+      end
 
-    private
+      def self.type_cast_value(column, value)
+        value =
+          if column.respond_to?(:type_cast)
+            column.type_cast(value)
+          else
+            column.type_cast_from_database(value)
+          end
 
-    def self.type_cast_value(klass, attribute, value)
-      klass.columns_hash[attribute].type_cast(value)
-    end
+        if column.limit && value.is_a?(String)
+          value.mb_chars[0, column.limit]
+        else
+          value
+        end
+      end
 
-    def self.find_topmost_superclass(klass)
-      if is_class?(klass.superclass)
-        find_topmost_superclass(klass.superclass)
-      else
-        klass
+      def self.find_topmost_superclass(klass)
+        if class?(klass.superclass)
+          find_topmost_superclass(klass.superclass)
+        else
+          klass
+        end
       end
     end
-
   end
 end

data/lib/client_side_validations/active_record/uniqueness.rb

@@ -1,29 +1,33 @@
-module ClientSideValidations::ActiveRecord
-  module Uniqueness
-    def client_side_hash(model, attribute, force = nil)
-      hash = {}
-      hash[:message]        = model.errors.generate_message(attribute, message_type, options.except(:scope))
-      hash[:case_sensitive] = options[:case_sensitive]
-      hash[:id]             = model.id unless model.new_record?
-      hash[:allow_blank]    = true if options[:allow_blank]
-      if options.key?(:scope) && options[:scope].present?
-        hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
-          scope_hash.merge!(scope_item => model.send(scope_item))
+module ClientSideValidations
+  module ActiveRecord
+    module Uniqueness
+      def client_side_hash(model, attribute, _force = nil)
+        hash = {}
+        hash[:message]        = model.errors.generate_message(attribute, message_type, options.except(:scope))
+        hash[:case_sensitive] = options[:case_sensitive]
+        hash[:id]             = model.id unless model.new_record?
+        hash[:allow_blank]    = true if options[:allow_blank]
+
+        if options.key?(:client_validations) && options[:client_validations].key?(:class)
+          hash[:class] = options[:client_validations][:class].underscore
+        elsif model.class.name.demodulize != model.class.name
+          hash[:class] = model.class.name.underscore
         end
-      end
 
-      unless model.class.name.demodulize == model.class.name
-        hash[:class] = model.class.name.underscore
-      end
+        if options.key?(:scope) && options[:scope].present?
+          hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
+            scope_hash.merge!(scope_item => model.send(scope_item))
+          end
+        end
 
-      hash
-    end
+        hash
+      end
 
-    private
+      private
 
-    def message_type
-      :taken
+      def message_type
+        :taken
+      end
     end
   end
 end
-

data/lib/client_side_validations/active_record.rb

@@ -2,11 +2,10 @@ require 'client_side_validations/active_model'
 require 'client_side_validations/middleware'
 require 'client_side_validations/active_record/middleware'
 
-%w{uniqueness}.each do |validator|
-  require "client_side_validations/active_record/#{validator}"
-  validator.capitalize!
-  eval "ActiveRecord::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveRecord::#{validator})"
-end
-
 ActiveRecord::Base.send(:include, ClientSideValidations::ActiveModel::Validations)
 ClientSideValidations::Middleware::Uniqueness.register_orm(ClientSideValidations::ActiveRecord::Middleware)
+
+%w(Uniqueness).each do |validator|
+  require "client_side_validations/active_record/#{validator.downcase}"
+  ActiveRecord::Validations.const_get("#{validator}Validator").send :include, ClientSideValidations::ActiveRecord.const_get(validator)
+end

data/lib/client_side_validations/config.rb

@@ -6,7 +6,7 @@ module ClientSideValidations
       attr_accessor :root_path
     end
 
-    self.disabled_validators = []
+    self.disabled_validators = [:uniqueness]
     self.number_format_with_locale = false
     self.root_path = nil
   end

data/lib/client_side_validations/core_ext/range.rb

@@ -1,5 +1,5 @@
 class Range
-  def as_json(options = nil)
+  def as_json(*)
     [first, last]
   end
 
@@ -7,4 +7,3 @@ class Range
     as_json(options).inspect
   end
 end
-

data/lib/client_side_validations/core_ext/regexp.rb

@@ -1,13 +1,15 @@
+require 'js_regex'
+
 class Regexp
-  def as_json(options = nil)
-    Regexp.new inspect.sub('\\A','^').sub('\\Z','$').sub('\\z','$').sub(/^\//,'').sub(/\/[a-z]*$/,'').gsub(/\(\?#.+\)/, '').gsub(/\(\?-\w+:/,'(').gsub(/\s/,''), self.options & 5
+  def as_json(*)
+    JsRegex.new(self).to_h
   end
 
   def to_json(options = nil)
-    as_json(options).inspect
+    as_json(options)
   end
 
-  def encode_json(encoder)
+  def encode_json(_encoder)
     inspect
   end
 end