nimboids-client_side_validations 3.0.3

data/lib/client_side_validations/middleware.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module ClientSideValidations
+
+  module Middleware
+
+    class Validators
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        case env['PATH_INFO']
+        when %r{\/validators\/(\w+)\.json}
+          "::ClientSideValidations::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 = ClientSideValidations::ActiveRecord::Middleware
+        elsif (defined?(::Mongoid::Document) && klass.included_modules.include?(::Mongoid::Document))
+          middleware_klass = ClientSideValidations::Mongoid::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 ClientSideValidations::Middleware::Validators
+  end
+
+end
+

data/lib/client_side_validations/mongoid.rb

@@ -0,0 +1,9 @@
+require 'client_side_validations/active_model'
+require 'client_side_validations/mongoid/middleware'
+
+%w{uniqueness}.each do |validator|
+  require "client_side_validations/mongoid/#{validator}"
+  validator.capitalize!
+  eval "Mongoid::Validations::#{validator}Validator.send(:include, ClientSideValidations::Mongoid::#{validator})"
+end
+

data/lib/client_side_validations/mongoid/middleware.rb

@@ -0,0 +1,20 @@
+module ClientSideValidations::Mongoid
+  class Middleware
+
+    # Still need to handle embedded documents
+    def self.is_unique?(klass, attribute, value, params)
+      if params[:case_sensitive] == 'false'
+        value = Regexp.new("^#{Regexp.escape(value.to_s)}$", Regexp::IGNORECASE)
+      end
+
+      criteria = klass.where(attribute => value)
+      criteria = criteria.where(:_id => {'$ne' => BSON::ObjectId(params[:id])}) if params[:id]
+
+      (params[:scope] || {}).each do |key, value|
+        criteria = criteria.where(key => value)
+      end
+
+      !criteria.exists?
+    end
+  end
+end

data/lib/client_side_validations/mongoid/uniqueness.rb

@@ -0,0 +1,26 @@
+module ClientSideValidations::Mongoid
+  module Uniqueness
+    def client_side_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/client_side_validations/simple_form.rb

@@ -0,0 +1,24 @@
+module ClientSideValidations
+  module SimpleForm
+    module FormBuilder
+
+      def self.included(base)
+        base.class_eval do
+          def self.client_side_form_settings(options, form_helper)
+            {
+              :type => self.to_s,
+              :error_class => ::SimpleForm.error_class,
+              :error_tag => ::SimpleForm.error_tag,
+              :wrapper_error_class => ::SimpleForm.wrapper_error_class,
+              :wrapper_tag => ::SimpleForm.wrapper_tag
+            }
+          end
+        end
+      end
+
+    end
+  end
+end
+
+SimpleForm::FormBuilder.send(:include, ClientSideValidations::SimpleForm::FormBuilder)
+

data/lib/client_side_validations/version.rb

@@ -0,0 +1,3 @@
+module ClientSideValidations
+  VERSION = "3.0.3"
+end

data/lib/generators/client_side_validations/install_generator.rb

@@ -0,0 +1,22 @@
+module ClientSideValidations
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../templates', __FILE__)
+
+      desc 'Creates a ClientSideValidations initializer and copies client-side-validations.js to public/javascripts.'
+
+      def copy_initializer
+        copy_file 'client_side_validations.rb', 'config/initializers/client_side_validations.rb'
+      end
+
+      def copy_locale
+        copy_file '../../../javascript/rails.validations.js', 'public/javascripts/rails.validations.js'
+      end
+
+      def show_readme
+        readme 'README' if behavior == :invoke
+      end
+    end
+  end
+end
+

data/lib/generators/templates/README

@@ -0,0 +1,7 @@
+**************************************
+Client Side Validations
+
+Currently Client Side Validations only
+works with jQuery. You'll need to require
+jQuery in your layout file before you 
+require 'rails.validations.js'

data/lib/generators/templates/client_side_validations.rb

@@ -0,0 +1,14 @@
+# ClientSideValidations Initializer
+
+require 'client_side_validations/simple_form' if defined?(::SimpleForm)
+require 'client_side_validations/formtastic' if defined?(::Formtastic)
+
+# Uncomment the following block if you want each input field to have the validation messages attached.
+# ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+#   unless html_tag =~ /^<label/
+#     %{<div class="field_with_errors">#{html_tag}<label for="#{instance.send(:tag_id)}" class="message">#{instance.error_message.first}</label></div>}.html_safe
+#   else
+#     %{<div class="field_with_errors">#{html_tag}</div>}.html_safe
+#   end
+# end
+

data/test/action_view/cases/helper.rb

@@ -0,0 +1,152 @@
+require 'base_helper'
+require 'action_view'
+require 'client_side_validations/action_view'
+require 'action_view/template/handlers/erb'
+require 'action_view/models'
+
+module ActionViewTestSetup
+  include ::ClientSideValidations::ActionView::Helpers::FormHelper
+  include ::ClientSideValidations::ActionView::Helpers::FormTagHelper
+
+  def form_for(*)
+    @output_buffer = super
+  end
+
+  def setup
+    super
+
+    # Create "label" locale for testing I18n label helpers
+    I18n.backend.store_translations 'label', {
+      :activemodel => {
+        :attributes => {
+          :post => {
+            :cost => "Total cost"
+          }
+        }
+      },
+      :helpers => {
+        :label => {
+          :post => {
+            :body => "Write entire text here"
+          }
+        }
+      }
+    }
+
+    # Create "submit" locale for testing I18n submit helpers
+    I18n.backend.store_translations 'submit', {
+      :helpers => {
+        :submit => {
+          :create => 'Create %{model}',
+          :update => 'Confirm %{model} changes',
+          :submit => 'Save changes',
+          :another_post => {
+            :update => 'Update your %{model}'
+          }
+        }
+      }
+    }
+
+    @post = Post.new
+    @comment = Comment.new
+    def @post.errors()
+      Class.new{
+        def [](field); field == "author_name" ? ["can't be empty"] : [] end
+        def empty?() false end
+        def count() 1 end
+        def full_messages() [ "Author name can't be empty" ] end
+      }.new
+    end
+    def @post.id; 123; end
+    def @post.id_before_type_cast; 123; end
+    def @post.to_param; '123'; end
+
+    @post.persisted   = true
+    @post.title       = "Hello World"
+    @post.author_name = ""
+    @post.body        = "Back to the hill and over it again!"
+    @post.secret      = 1
+    @post.written_on  = Date.new(2004, 6, 15)
+  end
+
+  def url_for(object)
+    @url_for_options = object
+    if object.is_a?(Hash)
+      "http://www.example.com"
+    else
+      super
+    end
+  end
+
+  def snowman(method = nil)
+    txt =  %{<div style="margin:0;padding:0;display:inline">}
+    txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
+    txt << %{<input name="_method" type="hidden" value="#{method}" />} if method
+    txt << %{</div>}
+  end
+
+  def form_text(action = "http://www.example.com", id = nil, html_class = nil, remote = nil, validators = nil)
+    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
+    txt << %{ data-remote="true"} if remote
+    txt << %{ class="#{html_class}"} if html_class
+    txt << %{ data-validate="true"} if validators
+    txt << %{ id="#{id}"} if id
+    txt << %{ method="post">}
+  end
+
+  def whole_form(action = "http://www.example.com", id = nil, html_class = nil, options = nil)
+    contents = block_given? ? yield : ""
+
+    if options.is_a?(Hash)
+      method, remote, validators = options.values_at(:method, :remote, :validators)
+    else
+      method = options
+    end
+
+    html = form_text(action, id, html_class, remote, validators) + snowman(method) + (contents || "") + "</form>"
+
+    if options.is_a?(Hash) && options[:validators]
+      html + %Q{<script>var #{id} = #{client_side_form_settings_helper.merge(:validators => validators).to_json};</script>}
+    else
+      html
+    end
+  end
+
+  protected
+    def comments_path(post)
+      "/posts/#{post.id}/comments"
+    end
+    alias_method :post_comments_path, :comments_path
+
+    def comment_path(post, comment)
+      "/posts/#{post.id}/comments/#{comment.id}"
+    end
+    alias_method :post_comment_path, :comment_path
+
+    def admin_comments_path(post)
+      "/admin/posts/#{post.id}/comments"
+    end
+    alias_method :admin_post_comments_path, :admin_comments_path
+
+    def admin_comment_path(post, comment)
+      "/admin/posts/#{post.id}/comments/#{comment.id}"
+    end
+    alias_method :admin_post_comment_path, :admin_comment_path
+
+    def posts_path
+      "/posts"
+    end
+
+    def post_path(post, options = {})
+      if options[:format]
+        "/posts/#{post.id}.#{options[:format]}"
+      else
+        "/posts/#{post.id}"
+      end
+    end
+
+    def protect_against_forgery?
+      false
+    end
+
+end

data/test/action_view/cases/test_helpers.rb

@@ -0,0 +1,237 @@
+require 'action_view/cases/helper'
+
+class ClientSideValidations::ActionViewHelpersTest < ActionView::TestCase
+  include ActionViewTestSetup
+
+  cattr_accessor :field_error_proc
+  @@field_error_proc = Proc.new { |html_tag, instance| html_tag }
+
+  def client_side_form_settings_helper
+    {
+      :type => "ActionView::Helpers::FormBuilder",
+      :input_tag => %{<span id="input_tag" />},
+      :label_tag => %{<label id="label_tag" />}
+    }
+  end
+
+  def test_text_field
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_password_field
+    form_for(@post, :validate => true) do |f|
+      concat f.password_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="password" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_file_field
+    form_for(@post, :validate => true) do |f|
+      concat f.file_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" type="file" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_text_area
+    form_for(@post, :validate => true) do |f|
+      concat f.text_area(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<textarea cols="40" data-validate="true" id="post_cost" name="post[cost]" rows="20"></textarea>}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_search_field
+    form_for(@post, :validate => true) do |f|
+      concat f.search_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="search" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_telephone_field
+    form_for(@post, :validate => true) do |f|
+      concat f.telephone_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="tel" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_phone_field
+    form_for(@post, :validate => true) do |f|
+      concat f.phone_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="tel" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_url_field
+    form_for(@post, :validate => true) do |f|
+      concat f.url_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="url" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_email_field
+    form_for(@post, :validate => true) do |f|
+      concat f.email_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="email" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_number_field
+    form_for(@post, :validate => true) do |f|
+      concat f.number_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="number" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_range_field
+    form_for(@post, :validate => true) do |f|
+      concat f.range_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="range" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_check_box
+    form_for(@post, :validate => true) do |f|
+      concat f.check_box(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input name="post[cost]" type="hidden" value="0" />} +
+      %{<input data-validate="true" id="post_cost" name="post[cost]" type="checkbox" value="1" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_radio_button
+    form_for(@post, :validate => true) do |f|
+      concat f.radio_button(:cost, "10")
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost_10" name="post[cost]" type="radio" value="10" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_field_without_validations
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:title)
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
+      %{<input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_text_field_with_validations_turned_off
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost, :validate => false)
+    end
+
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
+      %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_nested_fields_for_inherit_validation_settings
+    form_for(@post, :validate => true) do |f|
+      concat f.fields_for(:comment, @comment) { |c|
+        concat c.text_field(:title)
+      }
+    end
+
+    validators = {'post[comment][title]' => {:presence => {:message => "can't be blank"}}}
+    expected =  whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_comment_title" name="post[comment][title]" size="30" type="text" />}
+    end
+
+    assert_equal expected, output_buffer
+  end
+
+  def test_nested_fields_for_dont_overwrite_validation_with_inheritance
+    form_for(@post, :validate => true) do |f|
+      concat f.fields_for(:comment, @comment, :validate => false) { |c|
+        concat c.text_field(:title)
+      }
+    end
+
+    expected =  whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
+      %{<input id="post_comment_title" name="post[comment][title]" size="30" type="text" />}
+    end
+
+    assert_equal expected, output_buffer
+  end
+
+  def test_with_custom_id_for_form
+    form_for(@post, :validate => true, :html => { :id => 'some_form' }) do |f|
+      concat f.text_field(:cost)
+    end
+
+    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
+    expected = whole_form("/posts/123", "some_form", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+end
+