Ticket #861: js_validation.diff

activerecord/test/validation_reflection_test.rb

@@ +1 @@
+require 'abstract_unit'
+require 'fixtures/topic'
+require 'set'
+
+class ValidationReflectionTest < Test::Unit::TestCase
+  fixtures :topics
+  
+  def setup
+    Topic.write_inheritable_attribute(:validate, nil)
+    Topic.write_inheritable_attribute(:validate_on_create, nil)
+    Topic.write_inheritable_attribute(:validate_on_update, nil)
+    Topic.write_inheritable_attribute("validations", nil)
+  end
+  
+  def test_reflect_on_all_validations
+    Topic.validates_presence_of(:title, :content)
+    Topic.validates_acceptance_of(:terms_of_service)
+    
+    assert_equal 3, Topic.reflect_on_all_validations.size
+    attr_names = Topic.reflect_on_all_validations.map { |v| v.name }
+    [:title,:content,:terms_of_service].each { |s| assert attr_names.include?(s) }
+    
+    macro_names = Topic.reflect_on_all_validations.map { |v| v.macro }
+    assert_equal 2, macro_names.select{ |m| m == :validates_presence_of }.size
+    assert_equal 1, macro_names.select{ |m| m == :validates_acceptance_of }.size
+  end
+
+  def test_reflect_on_validations_for
+    Topic.validates_presence_of(:title, :content)
+    Topic.validates_length_of(:title, :within => 1...10)
+    
+    title_validations = Topic.reflect_on_validations_for(:title)
+    assert_equal 2, title_validations.length
+    assert title_validations.find { |v| v.macro == :validates_presence_of }
+    assert title_validations.find { |v| v.macro == :validates_length_of }
+    assert !title_validations.find { |v| v.name != :title }
+
+    assert_equal 1, Topic.reflect_on_validations_for(:content).size
+    
+    assert_equal [], Topic.reflect_on_validations_for(:does_not_exist)
+  end
+
+  # test whether options passed to validation macros can be recovered correctly
+  def test_reflect_options
+    Topic.validates_length_of(:title, :within => 1...10, :msg => "should be one digit")
+    
+    validation = Topic.reflect_on_all_validations.first
+    assert_equal :title, validation.name
+    assert_equal 1...10, validation.options[:within]
+    assert_equal "should be one digit", validation.options[:msg]
+  end
+  
+end

activerecord/lib/active_record/reflection.rb

@@ -31 +31 @@
-          end
-        end_eval
-      end
+      
+      for validation_type in %w( validates_presence_of validates_acceptance_of validates_length_of )
+        base.module_eval <<-"end_eval"
+            class << self
+                alias_method :#{validation_type}_without_reflection, :#{validation_type}
+                
+                def #{validation_type}_with_reflection(*attr_names)
+                    #{validation_type}_without_reflection(*attr_names)
+                    configuration = attr_names.last.is_a?(Hash) ? attr_names.pop : nil
+                    for attr_name in attr_names
+                        write_inheritable_array "validations", [ MacroReflection.new(:#{validation_type}, attr_name, configuration, self) ]
+                    end
+                end
+            
+                alias_method :#{validation_type}, :#{validation_type}_with_reflection
+            end
+        end_eval
+      end
-    end
-
-    # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. 
@@ -60 +78 @@
-      def reflect_on_association(association)
-        reflect_on_all_associations.find { |reflection| reflection.name == association } unless reflect_on_all_associations.nil?
-      end
+
+      # Returns an array of MacroReflection objects for all validations in the class
+      def reflect_on_all_validations
+        read_inheritable_attribute "validations"
+      end
+      
+      # Returns an array of MacroReflection objects for all validations defined for the field +attr_name+ (expects a symbol)
+      def reflect_on_validations_for(attr_name)
+        reflect_on_all_validations.find_all { |reflection| reflection.name == attr_name } unless reflect_on_all_validations.nil?
+      end
-    end
-    
-
@@ -128 +156 @@
-          return class_name || name
-        end
-    end
+
-  end
-end

actionpack/lib/action_view/helpers/javascript_validation_helper.rb

@@ +1 @@
+require File.dirname(__FILE__) + '/form_helper'
+
+module ActionView
+  module Helpers
+    module FormHelper
+      # method names in FormHelper that will automatically register fields for javascript validation
+      VALIDATION_FIELD_TYPES = %w(text_field password_field file_field text_area check_box radio_button)
+      
+      for field_type in VALIDATION_FIELD_TYPES
+        module_eval <<-ENDEVAL
+            alias_method :#{field_type}_without_js_validation, :#{field_type}
+            
+            def #{field_type}_with_js_validation(object,method,*args)
+                register_for_javascript_validation(object,method)
+                #{field_type}_without_js_validation(object,method,*args)
+            end
+            
+            alias_method :#{field_type}, :#{field_type}_with_js_validation
+        ENDEVAL
+      end
+    end
+    
+    module JavascriptValidationHelper
+      def register_for_javascript_validation(object_name,method_name)
+        @rails_instance_tags ||= []
+        @rails_instance_tags << InstanceTag.new(object_name,method_name,self)
+      end
+
+      # Generate a javascript function for field validations. This will generate
+      # code to validate all fields that have been included via FormHelper methods and for
+      # which a validation with a supported validates_... macro has been defined.
+      # The javascript code returned will be wrapped in a proper +script+ tag and
+      # will be named as the value of the +function_name+ parameter (defaults to
+      # +validateForm+.
+      # To active validation before form submission, you should add the property
+      # <tt>onsubmit="return validateForm(this)"</tt> to your form tag.
+      def javascript_validation_for_fields(function_name="validateForm")
+        js_calls = @rails_instance_tags.inject([]) { |memo,tag| memo += function_names_for(tag) }
+        <<-ENDJS
+        <script type="text/javascript" language="javascript">
+        function #{function_name}(form) {
+            return #{js_calls.join(" && ")};
+        }
+        </script>
+        ENDJS
+      end
+
+      private
+      
+      def function_names_for(instance_tag)
+        instance_tag.object.class.reflect_on_validations_for(instance_tag.method_name.to_sym).
+            inject([]) do |js_calls,validation|
+          case validation.macro
+            when :validates_presence_of
+                js_calls << "validatePresence(form['#{instance_tag.js_tag_name}'])"
+            when :validates_length_of
+                js_calls += js_validate_length(validation,instance_tag)
+          end
+        end
+      end      
+
+      def js_validate_length(validation,tag)
+        js = []
+        if validation.options[:maximum]
+          js << "validateLength(form['#{tag.js_tag_name}'],#{validation.options[:maximum]})"
+        end
+        js
+      end
+            
+    end
+  end
+end

actionpack/lib/action_view/helpers/form_helper.rb

@@ -244 +244 @@
-        end
-      end
-
+      def js_tag_name(options = {})
+        add_default_name_and_id(options)
+        options["name"]
+      end
+      
-      private
-        def add_default_name_and_id(options)
-          if options.has_key?("index")