midas-g_live_validator 1.0.3

data/History.txt

@@ -0,0 +1,12 @@
+== 1.0.3
+
+* Updated JavaScript to keep a collection LiveValidation objects indexed by field name accessible in th g namespace
+
+
+== 1.0.1
+
+* Added a guilded.live_validator.min.js file.
+
+== 0.0.1 2009-03-09
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,22 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/g_live_validator.rb
+lib/g_live_validator/active_record_extensions.rb
+lib/g_live_validator/view_helpers.rb
+live_validator.gemspec
+rails_generators/live_validator_assets/live_validator_assets_generator.rb
+rails_generators/live_validator_assets/templates/default.css
+rails_generators/live_validator_assets/templates/guilded.live_validator.js
+rails_generators/live_validator_assets/templates/guilded.live_validator.min.js
+rails_generators/live_validator_assets/templates/livevalidation-1.3.js
+rails_generators/live_validator_assets/templates/livevalidation-1.3.min.js
+script/console
+script/destroy
+script/generate
+spec/live_validator_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on live_validator, see http://live_validator.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,83 @@
+= live_validator
+
+http://github.com/midas/live_validator/tree/master
+
+
+== DESCRIPTION:
+
+Live validator is a Rails Guilded (http://github.com/midas/guilded/tree/master) component that will reflect ActiveRecord validations 
+and use them to live validate forms.  Live validator uses the Live Validation (http://www.livevalidation.com) JavaScript library to 
+accomplish this task.  It also uses an ActiveRecord extension authored by Michael Schuerig to mre easily reflect on the ActiveRecord
+valdiations.
+
+
+== FEATURES:
+
+* Validate Rails XHTML forms without submitting form to server.
+* Declare validations once in ActiveRecord model's.  If JavaScript is enabled, the validation will happen live.  Otherwise,
+  the validation will happen normally, with a submission to the server.
+* The error message defined in the validation macro will be used in live validation
+* The following ActiveRecrod validations are currently implemented and working: validates_presence_of (:message), 
+  validates_numericality_of (:less_than, :less_than_or_equal_to, :equal_to, :greater_than, :greater_then_or_equal_to, 
+  :only_integer, :notANumberMessage, :notAnIntegerMessage, :wrongNumberMessage, :tooLowMessage, :tooHighMessage),
+  validates_length_of / validates_size_of (:maximum, :minimum, :is, :within, :in, :too_long, :too_short, :wrong_length),
+  validates_confirmation_of (Only works for 2 fields, no more nor less.), validates_acceptance_of (:message),
+  validates_inclusion_of (:message), validates_exclusion_of (:message)
+
+==PROBLEMS:
+
+
+== INSTALL:
+
+  sudo gem install midas-live_validator
+
+
+== USE:
+
+Add gem requirement to your environment.rb file:
+
+  config.gem 'midas-live_validator', :version => '1.0.3', :lib => 'live_validator', :source => 'http://gems.github.com'
+
+Generate the assets for live validator:
+
+  script/generate live_validator_assets
+
+Make a call to the view_helper within a form:
+
+  <%= g_live_validator f %> # where f is the form variable passed into the form_for block
+
+
+== OPTIONS:
+
+:except - List of fields not to validate.  Foreign key fields (that end in _id) are automatically excluded.  Can be a string, 
+symbol or an array of string or sybmols.
+
+== REQUIREMENTS:
+
+* Guilded >= 0.1.3 (http://github.com/midas/guilded/tree/master)
+* Rails >= 2.0
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 midas (excluding included material copyrighted by others)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+require File.dirname(__FILE__) + '/lib/g_live_validator'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new('g_live_validator', GLiveValidator::VERSION) do |p|
+  p.developer('C. Jason Harrelson (midas)', 'jason@lookforwardenterprises.com')
+  p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  p.rubyforge_name       = p.name # TODO this is default value
+  # p.extra_deps         = [
+  #   ['activesupport','>= 2.0.2'],
+  # ]
+  p.extra_dev_deps = [
+    ['newgem', ">= #{::Newgem::VERSION}"],
+    ['rails', ">= 2.2.0"],
+    ['midas-guilded', ">=0.1.4"]
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/lib/g_live_validator/active_record_extensions.rb

@@ -0,0 +1,72 @@
+#--
+# Copyright (c) 2006, Michael Schuerig, michael@schuerig.de
+#
+# == License
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# See http://www.gnu.org/copyleft/lesser.html
+#++
+require 'active_record/reflection'
+
+module GLiveValidator # :nodoc:
+  module ActiveRecordExtensions # :nodoc:
+    module ValidationReflection # :nodoc:
+      
+      VALIDATIONS = %w(
+         validates_acceptance_of
+         validates_associated
+         validates_confirmation_of
+         validates_exclusion_of
+         validates_format_of
+         validates_inclusion_of
+         validates_length_of
+         validates_size_of
+         validates_numericality_of
+         validates_presence_of
+         validates_uniqueness_of
+      ).freeze
+
+      def self.included( base )
+        base.extend( ClassMethods )
+
+        for validation_type in VALIDATIONS
+          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", [ ActiveRecord::Reflection::MacroReflection.new(:#{validation_type}, attr_name, configuration, self) ]
+                end
+              end
+
+              alias_method :#{validation_type}, :#{validation_type}_with_reflection
+            end
+          end_eval
+        end
+      end
+
+      module ClassMethods
+
+        # 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 do |reflection|
+            reflection.name.to_s == attr_name.to_s
+          end
+        end
+
+      end
+
+    end
+    
+  end
+end

data/lib/g_live_validator/view_helpers.rb

@@ -0,0 +1,181 @@
+module GLiveValidator
+  module ViewHelpers
+    
+    G_VALIDATION_METHODS = {
+      :presence => "Validate.Presence",
+      :numericality => "Validate.Numericality",
+      :format => "Validate.Format",
+      :length => "Validate.Length",
+      :size => "Validate.Length",
+      :acceptance => "Validate.Acceptance",
+      :confirmation => "Validate.Confirmation",
+      :exclusion => "Validate.Exclusion"
+    }
+
+    # Guilded component.  This reads from the server side validations and sets up client side 
+    # validations that match utilizing the Live Validation library.  The following validation
+    # macros and args are implemented:
+    # 
+    # validates_presence_of - :message
+    # validates_numericality_of - :less_than, :less_than_or_equal_to, :equal_to, :greater_than, 
+    #   :greater_then_or_equal_to, :only_integer, :notANumberMessage, :notAnIntegerMessage,
+    #   :wrongNumberMessage, :tooLowMessage, :tooHighMessage
+    # validates_length_of / validates_size_of - :maximum, :minimum, :is, :within, :in, :too_long,
+    #   :too_short, :wrong_length
+    # validates_confirmation_of - Only works for 2 fields, no more or less.
+    # validates_acceptance_of - :message
+    # validates_inclusion_of - :message
+    # validates_exclusion_of - :message
+    # 
+    # If you need to do custom initialization you can implement g.beforeLiveValidatorInit() or 
+    # g.afterLiveValidatorInit().
+    #
+    # If you need custom handling of valid or invalid fields, you can implement g.liveValidatorInvalidField() 
+    # or g. liveValidatorValidField().
+    # 
+    # *parameters*
+    # form:: The form object from the form_for helper.
+    # 
+    # *options*
+    # id:: (required)
+    # except:: List of fields to not include.  A string, symbol or array of strings or symbols. 
+    #
+    def g_live_validator( form, *args )
+      options = args.extract_options!
+      klass = form.object.class
+      class_name = klass.to_s.downcase
+      options.merge! :id => "live-validator-#{class_name}"
+      ar_obj_name = form.object.class.to_s.underscore
+      
+      # TODO: Add human names to options
+      #options.merge! :human_names => form.object
+      
+      validations = g_map_validations( klass.reflect_on_all_validations )
+      
+      # Remove any foreign keys as they will not be present on the form
+      validations.reject! { |field, validation| field.include?( "_id" ) }
+      
+      # Remove any excepts, if necessary
+      if options[:except]
+        if options[:except].is_a?( Array )
+          excepts = options[:except]
+        elsif options[:except].is_a?( String ) || options[:except].is_a?( Symbol )
+          excepts = Array.new << options[:except]          
+        else
+          throw "'Except' option must be a string symbol or arry of strings or symbols"
+        end
+
+        # Add the AR object name to the field name, as Rails does this on forms
+        excepts.map! { |except| "#{ar_obj_name}_#{except.to_s}" }
+        
+        excepts.each do |except|
+          validations.reject! { |field, validation| field == except }
+        end
+      end
+      
+      # Handle nested form namings, if necessary
+      if form.object.class.to_s.underscore != form.object_name
+        #field_precursor = form.object_name.gsub( /\[/, '_' ).gsub( /\]/, '_' )
+        field_precursor = form.object_name[0...form.object_name.index( "[" )] + '_'
+        nested_validations = Hash.new
+        validations.each do |key, value|
+          nested_validations[ "#{field_precursor}#{key}".to_sym ] = value
+        end
+        validations = nested_validations
+      end
+      
+      options.merge! :validations => validations
+      Guilded::Guilder.instance.add( :live_validator, options, [ 'livevalidation-1.3.min.js' ] )
+      return ""
+    end
+    
+    private
+    
+    def g_map_validations( validation_defs )
+      validations = {}
+      confirmation_of = []
+      
+      validation_defs.each do |validation_def|
+        klass = validation_def.active_record.to_s.underscore
+        temp = { :name => validation_def.macro }
+        options = {}
+        
+        unless validation_def.options.nil?
+          
+          validation_def.options.each do |key, value|
+            if key == :greater_than
+              options.merge!( :minimum => value + 1 )
+            elsif key == :greater_than_or_equal_to
+              options.merge!( :minimum => value )
+            elsif key == :equal_to
+              options.merge!( :is => value )
+            elsif key == :less_than
+              options.merge!( :maximum => value - 1 )
+            elsif key == :less_than_or_equal_to
+              options.merge!( :maximum => value )
+            elsif ( key == :within || key == :in ) && validation_def.macro == :validates_length_of
+              options.merge!( :minimum => value.begin )
+              options.merge!( :maximum => value.end )
+            elsif ( validation_def.macro == :validates_inclusion_of || validation_def.macro == :validates_exclusion_of ) && key == :in
+              if value.is_a?( Array )
+                options.merge!( :within => value )
+              else
+                options.merge!( :within => value.to_a )
+              end
+            elsif key == :message
+              options.merge!( :failureMessage => value )
+            elsif key == :allow_nil
+              options.merge!( :allowNull => value )
+            elsif key == :wrong_length
+              options.merge!( :wrongLengthMessage => value )
+            elsif key == :too_long
+              options.merge!( :tooLongMessage => value )
+            elsif key == :too_short
+              options.merge!( :tooShortMessage => value )
+            else
+              options.merge!( key.to_s.camelize( :lower ) => value )
+            end
+          end
+        
+          temp.merge!( :args => options )
+          
+        end
+        
+        # Handle validatesconfirmation_of
+        if validation_def.macro.to_sym == :validates_confirmation_of
+          
+          confirmation_of.push( validation_def.name )
+          
+          if confirmation_of.size ==2
+            key = "#{klass}_#{confirmation_of[1]}"
+            
+            temp[:args] = {} if temp[:options].nil?
+            
+            temp[:args].merge! :match => "#{klass}_#{confirmation_of[0]}" 
+            
+            if validations.has_key?( key )
+              validations[key].push( temp )
+            else
+              validations[key] = [ temp ]
+            end
+          end
+          
+        else # Handle others
+          
+          key = "#{klass}_#{validation_def.name}"
+          
+          if validations.has_key?( key )
+            validations[key].push( temp )
+          else
+            validations[key] = [ temp ]
+          end
+          
+        end
+        
+      end
+      
+      return validations
+    end
+    
+  end
+end

data/lib/g_live_validator.rb

@@ -0,0 +1,19 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'g_live_validator/view_helpers'
+require 'g_live_validator/active_record_extensions'
+
+module GLiveValidator
+  VERSION = '1.0.3'
+end
+
+if defined?( ActiveRecord::Base )
+  ActiveRecord::Base.class_eval do
+    include GLiveValidator::ActiveRecordExtensions::ValidationReflection
+  end
+end
+
+if defined?( ActionView::Base )
+  ActionView::Base.send( :include, GLiveValidator::ViewHelpers ) unless ActionView::Base.include?( GLiveValidator::ViewHelpers )
+end

data/live_validator.gemspec

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{live_validator}
+  s.version = "1.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["C. Jason Harrelson (midas)"]
+  s.date = %q{2009-03-13}
+  s.description = %q{Live validator is a Rails Guilded (http://github.com/midas/guilded/tree/master) component that will reflect ActiveRecord validations  and use them to live validate forms.  Live validator uses the Live Validation (http://www.livevalidation.com) JavaScript library to  accomplish this task.  It also uses an ActiveRecord extension authored by Michael Schuerig to mre easily reflect on the ActiveRecord valdiations.}
+  s.email = ["jason@lookforwardenterprises.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc"]
+  s.files = ["History.txt", "Manifest.txt", "PostInstall.txt", "README.rdoc", "Rakefile", "lib/live_validator.rb", "lib/live_validator/active_record_extensions.rb", "lib/live_validator/view_helpers.rb", "live_validator.gemspec", "rails_generators/live_validator_assets/live_validator_assets_generator.rb", "rails_generators/live_validator_assets/templates/default.css", "rails_generators/live_validator_assets/templates/guilded.live_validator.js", "rails_generators/live_validator_assets/templates/guilded.live_validator.min.js", "rails_generators/live_validator_assets/templates/livevalidation-1.3.min.js", "script/console", "script/destroy", "script/generate", "spec/live_validator_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/rspec.rake"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/midas/live_validator/tree/master}
+  s.post_install_message = %q{PostInstall.txt}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{live_validator}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Live validator is a Rails Guilded (http://github.com/midas/guilded/tree/master) component that will reflect ActiveRecord validations  and use them to live validate forms}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_development_dependency(%q<midas-guilded>, [">= 0.1.3"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_dependency(%q<midas-guilded>, [">= 0.1.3"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<newgem>, [">= 1.2.3"])
+    s.add_dependency(%q<midas-guilded>, [">= 0.1.3"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/rails_generators/live_validator_assets/live_validator_assets_generator.rb

@@ -0,0 +1,17 @@
+class LiveValidatorAssetsGenerator < Rails::Generator::Base
+  def initialize(runtime_args, runtime_options = {})
+    super
+  end
+
+  def manifest
+    record do |m|
+      m.file "guilded.live_validator.js", "public/javascripts/guilded.live_validator.js"
+      m.file "guilded.live_validator.min.js", "public/javascripts/guilded.live_validator.min.js"
+      m.file "livevalidation-1.3.min.js", "public/javascripts/livevalidation-1.3.min.js"
+      m.file "livevalidation-1.3.js", "public/javascripts/livevalidation-1.3.js"
+      m.directory "public/stylesheets/guilded/live_validator"
+      m.directory "public/stylesheets/guilded/live_validator/default"
+      m.file "default.css", "public/stylesheets/guilded/live_validator/default.css"
+    end
+  end
+end

data/rails_generators/live_validator_assets/templates/default.css

@@ -0,0 +1,23 @@
+.LV_valid { color:#00CC00; }
+.LV_invalid { color:#CC0000; }
+.LV_validation_message{ margin:0 0 0 5px; }
+.LV_valid_field,
+input.LV_valid_field:hover,
+input.LV_valid_field:active,
+textarea.LV_valid_field:hover,
+textarea.LV_valid_field:active,
+.fieldWithErrors input.LV_valid_field,
+.fieldWithErrors textarea.LV_valid_field {
+ border:1px solid #00CC00 !important;
+}
+.LV_invalid_field,
+input.LV_invalid_field:hover,
+input.LV_invalid_field:active,
+textarea.LV_invalid_field:hover,
+textarea.LV_invalid_field:active,
+.fieldWithErrors input.LV_invalid_field,
+.fieldWithErrors textarea.LV_invalid_field {
+ border:1px solid #CC0000 !important;
+}
+li.error { background:#f6c1b5; border:1px solid #9e0b0f !important; }
+li.error span.note { color:#9e0b0f; font-weight:bold; }

data/rails_generators/live_validator_assets/templates/guilded.live_validator.js

@@ -0,0 +1,84 @@
+/* Guilded Live Validator 1.0.1
+ * Copyright (c) 2009 C. Jason Harrelson (midas)
+ * Guilded Live Validator is licensed under the terms of the MIT License */
+
+g.liveValidationsByField = {}; /* The collection of live validation objects indexed by field names */
+g.liveValidations = []; /* The collection of live validation objects */
+
+g.doInvalidField = function()
+{
+  if( g.liveValidatorInvalidField )
+  {
+    g.liveValidatorInvalidField( this );
+  }
+  else
+  {
+    this.insertMessage( this.createMessageSpan() );
+    this.addFieldClass();
+  }
+};
+
+g.doValidField = function()
+{
+  if( g.liveValidatorValidField )
+    g.liveValidatorValidField( this );
+  else
+  {
+    this.insertMessage( this.createMessageSpan() );
+    this.addFieldClass();
+  }
+};
+
+g.liveValidatorInit = function( options )
+{
+  if( g.beforeLiveValidatorInit )
+    g.beforeLiveValidatorInit( options );
+
+  var moreValidationMethods = {
+    presence: Validate.Presence,
+    numericality: Validate.Numericality,
+    format: Validate.Format,
+    length: Validate.Length,
+    acceptance: Validate.Acceptance,
+    confirmation: Validate.Confirmation
+  };
+
+  var validationMethods = {
+    validates_presence_of: Validate.Presence,
+    validates_numericality_of: Validate.Numericality,
+    validates_format_of: Validate.Format,
+    validates_length_of: Validate.Length,
+    validates_size_of: Validate.Length,
+    validates_acceptance_of: Validate.Acceptance,
+    validates_confirmation_of: Validate.Confirmation,
+    validates_inclusion_of: Validate.Inclusion,
+    validates_exclusion_of: Validate.Exclusion
+  };
+
+  var validations = options[ 'validations' ];
+
+  for( field in validations )
+  {
+    /* Guard against fields that we cannot find throwing errors.  Just don't
+     * attach if you cannot find it. */
+    fieldEl = $j( '#' + field );
+    if( fieldEl.length == 0 )
+      continue;
+
+    var vList = validations[ field ];
+    var v = null;
+
+    v = new LiveValidation( field, { onlyOnBlur:true, onInvalid:g.doInvalidField, onValid:g.doValidField } );
+
+    for( var i=0; i<vList.length; i++ )
+    {
+      var validation = vList[i];
+      v.add( validationMethods[ validation.name ], validation.args );
+      g.liveValidationsByField[field] = v;
+      g.liveValidations.push( v );
+    }
+  }
+
+  if( g.afterLiveValidatorInit )
+    g.afterLiveValidatorInit( options );
+};

data/rails_generators/live_validator_assets/templates/guilded.live_validator.min.js

@@ -0,0 +1,18 @@
+/* Guilded Live Validator 1.0.1
+ * Copyright (c) 2009 C. Jason Harrelson (midas)
+ * Guilded Live Validator is licensed under the terms of the MIT License */
+g.doInvalidField=function()
+{if(g.liveValidatorInvalidField)
+{g.liveValidatorInvalidField(this);}
+else
+{this.insertMessage(this.createMessageSpan());this.addFieldClass();}};g.doValidField=function()
+{if(g.liveValidatorValidField)
+g.liveValidatorValidField(this);else
+{this.insertMessage(this.createMessageSpan());this.addFieldClass();}};g.liveValidatorInit=function(options)
+{if(g.beforeLiveValidatorInit)
+g.beforeLiveValidatorInit(options);var moreValidationMethods={presence:Validate.Presence,numericality:Validate.Numericality,format:Validate.Format,length:Validate.Length,acceptance:Validate.Acceptance,confirmation:Validate.Confirmation};var validationMethods={validates_presence_of:Validate.Presence,validates_numericality_of:Validate.Numericality,validates_format_of:Validate.Format,validates_length_of:Validate.Length,validates_size_of:Validate.Length,validates_acceptance_of:Validate.Acceptance,validates_confirmation_of:Validate.Confirmation,validates_inclusion_of:Validate.Inclusion,validates_exclusion_of:Validate.Exclusion};var validations=options['validations'];for(field in validations)
+{fieldEl=$j('#'+field);if(fieldEl.length==0)
+continue;var vList=validations[field];var v=null;v=new LiveValidation(field,{onlyOnBlur:true,onInvalid:g.doInvalidField,onValid:g.doValidField});for(var i=0;i<vList.length;i++)
+{var validation=vList[i];v.add(validationMethods[validation.name],validation.args);}}
+if(g.afterLiveValidatorInit)
+g.afterLiveValidatorInit(options);};