validatious-on-rails 0.3.1 → 0.3.2

data/lib/validatious-on-rails/helpers.rb

@@ -1,17 +1,33 @@
 module ValidatiousOnRails
   module Helpers
-    
-    extend self
-    
+
+    def attach_validator_for(object_name, method, options = {})
+      options = ::ValidatiousOnRails::ModelValidations.options_for(object_name, method, options, @content_for_validatious)
+      custom_js = options.delete(:js)
+      content_for :validatious, custom_js if custom_js.present?
+      options
+    end
+
     # Helper for the layout to host the custom Validatious-validators for forms rendered.
     # This will only show up if the current view contains one - or more - forms that
     # are triggered to be validated with Validatous (i.e. ValidatiousOnRails that is).
     #
-    def custom_validatious_validators
+    def attached_validators
       if @content_for_validatious.present?
         content_tag(:script, @content_for_validatious,
-          :type => 'text/javascript', :id => 'custom_validatious_validators')
+          :type => 'text/javascript', :id => 'custom_validators')
+      end
+    end
+    alias :javascript_for_validatious :attached_validators
+
+    def self.extract_args!(*args)
+      tail = []
+      tail.unshift(args.pop) until args.blank? || args.last.is_a?(::Hash)
+      unless args.last.is_a?(::Hash)
+        args = tail
+        tail = []
       end
+      return args, tail
     end
 
   end

data/lib/validatious-on-rails/model_validations.rb

@@ -47,12 +47,18 @@ module ValidatiousOnRails
       # Input may be an ActiveRecord class, a class name (string), or an object
       # name along with a method/field.
       #
-      def options_for(object_name, attribute_method, options = {})
-        validation = self.from_active_record(object_name, attribute_method)
-        options.merge!(
-            :class => [options[:class], validation[:classes]].flatten.compact.uniq.join(' '),
-            :validators => validation[:validators].flatten.compact.uniq
-          )
+      def options_for(object_name, attribute_method, options = {}, existing_validators = nil)
+        validators = self.from_active_record(object_name, attribute_method)
+        validator_classes, validator_js = [options[:class]], []
+
+        # Only attach validators that are not already attached.
+        validators.flatten.compact.uniq.each do |v|
+          validator_js << v.to_js unless existing_validators.present? && /#{v.name}/ =~ existing_validators
+          validator_classes << v.to_class
+        end
+        classes = validator_classes.compact.join(' ').strip
+        js = validator_js.compact.join(' ').strip
+        options.merge!(:class => (classes unless classes.blank?), :js => (js unless js.blank?))
       end
 
       # Groks Rails validations, and is able to convert a rails validation to
@@ -68,7 +74,7 @@ module ValidatiousOnRails
       #
       def from_active_record(object_or_class, attribute_method)
         klass = object_or_class.to_s.classify.constantize
-        attribute_validation = {:classes => [], :validators => []}
+        validators = []
 
         # Iterate thorugh the validations for the current class,
         # and collect validation options.
@@ -79,10 +85,7 @@ module ValidatiousOnRails
           # needs to be confirmed. Validatious expects this validation rule
           # on the confirmation field. *
           unless validates_type =~ /^confirmation_of$/
-            validation_options = self.send(validates_type.to_sym, validation)
-            attribute_validation[:classes] << validation_options[:class]
-            # One or multiple validators for each validation (possible to combine validators).
-            attribute_validation[:validators] << validation_options[:validator] || validation_options[:validators]
+            validators << self.send(validates_type.to_sym, validation)
           end
         end
 
@@ -93,31 +96,27 @@ module ValidatiousOnRails
           # if :hello_confirmation field exists - just to be safe.
           klass.reflect_on_validations_for(confirm_attribute_method.to_sym).each do |validation|
             if validation.macro.to_s =~ /^validates_confirmation_of$/
-              validation_options = self.confirmation_of(validation)
-              attribute_validation[:classes] << validation_options[:class]
+              validators << self.confirmation_of(validation)
               break
             end
           end
         end
-        attribute_validation
+        validators
       end
 
       # Resolve validation from validates_acceptance_of.
       #
       # Alias, but might change: acceptance_of <=> presence_of
       #
-      # TODO: Make this a custom validator - handle :accept.
-      #
       # NOTE: Not supported:
-      #   * :accept - TODO: not taken into consideration
-      #                 right now (but must have value "true" for db column values)
-      #   * :allow_nil - TODO.
       #   * :on - TODO.
       #   * :if/:unless - hard to port all to client-side JavaScript
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def acceptance_of(validation)
-        {:class => 'required', :validator => nil}
+        validators = []
+        validation.options[:accept] ||= '1' # Rails default.
+        validators << Validatious::AcceptanceValidator.new(validation, validation.options[:accept])
       end
 
       # Resolve validation from validates_associated.
@@ -125,7 +124,7 @@ module ValidatiousOnRails
       # NOTE: Not supported - low prio.
       #
       def associated(validation)
-        {:class => '', :validator => nil}
+        nil
       end
 
       # Resolve validation from validates_confirmation_of.
@@ -135,17 +134,19 @@ module ValidatiousOnRails
       # TODO: Message should be Rails I18n message, not Validatious.
       #
       # NOTE: Not supported:
+      #   * :message - TODO: Explicit or Rails I18n/default message.
       #   * :on - TODO.
       #   * :if/:unless - hard to port all to client-side JavaScript
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def confirmation_of(validation)
-        field_id_to_confirm = unless validation.active_record.present?
+        validators = []
+        arg = unless validation.active_record.present?
           "#{validation.active_record.name.tableize.singularize.gsub('/', '_')}_#{validation.name}"
         else
           "#{validation.name}"
         end
-        {:class => "confirmation-of_#{field_id_to_confirm}", :validator => nil}
+        validators << Validatious::ConfirmationValidator.new(validation, arg)
       end
 
       # Resolve validation from validates_exclusion_of.
@@ -158,8 +159,8 @@ module ValidatiousOnRails
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def exclusion_of(validation)
-        validator = Validatious::ExclusionValidator.new(validation)
-        {:class => validator.name, :validator => validator}
+        validators = []
+        validators << Validatious::ExclusionValidator.new(validation)
       end
 
       # Resolve validation from validates_format_of.
@@ -173,8 +174,8 @@ module ValidatiousOnRails
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def format_of(validation)
-        validator = Validatious::FormatValidator.new(validation)
-        {:class => validator.name, :validator => validator}
+        validators = []
+        validators << Validatious::FormatValidator.new(validation)
       end
 
       # Resolve validation from validates_inclusion_of.
@@ -187,8 +188,8 @@ module ValidatiousOnRails
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def inclusion_of(validation)
-        validator = Validatious::InclusionValidator.new(validation)
-        {:class => validator.name, :validator => validator}
+        validators = []
+        validators << Validatious::InclusionValidator.new(validation)
       end
 
       # Resolve validation from validates_length_of.
@@ -203,34 +204,25 @@ module ValidatiousOnRails
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def length_of(validation)
-        # TODO: DRY up this with the neat idea/combo:
-        # Validator#new(name, validation, *args)-idea + Validator#to_class
-        validators, min, max = case true
-        when validation.options[:is].present?
-          [Validatious::Length::IsValidator.new(validation),
-            validation.options[:is], validation.options[:is]]
-        when [:in, :within].any? { |k| validation.options[k].present? } ||
-              [:minimum, :maximum].all? { |k| validation.options[k].present? }
-          validation.options[:within] ||=
-            validation.options[:in] ||
-            (validation.options[:minimum].to_i..validation.options[:maximum].to_i)
-          [[Validatious::Length::MinimumValidator.new(validation),
-            Validatious::Length::MaximumValidator.new(validation)],
-            validation.options[:within].min, validation.options[:within].max]
-        when validation.options[:minimum].present?
-          [Validatious::Length::MinimumValidator.new(validation),
-            validation.options[:minimum], nil]
-        when validation.options[:maximum].present?
-          [Validatious::Length::MaximumValidator.new(validation),
-            nil, validation.options[:maximum]]
+        validators = []
+
+        if validation.options[:is].present?
+          validators << Validatious::Length::IsValidator.new(validation, validation.options[:is])
+        elsif [:in, :within, :minimum, :maximum].any? { |k| validation.options[k].present? }
+          validation.options[:within] ||= validation.options[:in]
+          validation.options[:minimum] ||= validation.options[:within].min rescue nil
+          validation.options[:maximum] ||= validation.options[:within].max rescue nil
+
+          if validation.options[:minimum].present?
+            validators << Validatious::Length::MinimumValidator.new(validation, validation.options[:minimum])
+          end
+
+          if validation.options[:maximum].present?
+            validators << Validatious::Length::MaximumValidator.new(validation, validation.options[:maximum])
+          end
         end
-        validators = [*validators]
-        # This piece of code is a bit diffuse, but works. =)
-        classes = [
-            ("#{validators.first.name}_#{min}" if min),
-            ("#{validators.last.name}_#{max}" if max)
-          ].compact.uniq.join(' ')
-        {:class => classes, :validator => validators}
+
+        validators
       end
       alias :size_of :length_of
 
@@ -240,36 +232,29 @@ module ValidatiousOnRails
       #   numericality-odd, numericality-only-integer, numericality-equal-to_5, etc.
       #
       # NOTE: Not supported:
-      #   * :on - TODO.
+      #   * :on - TODO.en
       #   * :if/:unless - hard to port all to client-side JavaScript
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def numericality_of(validation)
         validators = []
-        values = {}
-        
+
         if validation.options[:odd] && !validation.options[:even]
           validators << Validatious::Numericality::OddValidator.new(validation)
         end
+
         if validation.options[:even] && !validation.options[:odd]
           validators << Validatious::Numericality::EvenValidator.new(validation)
         end
-        
+
         (validation.options.keys & [:only_integer, :equal_to, :less_than, :less_than_or_equal_to,
           :greater_than, :greater_than_or_equal_to]).each { |v|
-            klass = "::ValidatiousOnRails::Validatious::Numericality::#{v.to_s.classify}Validator".constantize
-            validators << (validator = klass.new(validation))
-            values.merge!(validator.name.to_sym => validation.options[v]) if validation.options[v].is_a?(::Numeric)
+            validator_klass = "::ValidatiousOnRails::Validatious::Numericality::#{v.to_s.classify}Validator".constantize
+            value = validation.options[v] if validation.options[v].is_a?(::Numeric)
+            validators << validator_klass.new(validation, value)
           }
-          
-        # TODO: Needs DRYer solution,
-        # Maybe: validator.args = [...] => validator.to_class => "#{validator.name}_params[0]_params[1]_etc..."
-        classes = validators.collect { |validator|
-            [validator.name,
-              (values[validator.name.to_sym] if values[validator.name.to_sym].present?)
-              ].compact.join('_')
-          }.join(' ')
-        {:class => classes, :validator => validators}
+
+        validators
       end
 
       # Resolve validation from validates_presence_of.
@@ -282,7 +267,8 @@ module ValidatiousOnRails
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def presence_of(validation)
-        {:class => 'required', :validator => nil}
+        validators = []
+        validators << Validatious::PresenceValidator.new(validation)
       end
 
       # Resolve validation from validates_uniqueness_of.
@@ -290,7 +276,7 @@ module ValidatiousOnRails
       # TODO: Implement using RemoteValidator.
       #
       def uniqueness_of(validation)
-        {:class => '', :validator => nil}
+        nil
       end
 
       # Unknown validations - if no matching custom validator is found/registered.
@@ -300,7 +286,7 @@ module ValidatiousOnRails
           " No custom Validatious validator found for this validation makro. " <<
           "Maybe you forgot to register you custom validation using: " <<
           "ValidatiousOnRails::ModelValidations.add(<CustomValidationClass>)", :warn
-        {:class => '', :validator => nil}
+        nil
       end
 
       # TODO: Include custom validations here...

data/lib/validatious-on-rails/rails/action_view_helpers.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+require File.join(File.dirname(__FILE__), *%w[.. helpers])
 #
 # Tap into the built-in form/input helpers to add validatious class names from
 # model validations.
@@ -7,48 +8,22 @@ module ActionView # :nodoc:
   module Helpers # :nodoc:
     module FormHelper # :nodoc:
 
-      FIELD_TYPES = [:text_field, :password_field, :text_area, :file_field, :radio_button].freeze
+      include ::ValidatiousOnRails::Helpers
+
+      FIELD_TYPES = [:text_field, :password_field, :text_area, :file_field, :radio_button, :check_box].freeze
 
       # Only altering the options hash is interesting - we want to set a validator class for fields,
       # so the hooking of these helpers don't have to be very explicit.
       #
       FIELD_TYPES.each do |field_type|
         define_method :"#{field_type}_with_validation" do |*args|
-          options = args.extract_options!
-          # Get the validation options.
-          options = ::ValidatiousOnRails::ModelValidations.options_for(args.first, args.second, options)
-
-          # Attach custom validator - if any - to the layout (in the <head>-tag - the unobtrusive way).
-          # Don't attach validator(s) if it/they already attached.
-          # TODO: Refactor into helper.
-          validators_js = options.delete(:validators).collect { |v|
-              v.to_s unless /#{v.name}/ =~ @content_for_validatious
-            }.join(' ')
-          content_for :validatious, validators_js if validators_js.present?
-
-          self.send :"#{field_type}_without_validation", *(args << options)
+          args, tail = ::ValidatiousOnRails::Helpers.extract_args!(*args)
+          options = self.attach_validator_for(args.first, args.second, args.extract_options!)
+          self.send :"#{field_type}_without_validation", *((args << options) + tail)
         end
         alias_method_chain field_type, :validation
       end
 
-      # Special case...no hash as last argument.
-      #
-      def check_box_with_validation(object_name, method, options = {}, checked_value = '1', unchecked_value = '0')
-        # Get the validation options.
-        options = ::ValidatiousOnRails::ModelValidations.options_for(object_name, method, options)
-
-        # Attach custom validator - if any - to the layout (in the <head>-tag - the unobtrusive way).
-        # Don't attach validator(s) if it/they already attached.
-        # TODO: Refactor into helper.
-        validators_js = options.delete(:validators).collect { |v|
-            v.to_s unless /#{v.name}/ =~ @content_for_validatious
-          }.join(' ')
-        content_for :validatious, validators_js if validators_js.present?
-
-        self.check_box_without_validation object_name, method, options, checked_value, unchecked_value
-      end
-      alias_method_chain :check_box, :validation
-
       # Adds the title attribute to label tags when there is no title
       # set, and the label text is provided. The title is set to object_name.humanize
       #
@@ -62,23 +37,15 @@ module ActionView # :nodoc:
 
     module FormOptionsHelper
 
+      include ::ValidatiousOnRails::Helpers
+
       FIELD_TYPES = [:time_zone_select, :select, :collection_select, :grouped_options_for_select].freeze
 
       FIELD_TYPES.each do |field_type|
         define_method :"#{field_type}_with_validation" do |*args|
-          options = args.extract_options!
-          # Get the validation options.
-          options = ::ValidatiousOnRails::ModelValidations.options_for(args.first, args.second, options)
-
-          # Attach custom validator - if any - to the layout (in the <head>-tag - the unobtrusive way).
-          # Don't attach validator(s) if it/they already attached.
-          # TODO: Refactor into helper.
-          validators_js = options.delete(:validators).collect { |v|
-              v.to_s unless /#{v.name}/ =~ @content_for_validatious
-            }.join(' ')
-          content_for :validatious, validators_js if validators_js.present?
-
-          self.send :"#{field_type}_without_validation", *(args << options)
+          args, tail = ::ValidatiousOnRails::Helpers.extract_args!(*args)
+          options = self.attach_validator_for(args.first, args.second, args.extract_options!)
+          self.send :"#{field_type}_without_validation", *((args << options) + tail)
         end
         alias_method_chain field_type, :validation
       end
@@ -87,23 +54,15 @@ module ActionView # :nodoc:
 
     module DateHelper
 
+      include ::ValidatiousOnRails::Helpers
+
       FIELD_TYPES = [:date_select, :datetime_select, :time_select].freeze
 
       FIELD_TYPES.each do |field_type|
         define_method :"#{field_type}_with_validation" do |*args|
-          options = args.extract_options!
-          # Get the validation options.
-          options = ::ValidatiousOnRails::ModelValidations.options_for(args.first, args.second, options)
-
-          # Attach custom validator - if any - to the layout (in the <head>-tag - the unobtrusive way).
-          # Don't attach validator(s) if it/they already attached.
-          # TODO: Refactor into helper.
-          validators_js = options.delete(:validators).collect { |v|
-              v.to_s unless /#{v.name}/ =~ @content_for_validatious
-            }.join(' ')
-          content_for :validatious, validators_js if validators_js.present?
-
-          self.send :"#{field_type}_without_validation", *(args << options)
+          args, tail = ::ValidatiousOnRails::Helpers.extract_args!(*args)
+          options = self.attach_validator_for(args.first, args.second, args.extract_options!)
+          self.send :"#{field_type}_without_validation", *((args << options) + tail)
         end
         alias_method_chain field_type, :validation
       end

data/lib/validatious-on-rails/validatious/validator.rb

@@ -28,14 +28,17 @@ module ValidatiousOnRails
                     :params,
                     :aliases,
                     :accept_empty,
-                    :fn
+                    :fn,
+                    :args
 
-      def initialize(name, options = {})
+      def initialize(name, *args)
         raise ValidatorError, "Parameter :name is required for an Validatious validator" unless name.present?
         self.name = name
+        options = args.extract_options!
         options.each do |attr, value|
           self.send(:"#{attr}=", value) if value.present?
         end
+        self.args = args
       end
 
       # The primary name of the validator. This is the name you use with v2.$v('name');
@@ -125,7 +128,7 @@ module ValidatiousOnRails
         (@fn ||= "function(field, value, params) {return true;}").gsub(/[\n\t]/, '')
       end
 
-      def to_s
+      def to_js
         options = {
             :name => self.name,
             :message => self.message,
@@ -142,6 +145,15 @@ module ValidatiousOnRails
           }.compact.join(', ')
         "v2.Validator.add({#{js_options}});"
       end
+      alias :to_s :to_js
+
+      # Generate a full Validatious-style "class function call" to generic validators, e.g.
+      # Length::MinimumValidator#to_class(5) => "length-minimum_5", etc.
+      #
+      def to_class(*args)
+        args = @args if args.blank?
+        [self.name, (args if args.present?)].flatten.compact.join('_')
+      end
 
       class << self
 

data/lib/validatious-on-rails/validatious/validators/acceptance_validator.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class AcceptanceValidator < ClientSideValidator
+
+      def initialize(validation, options = {})
+        name = 'acceptance-accept'
+        super name, options
+        self.message = self.class.generate_message(validation)
+        self.accept_empty = validation.options[:allow_nil]
+        self.fn = %{
+          var accept_value = params[0] + '';
+          if (accept_value == 'true') {
+            accept_value = true
+          };
+          if (accept_value == 'false') {
+            accept_value = false
+          };
+          return value == accept_value;
+        }
+        self.fn.freeze
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/confirmation_validator.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class ConfirmationValidator < ClientSideValidator
+
+      def initialize(validation, options = {})
+        name = 'confirmation-of'
+        super name, options
+        self.params = ['field-id']
+        self.message = self.class.generate_message(validation)
+        self.accept_empty = true
+        # Identical to Validatious "confirmation-of" validator, but we want Rails I18n message support, so...
+        self.fn = %{
+          return value === v2.$f(params[0]).getValue();
+        }
+        self.fn.freeze
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails/validatious/validators/exclusion_validator.rb

@@ -10,7 +10,6 @@ module ValidatiousOnRails
       def initialize(validation, options = {})
         name, alias_name = self.class.generate_name(validation, :in, self.class.generate_id(validation.options[:in].inspect))
         super name, options
-        self.aliases = [alias_name] - [name]
         self.message = self.class.generate_message(validation)
         self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
         self.fn = %{

data/lib/validatious-on-rails/validatious/validators/format_validator.rb

@@ -19,7 +19,6 @@ module ValidatiousOnRails
       def initialize(validation, options = {})
         name, alias_name = self.class.generate_name(validation, :with, self.class.generate_id(validation.options[:with].inspect))
         super name, options
-        self.aliases = [alias_name] - [name]
         self.message = self.class.generate_message(validation)
         self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
         self.fn = %{

data/lib/validatious-on-rails/validatious/validators/inclusion_validator.rb

@@ -10,7 +10,6 @@ module ValidatiousOnRails
       def initialize(validation, options = {})
         name, alias_name = self.class.generate_name(validation, :in, self.class.generate_id(validation.options[:in].inspect))
         super name, options
-        self.aliases = [alias_name] - [name]
         self.message = self.class.generate_message(validation)
         self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]
         self.fn = %{

data/lib/validatious-on-rails/validatious/validators/length/is_validator.rb

@@ -10,7 +10,6 @@ module ValidatiousOnRails
           name, alias_name = self.class.generate_name(validation, :is, validation.options[:is])
           name = 'length-is'
           super name, options
-          self.aliases = [alias_name] - [name]
           self.params = ['count']
           self.message = self.class.generate_message(validation, :key => :wrong_length)
           self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]

data/lib/validatious-on-rails/validatious/validators/length/maximum_validator.rb

@@ -10,7 +10,6 @@ module ValidatiousOnRails
           name, alias_name = self.class.generate_name(validation, :maximum, validation.options[:maximum])
           name = 'length-maximum'
           super name, options
-          self.aliases = [alias_name] - [name]
           self.params = ['count']
           self.message = self.class.generate_message(validation, :key => :too_long)
           self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]

data/lib/validatious-on-rails/validatious/validators/length/minimum_validator.rb

@@ -10,7 +10,6 @@ module ValidatiousOnRails
           name, alias_name = self.class.generate_name(validation, :minimum, validation.options[:minimum])
           name = 'length-minimum'
           super name, options
-          self.aliases = [alias_name] - [name]
           self.params = ['count']
           self.message = self.class.generate_message(validation, :key => :too_short)
           self.accept_empty = validation.options[:allow_blank] || validation.options[:allow_nil]

data/lib/validatious-on-rails/validatious/validators/presence_validator.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class PresenceValidator < ClientSideValidator
+
+      def initialize(validation, options = {})
+        name = 'presence'
+        super name, options
+        self.message = self.class.generate_message(validation)
+        self.accept_empty = false
+        # Identical to Validatious "required" validator, but we want Rails I18n message support, so...
+        self.fn = %{
+          return !v2.empty(value) && !(typeof value.length !== 'undefined' && value.length === 0);
+        }
+        self.fn.freeze
+      end
+
+    end
+  end
+end

data/lib/validatious-on-rails.rb

@@ -5,9 +5,9 @@ require File.join(File.dirname(__FILE__), *%w[validatious-on-rails rails])
 require File.join(File.dirname(__FILE__), *%w[validatious-on-rails helpers])
 
 module ValidatiousOnRails # :nodoc:
-  
+
   extend self
-  
+
   # Standard error: Acts as base error class for the plugin.
   #
   class ValidatiousOnRailsError < ::StandardError
@@ -16,11 +16,11 @@ module ValidatiousOnRails # :nodoc:
       super message
     end
   end
-  
+
   mattr_accessor :verbose
-  
+
   @@verbose = ::Object.const_defined?(:RAILS_ENV) ? (::RAILS_ENV.to_sym == :development) : true
-  
+
   # Logging helper: Internal debug-logging for the plugin.
   #
   def log(message, level = :info)
@@ -29,13 +29,5 @@ module ValidatiousOnRails # :nodoc:
     @@logger ||= ::Logger.new(::STDOUT)
     @@logger.send(level.to_sym, message)
   end
-  
-  # Alias method for: ValidatiousOnRails::Helpers#custom_validatious_validators
-  #
-  def custom_validators
-    Helpers.custom_validatious_validators
-  end
-  alias :include_custom_validators :custom_validators
-  ::ActionController::Base.helper_method :custom_validators, :include_custom_validators
-  
+
 end

data/test/test_helper.rb

@@ -4,44 +4,33 @@
 # convenience methods.
 #
 
+def smart_require(lib_name, gem_name, gem_version = '>= 0.0.0')
+  begin
+    require lib_name
+  rescue LoadError
+    gem gem_name, gem_version
+    require lib_name
+  end
+end
+
 begin
   require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. .. .. config environment)))
 rescue LoadError
   require 'rubygems'
   
-  gem 'test-unit', '1.2.3'
-  gem 'activerecord', '>= 1.2.3'
-  gem 'actionpack', '>= 1.2.3'
-  gem 'sqlite3-ruby', '>= 1.2.0'
-  
-  require 'test/unit'
-  require 'active_record'
-  require 'action_controller'
-  require 'sqlite3'
+  smart_require 'test/unit', 'test-unit', '= 1.2.3'
+  smart_require 'active_record', 'activerecord', '>= 1.2.3'
+  smart_require 'action_controller', 'actionpack', '>= 1.2.3'
+  smart_require 'sqlite3', 'sqlite3-ruby', '>= 1.2.0'
 end
 
-begin
-  require 'context'
-rescue LoadError
-  gem 'jeremymcanally-context', '>= 0.5.5'
-  require 'context'
-end
+smart_require 'redgreen', 'redgreen', '>= 0.10.4'
+smart_require 'context', 'jeremymcanally-context', '>= 0.5.5'
+smart_require 'rr', 'rr', '>= 0.10.0'
+smart_require 'acts_as_fu', 'nakajima-acts_as_fu', '>= 0.0.5'
 
-begin
-  require 'rr'
-rescue LoadError
-  gem 'rr', '>= 0.0.0'
-  require 'rr'
-end
 extend RR::Adapters::RRMethods
 
-begin
-  require 'acts_as_fu'
-rescue LoadError
-  gem 'nakajima-acts_as_fu', '>= 0.0.5'
-  require 'acts_as_fu'
-end
-
 require 'validatious-on-rails'
 
 # TODO: Should extend Rails validators with this - to test respond_to.
@@ -70,7 +59,7 @@ build_model :bogus_items do
   
   validates_presence_of :name, :body, :variant
   validates_confirmation_of :name
-  validates_acceptance_of :signed
+  validates_acceptance_of :signed, :accept => true 
   validates_format_of :url,
     :with => /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i,
     :name => 'url', :message => 'Invalid URL.'

data/test/validatious_on_rails/helpers_test.rb

@@ -8,7 +8,7 @@ class HelpersTest < ::ActionView::TestCase
   include ActionView::Helpers::FormHelper
 
   attr_accessor :output_buffer
-  
+
   before do
     @output_buffer ||= ''
   end
@@ -17,7 +17,7 @@ class HelpersTest < ::ActionView::TestCase
     context "custom_validatious_validators" do
 
       test "should not output custom validators if there are none" do
-        helper_output = ::ValidatiousOnRails::Helpers.custom_validatious_validators
+        helper_output = ::ValidatiousOnRails::Helpers.attached_validators
         assert_equal '', helper_output.to_s
       end
 
@@ -27,7 +27,7 @@ class HelpersTest < ::ActionView::TestCase
         end
 
         # FIXME: Not sure how to test content_for-helpers...returns nil.
-        concat ::ValidatiousOnRails::Helpers.custom_validatious_validators
+        concat ::ValidatiousOnRails::Helpers.attached_validators
 
         # In parts...
         # assert_match /<script.+>.*v2.Validator.*<\/script>/, output_buffer

data/test/validatious_on_rails/model_validations_test.rb

@@ -7,9 +7,20 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
 
   include ActionView::Helpers::FormHelper
 
-  test "acceptance_of" do
-    validation = ::ValidatiousOnRails::ModelValidations.acceptance_of(validation(:validates_acceptance_of))
-    assert_equal 'required', validation[:class]
+  context "acceptance_of" do
+    test "with defaults" do
+      validators = ::ValidatiousOnRails::ModelValidations.acceptance_of(
+          validation(:validates_acceptance_of)
+        )
+      assert_validator_class 'acceptance-accept_1', validators
+    end
+
+    test "with :accept" do
+      validators = ::ValidatiousOnRails::ModelValidations.acceptance_of(
+          validation(:validates_acceptance_of, :accept => true)
+        )
+      assert_validator_class 'acceptance-accept_true', validators
+    end
   end
 
   test "associated" do
@@ -17,162 +28,163 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
   end
 
   test "confirmation_of" do
-    validation = ::ValidatiousOnRails::ModelValidations.confirmation_of(validation(:validates_confirmation_of))
-    assert_equal 'confirmation-of_name', validation[:class]
+    validators = ::ValidatiousOnRails::ModelValidations.confirmation_of(
+        validation(:validates_confirmation_of)
+      )
+    assert_validator_class 'confirmation-of_name', validators
   end
 
   test "exclusion_of" do
     values = (6..10).to_a
-    validation = ::ValidatiousOnRails::ModelValidations.exclusion_of(
+    validators = ::ValidatiousOnRails::ModelValidations.exclusion_of(
         validation(:validates_exclusion_of, :in => values)
       )
-    assert_match /^exclusion-in-(\d+)/, validation[:class]
-    assert_match /#{values.to_json}/, validation[:validator].fn
+    assert_validator_class /^exclusion-in-(\d+)/, validators
+    assert_match /#{values.to_json}/, validators.first.fn
   end
 
   test "format_of" do
     pattern = /^(http|https|ftp):\/\/(([A-Z0-9][A-Z0-9_-]*)(\.[A-Z0-9][A-Z0-9_-]*)+)(:(\d+))?\/?/i
-    validation = ::ValidatiousOnRails::ModelValidations.format_of(
+    validators = ::ValidatiousOnRails::ModelValidations.format_of(
         validation(:validates_format_of, :with => pattern)
       )
-    assert_match /^format-with-(\d+)/, validation[:class]
-    assert_match /#{pattern.inspect[1,-1]}/, validation[:validator].fn
+    assert_validator_class /^format-with-(\d+)/, validators
+    assert_match /#{pattern.inspect[1,-1]}/, validators.first.fn
   end
 
   test "inclusion_of" do
     values = (1..5).to_a
-    validation = ::ValidatiousOnRails::ModelValidations.inclusion_of(
+    validators = ::ValidatiousOnRails::ModelValidations.inclusion_of(
         validation(:validates_inclusion_of, :in => values)
       )
-    assert_match /^inclusion-in-(\d+)/, validation[:class]
-    assert_match /#{values.to_json}/, validation[:validator].fn
+    assert_validator_class /^inclusion-in-(\d+)/, validators
+    assert_match /#{values.to_json}/, validators.first.fn
   end
 
   context "length_of" do
 
     test "with :is" do
-      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+      validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :is => 2)
         )
-      assert_equal 'length-is_2', validation[:class]
+      assert_validator_class 'length-is_2', validators
     end
 
     test "with :in" do
-      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+      validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :in => 2..10)
         )
-      assert_equal 'length-minimum_2 length-maximum_10', validation[:class]
+      assert_validator_class 'length-minimum_2 length-maximum_10', validators
     end
 
     test "with :within" do
-      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+      validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :within => 2..10)
         )
-      assert_equal 'length-minimum_2 length-maximum_10', validation[:class]
+      assert_validator_class 'length-minimum_2 length-maximum_10', validators
     end
 
     test "with :minimum" do
-      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+      validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :minimum => 2)
         )
-      assert_equal 'length-minimum_2', validation[:class]
+      assert_validator_class 'length-minimum_2', validators
     end
 
     test "with :maximum" do
-      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+      validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :maximum => 10)
         )
-      assert_equal 'length-maximum_10', validation[:class]
+      assert_validator_class 'length-maximum_10', validators
     end
 
     test "with :minimum + :maximum" do
-      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+      validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :minimum => 2, :maximum => 10)
         )
-      assert_equal 'length-minimum_2 length-maximum_10', validation[:class]
+      assert_validator_class 'length-minimum_2 length-maximum_10', validators
     end
   end
 
   context "numericality_of" do
-    
+
     context ":odd/:even" do
       test "with :odd only" do
-        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+        validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
             validation(:validates_numericality_of, :even => false, :odd => true)
           )
-        assert_equal 'numericality-odd', validation[:class]
+        assert_validator_class 'numericality-odd', validators
       end
 
       test "with :even only" do
-        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+        validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
             validation(:validates_numericality_of, :even => true, :odd => false)
           )
-        assert_equal 'numericality-even', validation[:class]
+        assert_validator_class 'numericality-even', validators
       end
 
       test "with :odd and :even" do
-        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+        validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
             validation(:validates_numericality_of, :even => true, :odd => true)
           )
-        assert_equal '', validation[:class]
+        assert_validator_class '', validators
       end
 
       test "with neither :odd or :even" do
-        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+        validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
             validation(:validates_numericality_of)
           )
-        assert_equal '', validation[:class]
+        assert_validator_class '', validators
       end
     end
-    
 
     test "with :only_integer" do
-      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+      validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :only_integer => true)
         )
-      # Alt. more generic idea: assert_equal 'numericality-precision_0', validation[:class]
-      assert_equal 'numericality-only_integer', validation[:class]
+      # Alt. more generic idea: assert_equal 'numericality-precision_0', validator.to_class
+      assert_validator_class 'numericality-only_integer', validators
     end
 
     test "with :greater_than" do
-      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+      validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :greater_than => 2)
         )
-      assert_equal 'numericality-greater-than_2', validation[:class]
+      assert_validator_class 'numericality-greater-than_2', validators
     end
 
     test "with :greater_than_or_equal_to" do
-      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+      validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :greater_than_or_equal_to => 2)
         )
-      assert_equal 'numericality-greater-than-or-equal-to_2', validation[:class]
+      assert_validator_class 'numericality-greater-than-or-equal-to_2', validators
     end
 
     test "with :equal_to" do
-      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+      validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :equal_to => 2)
         )
-      assert_equal 'numericality-equal-to_2', validation[:class]
+      assert_validator_class 'numericality-equal-to_2', validators
     end
 
     test "with :less_than" do
-      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+      validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :less_than => 10)
         )
-      assert_equal 'numericality-less-than_10', validation[:class]
+      assert_validator_class 'numericality-less-than_10', validators
     end
 
     test "with :less_than_or_equal_to" do
-      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+      validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :less_than_or_equal_to => 10)
         )
-      assert_equal 'numericality-less-than-or-equal-to_10', validation[:class]
+      assert_validator_class 'numericality-less-than-or-equal-to_10', validators
     end
   end
 
   test "presence_of" do
-    validation = ::ValidatiousOnRails::ModelValidations.presence_of(validation(:validates_presence_of))
-    assert_equal 'required', validation[:class]
+    validators = ::ValidatiousOnRails::ModelValidations.presence_of(validation(:validates_presence_of))
+    assert_validator_class 'presence', validators
   end
 
   test "uniqueness_of" do
@@ -187,4 +199,12 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
       ::ActiveRecord::Reflection::MacroReflection.new(macro, :name, options, BogusItem.new)
     end
 
+    def assert_validator_class(expected, actual)
+      if expected.is_a?(::Regexp)
+        assert_match expected, [*actual].collect { |v| v.to_class }.join(' ')
+      else
+        assert_equal expected, [*actual].collect { |v| v.to_class }.join(' ')
+      end
+    end
+
 end

data/test/validatious_on_rails/rails/action_view_helpers_test.rb

@@ -38,69 +38,69 @@ class FormHelperTest < ::ActionView::TestCase
 
   test "required :text_field" do
     # Using helper
-    assert_has_class 'required', text_field(:bogus_item, :name)
-    assert_has_class 'required some_other_class', text_field(:bogus_item, :name, :class => 'some_other_class')
+    assert_has_class 'presence', text_field(:bogus_item, :name)
+    assert_has_class 'presence some_other_class', text_field(:bogus_item, :name, :class => 'some_other_class')
 
     # Using builder
-    assert_has_class 'required', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'presence', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.text_field(:name)
       }
-    assert_has_class 'required text', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'presence text', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.text_field(:name, :class => 'text')
       }
   end
 
   test "required :password_field" do
     # Using helper
-    assert_has_class 'required', password_field(:bogus_item, :name)
-    assert_has_class 'required some_other_class', password_field(:bogus_item, :name, :class => 'some_other_class')
+    assert_has_class 'presence', password_field(:bogus_item, :name)
+    assert_has_class 'presence some_other_class', password_field(:bogus_item, :name, :class => 'some_other_class')
     
     # Using builder
-    assert_has_class 'required', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'presence', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.password_field(:name)
       }
-    assert_has_class 'required some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'presence some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.password_field(:name, :class => 'some_other_class')
       }
   end
 
   test "required :text_area" do
     # Using helper
-    assert_has_class 'required', text_area(:bogus_item, :body)
-    assert_has_class 'required some_other_class', text_area(:bogus_item, :body, :class => 'some_other_class')
+    assert_has_class 'presence', text_area(:bogus_item, :body)
+    assert_has_class 'presence some_other_class', text_area(:bogus_item, :body, :class => 'some_other_class')
     
     # Using builder
-    assert_has_class 'required', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'presence', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.text_area(:body)
       }
-    assert_has_class 'required some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'presence some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.text_area(:body, :class => 'some_other_class')
       }
   end
 
   test "required :check_box" do # a.k.a. "acceptance required"
     # Using helper
-    assert_has_class 'required', check_box(:bogus_item, :signed)
-    assert_has_class 'required some_other_class', check_box(:bogus_item, :signed, :class => 'some_other_class')
+    assert_has_class 'acceptance-accept_true', check_box(:bogus_item, :signed)
+    assert_has_class 'acceptance-accept_true some_other_class', check_box(:bogus_item, :signed, :class => 'some_other_class')
     
     # Using builder
-    assert_has_class 'required', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'acceptance-accept_true', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.check_box(:signed)
       }
-    assert_has_class 'required some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
+    assert_has_class 'acceptance-accept_true some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
         concat f.check_box(:signed, :class => 'some_other_class')
       }
   end
 
   test "required :radio_button" do
     # Using helper
-     assert_has_class 'required', radio_button(:bogus_item, :variant, 1)
-     assert_has_class 'required some_other_class', radio_button(:bogus_item, :variant, 1, :class => 'some_other_class')
+     assert_has_class 'presence', radio_button(:bogus_item, :variant, 1)
+     assert_has_class 'presence some_other_class', radio_button(:bogus_item, :variant, 1, :class => 'some_other_class')
      
-     assert_has_class 'required', form_for(@bogus_item, :url => '/bogus_items') { |f|
+     assert_has_class 'presence', form_for(@bogus_item, :url => '/bogus_items') { |f|
          concat f.radio_button(:variant, 1)
        }
-     assert_has_class 'required some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
+     assert_has_class 'presence some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
          concat f.radio_button(:variant, 1, :class => 'some_other_class')
        }
   end

data/test/validatious_on_rails/validatious/validator_test.rb

@@ -16,7 +16,7 @@ class ValidatorTest < ::ActiveSupport::TestCase
     end
   end
 
-  test "creating an empty validator - and generate valid v2.Validator (using #to_s)" do
+  test "creating an empty validator - and generate valid v2.Validator and class call" do
     assert_equal 'dummie', @empty_validator.name
     assert_equal '', @empty_validator.message
     assert_equal ([]), @empty_validator.params
@@ -30,10 +30,12 @@ class ValidatorTest < ::ActiveSupport::TestCase
       name: "dummie"
     });'
 
-    assert_equal expected_v2_validator.gsub(/[\n\s\t]/, ''), @empty_validator.to_s.gsub(/[\n\s\t]/, '')
+    assert_equal @custom_validator.name, @custom_validator.to_class
+    assert_equal "#{@custom_validator.name}_1_hello_2", @custom_validator.to_class(1, "hello", 2)
+    assert_equal expected_v2_validator.gsub(/[\n\s\t]/, ''), @empty_validator.to_js.gsub(/[\n\s\t]/, '')
   end
 
-  test "creating a custom validator - and generate valid v2.Validator (using #to_s)" do
+  test "creating a custom validator - and generate valid v2.Validator and class call" do
     assert_equal 'dummie', @custom_validator.name
     assert_equal 'Fail, fail, fail!', @custom_validator.message
     assert_equal (["some", "params"]), @custom_validator.params
@@ -50,7 +52,9 @@ class ValidatorTest < ::ActiveSupport::TestCase
       params: ["some", "params"]
     });'
 
-    assert_equal expected_v2_validator.gsub(/[\n\s\t]/, ''), @custom_validator.to_s.gsub(/[\n\s\t]/, '')
+    assert_equal @custom_validator.name, @custom_validator.to_class
+    assert_equal "#{@custom_validator.name}_1_hello_2", @custom_validator.to_class(1, "hello", 2)
+    assert_equal expected_v2_validator.gsub(/[\n\s\t]/, ''), @custom_validator.to_js.gsub(/[\n\s\t]/, '')
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: validatious-on-rails
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors: 
 - Christian Johansen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-06 00:00:00 +02:00
+date: 2009-10-08 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,8 @@ extra_rdoc_files:
 - lib/validatious-on-rails/validatious/remote_validator.rb
 - lib/validatious-on-rails/validatious/validator.rb
 - lib/validatious-on-rails/validatious/validators.rb
+- lib/validatious-on-rails/validatious/validators/acceptance_validator.rb
+- lib/validatious-on-rails/validatious/validators/confirmation_validator.rb
 - lib/validatious-on-rails/validatious/validators/exclusion_validator.rb
 - lib/validatious-on-rails/validatious/validators/format_validator.rb
 - lib/validatious-on-rails/validatious/validators/inclusion_validator.rb
@@ -49,6 +51,7 @@ extra_rdoc_files:
 - lib/validatious-on-rails/validatious/validators/numericality/less_than_validator.rb
 - lib/validatious-on-rails/validatious/validators/numericality/odd_validator.rb
 - lib/validatious-on-rails/validatious/validators/numericality/only_integer_validator.rb
+- lib/validatious-on-rails/validatious/validators/presence_validator.rb
 - rails/init.rb
 - test/test_helper.rb
 - test/validatious_on_rails/helpers_test.rb
@@ -71,6 +74,8 @@ files:
 - lib/validatious-on-rails/validatious/remote_validator.rb
 - lib/validatious-on-rails/validatious/validator.rb
 - lib/validatious-on-rails/validatious/validators.rb
+- lib/validatious-on-rails/validatious/validators/acceptance_validator.rb
+- lib/validatious-on-rails/validatious/validators/confirmation_validator.rb
 - lib/validatious-on-rails/validatious/validators/exclusion_validator.rb
 - lib/validatious-on-rails/validatious/validators/format_validator.rb
 - lib/validatious-on-rails/validatious/validators/inclusion_validator.rb
@@ -85,6 +90,7 @@ files:
 - lib/validatious-on-rails/validatious/validators/numericality/less_than_validator.rb
 - lib/validatious-on-rails/validatious/validators/numericality/odd_validator.rb
 - lib/validatious-on-rails/validatious/validators/numericality/only_integer_validator.rb
+- lib/validatious-on-rails/validatious/validators/presence_validator.rb
 - rails/init.rb
 - test/test_helper.rb
 - test/validatious_on_rails/helpers_test.rb
@@ -116,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.3
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Rails plugin that maps model validations to class names on form elements to integrate with Validatious.