validatious-on-rails 0.4.5 → 0.4.6

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+# TODO/QUESTION: Should message be thrown on the confirmation field or the confirmed field (Rails).
+# First makes most sense, but not the Rails way.
+#
+module ValidatiousOnRails
+  module Validatious
+    class ConfirmationOfValidator < ClientSideValidator
+
+      def initialize(*args)
+        super
+        self.message = self.class.generate_message(:confirmation)
+        self.params = %w[field-id]
+        self.fn = %{
+          return value === v2.$f(params[0]).getValue();
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class ExclusionInValidator < ClientSideValidator
+
+      def initialize(*args)
+        data = args.first.dup
+        args.unshift self.class.generate_id(args.shift.inspect)
+        super *args
+        self.message = self.class.generate_message(:exclusion)
+        self.params = %w[exclude allow_nil allow_blank]
+        self.data = %{
+          v2.Rails.params['#{args.first}'] = #{data.to_json};
+        }
+        self.fn = %{
+          #{self.class.handle_nil(1)}
+          #{self.class.handle_blank(2)}
+          var exclusion_values = v2.Rails.params[params[0]];
+          for (var i = 0; i < exclusion_values.length; i++) {
+            if (exclusion_values[i] == value) { return false; }
+          };
+          return true;
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class FormatWithValidator < ClientSideValidator
+
+      def initialize(*args)
+        data = args.first.dup
+        args.unshift self.class.generate_id(args.shift.inspect)
+        super *args
+        self.message = self.class.generate_message(:invalid)
+        self.params = %w[format allow_nil allow_blank]
+        self.data = %{
+          v2.Rails.params['#{args.first}'] = #{data.inspect.gsub(/\\A/, '^').gsub(/\\z/, '$')};
+        }
+        # v2.Rails.messages['#{args.first}'] = #{self.message.to_json};
+        self.fn = %{
+          #{self.class.handle_nil(1)}
+          #{self.class.handle_blank(2)}
+          return v2.Rails.params[params[0]].test(value);
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class InclusionInValidator < ClientSideValidator
+
+      def initialize(*args)
+        data = args.first.dup
+        args.unshift self.class.generate_id(args.shift.inspect)
+        super *args
+        self.message = self.class.generate_message(:inclusion)
+        self.params = %w[include allow_nil allow_blank]
+        self.data = %{
+          v2.Rails.params['#{args.first}'] = #{data.to_json};
+        }
+        self.fn = %{
+          #{self.class.handle_nil(1)}
+          #{self.class.handle_blank(2)}
+          var inclusion_values = v2.Rails.params[params[0]];
+          for (var i = 0; i < inclusion_values.length; i++) {
+            if (inclusion_values[i] == value) { return true; }
+          };
+          return false;
+        }
+      end
+
+    end
+  end
+end

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

@@ -6,19 +6,16 @@ module ValidatiousOnRails
     module Length
       class IsValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name, alias_name = self.class.generate_name(validation, :is, validation.options[:is])
-          name = 'length-is'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :wrong_length, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:wrong_length, :count => '{{count}}')
+          self.params = %w[count allow_nil allow_blank]
           self.fn = %{
-            #{self.class.validate_blank(validation.options[:allow_blank])}
             value += '';
-            return value == params[0];
+            #{self.class.handle_nil}
+            #{self.class.handle_blank}
+            return value.length == params[0];
           }
-          self.fn.freeze
         end
 
       end

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

@@ -6,19 +6,16 @@ module ValidatiousOnRails
     module Length
       class MaximumValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name, alias_name = self.class.generate_name(validation, :maximum, validation.options[:maximum])
-          name = 'length-maximum'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :too_long, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:too_long, :count => '{{count}}')
+          self.params = %w[count allow_nil allow_blank]
           self.fn = %{
-            #{self.class.validate_blank(validation.options[:allow_blank])}
             value += '';
+            #{self.class.handle_nil}
+            #{self.class.handle_blank}
             return value.length <= params[0];
           }
-          self.fn.freeze
         end
 
       end

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

@@ -6,19 +6,16 @@ module ValidatiousOnRails
     module Length
       class MinimumValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name, alias_name = self.class.generate_name(validation, :minimum, validation.options[:minimum])
-          name = 'length-minimum'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :too_short, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:too_short, :count => '{{count}}')
+          self.params = %w[count allow_nil allow_blank]
           self.fn = %{
-            #{self.class.validate_blank(validation.options[:allow_blank])}
             value += '';
+            #{self.class.handle_nil}
+            #{self.class.handle_blank}
             return value.length >= params[0];
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/equal_to_validator.rb

@@ -6,17 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class EqualToValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-equal-to'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :equal_to, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:equal_to, :count => '{{count}}')
+          self.params = %w[count allow_nil]
           self.fn = %{
+            #{self.class.handle_nil}
             value = +value;
             return value == params[0];
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/even_validator.rb

@@ -6,16 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class EvenValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-even'
-          super name, options
-          self.message = self.class.generate_message(validation, :key => :even)
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:even)
+          self.params = %w[allow_nil]
           self.fn = %{
+            #{self.class.handle_nil(0)}
             value = +value;
             return (value % 2) == 0;
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/greater_than_or_equal_to_validator.rb

@@ -6,17 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class GreaterThanOrEqualToValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-greater-than-or-equal-to'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :greater_than_or_equal_to, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:greater_than_or_equal_to, :count => '{{count}}')
+          self.params = %w[count allow_nil]
           self.fn = %{
+            #{self.class.handle_nil}
             value = +value;
             return value >= params[0];
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/greater_than_validator.rb

@@ -6,17 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class GreaterThanValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-greater-than'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :greater_than, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:greater_than, :count => '{{count}}')
+          self.params = %w[count allow_nil]
           self.fn = %{
+            #{self.class.handle_nil}
             value = +value;
             return value > params[0];
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/less_than_or_equal_to_validator.rb

@@ -6,17 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class LessThanOrEqualToValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-less-than-or-equal-to'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :less_than_or_equal_to, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:less_than_or_equal_to, :count => '{{count}}')
+          self.params = %w[count allow_nil]
           self.fn = %{
+            #{self.class.handle_nil}
             value = +value;
             return value <= params[0];
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/less_than_validator.rb

@@ -6,17 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class LessThanValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-less-than'
-          super name, options
-          self.params = ['count']
-          self.message = self.class.generate_message(validation, :key => :less_than, :count => '{{count}}')
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:less_than, :count => '{{count}}')
+          self.params = %w[count allow_nil]
           self.fn = %{
+            #{self.class.handle_nil}
             value = +value;
             return value < params[0];
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/odd_validator.rb

@@ -6,16 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class OddValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-odd'
-          super name, options
-          self.message = self.class.generate_message(validation, :key => :odd)
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:odd)
+          self.params = %w[allow_nil]
           self.fn = %{
+            #{self.class.handle_nil(0)}
             value = +value;
             return (value % 2) == 1;
           }
-          self.fn.freeze
         end
 
       end

data/lib/validatious-on-rails/validatious/validators/numericality/only_integer_validator.rb

@@ -6,16 +6,15 @@ module ValidatiousOnRails
     module Numericality
       class OnlyIntegerValidator < ClientSideValidator
 
-        def initialize(validation, options = {})
-          name = 'numericality-only_integer'
-          super name, options
-          self.message = self.class.generate_message(validation, :key => :not_a_number)
-          self.accept_empty = validation.options[:allow_nil]
+        def initialize(*args)
+          super
+          self.message = self.class.generate_message(:not_a_number, :count => '{{count}}')
+          self.params = %w[allow_nil]
           self.fn = %{
+            #{self.class.handle_nil(0)}
             value = +value;
-            return /\A[+-]?\d+\Z/.test(value);
+            return /^[+-]?\d+$/.test(value);
           }
-          self.fn.freeze
         end
 
       end

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

@@ -5,16 +5,13 @@ module ValidatiousOnRails
   module Validatious
     class PresenceValidator < ClientSideValidator
 
-      def initialize(validation, options = {})
-        name = 'presence'
-        super name, options
-        self.message = self.class.generate_message(validation, :key => :blank)
-        self.accept_empty = false
-        # Identical to Validatious "required" validator, but we want Rails I18n message support, so...
+      def initialize(*args)
+        super
+        self.message = self.class.generate_message(:blank)
+        self.params = %w[]
         self.fn = %{
           return !v2.empty(value) && !(typeof value.length !== 'undefined' && value.length === 0) && !/^[#{'\s\t\n'}]*$/.test(value);
         }
-        self.fn.freeze
       end
 
     end

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

@@ -5,17 +5,10 @@ module ValidatiousOnRails
   module Validatious
     class UniquenessValidator < RemoteValidator
 
-      def initialize(validation, options = {})
+      def initialize(*args)
         super
-        self.accept_empty = false
-      end
-
-      class << self
-
-        def generate_message(validation)
-          super(validation, :key => :taken)
-        end
-
+        self.params = %w[]
+        self.message = self.class.generate_message(:blank)
       end
 
     end

data/test/validatious_on_rails/controller_test.rb

@@ -80,7 +80,7 @@ class ControllerTest < ::ActionController::TestCase
               
               get :uniqueness_of, :model => 'bogus_item', :attribute => 'name', :value => 'carrot' 
               assert_response 200
-              assert_equal 'false', @response.body
+              assert_equal 'true', @response.body
             end
             
             test "valid :value - should succeed" do

data/test/validatious_on_rails/model_validations_test.rb

@@ -40,14 +40,14 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
       validators = ::ValidatiousOnRails::ModelValidations.acceptance_of(
           validation(:validates_acceptance_of)
         )
-      assert_validator_class 'acceptance-accept_1', validators
+      assert_validator_class 'acceptance-accept_1_false', validators
     end
 
     test "with :accept" do
       validators = ::ValidatiousOnRails::ModelValidations.acceptance_of(
           validation(:validates_acceptance_of, :accept => true)
         )
-      assert_validator_class 'acceptance-accept_true', validators
+      assert_validator_class 'acceptance-accept_true_false', validators
     end
   end
 
@@ -67,7 +67,7 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
     validators = ::ValidatiousOnRails::ModelValidations.exclusion_of(
         validation(:validates_exclusion_of, :in => values)
       )
-    assert_validator_class /^exclusion-in-(\d+)/, validators
+    assert_validator_class /^exclusion-in_(\d+)/, validators
     assert_match /#{values.to_json}/, validators.first.fn
   end
 
@@ -76,7 +76,7 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
     validators = ::ValidatiousOnRails::ModelValidations.format_of(
         validation(:validates_format_of, :with => pattern)
       )
-    assert_validator_class /^format-with-(\d+)/, validators
+    assert_validator_class /^format-with_(\d+)_false_false/, validators
     assert_match /#{pattern.inspect[1,-1]}/, validators.first.fn
   end
 
@@ -85,7 +85,7 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
     validators = ::ValidatiousOnRails::ModelValidations.inclusion_of(
         validation(:validates_inclusion_of, :in => values)
       )
-    assert_validator_class /^inclusion-in-(\d+)/, validators
+    assert_validator_class /^inclusion-in_(\d+)_false_false/, validators
     assert_match /#{values.to_json}/, validators.first.fn
   end
 
@@ -95,42 +95,42 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
       validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :is => 2)
         )
-      assert_validator_class 'length-is_2', validators
+      assert_validator_class 'length-is_2_false_false', validators
     end
 
     test "with :in" do
       validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :in => 2..10)
         )
-      assert_validator_class 'length-minimum_2 length-maximum_10', validators
+      assert_validator_class 'length-minimum_2_false_false length-maximum_10_false_false', validators
     end
 
     test "with :within" do
       validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :within => 2..10)
         )
-      assert_validator_class 'length-minimum_2 length-maximum_10', validators
+      assert_validator_class 'length-minimum_2_false_false length-maximum_10_false_false', validators
     end
 
     test "with :minimum" do
       validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :minimum => 2)
         )
-      assert_validator_class 'length-minimum_2', validators
+      assert_validator_class 'length-minimum_2_false_false', validators
     end
 
     test "with :maximum" do
       validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :maximum => 10)
         )
-      assert_validator_class 'length-maximum_10', validators
+      assert_validator_class 'length-maximum_10_false_false', validators
     end
 
     test "with :minimum + :maximum" do
       validators = ::ValidatiousOnRails::ModelValidations.length_of(
           validation(:validates_length_of, :minimum => 2, :maximum => 10)
         )
-      assert_validator_class 'length-minimum_2 length-maximum_10', validators
+      assert_validator_class 'length-minimum_2_false_false length-maximum_10_false_false', validators
     end
   end
 
@@ -141,14 +141,14 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
         validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
             validation(:validates_numericality_of, :even => false, :odd => true)
           )
-        assert_validator_class 'numericality-odd', validators
+        assert_validator_class 'numericality-odd_false', validators
       end
 
       test "with :even only" do
         validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
             validation(:validates_numericality_of, :even => true, :odd => false)
           )
-        assert_validator_class 'numericality-even', validators
+        assert_validator_class 'numericality-even_false', validators
       end
 
       test "with :odd and :even" do
@@ -171,42 +171,42 @@ class ModelValidationsTest < ::ActiveSupport::TestCase
           validation(:validates_numericality_of, :only_integer => true)
         )
       # Alt. more generic idea: assert_equal 'numericality-precision_0', validator.to_class
-      assert_validator_class 'numericality-only_integer', validators
+      assert_validator_class 'numericality-only-integer_false', validators
     end
 
     test "with :greater_than" do
       validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :greater_than => 2)
         )
-      assert_validator_class 'numericality-greater-than_2', validators
+      assert_validator_class 'numericality-greater-than_2_false', validators
     end
 
     test "with :greater_than_or_equal_to" do
       validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :greater_than_or_equal_to => 2)
         )
-      assert_validator_class 'numericality-greater-than-or-equal-to_2', validators
+      assert_validator_class 'numericality-greater-than-or-equal-to_2_false', validators
     end
 
     test "with :equal_to" do
       validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :equal_to => 2)
         )
-      assert_validator_class 'numericality-equal-to_2', validators
+      assert_validator_class 'numericality-equal-to_2_false', validators
     end
 
     test "with :less_than" do
       validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :less_than => 10)
         )
-      assert_validator_class 'numericality-less-than_10', validators
+      assert_validator_class 'numericality-less-than_10_false', validators
     end
 
     test "with :less_than_or_equal_to" do
       validators = ::ValidatiousOnRails::ModelValidations.numericality_of(
           validation(:validates_numericality_of, :less_than_or_equal_to => 10)
         )
-      assert_validator_class 'numericality-less-than-or-equal-to_10', validators
+      assert_validator_class 'numericality-less-than-or-equal-to_10_false', validators
     end
   end