carlosbrando-remarkable 0.0.99

data/lib/remarkable/active_record/macros/validations/ensure_length_at_least.rb

@@ -0,0 +1,97 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class EnsureLengthAtLeast
+        include Remarkable::Private
+        
+        def initialize(attribute, min_length, opts)
+          @attribute  = attribute
+          @min_length = min_length
+          @opts       = opts
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            valid_value = "x" * (@min_length)
+            fail("not allow #{@attribute} to be at least #{@min_length} chars long") unless assert_good_value(klass, @attribute, valid_value, /is too short/)
+
+            if @min_length > 0
+              min_value = "x" * (@min_length - 1)
+              fail("allow #{@attribute} to be less than #{@min_length} chars long") unless assert_bad_value(klass, @attribute, min_value, /is too short/)
+            end
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "allow #{@attribute} to be at least #{@min_length} chars long"
+        end
+
+        def failure_message
+          @failure_message || "expected allow #{@attribute} to be at least #{@min_length} chars long, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected not allow #{@attribute} to be at least #{@min_length} chars long, but it did"
+        end
+      end
+
+      # Ensures that the length of the attribute is at least a certain length
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % min_length</tt>
+      #
+      # Example:
+      #   it { Tag.should ensure_length_at_least(:name, 3) }
+      #
+      def ensure_length_at_least(attribute, min_length, opts = {})
+        Remarkable::Syntax::RSpec::EnsureLengthAtLeast.new(attribute, min_length, opts)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the length of the attribute is at least a certain length
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % min_length</tt>
+      #
+      # Example:
+      #   should_ensure_length_at_least :name, 3
+      #
+      def should_ensure_length_at_least(attribute, min_length, opts = {})
+        short_message = get_options!([opts], :short_message)
+        short_message ||= default_error_message(:too_short, :count => min_length)
+
+        klass = model_class
+
+        if min_length > 0
+          min_value = "x" * (min_length - 1)
+          it "should not allow #{attribute} to be less than #{min_length} chars long" do
+            assert_bad_value(klass, attribute, min_value, short_message).should be_true
+          end
+        end
+        it "should allow #{attribute} to be at least #{min_length} chars long" do
+          valid_value = "x" * (min_length)
+          assert_good_value(klass, attribute, valid_value, short_message).should be_true
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/validations/ensure_length_in_range.rb

@@ -0,0 +1,134 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class EnsureLengthInRange
+        include Remarkable::Private
+        
+        def initialize(attribute, range, opts)
+          @min_length  = range.first
+          @max_length  = range.last
+          @same_length = (@min_length == @max_length)
+
+          @attribute = attribute
+          @range     = range
+          @opts      = opts
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            if @min_length > 0
+              min_value = "x" * @min_length
+              fail("not allow #{@attribute} to be exactly #{@min_length} chars long") unless assert_good_value(klass, @attribute, min_value, /is too short/)
+            end
+
+            unless @same_length
+              max_value = "x" * @max_length
+              fail("not allow #{@attribute} to be exactly #{@max_length} chars long") unless assert_good_value(klass, @attribute, max_value, /is too long/)
+            end
+
+            if @min_length > 0
+              min_value = "x" * (@min_length - 1)
+              fail("allow #{@attribute} to be less than #{@min_length} chars long") unless assert_bad_value(klass, @attribute, min_value, /is too short/)
+            end
+
+            max_value = "x" * (@max_length + 1)
+            fail("allow #{@attribute} to be more than #{@max_length} chars long") unless assert_bad_value(klass, @attribute, max_value, /is too long/)
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "ensure that the length of the #{@attribute} is in #{@range}"
+        end
+
+        def failure_message
+          @failure_message || "expected that the length of the #{@attribute} is in #{@range}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected that the length of the #{@attribute} isn't in #{@range}, but it did"
+        end
+      end
+
+      # Ensures that the length of the attribute is in the given range
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
+      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
+      #
+      # Example:
+      #   it { User.should ensure_length_in_range(:password, 6..20) }
+      #
+      def ensure_length_in_range(attribute, range, opts = {})
+        Remarkable::Syntax::RSpec::EnsureLengthInRange.new(attribute, range, opts)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the length of the attribute is in the given range
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
+      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
+      #
+      # Example:
+      #   should_ensure_length_in_range :password, (6..20)
+      #
+      def should_ensure_length_in_range(attribute, range, opts = {})
+        short_message, long_message = get_options!([opts], :short_message, :long_message)
+        short_message ||= default_error_message(:too_short, :count => range.first)
+        long_message  ||= default_error_message(:too_long, :count => range.last)
+
+        klass = model_class
+        min_length = range.first
+        max_length = range.last
+        same_length = (min_length == max_length)
+
+        if min_length > 0
+          it "should not allow #{attribute} to be less than #{min_length} chars long" do
+            min_value = "x" * (min_length - 1)
+            assert_bad_value(klass, attribute, min_value, short_message).should be_true
+          end
+        end
+
+        if min_length > 0
+          it "should allow #{attribute} to be exactly #{min_length} chars long" do
+            min_value = "x" * min_length
+            assert_good_value(klass, attribute, min_value, short_message).should be_true
+          end
+        end
+
+        it "should not allow #{attribute} to be more than #{max_length} chars long" do
+          max_value = "x" * (max_length + 1)
+          assert_bad_value(klass, attribute, max_value, long_message).should be_true
+        end
+
+        unless same_length
+          it "should allow #{attribute} to be exactly #{max_length} chars long" do
+            max_value = "x" * max_length
+            assert_good_value(klass, attribute, max_value, long_message).should be_true
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/validations/ensure_length_is.rb

@@ -0,0 +1,106 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class EnsureLengthIs
+        include Remarkable::Private
+        
+        def initialize(attribute, length, opts)
+          @message = get_options!([opts], :message)
+          @message ||= default_error_message(:wrong_length, :count => length)
+
+          @attribute = attribute
+          @length    = length
+          @opts      = opts
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            min_value = "x" * (@length - 1)
+            fail("allow #{@attribute} to be less than #{@length} chars long") unless assert_bad_value(klass, @attribute, min_value, @message)
+
+            max_value = "x" * (@length + 1)
+            fail("allow #{@attribute} to be greater than #{@length} chars long") unless assert_bad_value(klass, @attribute, max_value, @message)
+
+            valid_value = "x" * (@length)
+            fail("not allow #{@attribute} to be #{@length} chars long") unless assert_good_value(klass, @attribute, valid_value, @message)
+
+            true
+          rescue Exception => e
+            false
+          end
+
+        end
+
+        def description
+          "ensure that the length of the #{@attribute} is exactly #{@length} chars long"
+        end
+
+        def failure_message
+          @failure_message || "expected that the length of the #{@attribute} is exactly #{@length} chars long, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected that the length of the #{@attribute} isn't exactly #{@length} chars long, but it did"
+        end
+      end
+
+      # Ensures that the length of the attribute is exactly a certain length
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % length</tt>
+      #
+      # Example:
+      #   it { User.should ensure_length_is(:ssn, 9) }
+      #
+      def ensure_length_is(attribute, length, opts = {})
+        Remarkable::Syntax::RSpec::EnsureLengthIs.new(attribute, length, opts)
+      end
+    end
+
+    module Shoulda
+      # Ensures that the length of the attribute is exactly a certain length
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % length</tt>
+      #
+      # Example:
+      #   should_ensure_length_is :ssn, 9
+      #
+      def should_ensure_length_is(attribute, length, opts = {})
+        message = get_options!([opts], :message)
+        message ||= default_error_message(:wrong_length, :count => length)
+
+        klass = model_class
+
+        it "should not allow #{attribute} to be less than #{length} chars long" do
+          min_value = "x" * (length - 1)
+          assert_bad_value(klass, attribute, min_value, message).should be_true
+        end
+
+        it "should not allow #{attribute} to be greater than #{length} chars long" do
+          max_value = "x" * (length + 1)
+          assert_bad_value(klass, attribute, max_value, message).should be_true
+        end
+
+        it "should allow #{attribute} to be #{length} chars long" do
+          valid_value = "x" * (length)
+          assert_good_value(klass, attribute, valid_value, message).should be_true
+        end
+      end
+    end
+
+  end
+end

data/lib/remarkable/active_record/macros/validations/ensure_value_in_range.rb

@@ -0,0 +1,117 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      class EnsureValueInRange
+        include Remarkable::Private
+        
+        def initialize(attribute, range, opts = {})
+          @attribute = attribute
+          @range     = range
+          @opts      = opts
+
+          @min = range.first
+          @max = range.last
+
+          @low_message, @high_message = get_options!([@opts], :low_message, :high_message)
+          @low_message  ||= default_error_message(:inclusion)
+          @high_message ||= default_error_message(:inclusion)
+        end
+
+        def matches?(klass)
+          @klass = klass
+
+          begin
+            fail("allow #{@attribute} to be less than #{@min}") unless assert_bad_value(klass, @attribute, @min - 1, @low_message)
+            fail("not allow #{@attribute} to be #{@min}") unless assert_good_value(klass, @attribute, @min, @low_message)
+            fail("allow #{@attribute} to be more than #{@max}") unless assert_bad_value(klass, @attribute, @max + 1, @high_message)
+            fail("not allow #{@attribute} to be #{@max}") unless assert_good_value(klass, @attribute, @max, @high_message)
+
+            true
+          rescue Exception => e
+            false
+          end
+        end
+
+        def description
+          "ensure that the #{@attribute} is in #{@range}"
+        end
+
+        def failure_message
+          @failure_message || "expected that the #{@attribute} is in #{@range}, but it didn't"
+        end
+
+        def negative_failure_message
+          "expected that the #{@attribute} isn't in #{@range}, but it did"
+        end
+      end
+
+      # Ensure that the attribute is in the range specified
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      #
+      # Example:
+      #   it { User.should ensure_value_in_range(:age, 1..100) }
+      #
+      def ensure_value_in_range(attribute, range, opts = {})
+        Remarkable::Syntax::RSpec::EnsureValueInRange.new(attribute, range, opts)
+      end
+    end
+
+    module Shoulda
+      # Ensure that the attribute is in the range specified
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      #
+      # Example:
+      #   should_ensure_value_in_range :age, (0..100)
+      #
+      def should_ensure_value_in_range(attribute, range, opts = {})
+        low_message, high_message = get_options!([opts], :low_message, :high_message)
+        low_message  ||= default_error_message(:inclusion)
+        high_message ||= default_error_message(:inclusion)
+
+        klass = model_class
+        min   = range.first
+        max   = range.last
+
+        it "should not allow #{attribute} to be less than #{min}" do
+          v = min - 1
+          assert_bad_value(klass, attribute, v, low_message).should be_true
+        end
+
+        it "should allow #{attribute} to be #{min}" do
+          v = min
+          assert_good_value(klass, attribute, v, low_message).should be_true
+        end
+
+        it "should not allow #{attribute} to be more than #{max}" do
+          v = max + 1
+          assert_bad_value(klass, attribute, v, high_message).should be_true
+        end
+
+        it "should allow #{attribute} to be #{max}" do
+          v = max
+          assert_good_value(klass, attribute, v, high_message).should be_true
+        end
+      end
+    end
+
+  end
+end