carlosbrando-remarkable 0.0.99 → 2.2.1

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

@@ -1,97 +0,0 @@
-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

@@ -1,134 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

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

@@ -1,74 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveClassMethods
-        include Remarkable::Private
-        
-        def initialize(*methods)
-          get_options!(methods)
-          @methods = methods
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @methods.each do |method|
-              unless klass.respond_to?(method)
-                fail "#{klass.name} does not have class method #{method}"
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "respond to class method #{pretty_method_names}"
-        end
-
-        def failure_message
-          @failure_message || "expected that #{pretty_method_names} #{@methods.size > 1 ? "is" : "are"} defined on #{@klass.name}, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected that #{pretty_method_names} #{@methods.size > 1 ? "aren't" : "isn't"} defined on #{@klass.name}, but it did"
-        end
-
-        def pretty_method_names
-          @methods.map { |m| "##{m}" }.to_sentence
-        end
-      end
-
-      # Ensure that the given class methods are defined on the model.
-      #
-      #   it { User.should have_class_methods(:find, :destroy) }
-      #
-      def have_class_methods(*methods)
-        Remarkable::Syntax::RSpec::HaveClassMethods.new(*methods)
-      end
-    end
-
-    module Shoulda
-      # Ensure that the given class methods are defined on the model.
-      #
-      #   should_have_class_methods :find, :destroy
-      #
-      def should_have_class_methods(*methods)
-        get_options!(methods)
-        klass = model_class
-        methods.each do |method|
-          it "should respond to class method ##{method}" do
-            unless klass.respond_to?(method)
-              fail_with "#{klass.name} does not have class method #{method}"
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,74 +0,0 @@
-module Remarkable
-  module Syntax
-
-    module RSpec
-      class HaveInstanceMethods
-        include Remarkable::Private
-        
-        def initialize(*methods)
-          get_options!(methods)
-          @methods = methods
-        end
-
-        def matches?(klass)
-          @klass = klass
-
-          begin
-            @methods.each do |method|
-              unless klass.new.respond_to?(method)
-                fail "#{klass.name} does not have instance method #{method}"
-              end
-            end
-
-            true
-          rescue Exception => e
-            false
-          end
-        end
-
-        def description
-          "respond to instance method #{pretty_method_names}"
-        end
-
-        def failure_message
-          @failure_message || "expected that #{pretty_method_names} #{@methods.size > 1 ? "is" : "are"} defined on #{@klass.name}, but it didn't"
-        end
-
-        def negative_failure_message
-          "expected that #{pretty_method_names} #{@methods.size > 1 ? "aren't" : "isn't"} defined on #{@klass.name}, but it did"
-        end
-
-        def pretty_method_names
-          @methods.map { |m| "##{m}" }.to_sentence
-        end
-      end
-
-      # Ensure that the given instance methods are defined on the model.
-      #
-      #   it { User.should have_instance_methods(:email, :name, :name=) }
-      #
-      def have_instance_methods(*methods)
-        Remarkable::Syntax::RSpec::HaveInstanceMethods.new(*methods)
-      end
-    end
-
-    module Shoulda
-      # Ensure that the given instance methods are defined on the model.
-      #
-      #   should_have_instance_methods :email, :name, :name=
-      #
-      def should_have_instance_methods(*methods)
-        get_options!(methods)
-        klass = model_class
-        methods.each do |method|
-          it "should respond to instance method ##{method}" do
-            unless klass.new.respond_to?(method)
-              fail_with "#{klass.name} does not have instance method #{method}"
-            end
-          end
-        end
-      end
-    end
-
-  end
-end