remarkable_mongo 0.1.2

data/lib/remarkable/mongo_mapper/human_names.rb

@@ -0,0 +1,37 @@
+if defined?(Spec)
+  module Spec #:nodoc:
+    module Example #:nodoc:
+      module ExampleGroupMethods #:nodoc:
+
+        # This allows "describe User" to use the I18n human name of User.
+        #
+        def self.build_description_with_i18n(*args)
+          args.inject("") do |description, arg|
+            arg = if arg.respond_to?(:human_name)
+              arg.human_name(:locale => Remarkable.locale)
+            else
+              arg.to_s
+            end
+
+            description << " " unless (description == "" || arg =~ /^(\s|\.|#)/)
+            description << arg
+          end
+        end
+
+        # This is for rspec <= 1.1.12.
+        #
+        def self.description_text(*args)
+          self.build_description_with_i18n(*args)
+        end
+
+        # This is for rspec >= 1.2.0.
+        #
+        def self.build_description_from(*args)
+          text = ExampleGroupMethods.build_description_with_i18n(*args)
+          text == "" ? nil : text
+        end
+
+      end
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/matchers/allow_values_for_matcher.rb

@@ -0,0 +1,86 @@
+module Remarkable
+  module MongoMapper
+    module Matchers
+      class AllowValuesForMatcher < Remarkable::MongoMapper::Base #:nodoc:
+        include Remarkable::Negative
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :message
+        optional :in, :splat => true
+        optional :allow_nil, :allow_blank, :default => true
+
+        collection_assertions :is_valid?, :is_invalid?, :allow_nil?, :allow_blank?
+
+        default_options :message => "is invalid"
+
+        before_assert do
+          first_value = @options[:in].is_a?(Array) ? @options[:in].first : @options[:in]
+          @in_range = first_value.is_a?(Range)
+
+          @options[:in] = if @in_range
+            first_value.to_a[0,2] + first_value.to_a[-2,2]
+          else
+            [*@options[:in]].compact
+          end
+
+          @options[:in].uniq!
+        end
+
+        protected
+
+          def is_valid?
+            assert_collection :value, valid_values do |value|
+              good?(value)
+            end
+          end
+
+          def is_invalid?
+            assert_collection :value, invalid_values do |value|
+              bad?(value)
+            end
+          end
+
+          def valid_values
+            @options[:in]
+          end
+
+          def invalid_values
+            []
+          end
+
+          def interpolation_options
+            options = if @in_range
+              { :in => (@options[:in].first..@options[:in].last).inspect }
+            elsif @options[:in].is_a?(Array)
+              { :in => array_to_sentence(@options[:in], true, '[]') }
+            else
+              { :in => @options[:in].inspect }
+            end
+
+            options.merge!(:behavior => @behavior.to_s)
+          end
+
+      end
+
+      # Ensures that the attribute can be set to the given values.
+      #
+      # == Options
+      #
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
+      #
+      # == Examples
+      #
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      #   it { should allow_values_for(:isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0") }
+      #
+      def allow_values_for(attribute, *args, &block)
+        options = args.extract_options!
+        AllowValuesForMatcher.new(attribute, options.merge!(:in => args), &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/matchers/association_matcher.rb

@@ -0,0 +1,105 @@
+module Remarkable
+  module MongoMapper
+    module Matchers
+      class AssociationMatcher < Remarkable::MongoMapper::Base
+        arguments :type, :collection => :associations, :as => :association
+        
+        optionals :class_name
+
+        collection_assertions :association_exists?, :type_matches?, :klass_exists?, :options_match?
+
+        protected
+
+          def association_exists?
+            reflection
+          end
+
+          def type_matches?
+            reflection.type == @type
+          end
+          
+          def klass_exists?
+            return true if @options[:polymorphic]
+            reflection.klass rescue nil
+          end
+          
+          def options_match?
+            actual_options = {}
+
+            @options.keys.each do |key|
+              method = :"reflection_#{key}"
+
+              @options[key]       = @options[key].to_s
+              actual_options[key] = (respond_to?(method, true) ? send(method) : reflection.options[key]).to_s
+            end
+
+            return @options == actual_options, :actual => actual_options.inspect
+          end
+        
+        private
+          
+          def reflection
+            @reflection ||= subject_class.associations[@association]
+          end
+          
+          def interpolation_options
+            options = {}
+            options[:type] = Remarkable.t(@type, :scope => matcher_i18n_scope, :default => @type.to_s.gsub("_", ""))
+            options[:options] = @options.inspect
+            
+            if @subject && reflection
+              options.merge!(
+                :actual_type => Remarkable.t(reflection.type, :scope => matcher_i18n_scope, :default => reflection.type.to_s)
+              )
+            end
+            
+            options
+          end
+
+      end
+
+      # Ensures that the many relationship exists. Will also test that the
+      # associated table has the required columns.
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt> - the expected associted class name.
+      # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
+      #   When true it also checks for the association_type column in the subject table.
+      #
+      # == Examples
+      #
+      #   should_have_many :addresses
+      #   should_have_many :users, :class_name => 'Person'
+      #
+      #   it { should have_many(:addresses) }
+      #   it { should have_many(:users, :class_name => 'Person') }
+      #
+      def have_many(*associations, &block)
+        AssociationMatcher.new(:many, *associations, &block).spec(self)
+      end
+      
+      # Ensures that the many relationship exists. Will also test that the
+      # associated table has the required columns.
+      #
+      # == Options
+      #
+      # * <tt>:class_name</tt> - the expected associted class name.
+      # * <tt>:polymorphic</tt> - if the association should be polymorphic or not.
+      #   When true it also checks for the association_type column in the subject table.
+      #
+      # == Examples
+      #
+      #   should_belong_to :user
+      #   should_belong_to :user, :class_name => 'Person'
+      #
+      #   it { should belong_to(:user) }
+      #   it { should belong_to(:user, :class_name => 'Person') }
+      #
+      def belong_to(*associations, &block)
+        AssociationMatcher.new(:belongs_to, *associations, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/matchers/have_key_matcher.rb

@@ -0,0 +1,38 @@
+module Remarkable
+  module MongoMapper
+    module Matchers
+      class HaveKeyMatcher < Remarkable::MongoMapper::Base
+        
+        arguments :type, :collection => :attributes, :as => :attribute
+        
+        collection_assertions :has_key?
+        
+        # before_assert do
+        #   @type = @options[:type]
+        # end
+
+        protected
+
+          def has_key?
+            @subject.respond_to?(@attribute) && @subject.class.keys[@attribute] == ::MongoMapper::Key.new(@attribute, @type)
+          end
+
+      end
+      
+      # Ensures that a key of the database actually exists.
+      #
+      # == Examples
+      #
+      #   should_have_key :name, String
+      #
+      #   it { should have_key(:name, String) }
+      #   it { should have_keys(:name, :phone_number, String) }
+      #
+      def have_key(*args, &block)
+        HaveKeyMatcher.new(args.pop, *args, &block).spec(self)
+      end
+      alias :have_keys :have_key
+
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/matchers/validate_confirmation_of_matcher.rb

@@ -0,0 +1,44 @@
+module Remarkable
+  module MongoMapper
+    module Matchers
+      class ValidateConfirmationOfMatcher < Remarkable::MongoMapper::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :message
+        collection_assertions :responds_to_confirmation?, :confirms?
+
+        default_options :message => "doesn't match confirmation"
+
+        protected
+
+          def responds_to_confirmation?
+            @subject.respond_to?(:"#{@attribute}_confirmation=")
+          end
+
+          def confirms?
+            @subject.send(:"#{@attribute}_confirmation=", 'something')
+            bad?('different')
+          end
+
+      end
+
+      # Ensures that the model cannot be saved if one of the attributes is not confirmed.
+      #
+      # == Options
+      #
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol.  Default = "doesn't match confirmation"
+      #
+      # == Examples
+      #
+      #   should_validate_confirmation_of :email, :password
+      #
+      #   it { should validate_confirmation_of(:email, :password) }
+      #
+      def validate_confirmation_of(*attributes, &block)
+        ValidateConfirmationOfMatcher.new(*attributes, &block).spec(self)
+      end
+
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/matchers/validate_length_of_matcher.rb

@@ -0,0 +1,106 @@
+module Remarkable
+  module MongoMapper
+    module Matchers
+      class ValidateLengthOfMatcher < Remarkable::MongoMapper::Base #:nodoc:
+        arguments :collection => :attributes, :as => :attribute
+
+        optional :within, :minimum, :maximum, :is
+        optional :allow_nil, :allow_blank, :default => true
+        optional :message
+        
+        default_options :message => "is invalid"
+
+        collection_assertions :less_than_min_length?, :exactly_min_length?,
+                              :more_than_max_length?, :exactly_max_length?,
+                              :allow_nil?, :allow_blank?
+
+        before_assert do
+          if @options[:is]
+            @min_value, @max_value = @options[:is], @options[:is]
+          elsif @options[:within]
+            @min_value, @max_value = @options[:within].first, @options[:within].last
+          elsif @options[:maximum]
+            @min_value, @max_value = nil, @options[:maximum]
+          elsif @options[:minimum]
+            @min_value, @max_value = @options[:minimum], nil
+          end
+        end
+
+        protected
+          def allow_nil?
+            super(default_message_for(:too_short))
+          end
+
+          def allow_blank?
+            super(default_message_for(:too_short))
+          end
+
+          def less_than_min_length?
+            @min_value.nil? || @min_value <= 1 || bad?(@min_value - 1, default_message_for(:too_short))
+          end
+
+          def exactly_min_length?
+            @min_value.nil? || @min_value <= 0 || good?(@min_value, default_message_for(:too_short))
+          end
+
+          def more_than_max_length?
+            @max_value.nil? || bad?(@max_value + 1, default_message_for(:too_long))
+          end
+
+          def exactly_max_length?
+            @max_value.nil? || @min_value == @max_value || good?(@max_value, default_message_for(:too_long))
+          end
+
+          def interpolation_options
+            { :minimum => @min_value, :maximum => @max_value }
+          end
+
+          # Returns the default message for the validation type.
+          # If user supplied :message, it will return it. Otherwise it will return
+          # wrong_length on :is validation and :too_short or :too_long in the other
+          # types.
+          #
+          def default_message_for(validation_type)
+            return :message if @options[:message]
+          end
+      end
+
+      # Validates the length of the given attributes. You have also to supply
+      # one of the following options: minimum, maximum, is or within.
+      #
+      # Note: this method is also aliased as <tt>validate_size_of</tt>.
+      #
+      # == Options
+      #
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute.
+      # * <tt>:allow_nil</tt> - when supplied, validates if it allows nil or not.
+      # * <tt>:allow_blank</tt> - when supplied, validates if it allows blank or not.
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp, string or symbol. Default = "is invalid"</tt>
+      #
+      # == Examples
+      #
+      #   it { should validate_length_of(:password).within(6..20) }
+      #   it { should validate_length_of(:password).maximum(20) }
+      #   it { should validate_length_of(:password).minimum(6) }
+      #   it { should validate_length_of(:age).is(18) }
+      #
+      #   should_validate_length_of :password, :within => 6..20
+      #   should_validate_length_of :password, :maximum => 20
+      #   should_validate_length_of :password, :minimum => 6
+      #   should_validate_length_of :age, :is => 18
+      #
+      #   should_validate_length_of :password do |m|
+      #     m.minimum 6
+      #     m.maximum 20
+      #   end
+      #
+      def validate_length_of(*attributes, &block)
+        ValidateLengthOfMatcher.new(*attributes, &block).spec(self)
+      end
+    end
+  end
+end

data/lib/remarkable/mongo_mapper/matchers/validate_presence_of_matcher.rb

@@ -0,0 +1,37 @@
+module Remarkable
+  module MongoMapper
+    module Matchers
+      class ValidatePresenceOfMatcher < Remarkable::MongoMapper::Base
+        arguments :collection => :attributes, :as => :attribute
+        optional  :message
+
+        collection_assertions :allow_nil?
+        default_options :message => "can't be empty"
+
+        protected
+
+          def allow_nil?
+            bad?(nil, :message)
+          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.on(:attribute)</tt>.
+      #   Regexp, string or symbol. Default = "can't be empty"
+      #
+      # == 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