wanew_client_validate 0.0.11

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/init.rb

@@ -0,0 +1,3 @@
+# Include hook code here
+
+require 'client_validate'

data/lib/wanew/client_validate/action_view.rb

@@ -0,0 +1,16 @@
+module WaNew
+	module ClientValidate
+		module ActionView
+			module Helpers
+				
+			end
+		end
+	end
+end
+
+
+require 'wanew/client_validate/action_view/form_helper'
+require 'wanew/client_validate/action_view/form_builder'
+
+ActionView::Base.send(:include, WaNew::ClientValidate::ActionView::Helpers::FormHelper)
+ActionView::Helpers::FormBuilder.send(:include, WaNew::ClientValidate::ActionView::Helpers::FormBuilder)

data/lib/wanew/client_validate/action_view/form_builder.rb

@@ -0,0 +1,103 @@
+module WaNew::ClientValidate::ActionView::Helpers
+	module FormBuilder
+		
+		def self.included(base)
+	    (base.field_helpers - %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_validations(method, options = {})
+	          apply_client_validators(method, options)
+	          options.delete(:validate)
+	          #{selector}_without_client_validations(method, options)
+	        end
+	      RUBY_EVAL
+	
+	      base.class_eval { alias_method_chain selector, :client_validations }
+	    end
+	
+	    base.class_eval do
+	      alias_method_chain :initialize,                :client_validations
+	      alias_method_chain :fields_for,                :client_validations
+	      alias_method_chain :check_box,                 :client_validations
+	      alias_method_chain :radio_button,              :client_validations
+	      alias_method_chain :select,                    :client_validations
+	      alias_method_chain :collection_select,         :client_validations
+	      alias_method_chain :grouped_collection_select, :client_validations
+	      alias_method_chain :time_zone_select,          :client_validations
+	
+	      def self.client_form_settings(options, form_helper)
+	        {
+	          #:type => self.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 initialize_with_client_validations(object_name, object, template, options, proc)
+	    initialize_without_client_validations(object_name, object, template, options, proc)
+	    @options[:validators] = {}
+	  end
+	
+	  def fields_for_with_client_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_validations(record_or_name_or_array, *(args << options), &block)
+	  end
+	
+	  def check_box_with_client_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
+	    apply_client_validators(method, options)
+	    check_box_without_client_validations(method, options, checked_value, unchecked_value)
+	  end
+	
+	  def radio_button_with_client_validations(method, tag_value, options = {})
+	    apply_client_validators(method, options)
+	    radio_button_without_client_validations(method, tag_value, options)
+	  end
+	
+	  def select_with_client_validations(method, choices, options = {}, html_options = {})
+	    apply_client_validators(method, html_options)
+	    select_without_client_validations(method, choices, options, html_options)
+	  end
+	
+	  def collection_select_with_client_validations(method, collection, value_method, text_method, options = {}, html_options = {})
+	    apply_client_validators(method, html_options)
+	    collection_select_without_client_validations(method, collection, value_method, text_method, options, html_options)
+	  end
+	
+	  def grouped_collection_select_with_client_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+	    apply_client_validators(method, html_options)
+	    grouped_collection_select_without_client_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+	  end
+	
+	  def time_zone_select_with_client_validations(method, priority_zones = nil, options = {}, html_options = {})
+	    apply_client_validators(method, html_options)
+	    time_zone_select_without_client_validations(method, priority_zones = nil, options, html_options)
+	  end
+	
+	private
+	
+	  def apply_client_validators(method, options = {})
+	    if @options[:validate] && options[:validate] != false && validators = filter_validators(@object.client_validation_hash[method], options[:validate])
+	    	
+	      options.merge!("validate" => validators.to_json)
+	      
+	      @options[:validators].merge!("#{@object_name}[#{method}]" => validators)
+	    end
+	  end
+	
+	  def filter_validators(validators, filters)
+	    if validators
+	      filtered_validators = validators.inject({}) do |filtered_validators, validator|
+	        unless filters && filters.key?(validator.first) && !filters[validator.first]
+	          filtered_validators[validator.first] = validator.last
+	        end
+	
+	        filtered_validators
+	      end
+	
+	      filtered_validators.empty? ? nil : filtered_validators
+	    end
+	  end					
+	end
+end

data/lib/wanew/client_validate/action_view/form_helper.rb

@@ -0,0 +1,76 @@
+module WaNew::ClientValidate::ActionView::Helpers
+	module FormHelper
+		def form_for(record_or_name_or_array, *args, &proc)
+      raise ArgumentError, "Missing block" unless block_given?
+
+      options = args.extract_options!
+
+      case record_or_name_or_array
+      when String, Symbol
+        ActiveSupport::Deprecation.warn("Using form_for(:name, @resource) is deprecated. Please use form_for(@resource, :as => :name) instead.", caller) unless args.empty?
+        object_name = record_or_name_or_array
+      when Array
+        object = record_or_name_or_array.last
+        object_name = options[:as] || ActiveModel::Naming.singular(object)
+        apply_form_for_options!(record_or_name_or_array, options)
+        args.unshift object
+      else
+        object = record_or_name_or_array
+        object_name = options[:as] || ActiveModel::Naming.singular(object)
+        apply_form_for_options!([object], options)
+        args.unshift object
+      end
+
+      (options[:html] ||= {})[:remote] = true if options.delete(:remote)
+
+ 			@validators = {}
+      # Order matters here. Rails mutates the options object
+      script = client_form_settings(object, options)
+      form   = super(record_or_name_or_array, *(args << options), &proc)
+      # Because of the load order requirement above this sub is necessary
+      # Would be nice to not do this
+      "#{form}#{script ? script.sub('"validator_hash"', @validators.to_json) : nil}#{script_bind(dom_id(object))}".html_safe
+		end
+		
+
+    def apply_form_for_options!(object_or_array, options)
+      super
+      options[:html][:validate] = true if options[:validate]
+    end
+
+    def fields_for(record_or_name_or_array, *args, &block)
+      output = super
+      @validators.merge!(args.last[:validators]) if @validators
+      output
+    end
+
+    private
+
+    def client_form_settings(object, options)
+      if options[:validate]
+        builder = options[:builder] || ActionView::Base.default_form_builder
+        if options[:html] && options[:html][:id]
+          var_name = options[:html][:id]
+        else
+          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)
+          end
+        end
+
+        content_tag(:script, :type=>'text/javascript') do
+          "var #{var_name} = #{builder.client_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
+        end
+
+      end
+    end
+    
+    def script_bind(id)
+  		content_tag(:script, :type=>'text/javascript') do
+  			"$('##{id}').validate();"
+			end
+  	end
+
+	end
+end

data/lib/wanew/client_validate/active_model.rb

@@ -0,0 +1,14 @@
+module WaNew
+	module ClientValidate
+		module ActiveModel
+		end
+	end
+end
+
+require 'active_model/validator'
+
+require 'wanew/client_validate/active_model/validators'
+require 'wanew/client_validate/active_model/validator'
+
+ActiveModel::Validations::HelperMethods.send(:include, 
+	WaNew::ClientValidate::ActionView::Validations::HelperMethods) if defined?(:ActiveModel)

data/lib/wanew/client_validate/active_model/validator.rb

@@ -0,0 +1,44 @@
+module WaNew::ClientValidate::ActiveModel
+  module Validator
+
+    def client_hash(model, attribute)
+      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
+      { :message => model.errors.generate_message(attribute, message_type, extra_options) }.merge(extra_options)
+    end
+
+    private
+
+    def message_type
+      kind
+    end
+  end
+  	
+	module Validations
+    def client_validation_hash
+      _validators.except(nil, :block).inject({}) do |attr_hash, attr|
+
+        validator_hash = attr[1].inject({}) do |kind_hash, validator|
+          client_hash = validator.client_hash(self, attr[0])
+          # Yeah yeah, #new_record? is not part of ActiveModel :p
+          if (can_use_for_client_validation?(client_hash, validator))
+            kind_hash.merge!(validator.kind => client_hash.except(:on))
+          else
+            kind_hash.merge!({})
+          end
+        end
+
+        attr_hash.merge!(attr[0] => validator_hash)
+      end.delete_if { |key, value| value.blank? }
+    end
+
+    private
+
+    def can_use_for_client_validation?(client_hash, validator)
+      ((self.respond_to?(:new_record?) && client_hash[:on] == (self.new_record? ? :create : :update)) || client_hash[:on].nil?) && !validator.options.key?(:if) && !validator.options.key?(:unless) && validator.kind != :block
+    end		
+	end
+end
+
+
+ActiveModel::Validator.send(:include, WaNew::ClientValidate::ActiveModel::Validator)
+ActiveModel::Validations.send(:include, WaNew::ClientValidate::ActiveModel::Validations)

data/lib/wanew/client_validate/active_model/validators.rb

@@ -0,0 +1,20 @@
+module WaNew::ClientValidate::ActionView::Validations
+	module HelperMethods
+		
+		def self.included(base)
+			base.class_eval do 
+				
+				def validates_presence_of_with_client(*attr_names)
+					options = attr_names.extract_options!
+					options[:message] ||= ""
+					options[:message] += " with client!"
+					attr_names << options;
+
+					validates_presence_of_without_client(*attr_names)
+				end
+
+				alias_method_chain :validates_presence_of, :client
+			end
+		end
+	end
+end

data/lib/wanew/client_validate/active_record.rb

@@ -0,0 +1,11 @@
+require 'wanew/client_validate/active_model'
+require 'wanew/client_validate/active_record/middleware'
+
+%w{uniqueness}.each do |validator|
+  require "wanew/client_validate/active_record/#{validator}"
+  validator.capitalize!
+  eval "ActiveRecord::Validations::#{validator}Validator.send(:include, WaNew::ClientValidate::ActiveRecord::#{validator})"
+end
+
+ActiveRecord::Base.send(:include, WaNew::ClientValidate::ActiveModel::Validations)
+

data/lib/wanew/client_validate/active_record/middleware.rb

@@ -0,0 +1,29 @@
+module WaNew::ClientValidate::ActiveRecord
+  class Middleware
+
+    def self.is_unique?(klass, attribute, value, params)
+      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.instance_variable_get("@config")[:adapter] == 'mysql'
+          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
+
+      relation = relation.and(t.primary_key.not_eq(params[:id])) if params[:id]
+
+      (params[:scope] || {}).each do |key, value|
+        relation = relation.and(t[key].eq(value))
+      end
+
+      !klass.where(relation).exists?
+    end
+  end
+end

data/lib/wanew/client_validate/active_record/uniqueness.rb

@@ -0,0 +1,26 @@
+module WaNew::ClientValidate::ActiveRecord
+  module Uniqueness
+    def client_hash(model, attribute)
+      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
+      hash = { :message => model.errors.generate_message(attribute, message_type, extra_options.except(:case_sensitive, :scope)) }
+      hash = hash.merge(extra_options).merge(model.new_record? ? {} : { :id => model.id })
+
+      if hash[:scope].present?
+        hash[:scope] = Array.wrap(hash[:scope]).inject({}) do |scope_hash, scope_item|
+          scope_hash.merge!(scope_item => model.send(scope_item))
+        end
+      else
+        hash.delete(:scope)
+      end
+
+      hash
+    end
+
+    private
+
+    def message_type
+      :taken
+    end
+  end
+end
+

data/lib/wanew/client_validate/middleware.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module WaNew::ClientValidate
+
+  module Middleware
+
+    class Validators
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        case env['PATH_INFO']
+        when %r{\/validators\/(\w+)\.json}
+          "::WaNew::ClientValidate::Middleware::#{$1.camelize}".constantize.new(env).response
+        else
+          @app.call(env)
+        end
+      end
+    end
+
+    class Base
+      attr_accessor :request, :body, :status
+
+      def initialize(env)
+        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}
+
+      def response
+        if is_unique?
+          self.status = 404
+          self.body   = 'true'
+        else
+          self.status = 200
+          self.body   = 'false'
+        end
+        super
+      end
+
+      private
+
+      def is_unique?
+        resource = extract_resource
+        klass = resource.classify.constantize
+        attribute = request.params[resource].keys.first
+        value = request.params[resource][attribute]
+
+        if (defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base)
+          middleware_klass = WaNew::ClientValidate::ActiveRecord::Middleware
+        end
+
+        middleware_klass.is_unique?(klass, attribute, value, request.params)
+      end
+
+      def extract_resource
+        parent_key = (request.params.keys - IGNORE_PARAMS).first
+      end
+    end
+
+  end
+
+  class Engine < ::Rails::Engine
+    config.app_middleware.use WaNew::ClientValidate::Middleware::Validators
+  end
+
+end
+

data/lib/wanew/client_validate/version.rb

@@ -0,0 +1,5 @@
+module WaNew
+	module ClientValidate
+		VERSION = "0.0.11"
+	end
+end

data/lib/wanew_client_validate.rb

@@ -0,0 +1,12 @@
+# ClientValidate
+module WaNew
+	module ClientValidate
+	end
+end
+
+
+require 'wanew/client_validate/action_view'
+require 'wanew/client_validate/active_model'
+require 'wanew/client_validate/active_record'
+require 'wanew/client_validate/middleware'
+

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: wanew_client_validate
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 11
+  version: 0.0.11
+platform: ruby
+authors: 
+- wanliu corporation
+- hysios
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-31 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: Client Validate mainly appiled for WaNew Engine in the browser client side validate utils
+email: 
+- hysios@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/wanew/client_validate/action_view/form_builder.rb
+- lib/wanew/client_validate/action_view/form_helper.rb
+- lib/wanew/client_validate/action_view.rb
+- lib/wanew/client_validate/active_model/validator.rb
+- lib/wanew/client_validate/active_model/validators.rb
+- lib/wanew/client_validate/active_model.rb
+- lib/wanew/client_validate/active_record/middleware.rb
+- lib/wanew/client_validate/active_record/uniqueness.rb
+- lib/wanew/client_validate/active_record.rb
+- lib/wanew/client_validate/middleware.rb
+- lib/wanew/client_validate/version.rb
+- lib/wanew_client_validate.rb
+- MIT-LICENSE
+- init.rb
+has_rdoc: true
+homepage: http://github.com/hysios/client_validate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: wanew_client_validate
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: WaNew Client Side Validations(like ClientSideValidations)
+test_files: []
+