rails4_client_side_validations 0.0.2 → 0.0.3

data/lib/rails4_client_side_validations/active_model/absence.rb

@@ -0,0 +1,10 @@
+module Rails4ClientSideValidations::ActiveModel
+  module Absence
+    private
+
+    def message_type
+      :present
+    end
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/acceptance.rb

@@ -0,0 +1,10 @@
+module Rails4ClientSideValidations::ActiveModel
+  module Acceptance
+    private
+
+    def message_type
+      :accepted
+    end
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/exclusion.rb

@@ -0,0 +1,27 @@
+module Rails4ClientSideValidations::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
+    end
+
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/format.rb

@@ -0,0 +1,31 @@
+module Rails4ClientSideValidations::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
+        super
+      end
+    end
+
+    private
+
+    def message_type
+      :invalid
+    end
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/inclusion.rb

@@ -0,0 +1,26 @@
+module Rails4ClientSideValidations::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
+    end
+
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/length.rb

@@ -0,0 +1,26 @@
+module Rails4ClientSideValidations::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]
+
+      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[option] = count
+        end
+      end
+
+      copy_conditional_attributes(hash, options)
+
+      hash
+    end
+
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/numericality.rb

@@ -0,0 +1,42 @@
+module Rails4ClientSideValidations::ActiveModel
+  module Numericality
+
+    OPTION_MAP = {}
+
+    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) } }
+
+      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]
+
+      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
+          end
+          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
+          hash[option] = count
+        end
+      end
+
+      copy_conditional_attributes(hash, options)
+
+      hash
+    end
+
+  end
+end
+

data/lib/rails4_client_side_validations/active_model/presence.rb

@@ -0,0 +1,10 @@
+module Rails4ClientSideValidations::ActiveModel
+  module Presence
+    private
+
+    def message_type
+      :blank
+    end
+  end
+end
+

data/lib/rails4_client_side_validations/active_record.rb

@@ -0,0 +1,12 @@
+require 'rails4_client_side_validations/active_model'
+require 'rails4_client_side_validations/middleware'
+require 'rails4_client_side_validations/active_record/middleware'
+
+%w{uniqueness}.each do |validator|
+  require "rails4_client_side_validations/active_record/#{validator}"
+  validator.capitalize!
+  eval "ActiveRecord::Validations::#{validator}Validator.send(:include, Rails4ClientSideValidations::ActiveRecord::#{validator})"
+end
+
+ActiveRecord::Base.send(:include, Rails4ClientSideValidations::ActiveModel::Validations)
+Rails4ClientSideValidations::Middleware::Uniqueness.register_orm(Rails4ClientSideValidations::ActiveRecord::Middleware)

data/lib/rails4_client_side_validations/active_record/middleware.rb

@@ -0,0 +1,59 @@
+module Rails4ClientSideValidations::ActiveRecord
+  class Middleware
+
+    def self.is_class?(klass)
+      klass.abstract_class.blank? && klass < ::ActiveRecord::Base
+    end
+
+    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
+
+      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}")
+        else
+          relation = t[attribute].eq(value)
+        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
+
+      (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))
+        end
+      end
+
+      !klass.where(relation).exists?
+    end
+
+    private
+
+    def self.type_cast_value(klass, attribute, value)
+      klass.columns_hash[attribute].type_cast(value)
+    end
+
+    def self.find_topmost_superclass(klass)
+      if is_class?(klass.superclass)
+        find_topmost_superclass(klass.superclass)
+      else
+        klass
+      end
+    end
+
+  end
+end

data/lib/rails4_client_side_validations/active_record/uniqueness.rb

@@ -0,0 +1,29 @@
+module Rails4ClientSideValidations::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))
+        end
+      end
+
+      unless model.class.name.demodulize == model.class.name
+        hash[:class] = model.class.name.underscore
+      end
+
+      hash
+    end
+
+    private
+
+    def message_type
+      :taken
+    end
+  end
+end
+

data/lib/rails4_client_side_validations/config.rb

@@ -0,0 +1,13 @@
+module Rails4ClientSideValidations
+  module Config
+    class << self
+      attr_accessor :disabled_validators
+      attr_accessor :number_format_with_locale
+      attr_accessor :root_path
+    end
+
+    self.disabled_validators = []
+    self.number_format_with_locale = false
+    self.root_path = nil
+  end
+end

data/lib/rails4_client_side_validations/core_ext.rb

@@ -0,0 +1,3 @@
+require 'active_support/json'
+require 'rails4_client_side_validations/core_ext/range'
+require 'rails4_client_side_validations/core_ext/regexp'

data/lib/rails4_client_side_validations/core_ext/range.rb

@@ -0,0 +1,10 @@
+class Range
+  def as_json(options = nil)
+    [first, last]
+  end
+
+  def to_json(options = nil)
+    as_json(options).inspect
+  end
+end
+

data/lib/rails4_client_side_validations/core_ext/regexp.rb

@@ -0,0 +1,13 @@
+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
+  end
+
+  def to_json(options = nil)
+    as_json(options).inspect
+  end
+
+  def encode_json(encoder)
+    inspect
+  end
+end

data/lib/rails4_client_side_validations/engine.rb

@@ -0,0 +1,6 @@
+module Rails4ClientSideValidations
+  class Engine < ::Rails::Engine
+    config.app_middleware.use Rails4ClientSideValidations::Middleware::Validators
+  end
+end
+

data/lib/rails4_client_side_validations/files.rb

@@ -0,0 +1,8 @@
+# This is only used by dependant libraries that need to find the files
+
+module Rails4ClientSideValidations
+  module Files
+    Initializer = File.expand_path(File.dirname(__FILE__) + '/../generators/templates/rails4_client_side_validations/initializer.rb')
+    Javascript  = File.expand_path(File.dirname(__FILE__) + '/../../vendor/assets/javascripts/rails.validations.js')
+  end
+end

data/lib/rails4_client_side_validations/generators.rb

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

data/lib/rails4_client_side_validations/generators/rails_validations.rb

@@ -0,0 +1,15 @@
+module Rails4ClientSideValidations
+  module Generators
+    class RailsValidations
+      def self.assets
+        [{
+          :path => File.expand_path('../../../../vendor/assets/javascripts', __FILE__),
+          :file => 'rails.validations.js'
+        }]
+      end
+
+      Generators.register_assets(self)
+    end
+  end
+end
+

data/lib/rails4_client_side_validations/middleware.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+
+require 'rails4_client_side_validations/core_ext'
+
+module Rails4ClientSideValidations
+
+  module Middleware
+    class Validators
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        if matches = /^\/validators\/(\w+)$/.match(env['PATH_INFO'])
+          if Rails4ClientSideValidations::Config.disabled_validators.include?(matches[1].to_sym)
+            [500, {'Content-Type' => 'application/json', 'Content-Length' => '0'}, ['']]
+          else
+            "::Rails4ClientSideValidations::Middleware::#{matches[1].camelize}".constantize.new(env).response
+          end
+        else
+          @app.call(env)
+        end
+      end
+    end
+
+    class Base
+      attr_accessor :request, :body, :status
+
+      def initialize(env)
+        # Filter out cache buster
+        env['QUERY_STRING'] = env['QUERY_STRING'].split('&').select { |p| !p.match(/^_=/) }.join('&')
+        self.body           = ''
+        self.status         = 200
+        self.request        = ActionDispatch::Request.new(env)
+      end
+
+      def response
+        [status, {'Content-Type' => content_type, 'Content-Length' => body.length.to_s}, [body]]
+      end
+
+      def content_type
+        'application/json'
+      end
+    end
+
+    class Uniqueness < Base
+      IGNORE_PARAMS = %w{case_sensitive id scope}
+      REGISTERED_ORMS = []
+      class NotValidatable < StandardError; end
+
+      def response
+        begin
+          if is_unique?
+            self.status = 404
+            self.body   = 'true'
+          else
+            self.status = 200
+            self.body   = 'false'
+          end
+        rescue NotValidatable
+          self.status = 500
+          self.body = ''
+        end
+        super
+      end
+
+      def self.register_orm(orm)
+        registered_orms << orm
+      end
+
+      def self.registered_orms
+        REGISTERED_ORMS
+      end
+
+      def registered_orms
+        self.class.registered_orms
+      end
+
+      private
+
+      def is_unique?
+        convert_scope_value_from_null_to_nil
+        resource         = extract_resource
+        klass            = resource.classify.constantize
+        attribute        = request.params[resource].keys.first
+        value            = request.params[resource][attribute]
+        middleware_class = nil
+
+        unless Array.wrap(klass._validators[attribute.to_sym]).find { |v| v.kind == :uniqueness }
+          raise NotValidatable
+        end
+
+        registered_orms.each do |orm|
+          if orm.is_class?(klass)
+            middleware_class = orm
+            break
+          end
+        end
+
+        middleware_class.is_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
+        end
+      end
+
+      def extract_resource
+        parent_key = (request.params.keys - IGNORE_PARAMS).first
+      end
+    end
+  end
+
+end
+