client_side_validations 0.8.0 → 2.2.0

data/javascript/vendor/jspec.xhr.js

@@ -1,210 +0,0 @@
-
-// 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

@@ -1,39 +0,0 @@
-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>}
-            if js.respond_to?(:html_safe)
-              js.html_safe
-            else
-              js
-            end
-          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/spec/action_view_2_spec.rb

@@ -1,55 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-gem 'actionpack', '~> 2.0'
-require 'action_pack'
-require 'action_view'
-require 'client_side_validations'
-
-describe 'ActionView 2.x Form Helper' do
-  context 'ActionView::Base' do
-    subject { ActionView::Base.new }
-    
-    context 'only the url' do
-      before do
-        @object_name         = 'object'
-        @url                 = '/objects/new.json'
-        @expected_javascript = %{<script type="text/javascript">$(document).ready(function(){$('##{@object_name}').clientSideValidations('#{@url}','jquery.validate');});</script>}
-        subject.should_receive(:dom_id).and_return(@object_name)
-      end
-      
-      it 'should generate the proper javascript' do
-        subject.client_side_validations(@object_name, 
-          :url => @url).should == @expected_javascript
-      end
-    end
-    
-    context 'a different adapter' do
-      before do
-        @object_name         = 'object'
-        @url                 = '/objects/new.json'
-        @adapter             = 'some.other.adapter'
-        @expected_javascript = %{<script type="text/javascript">$(document).ready(function(){$('##{@object_name}').clientSideValidations('#{@url}','#{@adapter}');});</script>}
-        subject.should_receive(:dom_id).and_return(@object_name)
-      end
-      
-      it 'should generate the proper javascript' do
-        subject.client_side_validations(@object_name, 
-          :url => @url, :adapter => @adapter).should == @expected_javascript
-      end
-    end
-
-    context 'not including the :url' do
-      before do
-        @object_name = 'object'
-        @adapter     = 'some.other.adapter'
-      end
-      
-      it 'should raise an error' do
-        expect {
-          subject.client_side_validations(@object_name, 
-            :adapter => @some_other_adapter)
-        }.to raise_error
-      end
-    end
-    
-  end
-end

data/spec/action_view_3_spec.rb

@@ -1,55 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-gem 'actionpack', '~> 3.0'
-require 'action_pack'
-require 'action_view'
-require 'client_side_validations'
-
-describe 'ActionView 3.x Form Helper' do
-    context 'ActionView::Base' do
-      subject { ActionView::Base.new }
-
-      context 'only the url' do
-        before do
-          @object_name         = 'object'
-          @url                 = '/objects/new.json'
-          @expected_javascript = %{<script type="text/javascript">$(document).ready(function(){$('##{@object_name}').clientSideValidations('#{@url}','jquery.validate');});</script>}
-          subject.should_receive(:dom_id).and_return(@object_name)
-        end
-
-        it 'should generate the proper javascript' do
-          subject.client_side_validations(@object_name, 
-            :url => @url).should == @expected_javascript
-        end
-      end
-
-      context 'a different adapter' do
-        before do
-          @object_name         = 'object'
-          @url                 = '/objects/new.json'
-          @adapter             = 'some.other.adapter'
-          @expected_javascript = %{<script type="text/javascript">$(document).ready(function(){$('##{@object_name}').clientSideValidations('#{@url}','#{@adapter}');});</script>}
-          subject.should_receive(:dom_id).and_return(@object_name)
-        end
-
-        it 'should generate the proper javascript' do
-          subject.client_side_validations(@object_name, 
-            :url => @url, :adapter => @adapter).should == @expected_javascript
-        end
-      end
-
-      context 'not including the :url' do
-        before do
-          @object_name = 'object'
-          @adapter     = 'some.other.adapter'
-        end
-
-        it 'should raise an error' do
-          expect {
-            subject.client_side_validations(@object_name, 
-              :adapter => @some_other_adapter)
-          }.to raise_error
-        end
-      end
-
-    end
-  end

data/spec/active_model_3_spec.rb

@@ -1,271 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-require 'active_model'
-require 'client_side_validations'
-
-describe "Validation to hash" do
-  
-  before do
-    class Klass
-      include ActiveModel::Validations
-    end
-  end
-  
-  after do
-    Object.send(:remove_const, :Klass)
-  end
-  
-  it "should support validate_presence_of" do
-    Klass.class_eval { validates_presence_of :string }
-    instance      = Klass.new
-    expected_hash = { "presence" => { "message" => "can't be blank"} }
-    result_hash   = instance.validation_to_hash(:string)
-    result_hash.should == expected_hash
-  end
-  
-  it "should support validates_format_of of" do
-    Klass.class_eval { validates_format_of :string, :with => /\A\d\Z/i }
-    instance      = Klass.new
-    expected_hash = { "format" => { "message" => "is invalid", "with" => "^\\d$" } }
-    result_hash   = instance.validation_to_hash(:string)
-    result_hash.should == expected_hash
-  end
-  
-  it "should support different ways to write regex" do
-    Klass.class_eval do
-      validates_format_of :string, :with => /^\d$/i
-      validates_format_of :string_2, :with => /\d/
-    end
-    instance        = Klass.new
-    expected_hash_1 = { "format" => { "message" => "is invalid", "with" => "^\\d$" } }
-    expected_hash_2 = { "format" => { "message" => "is invalid", "with" => "\\d" } }
-    result_hash_1   = instance.validation_to_hash(:string)
-    result_hash_2   = instance.validation_to_hash(:string_2)
-    result_hash_1.should == expected_hash_1
-    result_hash_2.should == expected_hash_2
-  end
-  
-  it "should support minimum validates_length_of of" do
-    Klass.class_eval { validates_length_of :string, :minimum => 10 }
-    instance      = Klass.new
-    expected_hash = { "length" => { "message" => "is too short (minimum is 10 characters)", "minimum" => 10 } }
-    result_hash   = instance.validation_to_hash(:string)
-    result_hash.should == expected_hash
-  end
-
-  it "should support maximum validates_length_of of" do
-    Klass.class_eval { validates_length_of :string, :maximum => 10 }
-    instance      = Klass.new
-    expected_hash = { "length" => { "message" => "is too long (maximum is 10 characters)", "maximum" => 10 } }
-    result_hash   = instance.validation_to_hash(:string)
-    result_hash.should == expected_hash
-  end
-  
-  it "should support validations with conditionals" do
-    Klass.class_eval do
-      validates_presence_of :string, :if => :need_string?
-      validates_presence_of :string_2, :unless => :need_string?
-      validates_presence_of :integer, :if => :need_integer?
-      
-      def need_string?
-        true
-      end
-      
-      def need_integer?
-        false
-      end
-    end
-    
-    instance        = Klass.new
-    expected_hash_1 = { "presence" => { "message" => "can't be blank" } }
-    result_hash_1   = instance.validation_to_hash(:string)
-    result_hash_1.should == expected_hash_1
-    
-    expected_hash_2 = { }
-    result_hash_2   = instance.validation_to_hash(:string_2)
-    result_hash_2.should == expected_hash_2
-    
-    expected_hash_3 = { }
-    result_hash_3   = instance.validation_to_hash(:integer)
-    result_hash_3.should == expected_hash_3
-  end
-  
-  it "should support validating the validates_numericality_of of" do
-    Klass.class_eval { validates_numericality_of :integer }
-    instance      = Klass.new
-    expected_hash = { "numericality" => { "message" => "is not a number" } }
-    result_hash   = instance.validation_to_hash(:integer)
-    result_hash.should == expected_hash
-  end
-  
-  it "should strip out the AR callback options" do
-    Klass.class_eval { validates_presence_of :string, :on => :create }
-    instance      = Klass.new
-    expected_hash = { "presence" => { "message" => "can't be blank"} }
-    result_hash   = instance.validation_to_hash(:string)
-    result_hash.should == expected_hash
-  end
-  
-  it "should support multiple validations for the same method" do
-    Klass.class_eval do
-      validates_presence_of :integer
-      validates_numericality_of :integer
-    end
-    
-    instance      = Klass.new
-    expected_hash = { "presence" => { "message" => "can't be blank" },
-                      "numericality" => { "message" => "is not a number" } }
-    result_hash   = instance.validation_to_hash(:integer)
-    result_hash.should == expected_hash
-  end
-  
-  context 'with custom validation messages' do
-    before do
-      add_translation(:en, :klass => { :attributes => { :string_2 => { :presence => "String_2" } } })
-      
-      Klass.class_eval do
-        validates_presence_of :string, :message => "String"
-        validates_presence_of :string_2, :message => :presence
-      end
-    end
-    
-    after do
-      remove_translation(:en, :klass)
-    end
-    
-    it 'should have a message of "String" for #string' do
-      instance      = Klass.new
-      expected_hash = { "presence" => { "message" => "String" } }
-      result_hash   = instance.validation_to_hash(:string)
-      result_hash.should == expected_hash
-    end
-
-    it 'should have a message of "String_2" for #string_2' do
-      instance      = Klass.new
-      expected_hash = { "presence" => { "message" => "String_2" } }
-      result_hash   = instance.validation_to_hash(:string_2)
-      result_hash.should == expected_hash
-    end
-  end
-  
-  context 'Other languages' do
-    before do
-      add_translation(:es, :klass => { :attributes => { :string => { :presence => "String-es" } } })
-      
-      Klass.class_eval do
-        validates_presence_of :string, :message => :presence
-      end
-    end
-    
-    after do
-      remove_translation(:es, :klass)
-    end
-    
-    it 'should result in "String-es" for Spanish translations' do
-      instance      = Klass.new
-      expected_hash = { "presence" => { "message" => "String-es" } }
-      result_hash   = instance.validation_to_hash(:string, :locale => :es)
-      result_hash.should == expected_hash
-    end
-    
-    it 'should result in "String-es" for Spanish translations when passed string "es" instead of symbol' do
-      instance      = Klass.new
-      expected_hash = { "presence" => { "message" => "String-es" } }
-      result_hash   = instance.validation_to_hash(:string, :locale => "es")
-      result_hash.should == expected_hash
-    end
-  end
-  
-  xit "should support the regular validate method" do
-    Klass.class_eval do
-      validate :do_something
-      
-      def do_something
-        errors.add(:string, "test this out")
-      end
-    end
-    
-    instance = Klass.new
-    # TODO: Unsupported right now
-  end
-
-  def add_translation(lang, hash)
-    validations = {
-      :errors => {
-        :models => hash
-      }
-    }
-    I18n.backend.store_translations(lang, validations)
-  end
-  
-  def remove_translation(lang, key)
-    model_validations = I18n.translate('errors.models')
-    model_validations.delete(key)
-    validations = {
-      :errors => model_validations
-    }
-    I18n.backend.store_translations(lang, validations)
-  end
-end
-
-describe "Validations to JSON" do
-  before do
-    class Klass
-      include ActiveModel::Validations
-    end
-  end
-  
-  after do
-    Object.send(:remove_const, :Klass)
-  end
-
-  it "should support a sinlgle validation" do
-    Klass.class_eval do
-      validates_presence_of :string
-    end
-    
-    instance      = Klass.new
-    expected_json = {:string => { "presence" => { "message" => "can't be blank" } } }.to_json
-    result_json   = instance.validations_to_json(:string)
-    result_json.should == expected_json
-  end
-
-  it "should support multiple validations on the same field" do
-    Klass.class_eval do
-      validates_presence_of :number
-      validates_numericality_of :number
-    end
-    
-    instance      = Klass.new
-    expected_json = {:number => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } } }.to_json
-    result_json   = instance.validations_to_json(:number)
-    result_json.should == expected_json
-  end
-  
-  it "should support single validations on different fields" do
-    Klass.class_eval do
-      validates_presence_of :string
-      validates_presence_of :string_2
-    end
-    
-    instance      = Klass.new
-    expected_json = {:string => { "presence" => { "message" => "can't be blank" } },
-                     :string_2 => { "presence" => { "message" => "can't be blank" } } }.to_json
-    result_json   = instance.validations_to_json(:string, :string_2)
-    result_json.should == expected_json
-  end
-  
-  it "should support multiple validations on different fields" do
-    Klass.class_eval do
-      validates_presence_of     :number_1
-      validates_numericality_of :number_1
-      validates_presence_of     :number_2
-      validates_numericality_of :number_2
-    end
-    
-    instance      = Klass.new
-    expected_json = {:number_1 => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } },
-                     :number_2 => { "presence" => { "message" => "can't be blank" }, "numericality" => { "message" => "is not a number" } } }.to_json
-    result_json   = instance.validations_to_json(:number_1, :number_2)
-    result_json.should == expected_json
-  end
-end