client_side_validations 0.6.0

data/javascript/vendor/jspec.xhr.js

@@ -0,0 +1,210 @@
+
+// JSpec - XHR - Copyright TJ Holowaychuk <tj@vision-media.ca> (MIT Licensed)
+
+(function(){
+
+  var lastRequest
+
+  // --- Original XMLHttpRequest
+
+  var OriginalXMLHttpRequest = 'XMLHttpRequest' in this ?
+                                 XMLHttpRequest :
+                                   function(){}
+  var OriginalActiveXObject = 'ActiveXObject' in this ?
+                                 ActiveXObject :
+                                   undefined
+
+  // --- MockXMLHttpRequest
+
+  var MockXMLHttpRequest = function() {
+    this.requestHeaders = {}
+  }
+
+  MockXMLHttpRequest.prototype = {
+    status: 0,
+    async: true,
+    readyState: 0,
+	  responseXML: null,
+    responseText: '',
+    abort: function(){},
+    onreadystatechange: function(){},
+
+   /**
+    * Return response headers hash.
+    */
+
+    getAllResponseHeaders : function(){
+      return JSpec.inject(this.responseHeaders, '', function(buf, key, val){
+        return buf + key + ': ' + val + '\r\n'
+      })
+    },
+
+    /**
+     * Return case-insensitive value for header _name_.
+     */
+
+    getResponseHeader : function(name) {
+      return this.responseHeaders[name.toLowerCase()]
+    },
+
+    /**
+     * Set case-insensitive _value_ for header _name_.
+     */
+
+    setRequestHeader : function(name, value) {
+      this.requestHeaders[name.toLowerCase()] = value
+    },
+
+    /**
+     * Open mock request.
+     */
+
+    open : function(method, url, async, user, password) {
+      this.user = user
+      this.password = password
+      this.url = url
+      this.readyState = 1
+      this.method = method.toUpperCase()
+      if (async != undefined) this.async = async
+      if (this.async) this.onreadystatechange()
+    },
+
+    /**
+     * Send request _data_.
+     */
+
+    send : function(data) {
+      var self = this
+      this.data = data
+      this.readyState = 4
+      if (this.method == 'HEAD') this.responseText = null
+      this.responseHeaders['content-length'] = (this.responseText || '').length
+      if(this.async) this.onreadystatechange()
+	    this.populateResponseXML()
+      lastRequest = function(){
+        return self
+      }
+    },
+
+	/**
+	 * Parse request body and populate responseXML if response-type is xml
+	 * Based on the standard specification : http://www.w3.org/TR/XMLHttpRequest/
+	 */
+	populateResponseXML: function() {
+		var type = this.getResponseHeader("content-type")
+		if (!type || !this.responseText || !type.match(/(text\/xml|application\/xml|\+xml$)/g))
+			return
+		this.responseXML = JSpec.parseXML(this.responseText)
+	  }
+  }
+
+  // --- Response status codes
+
+  JSpec.statusCodes = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    300: 'Multiple Choice',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    305: 'Use Proxy',
+    307: 'Temporary Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Request Entity Too Large',
+    414: 'Request-URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Requested Range Not Satisfiable',
+    417: 'Expectation Failed',
+    422: 'Unprocessable Entity',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported'
+  }
+
+  /**
+   * Mock XMLHttpRequest requests.
+   *
+   *   mockRequest().and_return('some data', 'text/plain', 200, { 'X-SomeHeader' : 'somevalue' })
+   *
+   * @return {hash}
+   * @api public
+   */
+
+  function mockRequest() {
+    return { and_return : function(body, type, status, headers) {
+      XMLHttpRequest = MockXMLHttpRequest
+      ActiveXObject = false
+      status = status || 200
+      headers = headers || {}
+      headers['content-type'] = type
+      JSpec.extend(XMLHttpRequest.prototype, {
+        responseText: body,
+        responseHeaders: headers,
+        status: status,
+        statusText: JSpec.statusCodes[status]
+      })
+    }}
+  }
+
+  /**
+   * Unmock XMLHttpRequest requests.
+   *
+   * @api public
+   */
+
+  function unmockRequest() {
+    XMLHttpRequest = OriginalXMLHttpRequest
+    ActiveXObject = OriginalActiveXObject
+  }
+
+  JSpec.include({
+    name: 'Mock XHR',
+
+    // --- Utilities
+
+    utilities : {
+      mockRequest: mockRequest,
+      unmockRequest: unmockRequest
+    },
+
+    // --- Hooks
+
+    afterSpec : function() {
+      unmockRequest()
+    },
+
+    // --- DSLs
+
+    DSLs : {
+      snake : {
+        mock_request: mockRequest,
+        unmock_request: unmockRequest,
+        last_request: function(){ return lastRequest() }
+      }
+    }
+
+  })
+})()

data/lib/adapters/action_view.rb

@@ -0,0 +1,40 @@
+module DNCLabs
+  module ClientSideValidations
+    module Adapters
+      module ActionView
+        module BaseMethods
+  
+          def client_side_validations(object_name, options = {})
+            url     = options.delete(:url)
+            raise "No URL Specified!" unless url
+            adapter = options.delete(:adapter) || 'jquery.validate'
+    <<-JS
+      <script type="text/javascript">
+        $(document).ready(function() {
+          $('##{dom_id(options[:object])}').clientSideValidations('#{url}', '#{adapter}');
+        })
+      </script>
+    JS
+          end
+          
+        end # BaseMethods
+        
+        module FormBuilderMethods
+
+          def client_side_validations(options = {})
+            @template.send(:client_side_validations, @object_name, objectify_options(options))
+          end
+          
+        end # FormBuilderMethods
+      end
+    end
+  end
+end
+
+ActionView::Base.class_eval do
+  include DNCLabs::ClientSideValidations::Adapters::ActionView::BaseMethods
+end
+
+ActionView::Helpers::FormBuilder.class_eval do
+  include DNCLabs::ClientSideValidations::Adapters::ActionView::FormBuilderMethods
+end

data/lib/adapters/active_model.rb

@@ -0,0 +1,90 @@
+module DNCLabs
+  module ClientSideValidations
+    module Adapters
+      class ActiveModel
+        attr_accessor :base
+        
+        def initialize(base)
+          self.base = base
+        end
+        
+        def validation_to_hash(_attr, _options = {})
+          validation_hash = {}
+          base._validators[_attr.to_sym].each do |validation|
+            message = get_validation_message(validation, _options[:locale])
+            validation.options.delete(:message)
+            options = get_validation_options(validation.options)
+            method  = get_validation_method(validation.kind)
+            if conditional_method = remove_reserved_conditionals(options['if'])
+              if base.instance_eval(conditional_method.to_s)
+                options.delete('if')
+                validation_hash[method] = { 'message' => message }.merge(options)
+              end
+            elsif conditional_method = options['unless']
+              unless base.instance_eval(conditional_method.to_s)
+                options.delete('unless')
+                validation_hash[method] = { 'message' => message }.merge(options)
+              end
+            else
+              options.delete('if')
+              options.delete('unless')
+              validation_hash[method] = { 'message' => message }.merge(options)
+            end
+          end
+
+          validation_hash
+        end
+        
+        private
+
+        def get_validation_message(validation, locale)
+          default = case validation.kind
+          when :presence
+            I18n.translate('errors.messages.blank', :locale => locale)
+          when :format
+            I18n.translate('errors.messages.invalid', :locale => locale)
+          when :length
+            if count = validation.options[:minimum]
+              I18n.translate('errors.messages.too_short', :locale => locale).sub('{{count}}', count.to_s)
+            elsif count = validation.options[:maximum]
+              I18n.translate('errors.messages.too_long', :locale => locale).sub('{{count}}', count.to_s)
+            end
+          when :numericality
+            I18n.translate('errors.messages.not_a_number', :locale => locale)
+          end
+
+          message = validation.options[:message]
+          if message.kind_of?(String)
+            message
+          elsif message.kind_of?(Symbol)
+            I18n.translate("errors.models.#{base.class.to_s.downcase}.attributes.#{validation.attributes.first}.#{message}", :locale => locale)
+          else
+            default
+          end
+        end
+
+        def get_validation_options(options)
+          options = options.stringify_keys
+          options.delete('on')
+          options.delete('tokenizer')
+          options.delete('only_integer')
+          options.delete('allow_nil')
+          if options['with'].kind_of?(Regexp)
+            options['with'] = options['with'].inspect.to_s.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
+          end
+          options
+        end
+        
+        def get_validation_method(kind)
+          kind.to_s
+        end
+        
+        def remove_reserved_conditionals(*conditionals)
+          conditionals.flatten!
+          conditionals.delete_if { |conditional| conditional =~ /@_/ }
+          conditionals.first
+        end
+      end
+    end
+  end
+end

data/lib/adapters/active_record_2.rb

@@ -0,0 +1,90 @@
+require 'validation_reflection'
+
+module DNCLabs
+  module ClientSideValidations
+    module Adapters
+      class ActiveRecord2
+        attr_accessor :base
+        
+        def initialize(base)
+          self.base = base
+        end
+        
+        def validation_to_hash(_attr, _options = {})
+          validation_hash = {}
+          base.class.reflect_on_validations_for(_attr).each do |validation|
+            message = get_validation_message(validation, _options[:locale])
+            validation.options.delete(:message)
+            options = get_validation_options(validation.options)
+            method  = get_validation_method(validation.macro)
+            if conditional_method = options['if']
+              if base.instance_eval(conditional_method.to_s)
+                options.delete('if')
+                validation_hash[method] = { 'message' => message }.merge(options)
+              end
+            elsif conditional_method = options['unless']
+              unless base.instance_eval(conditional_method.to_s)
+                options.delete('unless')
+                validation_hash[method] = { 'message' => message }.merge(options)
+              end
+            else
+              validation_hash[method] = { 'message' => message }.merge(options)
+            end
+          end
+
+          validation_hash
+        end
+        
+        private
+
+        def get_validation_message(validation, locale)
+          default = case validation.macro.to_s
+          when 'validates_presence_of'
+            I18n.translate('activerecord.errors.messages.blank', :locale => locale)
+          when 'validates_format_of'
+            I18n.translate('activerecord.errors.messages.invalid', :locale => locale)
+          when 'validates_length_of'
+            if count = validation.options[:minimum]
+              I18n.translate('activerecord.errors.messages.too_short', :locale => locale).sub('{{count}}', count.to_s)
+            elsif count = validation.options[:maximum]
+              I18n.translate('activerecord.errors.messages.too_long', :locale => locale).sub('{{count}}', count.to_s)
+            end
+          when 'validates_numericality_of'
+            I18n.translate('activerecord.errors.messages.not_a_number', :locale => locale)
+          end
+
+          message = validation.options[:message]
+          if message.kind_of?(String)
+            message
+          elsif message.kind_of?(Symbol)
+            I18n.translate("activerecord.errors.models.#{base.class.to_s.downcase}.attributes.#{validation.name}.#{message}", :locale => locale)
+          else
+            default
+          end
+        end
+
+        def get_validation_options(options)
+          options = options.stringify_keys
+          options.delete('on')
+          if options['with'].kind_of?(Regexp)
+            options['with'] = options['with'].inspect.to_s.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
+          end
+          options
+        end
+        
+        def get_validation_method(method)
+          case method.to_s
+          when 'validates_presence_of'
+            'presence'
+          when 'validates_format_of'
+            'format'
+          when 'validates_numericality_of'
+            'numericality'
+          when 'validates_length_of'
+            'length'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/client_side_validations.rb

@@ -0,0 +1,47 @@
+require 'rubygems' unless defined?(Gem)
+
+module DNCLabs
+  module ClientSideValidations
+    def validations_to_json(*attrs)
+      hash = Hash.new { |h, attribute| h[attribute] = {} }
+      attrs.each do |attr|
+        hash[attr].merge!(validation_to_hash(attr))
+      end
+      hash.to_json
+    end
+    
+    def validation_to_hash(_attr, _options = {})
+      @dnc_csv_adapter ||= Adapter.new(self)
+      @dnc_csv_adapter.validation_to_hash(_attr, _options)
+    end
+  end
+end
+
+
+# ORM
+
+if defined?(ActiveModel)
+  require 'adapters/active_model'
+  unless Object.respond_to?(:to_json)
+    require 'active_support/json/encoding'
+  end
+  DNCLabs::ClientSideValidations::Adapter = DNCLabs::ClientSideValidations::Adapters::ActiveModel
+  klass = ActiveModel::Validations
+elsif defined?(ActiveRecord)
+  if ActiveRecord::VERSION::MAJOR == 2
+    require 'adapters/active_record_2'
+    DNCLabs::ClientSideValidations::Adapter = DNCLabs::ClientSideValidations::Adapters::ActiveRecord2
+    klass = ActiveRecord::Base
+  end
+end
+
+klass.class_eval do
+  include DNCLabs::ClientSideValidations
+end
+
+
+# Template
+
+if defined?(ActionView)
+  require 'adapters/action_view'
+end