remarkable_activemodel 4.0.0.alpha1

data/lib/remarkable_activemodel/matchers/validate_numericality_of_matcher.rb

@@ -0,0 +1,188 @@
+module Remarkable
+  module ActiveModel
+    module Matchers
+      class ValidateNumericalityOfMatcher < Remarkable::ActiveModel::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :equal_to, :greater_than_or_equal_to, :greater_than,
+                 :less_than_or_equal_to, :less_than, :message
+
+        optional :only_integer, :odd, :even, :allow_nil, :allow_blank, :default => true
+
+        collection_assertions :only_numeric_values?, :allow_blank?, :allow_nil?,
+                              :only_integer?, :only_odd?, :only_even?, :equals_to?,
+                              :less_than_minimum?, :more_than_maximum?
+
+        # Before assertions, we rearrange the values.
+        #
+        # Notice that :less_than gives a maximum value while :more_than given
+        # a minimum value. While :equal_to generate both.
+        #
+        before_assert do
+          @maximum_values = {}
+          @minimum_values = {}
+
+          if value = @options[:equal_to]
+            @maximum_values[:equal_to] = value
+            @minimum_values[:equal_to] = value
+          elsif value = @options[:less_than]
+            @maximum_values[:less_than] = value - 1
+          elsif value = @options[:greater_than]
+            @minimum_values[:greater_than] = value + 1
+          elsif value = @options[:less_than_or_equal_to]
+            @maximum_values[:less_than_or_equal_to] = value
+          elsif value = @options[:greater_than_or_equal_to]
+            @minimum_values[:greater_than_or_equal_to] = value
+          end
+        end
+
+        private
+
+          def allow_nil?
+            super(default_message_for(:not_a_number))
+          end
+
+          def allow_blank?
+            super(default_message_for(:not_a_number))
+          end
+
+          def only_numeric_values?
+            bad?("abcd", default_message_for(:not_a_number))
+          end
+
+          def only_integer?
+            assert_bad_or_good_if_key(:only_integer, valid_value_for_test.to_f, default_message_for(:not_a_number))
+          end
+
+          # In ActiveModel, when we supply :even, does not matter the value, it
+          # considers that should even values should be accepted.
+          #
+          def only_even?
+            return true unless @options[:even]
+            bad?(even_valid_value_for_test + 1, default_message_for(:even))
+          end
+
+          # In ActiveModel, when we supply :odd, does not matter the value, it
+          # considers that should odd values should be accepted.
+          #
+          def only_odd?
+            return true unless @options[:odd]
+            bad?(even_valid_value_for_test, default_message_for(:odd))
+          end
+
+          # Check equal_to for all registered values.
+          #
+          def equals_to?
+            values = {}
+            @maximum_values.each { |k, v| values[k] = v }
+            @minimum_values.each { |k, v| values[k] = v }
+
+            values.each do |key, value|
+              return false, :count => value unless good?(value, default_message_for(key))
+            end
+            true
+          end
+
+          # Check more_than_maximum? for equal_to, less_than and
+          # less_than_or_equal_to options.
+          #
+          def more_than_maximum?
+            @maximum_values.each do |key, value|
+              return false, :count => value unless bad?(value + 1, default_message_for(key))
+            end
+            true
+          end
+
+          # Check less_than_minimum? for equal_to, more_than and
+          # more_than_or_equal_to options.
+          #
+          def less_than_minimum?
+            @minimum_values.each do |key, value|
+              return false, :count => value unless bad?(value - 1, default_message_for(key))
+            end
+            true
+          end
+
+          # Returns a valid value for test.
+          #
+          def valid_value_for_test
+            value = @options[:equal_to] || @options[:less_than_or_equal_to] || @options[:greater_than_or_equal_to]
+
+            value ||= @options[:less_than]    - 1 if @options[:less_than]
+            value ||= @options[:greater_than] + 1 if @options[:greater_than]
+
+            value ||= 10
+
+            if @options[:even]
+              value = (value / 2) * 2
+            elsif @options[:odd]
+              value = ((value / 2) * 2) + 1
+            end
+
+            value
+          end
+
+          # Returns a valid even value for test.
+          # The method valid_value_for_test checks for :even option but does not
+          # return necessarily an even value
+          #
+          def even_valid_value_for_test
+            (valid_value_for_test / 2) * 2
+          end
+
+          # Returns the default message for each key (:odd, :even, :equal_to, ...).
+          # If the user provided a message, we use it, otherwise we should use
+          # the given key as message.
+          #
+          # For example, a default_message_for(:odd), if none is provided, will be
+          # :odd. So we have create :odd_message in the options hash, that when
+          # called later, will return :odd.
+          #
+          def default_message_for(key)
+            if @options[:message]
+              :message
+            else
+              @options[:"#{key}_message"] = key
+              :"#{key}_message"
+            end
+          end
+      end
+
+      # Ensures that the given attributes accepts only numbers.
+      #
+      # == Options
+      #
+      # * <tt>:only_integer</tt> - when supplied, checks if it accepts only integers or not
+      # * <tt>:odd</tt> - when supplied, checks if it accepts only odd values or not
+      # * <tt>:even</tt> - when supplied, checks if it accepts only even values or not
+      # * <tt>:equal_to</tt> - when supplied, checks if attributes are only valid when equal to given value
+      # * <tt>:less_than</tt> - when supplied, checks if attributes are only valid when less than given value
+      # * <tt>:greater_than</tt> - when supplied, checks if attributes are only valid when greater than given value
+      # * <tt>:less_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when less than or equal to given value
+      # * <tt>:greater_than_or_equal_to</tt> - when supplied, checks if attributes are only valid when greater than or equal to given value
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors[:attribute]</tt>.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
+      #
+      # == Examples
+      #
+      #   it { should validate_numericality_of(:age).odd }
+      #   it { should validate_numericality_of(:age).even }
+      #   it { should validate_numericality_of(:age).only_integer }
+      #   it { should validate_numericality_of(:age, :odd => true) }
+      #   it { should validate_numericality_of(:age, :even => true) }
+      #
+      #   should_validate_numericality_of :age, :price
+      #   should_validate_numericality_of :price, :only_integer => false, :greater_than => 10
+      #
+      #   should_validate_numericality_of :price do |m|
+      #     m.only_integer = false
+      #     m.greater_than = 10
+      #   end
+      #
+      def validate_numericality_of(*attributes, &block)
+        ValidateNumericalityOfMatcher.new(*attributes, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable_activemodel/matchers/validate_presence_of_matcher.rb

@@ -0,0 +1,91 @@
+module Remarkable
+  module ActiveModel
+    # Holds ActiveModel matchers.
+    #
+    # == Validations matchers
+    #
+    # Remarkable supports all ActiveModel validations, and the only options
+    # not supported in those matchers is the :on options. So whenever you have
+    # to test that a validation runs on update, you have to do reproduce the
+    # state in your tests:
+    #
+    #   describe Project do
+    #     describe 'validations on create' do
+    #       should_validate_presence_of :title
+    #     end
+    #
+    #     describe 'validations on update' do
+    #       subject { Post.create!(@valid_attributes) }
+    #       should_validate_presence_of :updated_at
+    #     end
+    #   end
+    #
+    # Another behavior in validations is the :message option. Whenever you change
+    # the message in your model, it must be given in your tests too:
+    #
+    #   class Post < ActiveModel::Base
+    #     validates_presence_of :title, :message => 'must be filled'
+    #   end
+    #
+    #   describe Post do
+    #     should_validate_presence_of :title #=> fails
+    #     should_validate_presence_of :title, :message => 'must be filled'
+    #   end
+    #
+    # However, if you change the title using the I18n API, you don't need to
+    # specify the message in your tests, because it's retrieved properly.
+    #
+    module Matchers
+      class ValidatePresenceOfMatcher < Remarkable::ActiveModel::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+        optional  :message
+
+        collection_assertions :allow_nil?
+        default_options :message => :blank
+
+        protected
+
+          def allow_nil?
+            bad?(blank_value, :message)
+          end
+
+          def blank_value
+            collection? ? [] : nil
+          end
+
+          def collection?
+            if reflection = find_reflection
+              [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
+            else
+              false
+            end
+          end
+
+        private
+
+          def find_reflection
+            if subject_class.respond_to?(:reflect_on_association)
+              subject_class.reflect_on_association(@attribute)
+            end
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not present.
+      #
+      # == Options
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors[:attribute]</tt>.
+      #   Regexp, string or symbol. Default = <tt>I18n.translate('activerecord.errors.messages.blank')</tt>
+      #
+      # == Examples
+      #
+      #   should_validate_presence_of :name, :phone_number
+      #   it { should validate_presence_of(:name, :phone_number) }
+      #
+      def validate_presence_of(*args, &block)
+        ValidatePresenceOfMatcher.new(*args, &block).spec(self)
+      end
+    end
+  end
+end

data/locale/en.yml

@@ -0,0 +1,116 @@
+en:
+  remarkable:
+    active_model:
+      describe:
+        each: "{{key}} is {{value}}"
+        prepend: "when "
+        connector: " and "
+      expectations:
+        allow_nil: "{{subject_name}} to {{not}}allow nil values for {{attribute}}"
+        allow_blank: "{{subject_name}} to {{not}}allow blank values for {{attribute}}"
+      optionals:
+        allow_nil:
+          positive: "allowing nil values"
+          negative: "not allowing nil values"
+        allow_blank:
+          positive: "allowing blank values"
+          negative: "not allowing blank values"
+
+      allow_values_for:
+        description: "allow {{in}} as values for {{attributes}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+
+      validate_acceptance_of:
+        description: "require {{attributes}} to be accepted"
+        expectations:
+          requires_acceptance: "{{subject_name}} to be invalid if {{attribute}} is not accepted"
+          accept_is_valid: "{{subject_name}} to be valid when {{attribute}} is accepted with value {{accept}}"
+        optionals:
+          accept:
+            positive: "with value {{inspect}}"
+
+      validate_confirmation_of:
+        description: "require {{attributes}} to be confirmed"
+        expectations:
+          responds_to_confirmation: "{{subject_name}} instance responds to {{attribute}}_confirmation"
+          confirms: "{{subject_name}} to be valid only when {{attribute}} is confirmed"
+
+      validate_exclusion_of:
+        description: "ensure exclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+
+      validate_inclusion_of:
+        description: "ensure inclusion of {{attributes}} in {{in}}"
+        expectations:
+          is_valid: "{{subject_name}} to be valid when {{attribute}} is set to {{value}}"
+          is_invalid: "{{subject_name}} to be invalid when {{attribute}} is set to {{value}}"
+
+      validate_length_of:
+        description: "ensure length of {{attributes}}"
+        expectations:
+          less_than_min_length: "{{subject_name}} to be invalid when {{attribute}} length is less than {{minimum}} characters"
+          exactly_min_length: "{{subject_name}} to be valid when {{attribute}} length is {{minimum}} characters"
+          more_than_max_length: "{{subject_name}} to be invalid when {{attribute}} length is more than {{maximum}} characters"
+          exactly_max_length: "{{subject_name}} to be valid when {{attribute}} length is {{maximum}} characters"
+        optionals:
+          within:
+            positive: "is within {{inspect}} characters"
+          maximum:
+            positive: "is maximum {{inspect}} characters"
+          minimum:
+            positive: "is minimum {{inspect}} characters"
+          is:
+            positive: "is equal to {{inspect}} characters"
+          with_kind_of:
+            positive: "with kind of {{value}}"
+
+      validate_numericality_of:
+        description: "ensure numericality of {{attributes}}"
+        expectations:
+          only_numeric_values: "{{subject_name}} to allow only numeric values for {{attribute}}"
+          only_integer: "{{subject_name}} to {{not}}allow only integer values for {{attribute}}"
+          only_even: "{{subject_name}} to allow only even values for {{attribute}}"
+          only_odd: "{{subject_name}} to allow only odd values for {{attribute}}"
+          equals_to: "{{subject_name}} to be valid only when {{attribute}} is equal to {{count}}"
+          more_than_maximum: "{{subject_name}} to be invalid when {{attribute}} is greater than {{count}}"
+          less_than_minimum: "{{subject_name}} to be invalid when {{attribute}} is less than {{count}}"
+        optionals:
+          only_integer:
+            positive: "allowing only integer values"
+          odd:
+            positive: "allowing only odd values"
+          even:
+            positive: "allowing only even values"
+          equal_to:
+            positive: "is equal to {{inspect}}"
+          less_than:
+            positive: "is less than {{inspect}}"
+          greater_than:
+            positive: "is greater than {{inspect}}"
+          less_than_or_equal_to:
+            positive: "is less than or equal to {{inspect}}"
+          greater_than_or_equal_to:
+            positive: "is greater than or equal to {{inspect}}"
+
+      validate_presence_of:
+        description: "require {{attributes}} to be set"
+        expectations:
+          allow_nil: "{{subject_name}} to require {{attribute}} to be set"
+
+      validate_uniqueness_of:
+        description: "require unique values for {{attributes}}"
+        expectations:
+          responds_to_scope: "{{subject_name}} instance responds to {{method}}"
+          is_unique: "{{subject_name}} to require unique values for {{attribute}}"
+          case_sensitive: "{{subject_name}} to {{not}}be case sensitive on {{attribute}} validation"
+          valid_with_new_scope: "{{subject_name}} to be valid when {{attribute}} scope ({{method}}) change"
+        optionals:
+          scope:
+            positive: "scoped to {{sentence}}"
+          case_sensitive:
+            positive: "case sensitive"
+            negative: "case insensitive"
+

data/remarkable_activemodel.gemspec

@@ -0,0 +1,61 @@
+# 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{remarkable_activemodel}
+  s.version = "4.0.0.alpha1"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ho-Sheng Hsiao", "Carlos Brando", "Jos\303\251 Valim", "Diego Carrion"]
+  s.date = %q{2010-04-22}
+  s.description = %q{Remarkable ActiveModel: collection of matchers and macros with I18n for ActiveModel}
+  s.email = ["hosh@sparkfly.com", "eduardobrando@gmail.com", "jose.valim@gmail.com", "dc.rec1@gmail.com"]
+  s.extra_rdoc_files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README"
+  ]
+  s.files = [
+    "CHANGELOG",
+     "LICENSE",
+     "README",
+     "lib/remarkable_activemodel.rb",
+     "lib/remarkable_activemodel/base.rb",
+     "lib/remarkable_activemodel/matchers/allow_values_for_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_acceptance_of_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_confirmation_of_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_exclusion_of_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_inclusion_of_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_length_of_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_numericality_of_matcher.rb",
+     "lib/remarkable_activemodel/matchers/validate_presence_of_matcher.rb",
+     "locale/en.yml",
+     "remarkable_activemodel.gemspec",
+     "remarkable_activerecord.gemspec"
+  ]
+  s.homepage = %q{http://github.com/carlosbrando/remarkable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{remarkable}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Remarkable ActiveModel: collection of matchers and macros with I18n for ActiveModel}
+
+  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<rspec>, [">= 2.0.0.alpha7"])
+      s.add_runtime_dependency(%q<remarkable>, ["~> 4.0.0.alpha1"])
+    else
+      s.add_dependency(%q<rspec>, [">= 2.0.0.alpha7"])
+      s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha1"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 2.0.0.alpha7"])
+    s.add_dependency(%q<remarkable>, ["~> 4.0.0.alpha1"])
+  end
+end
+