client_side_validations 3.2.8 → 4.2.0

data/lib/client_side_validations/active_model/numericality.rb

@@ -1,25 +1,27 @@
-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({}) { |a, e| a.merge!(e => e) })
+      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)
@@ -27,16 +29,15 @@ module ClientSideValidations::ActiveModel
               next
             end
           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_record.rb

@@ -2,10 +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|
+%w(uniqueness).each do |validator|
   require "client_side_validations/active_record/#{validator}"
   validator.capitalize!
-  eval "ActiveRecord::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveRecord::#{validator})"
+  ActiveRecord::Validations.const_get("#{validator}Validator").send :include, ClientSideValidations::ActiveRecord.const_get(validator)
 end
 
 ActiveRecord::Base.send(:include, ClientSideValidations::ActiveModel::Validations)

data/lib/client_side_validations/active_record/middleware.rb

@@ -1,51 +1,53 @@
-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)
+        value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if value.is_a?(String)
 
-    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?
-
-      t = klass.arel_table
-
-      sql = []
-      if params[:case_sensitive] == 'true'
-        sql << 'BINARY' if t.engine.connection.adapter_name =~ /^mysql/i
-        sql << t[attribute].eq(value).to_sql
-      else
-        escaped_value = value.gsub(/[%_]/, '\\\\\0')
-        sql << "#{t[attribute].matches(escaped_value).to_sql} ESCAPE '\\'"
-      end
+        t = klass.arel_table
 
-      sql << "AND #{t[klass.primary_key].not_eq(params[:id]).to_sql}" if params[:id]
+        sql = []
+        if params[:case_sensitive] == 'true'
+          sql << 'BINARY' if t.engine.connection.adapter_name =~ /^mysql/i
+          sql << t[attribute].eq(value).to_sql
+        else
+          escaped_value = value.gsub(/[%_]/, '\\\\\0')
+          sql << "#{t[attribute].matches(escaped_value).to_sql} ESCAPE '\\'"
+        end
 
-      (params[:scope] || {}).each do |attribute, value|
-        value = type_cast_value(klass, attribute, value)
-        sql << "AND #{t[attribute].eq(value).to_sql}"
-      end
+        sql << "AND #{t[klass.primary_key].not_eq(params[:id]).to_sql}" if params[:id]
 
-      relation = Arel::Nodes::SqlLiteral.new(sql.join(' '))
-      !klass.where(relation).exists?
-    end
+        (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
 
-    private
+        relation = Arel::Nodes::SqlLiteral.new(sql.join(' '))
+        !klass.where(relation).exists?
+      end
 
-    def self.type_cast_value(klass, attribute, value)
-      klass.columns_hash[attribute].type_cast(value)
-    end
+      def self.type_cast_value(column, value)
+        if column.respond_to?(:type_cast)
+          column.type_cast(value)
+        else
+          column.type_cast_from_database(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,32 +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]
+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
+        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
 
-      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))
+        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
-      end
 
-      hash
-    end
+        hash
+      end
 
-    private
+      private
 
-    def message_type
-      :taken
+      def message_type
+        :taken
+      end
     end
   end
 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

data/lib/client_side_validations/engine.rb

@@ -3,4 +3,3 @@ module ClientSideValidations
     config.app_middleware.use ClientSideValidations::Middleware::Validators
   end
 end
-

data/lib/client_side_validations/generators.rb

@@ -1,12 +1,11 @@
 module ClientSideValidations
   module Generators
-    Assets = []
+    ASSETS = []
 
     def self.register_assets(klass)
-      Assets.push(*klass.assets)
+      ASSETS.push(*klass.assets)
     end
   end
 end
 
 require 'client_side_validations/generators/rails_validations'
-

data/lib/client_side_validations/generators/rails_validations.rb

@@ -3,8 +3,8 @@ module ClientSideValidations
     class RailsValidations
       def self.assets
         [{
-          :path => File.expand_path('../../../../vendor/assets/javascripts', __FILE__),
-          :file => 'rails.validations.js'
+          path: File.expand_path('../../../../vendor/assets/javascripts', __FILE__),
+          file: 'rails.validations.js'
         }]
       end
 
@@ -12,4 +12,3 @@ module ClientSideValidations
     end
   end
 end
-

data/lib/client_side_validations/middleware.rb

@@ -1,9 +1,6 @@
-# encoding: utf-8
-
 require 'client_side_validations/core_ext'
 
 module ClientSideValidations
-
   module Middleware
     class Validators
       def initialize(app)
@@ -11,7 +8,8 @@ module ClientSideValidations
       end
 
       def call(env)
-        if matches = /\A\/validators\/(\w+)\z/.match(env['PATH_INFO'])
+        matches = %r{\A/validators/(\w+)\z}.match(env['PATH_INFO'])
+        if matches
           process_request(matches.captures.first, env)
         else
           @app.call(env)
@@ -19,23 +17,23 @@ module ClientSideValidations
       end
 
       def process_request(validation, env)
-        if disabled_validators.include?(validation.downcase)
+        if disabled_validators.include?(validation)
           error_resp
         else
           klass_name = validation.camelize
           klass_name = "::ClientSideValidations::Middleware::#{klass_name}"
           klass_name.constantize.new(env).response
         end
-      rescue => e
+      rescue
         error_resp
       end
 
       def disabled_validators
-        ClientSideValidations::Config.disabled_validators.map { |v| v.to_s.downcase }
+        ClientSideValidations::Config.disabled_validators.map(&:to_s)
       end
 
       def error_resp
-        [500, {'Content-Type' => 'application/json', 'Content-Length' => '0'}, ['']]
+        [500, { 'Content-Type' => 'application/json', 'Content-Length' => '0' }, ['']]
       end
     end
 
@@ -51,7 +49,7 @@ module ClientSideValidations
       end
 
       def response
-        [status, {'Content-Type' => content_type, 'Content-Length' => body.length.to_s}, [body]]
+        [status, { 'Content-Type' => content_type, 'Content-Length' => body.length.to_s }, [body]]
       end
 
       def content_type
@@ -60,13 +58,13 @@ module ClientSideValidations
     end
 
     class Uniqueness < Base
-      IGNORE_PARAMS = %w{case_sensitive id scope}
+      IGNORE_PARAMS = %w(case_sensitive id scope)
       REGISTERED_ORMS = []
       class NotValidatable < StandardError; end
 
       def response
         begin
-          if is_unique?
+          if unique?
             self.status = 404
             self.body   = 'true'
           else
@@ -94,32 +92,29 @@ module ClientSideValidations
 
       private
 
-      def is_unique?
+      def unique?
         convert_scope_value_from_null_to_nil
         klass, attribute, value = extract_resources
         middleware_class        = nil
 
         unless Array.wrap(klass._validators[attribute.to_sym]).find { |v| v.kind == :uniqueness }
-          raise NotValidatable
+          fail NotValidatable
         end
 
         registered_orms.each do |orm|
-          if orm.is_class?(klass)
+          if orm.class?(klass)
             middleware_class = orm
             break
           end
         end
 
-        middleware_class.is_unique?(klass, attribute, value, request.params)
+        middleware_class.unique?(klass, attribute, value, request.params)
       end
 
       def convert_scope_value_from_null_to_nil
-        if request.params['scope']
-          request.params['scope'].each do |key, value|
-            if value == 'null'
-              request.params['scope'][key] = nil
-            end
-          end
+        return unless request.params['scope']
+        request.params['scope'].each do |key, value|
+          request.params['scope'][key] = nil if value == 'null'
         end
       end
 
@@ -153,14 +148,12 @@ module ClientSideValidations
 
       def nested?(hash = nil, levels = 0)
         i = 0
-        until !(hash.respond_to? :keys)
+        while hash.respond_to? :keys
           hash = hash[hash.keys.first]
           i += 1
         end
         i > levels
       end
-
     end
   end
 end
-