yeastymobs-remarkable_mongomapper 0.0.1 → 0.1.0

data/README.md

@@ -1 +1,23 @@
-Remarkable matchers for [MongoMapper](http://github.com/jnunemaker/mongomapper).
+# Remarkable MongoMapper
+
+Remarkable matchers for [MongoMapper](http://github.com/jnunemaker/mongomapper).
+
+## Matchers
+
+<pre><code>
+it { should have_key(:name, String) }
+it { should have_keys(:name, :phone_number, String) }
+it { should validate_presence_of(:name, :phone_number, :message => "not there!") }
+it { should belong_to(:user, :class_name => 'Person') }
+it { should have_many(:users, :class_name => 'Person', :polymorphic => true) }
+</code></pre>
+
+## Contributions
+
+It is far from complete! It'd be very helpful to have some help.
+
+## Contributors
+
+* Nicolas Mérouze
+* Mathieu Fosse
+* Vincent Hellot

data/Rakefile

@@ -11,7 +11,7 @@ begin
     gem.authors = ["Nicolas Mérouze", "Vincent Hellot", "Mathieu Fosse"]
     
     gem.add_dependency('remarkable',  '~> 3.1.8')
-    gem.add_dependency('mongomapper', '~> 0.2.0')
+    gem.add_dependency('mongomapper', '~> 0.3.1')
   end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/remarkable_mongomapper/base.rb

@@ -1,6 +1,225 @@
 module Remarkable
   module MongoMapper
     class Base < Remarkable::Base
+      I18N_COLLECTION = [ :attributes, :associations ]
+
+      # Provides a way to send options to all MongoMapper matchers.
+      #
+      #   validates_presence_of(:name).with_options(:allow_nil => false)
+      #
+      # Is equivalent to:
+      #
+      #   validates_presence_of(:name, :allow_nil => false)
+      #
+      def with_options(opts={})
+        @options.merge!(opts)
+        self
+      end
+
+      protected
+
+        # Checks for the given key in @options, if it exists and it's true,
+        # tests that the value is bad, otherwise tests that the value is good.
+        #
+        # It accepts the key to check for, the value that is used for testing
+        # and an @options key where the message to search for is.
+        #
+        def assert_bad_or_good_if_key(key, value, message_key=:message) #:nodoc:
+          return positive? unless @options.key?(key)
+
+          if @options[key]
+            return bad?(value, message_key), :not => not_word
+          else
+            return good?(value, message_key), :not => ''
+          end
+        end
+
+        # Checks for the given key in @options, if it exists and it's true,
+        # tests that the value is good, otherwise tests that the value is bad.
+        #
+        # It accepts the key to check for, the value that is used for testing
+        # and an @options key where the message to search for is.
+        #
+        def assert_good_or_bad_if_key(key, value, message_key=:message) #:nodoc:
+          return positive? unless @options.key?(key)
+
+          if @options[key]
+            return good?(value, message_key), :not => ''
+          else
+            return bad?(value, message_key), :not => not_word
+          end
+        end
+
+        # Default allow_nil? validation. It accepts the message_key which is
+        # the key which contain the message in @options.
+        #
+        # It also gets an allow_nil message on remarkable.mongo_mapper.allow_nil
+        # to be used as default.
+        #
+        def allow_nil?(message_key=:message) #:nodoc:
+          assert_good_or_bad_if_key(:allow_nil, nil, message_key)
+        end
+
+        # Default allow_blank? validation. It accepts the message_key which is
+        # the key which contain the message in @options.
+        #
+        # It also gets an allow_blank message on remarkable.mongo_mapper.allow_blank
+        # to be used as default.
+        #
+        def allow_blank?(message_key=:message) #:nodoc:
+          assert_good_or_bad_if_key(:allow_blank, '', message_key)
+        end
+
+        # Shortcut for assert_good_value.
+        #
+        def good?(value, message_sym=:message) #:nodoc:
+          assert_good_value(@subject, @attribute, value, @options[message_sym])
+        end
+
+        # Shortcut for assert_bad_value.
+        #
+        def bad?(value, message_sym=:message) #:nodoc:
+          assert_bad_value(@subject, @attribute, value, @options[message_sym])
+        end
+
+        # Asserts that an MongoMapper model validates with the passed
+        # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+        # contained within the list of errors for that attribute.
+        #
+        #   assert_good_value(User.new, :email, "user@example.com")
+        #   assert_good_value(User.new, :ssn, "123456789", /length/)
+        #
+        # If a class is passed as the first argument, a new object will be
+        # instantiated before the assertion.  If an instance variable exists with
+        # the same name as the class (underscored), that object will be used
+        # instead.
+        #
+        #   assert_good_value(User, :email, "user@example.com")
+        #
+        #   @product = Product.new(:tangible => false)
+        #   assert_good_value(Product, :price, "0")
+        #
+        def assert_good_value(model, attribute, value, error_message_to_avoid=//) # :nodoc:
+          model.send("#{attribute}=", value)
+
+          return true if model.valid?
+          
+          # FIXME
+          error_message_to_avoid = error_message_from_model(model, attribute, error_message_to_avoid)
+          assert_does_not_contain(model.errors.on(attribute), error_message_to_avoid)
+        end
+
+        # Asserts that an MongoMapper model invalidates the passed
+        # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+        # contained within the list of errors for that attribute.
+        #
+        #   assert_bad_value(User.new, :email, "invalid")
+        #   assert_bad_value(User.new, :ssn, "123", /length/)
+        #
+        # If a class is passed as the first argument, a new object will be
+        # instantiated before the assertion.  If an instance variable exists with
+        # the same name as the class (underscored), that object will be used
+        # instead.
+        #
+        #   assert_bad_value(User, :email, "invalid")
+        #
+        #   @product = Product.new(:tangible => true)
+        #   assert_bad_value(Product, :price, "0")
+        #
+        def assert_bad_value(model, attribute, value, error_message_to_expect=:invalid) #:nodoc:
+          model.send("#{attribute}=", value)
+
+          return false if model.valid? || model.errors.on(attribute).blank?
+          
+          # FIXME
+          error_message_to_expect = error_message_from_model(model, attribute, error_message_to_expect)
+          assert_contains(model.errors.on(attribute), error_message_to_expect)
+        end
+
+        # Return the error message to be checked. If the message is not a Symbol
+        # neither a Hash, it returns the own message.
+        #
+        # But the nice thing is that when the message is a Symbol we get the error
+        # messsage from within the model, using already existent structure inside
+        # MongoMapper.
+        #
+        # This allows a couple things from the user side:
+        #
+        #   1. Specify symbols in their tests:
+        #
+        #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => :inclusion)
+        #
+        #   As we know, allow_values_for searches for a :invalid message. So if we
+        #   were testing a validates_inclusion_of with allow_values_for, previously
+        #   we had to do something like this:
+        #
+        #     should_allow_values_for(:shirt_size, 'S', 'M', 'L', :message => 'not included in list')
+        #
+        #   Now everything gets resumed to a Symbol.
+        #
+        #   2. Do not worry with specs if their are using I18n API properly.
+        #
+        #   As we know, I18n API provides several interpolation options besides
+        #   fallback when creating error messages. If the user changed the message,
+        #   macros would start to pass when they shouldn't.
+        #
+        #   Using the underlying mechanism inside ActiveRecord makes us free from
+        #   all thos errors.
+        #
+        # We replace {{count}} interpolation for 12345 which later is replaced
+        # by a regexp which contains \d+.
+        #
+        def error_message_from_model(model, attribute, message) #:nodoc:
+          # FIXME
+          message
+        end
+
+        # Asserts that the given collection does not contain item x. If x is a
+        # regular expression, ensure that none of the elements from the collection
+        # match x.
+        #
+        def assert_does_not_contain(collection, x) #:nodoc:
+          !assert_contains(collection, x)
+        end
+
+        # Changes how collection are interpolated to provide localized names
+        # whenever is possible.
+        #
+        def collection_interpolation #:nodoc:
+          described_class = if @subject
+            subject_class
+          elsif @spec
+            @spec.send(:described_class)
+          end
+
+          if i18n_collection? && described_class.respond_to?(:human_attribute_name)
+            options = {}
+
+            collection_name = self.class.matcher_arguments[:collection].to_sym
+            if collection = instance_variable_get("@#{collection_name}")
+              collection = collection.map do |attr|
+                described_class.human_attribute_name(attr.to_s, :locale => Remarkable.locale).downcase
+              end
+              options[collection_name] = array_to_sentence(collection)
+            end
+
+            object_name = self.class.matcher_arguments[:as]
+            if object = instance_variable_get("@#{object_name}")
+              object = described_class.human_attribute_name(object.to_s, :locale => Remarkable.locale).downcase
+              options[object_name] = object
+            end
+
+            options
+          else
+            super
+          end
+        end
+
+        # Returns true if the given collection should be translated.
+        #
+        def i18n_collection? #:nodoc:
+          RAILS_I18N && I18N_COLLECTION.include?(self.class.matcher_arguments[:collection])
+        end
     end
   end
 end

data/lib/remarkable_mongomapper/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_mongomapper/matchers/have_key_matcher.rb

@@ -1,24 +1,20 @@
 module Remarkable
   module MongoMapper
     module Matchers
-      class HaveKeyMatcher < Remarkable::MongoMapper::Base #:nodoc:
+      class HaveKeyMatcher < Remarkable::MongoMapper::Base
         
-        arguments :collection => :keys, :as => :key
-        
-        optional :type
-        
-        default_options :type => nil
+        arguments :type, :collection => :attributes, :as => :attribute
         
         collection_assertions :has_key?
         
-        before_assert do
-          @type = @options[:type]
-        end
+        # before_assert do
+        #   @type = @options[:type]
+        # end
 
         protected
 
           def has_key?
-            @subject.reader?(@key) && @subject.class.keys[@key] == ::MongoMapper::Key.new(@key, @type)
+            @subject.respond_to?(@attribute) && @subject.class.keys[@attribute] == ::MongoMapper::Key.new(@attribute, @type)
           end
 
       end
@@ -27,14 +23,13 @@ module Remarkable
       #
       # == Examples
       #
-      #   should_have_column :name, :type => String
+      #   should_have_key :name, String
       #
-      #   it { should have_column(:name, :type => String) }
-      #   it { should have_column(:name, :phone_number, :type => String) }
-      #   it { should have_column(:name).type(String) }
+      #   it { should have_key(:name, String) }
+      #   it { should have_keys(:name, :phone_number, String) }
       #
       def have_key(*args, &block)
-        HaveKeyMatcher.new(*args, &block).spec(self)
+        HaveKeyMatcher.new(args.pop, *args, &block).spec(self)
       end
       alias :have_keys :have_key
 

data/lib/remarkable_mongomapper/matchers/validate_presence_of_matcher.rb

@@ -1,17 +1,18 @@
 module Remarkable
   module MongoMapper
     module Matchers
-      class ValidatePresenceOfMatcher < Remarkable::MongoMapper::Base #:nodoc:
+      class ValidatePresenceOfMatcher < Remarkable::MongoMapper::Base
         
-        arguments :collection => :keys, :as => :key
+        arguments :collection => :attributes, :as => :attribute
+        optional  :message
 
         collection_assertions :allow_nil?
+        default_options :message => "can't be empty"
 
         protected
 
           def allow_nil?
-            @subject.send("#{@key}=", nil)
-            !@subject.valid? && !@subject.errors.on(@key).blank?
+            bad?(nil, :message)
           end
 
       end

data/locales/en.yml

@@ -1,12 +1,22 @@
 en:
   remarkable:
     mongo_mapper:
+      association:
+        many: have many
+        belongs_to: belong to
+        description: "{{type}} {{associations}}"
+        expectations:
+          association_exists: "{{subject_name}} records {{type}} {{association}}, but the association does not exist"
+          type_matches: "{{subject_name}} records {{type}} {{association}}, got {{subject_name}} records {{actual_type}} {{association}}"
+          klass_exists: "{{subject_name}} records {{type}} {{association}}, but the association class does not exist"
+          options_match: "{{subject_name}} records {{type}} {{association}} with options {{options}}, got {{actual}}"
+          
       have_key:
-        description: "have key(s) {{keys}}"
+        description: "have key(s) {{attributes}}"
         expectations:
-          has_key: "{{subject_name}} to have key named {{key}} with type {{type}}"
+          has_key: "{{subject_name}} to have key named {{attribute}} with type {{type}}"
 
       validate_presence_of:
-        description: "require {{keys}} to be set"
+        description: "require {{attributes}} to be set"
         expectations:
-          allow_nil: "{{subject_name}} to require {{key}} to be set"
+          allow_nil: "{{subject_name}} to require {{attribute}} to be set"

data/remarkable_mongomapper.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{remarkable_mongomapper}
-  s.version = "0.0.1"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nicolas M\303\251rouze", "Vincent Hellot", "Mathieu Fosse"]
-  s.date = %q{2009-07-28}
+  s.date = %q{2009-07-29}
   s.email = %q{dev@yeastymobs.com}
   s.extra_rdoc_files = [
     "LICENSE",
@@ -20,10 +20,12 @@ Gem::Specification.new do |s|
      "VERSION",
      "lib/remarkable_mongomapper.rb",
      "lib/remarkable_mongomapper/base.rb",
+     "lib/remarkable_mongomapper/matchers/association_matcher.rb",
      "lib/remarkable_mongomapper/matchers/have_key_matcher.rb",
      "lib/remarkable_mongomapper/matchers/validate_presence_of_matcher.rb",
      "locales/en.yml",
      "remarkable_mongomapper.gemspec",
+     "spec/matchers/association_matcher_spec.rb",
      "spec/matchers/have_key_matcher_spec.rb",
      "spec/matchers/validate_presence_of_matcher_spec.rb",
      "spec/models.rb",
@@ -36,7 +38,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{MongoMapper Remarkable Matchers}
   s.test_files = [
-    "spec/matchers/have_key_matcher_spec.rb",
+    "spec/matchers/association_matcher_spec.rb",
+     "spec/matchers/have_key_matcher_spec.rb",
      "spec/matchers/validate_presence_of_matcher_spec.rb",
      "spec/models.rb",
      "spec/spec_helper.rb"
@@ -48,13 +51,13 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<remarkable>, ["~> 3.1.8"])
-      s.add_runtime_dependency(%q<mongomapper>, ["~> 0.2.0"])
+      s.add_runtime_dependency(%q<mongomapper>, ["~> 0.3.1"])
     else
       s.add_dependency(%q<remarkable>, ["~> 3.1.8"])
-      s.add_dependency(%q<mongomapper>, ["~> 0.2.0"])
+      s.add_dependency(%q<mongomapper>, ["~> 0.3.1"])
     end
   else
     s.add_dependency(%q<remarkable>, ["~> 3.1.8"])
-    s.add_dependency(%q<mongomapper>, ["~> 0.2.0"])
+    s.add_dependency(%q<mongomapper>, ["~> 0.3.1"])
   end
 end

data/spec/matchers/association_matcher_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe 'association_matcher' do
+  subject do
+    Article.new
+  end
+  
+  describe 'have_many' do
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = have_many(:comments)
+        matcher.description.should == 'have many comments'
+      end
+
+      it 'should set association_exists? message' do
+        matcher = have_many(:whatever)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many whatever, but the association does not exist'
+      end
+
+      it 'should set type_matches? message' do
+        matcher = belong_to(:comments)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to comments, got Article records have many comments'
+      end
+      
+      it 'should set klass_exists? message' do
+        matcher = have_many(:unknowns)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many unknowns, but the association class does not exist'
+      end
+      
+      it 'should set options_matches? message when :class_name is given' do
+        matcher = have_many(:ratings, :class_name => 'Rating')
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many ratings with options {:class_name=>"Rating"}, got {:class_name=>"Rate"}'
+      end
+      
+      it 'should set options_matches? message when :polymorphic is given' do
+        matcher = have_many(:assets, :polymorphic => true)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many assets with options {:polymorphic=>"true"}, got {:polymorphic=>""}'
+      end
+    end
+    
+    describe 'matchers' do
+      it { should have_many(:comments) }
+      it { should_not belong_to(:comment) }
+    end
+    
+    describe 'macros' do
+      should_have_many :comments
+      should_not_belong_to :comment
+    end
+
+  end
+  
+  describe 'belong_to' do
+
+    describe 'messages' do
+      it 'should contain a description' do
+        matcher = belong_to(:user)
+        matcher.description.should == 'belong to user'
+      end
+
+      it 'should set association_exists? message' do
+        matcher = belong_to(:whatever)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to whatever, but the association does not exist'
+      end
+      
+      it 'should set type_matches? message' do
+        matcher = have_many(:user)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records have many user, got Article records belong to user'
+      end
+      
+      it 'should set klass_exists? message' do
+        matcher = belong_to(:unknown)
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to unknown, but the association class does not exist'
+      end
+      
+      it 'should set options_matches? message when :class_name is given' do
+        matcher = belong_to(:site, :class_name => 'Website')
+        matcher.matches?(subject)
+        matcher.failure_message.should == 'Expected Article records belong to site with options {:class_name=>"Website"}, got {:class_name=>"Site"}'
+      end
+    end
+    
+    describe 'matchers' do
+      it { should belong_to(:user) }
+      it { should_not have_many(:users) }
+    end
+    
+    describe 'macros' do
+      should_belong_to :user
+      should_not_have_many :users
+    end
+
+  end
+
+end

data/spec/matchers/have_key_matcher_spec.rb

@@ -8,12 +8,12 @@ describe 'have_key' do
   describe 'messages' do
 
     it 'should contain a description' do
-      matcher = have_key(:title, :type => String)
+      matcher = have_key(:title, String)
       matcher.description.should == 'have key(s) title'
     end
 
     it 'should set has_key? message' do
-      matcher = have_key(:owner, :type => String)
+      matcher = have_key(:owner, String)
       matcher.matches?(subject)
       matcher.failure_message.should == 'Expected Article to have key named owner with type String'
     end
@@ -21,12 +21,12 @@ describe 'have_key' do
   end
   
   describe 'matchers' do
-    it { should have_key(:title, :type => String) }
-    it { should have_keys(:title, :body, :type => String) }
+    it { should have_key(:title, String) }
+    it { should have_keys(:title, :body, String) }
   end
 
   describe 'macros' do
-    should_have_key :title, :type => String
-    should_have_keys :title, :body, :type => String
+    should_have_key :title, String
+    should_have_keys :title, :body, String
   end
 end

data/spec/models.rb

@@ -3,4 +3,40 @@ class Article
   
   key :title, String, :required => true
   key :body, String
+  
+  many :comments
+  many :unknowns
+  many :ratings, :class_name => "Rate"
+  many :assets
+  belongs_to :user
+  belongs_to :unknown
+  belongs_to :site, :class_name => 'Site'
+end
+
+class Comment
+  include MongoMapper::EmbeddedDocument
+  
+  key :body, String
+end
+
+class User
+  include MongoMapper::Document
+  
+  key :login, String
+end
+
+class Rate
+  include MongoMapper::EmbeddedDocument
+end
+
+class Rating
+  include MongoMapper::EmbeddedDocument
+end
+
+class Site
+  include MongoMapper::EmbeddedDocument
+end
+
+class Webiste
+  include MongoMapper::EmbeddedDocument
 end

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ end
 
 Spec::Runner.configure do |config|
   config.before(:all) { reset_test_db! }
-  config.after(:all) { reset_test_db! }
+  config.after(:all)  { reset_test_db! }
 end
 
 require File.join(File.dirname(__FILE__), "..", "lib", "remarkable_mongomapper")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: yeastymobs-remarkable_mongomapper
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - "Nicolas M\xC3\xA9rouze"
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-28 00:00:00 -07:00
+date: 2009-07-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.2.0
+        version: 0.3.1
     version: 
 description: 
 email: dev@yeastymobs.com
@@ -51,10 +51,12 @@ files:
 - VERSION
 - lib/remarkable_mongomapper.rb
 - lib/remarkable_mongomapper/base.rb
+- lib/remarkable_mongomapper/matchers/association_matcher.rb
 - lib/remarkable_mongomapper/matchers/have_key_matcher.rb
 - lib/remarkable_mongomapper/matchers/validate_presence_of_matcher.rb
 - locales/en.yml
 - remarkable_mongomapper.gemspec
+- spec/matchers/association_matcher_spec.rb
 - spec/matchers/have_key_matcher_spec.rb
 - spec/matchers/validate_presence_of_matcher_spec.rb
 - spec/models.rb
@@ -88,6 +90,7 @@ signing_key:
 specification_version: 3
 summary: MongoMapper Remarkable Matchers
 test_files: 
+- spec/matchers/association_matcher_spec.rb
 - spec/matchers/have_key_matcher_spec.rb
 - spec/matchers/validate_presence_of_matcher_spec.rb
 - spec/models.rb