validatious-on-rails 0.3.1

data/lib/validatious-on-rails.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), *%w[validatious-on-rails validatious])
+require File.join(File.dirname(__FILE__), *%w[validatious-on-rails model_validations])
+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
+    def initialize(message)
+      ::Validatious.log message, :debug
+      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)
+    return unless @@verbose
+    level = :info if level.blank?
+    @@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/rails/init.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. lib validatious-on-rails)))

data/test/test_helper.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+#
+# This file loads up the in-memory database needed to run the tests, and adds a few
+# convenience methods.
+#
+
+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'
+end
+
+begin
+  require 'context'
+rescue LoadError
+  gem 'jeremymcanally-context', '>= 0.5.5'
+  require 'context'
+end
+
+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.
+module ActiveRecord
+  module Validations
+    module ClassMethods
+      def validates_craziness_of(*args)
+        #...
+      end
+    end
+  end
+end
+
+# Reflected_validations already freezed...ned to find a workaround.
+# reflected_validatons = ActiveRecordExtensions::ValidationReflection.reflected_validations
+# stub(ActiveRecordExtensions::ValidationReflection).reflected_validations {reflected_validatons + [:validates_craziness_of]}
+
+build_model :bogus_items do
+  string :url
+  string :name
+  string :email
+  
+  text    :body
+  integer :variant
+  boolean :signed
+  
+  validates_presence_of :name, :body, :variant
+  validates_confirmation_of :name
+  validates_acceptance_of :signed
+  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.'
+  validates_inclusion_of :variant, :in => (1..5).to_a
+  validates_exclusion_of :variant, :in => (6..10).to_a
+  
+  # TODO: Test: If this is a validator makro, then it should not cause any issues.
+  validates_craziness_of :name
+end
+
+#
+# ValidationReflection seems to expect RAILS_ROOT to be defined, but it's not
+# if it's tested outside of a Rails project. So, just set it to something random.
+#
+RAILS_ROOT = File.join(File.dirname(__FILE__)) unless defined?(RAILS_ROOT)
+
+#
+# Log file for testing only.
+#
+ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), 'debug.log'))

data/test/validatious_on_rails/helpers_test.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. test_helper)))
+
+require 'action_view/test_case'
+
+class HelpersTest < ::ActionView::TestCase
+
+  include ActionView::Helpers::FormHelper
+
+  attr_accessor :output_buffer
+  
+  before do
+    @output_buffer ||= ''
+  end
+
+  context "helpers" do
+    context "custom_validatious_validators" do
+
+      test "should not output custom validators if there are none" do
+        helper_output = ::ValidatiousOnRails::Helpers.custom_validatious_validators
+        assert_equal '', helper_output.to_s
+      end
+
+      test "should output custom validators if they exists" do
+        form_for(::BogusItem.new, :url => '/bogus_items') do |f|
+          concat f.text_field(:url)
+        end
+
+        # FIXME: Not sure how to test content_for-helpers...returns nil.
+        concat ::ValidatiousOnRails::Helpers.custom_validatious_validators
+
+        # In parts...
+        # assert_match /<script.+>.*v2.Validator.*<\/script>/, output_buffer
+        # assert_match /<script.*id="custom_validatious_validators".*>/, helper_output
+        # assert_match /<script.*type="text\/javascript".*>/, helper_output
+      end
+
+    end
+  end
+
+  private
+
+    def protect_against_forgery?
+      false
+    end
+
+end

data/test/validatious_on_rails/model_validations_test.rb

@@ -0,0 +1,190 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. test_helper)))
+
+require 'active_support/test_case'
+
+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]
+  end
+
+  test "associated" do
+    # TODO: not implemented
+  end
+
+  test "confirmation_of" do
+    validation = ::ValidatiousOnRails::ModelValidations.confirmation_of(validation(:validates_confirmation_of))
+    assert_equal 'confirmation-of_name', validation[:class]
+  end
+
+  test "exclusion_of" do
+    values = (6..10).to_a
+    validation = ::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
+  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(
+        validation(:validates_format_of, :with => pattern)
+      )
+    assert_match /^format-with-(\d+)/, validation[:class]
+    assert_match /#{pattern.inspect[1,-1]}/, validation[:validator].fn
+  end
+
+  test "inclusion_of" do
+    values = (1..5).to_a
+    validation = ::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
+  end
+
+  context "length_of" do
+
+    test "with :is" do
+      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+          validation(:validates_length_of, :is => 2)
+        )
+      assert_equal 'length-is_2', validation[:class]
+    end
+
+    test "with :in" do
+      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+          validation(:validates_length_of, :in => 2..10)
+        )
+      assert_equal 'length-minimum_2 length-maximum_10', validation[:class]
+    end
+
+    test "with :within" do
+      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+          validation(:validates_length_of, :within => 2..10)
+        )
+      assert_equal 'length-minimum_2 length-maximum_10', validation[:class]
+    end
+
+    test "with :minimum" do
+      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+          validation(:validates_length_of, :minimum => 2)
+        )
+      assert_equal 'length-minimum_2', validation[:class]
+    end
+
+    test "with :maximum" do
+      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+          validation(:validates_length_of, :maximum => 10)
+        )
+      assert_equal 'length-maximum_10', validation[:class]
+    end
+
+    test "with :minimum + :maximum" do
+      validation = ::ValidatiousOnRails::ModelValidations.length_of(
+          validation(:validates_length_of, :minimum => 2, :maximum => 10)
+        )
+      assert_equal 'length-minimum_2 length-maximum_10', validation[:class]
+    end
+  end
+
+  context "numericality_of" do
+    
+    context ":odd/:even" do
+      test "with :odd only" do
+        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+            validation(:validates_numericality_of, :even => false, :odd => true)
+          )
+        assert_equal 'numericality-odd', validation[:class]
+      end
+
+      test "with :even only" do
+        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+            validation(:validates_numericality_of, :even => true, :odd => false)
+          )
+        assert_equal 'numericality-even', validation[:class]
+      end
+
+      test "with :odd and :even" do
+        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+            validation(:validates_numericality_of, :even => true, :odd => true)
+          )
+        assert_equal '', validation[:class]
+      end
+
+      test "with neither :odd or :even" do
+        validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+            validation(:validates_numericality_of)
+          )
+        assert_equal '', validation[:class]
+      end
+    end
+    
+
+    test "with :only_integer" do
+      validation = ::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]
+    end
+
+    test "with :greater_than" do
+      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+          validation(:validates_numericality_of, :greater_than => 2)
+        )
+      assert_equal 'numericality-greater-than_2', validation[:class]
+    end
+
+    test "with :greater_than_or_equal_to" do
+      validation = ::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]
+    end
+
+    test "with :equal_to" do
+      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+          validation(:validates_numericality_of, :equal_to => 2)
+        )
+      assert_equal 'numericality-equal-to_2', validation[:class]
+    end
+
+    test "with :less_than" do
+      validation = ::ValidatiousOnRails::ModelValidations.numericality_of(
+          validation(:validates_numericality_of, :less_than => 10)
+        )
+      assert_equal 'numericality-less-than_10', validation[:class]
+    end
+
+    test "with :less_than_or_equal_to" do
+      validation = ::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]
+    end
+  end
+
+  test "presence_of" do
+    validation = ::ValidatiousOnRails::ModelValidations.presence_of(validation(:validates_presence_of))
+    assert_equal 'required', validation[:class]
+  end
+
+  test "uniqueness_of" do
+    # TODO: not implemented
+  end
+
+  private
+
+    # Simulate a validation
+    #
+    def validation(macro, options = {})
+      ::ActiveRecord::Reflection::MacroReflection.new(macro, :name, options, BogusItem.new)
+    end
+
+end

data/test/validatious_on_rails/rails/action_view_helpers_test.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. test_helper)))
+
+module Test::Unit::Assertions
+
+  #
+  # Assert that a piece of HTML includes the class name.
+  #
+  def assert_has_class(class_name, html, message = nil)
+    # Might need to consider this...but works a bit better.
+    classes = html.scan(/class="([^"]*)"/).collect { |c| c.to_s.split(' ') }.flatten
+    full_message = build_message(message, "<?>\nexpected to include class(es) <?>.\n", html, class_name)
+
+    assert_block(full_message) do
+      class_name.split(' ').all? { |cname| classes.include?(cname) }
+    end
+  end
+
+end
+
+require 'action_view/test_case'
+
+class FormHelperTest < ::ActionView::TestCase
+
+  include ActionView::Helpers::FormHelper
+
+  def setup
+    @bogus_item = BogusItem.new
+  end
+
+  test "attach custom javascript validations to layout" do
+    @content_for_validatious = nil
+    view_output = form_for(@bogus_item, :url => '/bogus_items') do |f|
+      concat f.text_field(:url)
+    end
+    assert_match /v2.Validator/, @content_for_validatious
+  end
+
+  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')
+
+    # Using builder
+    assert_has_class 'required', 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|
+        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')
+    
+    # Using builder
+    assert_has_class 'required', 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|
+        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')
+    
+    # Using builder
+    assert_has_class 'required', 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|
+        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')
+    
+    # Using builder
+    assert_has_class 'required', 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|
+        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 'required', 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|
+         concat f.radio_button(:variant, 1, :class => 'some_other_class')
+       }
+  end
+
+  test "confirmation_of :name field" do
+    # Using helper
+    assert_has_class 'confirmation-of_name', text_field(:bogus_item, :name_confirmation)
+    assert_has_class 'confirmation-of_name some_other_class', text_field(:bogus_item, :name_confirmation, :class => 'some_other_class')
+    
+    # Using builder
+    assert_has_class 'confirmation-of_name', form_for(@bogus_item, :url => '/bogus_items') { |f|
+        concat f.text_field(:name_confirmation)
+      }
+    assert_has_class 'confirmation-of_name some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
+        concat f.text_field(:name_confirmation, :class => 'some_other_class')
+      }
+  end
+
+  test "format_of :url field" do
+    # Using helper
+    assert_has_class 'url', text_field(:bogus_item, :url)
+    assert_has_class 'url some_other_class', text_field(:bogus_item, :url, :class => 'some_other_class')
+    
+    # Using builder
+    assert_has_class 'url', form_for(@bogus_item, :url => '/bogus_items') { |f|
+        concat f.text_field(:url)
+      }
+    assert_has_class 'url some_other_class', form_for(@bogus_item, :url => '/bogus_items') { |f|
+        concat f.text_field(:url, :class => 'some_other_class')
+      }
+    assert_match /v2.Validator\.add\(.*\{.*"url"/, @content_for_validatious
+  end
+  
+  test "exclusion_of :variant field" do
+    # TODO
+  end
+
+  test "inclusion_of :variant field" do
+    # TODO
+  end
+
+  test "regular label" do
+    # Using helper
+    assert_equal "<label for=\"bogus_item_name\">Name</label>", label(:bogus_item, :name)
+  end
+
+  test "label with title" do
+    # Using helper
+    assert_equal "<label for=\"bogus_item_name\" title=\"craaazy\">Name</label>",
+                 label(:bogus_item, :name, nil, :title => "craaazy")
+  end
+
+  test "label without title" do
+    # Using helper
+    assert_equal "<label for=\"bogus_item_name\" title=\"Name\">Your name</label>",
+                 label(:bogus_item, :name, "Your name")
+  end
+
+  private
+
+    def protect_against_forgery?
+      false
+    end
+
+end

data/test/validatious_on_rails/validatious/validator_test.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w(.. .. test_helper)))
+
+require 'active_support/test_case'
+
+class ValidatorTest < ::ActiveSupport::TestCase
+
+  def setup
+    @empty_validator = ValidatiousOnRails::Validatious::Validator.new('dummie')
+    @custom_validator = returning ValidatiousOnRails::Validatious::Validator.new('dummie') do |v|
+      v.message = 'Fail, fail, fail!'
+      v.params = ['some', 'params']
+      v.aliases = ['some', 'aliases']
+      v.accept_empty = false
+      v.fn = "return false;"
+    end
+  end
+
+  test "creating an empty validator - and generate valid v2.Validator (using #to_s)" do
+    assert_equal 'dummie', @empty_validator.name
+    assert_equal '', @empty_validator.message
+    assert_equal ([]), @empty_validator.params
+    assert_equal ([]), @empty_validator.aliases
+    assert_equal true, @empty_validator.accept_empty
+    assert_equal "function(field, value, params) {return true;}", @empty_validator.fn.gsub(/\n/, '')
+
+    expected_v2_validator = 'v2.Validator.add({
+      acceptEmpty: true,
+      fn: function(field, value, params) {return true;},
+      name: "dummie"
+    });'
+
+    assert_equal expected_v2_validator.gsub(/[\n\s\t]/, ''), @empty_validator.to_s.gsub(/[\n\s\t]/, '')
+  end
+
+  test "creating a custom validator - and generate valid v2.Validator (using #to_s)" do
+    assert_equal 'dummie', @custom_validator.name
+    assert_equal 'Fail, fail, fail!', @custom_validator.message
+    assert_equal (["some", "params"]), @custom_validator.params
+    assert_equal (["some", "aliases"]), @custom_validator.aliases
+    assert_equal false, @custom_validator.accept_empty
+    assert_equal "function(field, value, params) {return false;}", @custom_validator.fn.gsub(/\n/, '')
+
+    expected_v2_validator = 'v2.Validator.add({
+      acceptEmpty: false,
+      aliases: ["some", "aliases"],
+      fn: function(field, value, params) {return false;},
+      message: "Fail, fail, fail!",
+      name: "dummie",
+      params: ["some", "params"]
+    });'
+
+    assert_equal expected_v2_validator.gsub(/[\n\s\t]/, ''), @custom_validator.to_s.gsub(/[\n\s\t]/, '')
+  end
+
+end

data/test/validatious_on_rails_test.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+# class ValidatiousTest < Test::Unit::TestCase
+#   
+# end