g_live_validator 1.0.7

data/.gitignore

@@ -0,0 +1 @@
+.idea/*

data/History.txt

@@ -0,0 +1,32 @@
+== 1.0.7 2010-01-04
+
+* Stopped automatically eliminating *_id fields from validations.
+
+
+== 1.0.6 2009-06-18
+
+* Added code so that client side JavaScript does not add validations with if or except options.
+
+
+== 1.0.5 2009-06-03
+
+* Added the g_live_dynamic_validations view helper that works with dynamic validations gem.
+
+
+== 1.0.4 2009-04-03
+
+* Added support for InacvtiveRecord (http://github.com/midas/inactive_record/tree/master) validations.
+
+
+== 1.0.3
+
+* Updated JavaScript to keep a collection LiveValidation objects indexed by field name accessible in the g namespace.
+
+
+== 1.0.1
+
+* Added a guilded.live_validator.min.js file.
+
+== 0.0.1 2009-03-09
+
+* Initial release.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jason Harrelson (midas)
+
+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/README.rdoc

@@ -0,0 +1,90 @@
+= 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 ActiveRecord 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-g_live_validator
+
+Add gem requirement to your environment.rb file:
+
+  config.gem 'midas-g_live_validator', :version => '1.0.4', :lib => 'g_live_validator', :source => 'http://gems.github.com'
+
+Generate:
+
+  script/generate live_validator_assets
+
+
+== USE:
+
+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
+
+To use with a library like midas-dynamic_Validations, that does not use ActiveRecord validations, but some other method of 
+defining validations:
+
+  <%= g_live_dynamic_validator f, @validation_definitions %>
+
+
+== 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,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "g_live_validator"
+    gem.summary = %Q{A Guilded (http://github.com/midas/guilded/tree/master) component that will reflect ActiveRecord validations and use them to live validate forms.}
+    gem.email = "jason@lookforwardenterprises.com"
+    gem.homepage = "http://github.com/midas/g_live_validator"
+    gem.authors = ["C. Jason Harrelson (midas)"]
+    gem.add_dependency "rails", ">= 2.2.0"
+    gem.add_dependency "guilded", ">= 1.0.3"
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "g_live_validator #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.7

data/g_live_validator.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{g_live_validator}
+  s.version = "1.0.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["C. Jason Harrelson (midas)"]
+  s.date = %q{2010-01-04}
+  s.email = %q{jason@lookforwardenterprises.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "g_live_validator.gemspec",
+     "lib/g_live_validator.rb",
+     "lib/g_live_validator/active_record_extensions.rb",
+     "lib/g_live_validator/validation_definition.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"
+  ]
+  s.homepage = %q{http://github.com/midas/g_live_validator}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A Guilded (http://github.com/midas/guilded/tree/master) component that will reflect ActiveRecord validations and use them to live validate forms.}
+  s.test_files = [
+    "spec/live_validator_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 2.2.0"])
+      s.add_runtime_dependency(%q<guilded>, [">= 1.0.3"])
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rails>, [">= 2.2.0"])
+      s.add_dependency(%q<guilded>, [">= 1.0.3"])
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 2.2.0"])
+    s.add_dependency(%q<guilded>, [">= 1.0.3"])
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/g_live_validator.rb

@@ -0,0 +1,26 @@
+$:.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/validation_definition'
+require 'g_live_validator/active_record_extensions'
+
+module GLiveValidator
+  VERSION = '1.0.7'
+end
+
+if defined?( ActiveRecord::Base )
+  ActiveRecord::Base.class_eval do
+    include GLiveValidator::ActiveRecordExtensions::ValidationReflection
+  end
+end
+
+if defined?( InactiveRecord::Base )
+  InactiveRecord::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/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/validation_definition.rb

@@ -0,0 +1,21 @@
+module GLiveValidator
+  
+  class ValidationDefinition
+    attr_accessor :active_record, :macro, :name, :options
+    
+    def initialize( validation )
+      if validation.is_a?(ActiveRecord::Reflection::MacroReflection )
+        self.active_record = validation.active_record
+        self.macro = validation.macro
+        self.name = validation.name
+        self.options = validation.options
+      elsif validation.is_a?( ValidationRule )
+        self.active_record = validation.entity_type.constantize
+        self.macro = "validates_#{validation.validation}_of"
+        self.name = validation.attribute
+        self.options = YAML.load( validation.description ) unless validation.description.nil?
+      end
+    end
+  end
+  
+end

data/lib/g_live_validator/view_helpers.rb

@@ -0,0 +1,222 @@
+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() in the client side JavaScript environment.
+    #
+    # If you need custom handling of valid or invalid fields, you can implement g.liveValidatorInvalidField() 
+    # or g.liveValidatorValidField() in the client side JavaScript environment.
+    # 
+    # *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 )
+      validations = apply_options( form, validations, ar_obj_name, options )
+      
+      options.merge! :validations => validations
+      Guilded::Guilder.instance.add( :live_validator, options, [ 'livevalidation-1.3.min.js' ] )
+      return ""
+    end
+    
+    # Guilded component.  The live dynamic validator accepts an array of ValidationDefinition objects and
+    # sets up the live validations accordingly.  This makes the live dynamic validator usable with the 
+    # midas-dynamic_validations gem and possibly other validations that can be standardized through the 
+    # ValidationDefinition object.
+    # 
+    # The same validations that are supported by the g_live_validator are also supported.
+    #
+    # If you need to do custom initialization you can implement g.beforeLiveValidatorInit() or 
+    # g.afterLiveValidatorInit() in the client side JavaScript environment.
+    #
+    # If you need custom handling of valid or invalid fields, you can implement g.liveValidatorInvalidField() 
+    # or g.liveValidatorValidField() in the client side JavaScript environment.
+    # 
+    # *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_dynamic_validator( form, validation_rules, *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
+      
+      validation_defs = validation_rules.map { |validation_rule| ValidationDefinition.new( validation_rule ) }
+      
+      validations = g_map_validations( validation_defs )
+      validations = apply_options( form, validations, ar_obj_name, options )
+      
+      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
+    
+    def apply_options( form, validations, ar_obj_name, options )
+      # 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
+      
+      validations
+    end
+  end
+end