remarkable_mongoid 0.5.0 → 0.5.2

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+doc/*
+.yardoc/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create default@remarkable_mongoid > /dev/null

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ..gemspec
+gemspec

data/HISTORY.txt

@@ -0,0 +1,7 @@
+## 0.5.2
+  * Updated README
+
+## 0.5.1
+  * Updated for mongoid-2.0.0.rc.6
+  * reference_many_as_array Matcher is gone, replaced with the reference_many_and_be_referenced_in Matcher
+  * Added YARD documentation

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Brian Cardarella
+Copyright (c) 2010 - 2011 Brian Cardarella
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,5 +1,5 @@
 # remarkable_mongoid
-NOTE: This gem is based upon the 2.0 beta of Mongoid and the 4.0 alpha of Remarkable
+NOTE: This gem is based upon the 2.0 Release Candidate of Mongoid and the 4.0 alpha of Remarkable
 
 RSpec Matchers for Mongoid
 
@@ -14,6 +14,7 @@ Associations
 * reference_one
 * reference_many
 * be_referenced_in
+* reference_many_and_be_referenced_in
 * embed_one
 * embed_many
 * be_embedded_in
@@ -38,4 +39,4 @@ Validations
     
 ## Copyright
 
-Copyright (c) 2010 Brian Cardarella. See LICENSE for details.
+Copyright (c) 2010 - 2011 Brian Cardarella. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/remarkable/mongoid/fields.rb

@@ -1,5 +1,17 @@
 module Remarkable::Mongoid
   module Matchers
+
+    # Specify the document should have a field
+    #
+    # examples:
+    #  it { should have_field :name }
+    #  it { should have_field :age, :type => Integer, :default => 0 }
+    #
+    # @param [Symbol, Hash] options
+    # @option options [Class] :type The data type
+    # @option options :default The default value for this field
+    #
+    # @return [Remarkable::Mongoid::Matchers::HasFieldMatcher]
     def have_field(field, options = {})
       HasFieldMatcher.new(field, options)
     end
@@ -9,11 +21,11 @@ module Remarkable::Mongoid
 
       def initialize(field, options)
         self.field   = field.to_s
-        self.options = { :type => String }.merge(options)
+        self.options = { :type => Object }.merge(options)
       end
 
       def matches?(subject)
-        @subject     = subject.is_a?(Class) ? subject : subject.class
+        @subject = subject.is_a?(Class) ? subject : subject.class
         @subject.fields.has_key?(field) && (@subject.fields[field].type == options[:type])
       end
 

data/lib/remarkable/mongoid/relations.rb

@@ -0,0 +1,117 @@
+module Remarkable::Mongoid
+  module Matchers
+
+    # Specify the document references another document
+    #
+    # examples:
+    #  it { should reference_one :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def reference_one(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Referenced::One)
+    end
+    
+    # Specify the document references many documents
+    #
+    # examples:
+    #  it { should reference_many :dogs }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def reference_many(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Referenced::Many)
+    end
+
+    # Specify the document references many documents and is referenced in many documents
+    #
+    # examples:
+    #  it { should reference_many_and_be_referenced_in :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def reference_many_and_be_referenced_in(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Referenced::ManyToMany)
+    end
+    
+    # Specify the document is referenced in another document
+    #
+    # examples:
+    #  it { should be_referenced_in :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def be_referenced_in(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Referenced::In)
+    end
+
+    # Specify the document embeds another document
+    #
+    # examples:
+    #  it { should embed_one :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def embed_one(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Embedded::One)
+    end
+    
+    # Specify the document embeds many documents
+    #
+    # examples:
+    #  it { should embed_many :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def embed_many(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Embedded::Many)
+    end
+    
+    # Specify the document is embedded in another document
+    #
+    # examples:
+    #  it { should be_embedded_in :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::RelationMatcher]
+    def be_embedded_in(attr)
+      RelationMatcher.new(attr, ::Mongoid::Relations::Embedded::In)
+    end
+    
+    class RelationMatcher
+      attr_accessor :attr, :relation_type
+
+      def initialize(attr, relation_type)
+        self.attr             = attr.to_s
+        self.relation_type = relation_type
+      end
+
+      def matches?(subject)
+        @subject     = subject
+        relations = @subject.relations.select { |k,v| v.relation == relation_type }
+        relations.detect { |k| k.first == attr } != nil
+      end
+
+      def description
+        "has #{humanized_relation} relation :#{attr}"
+      end
+      
+      def failure_message_for_should
+        "\n#{humanized_relation} relation failure\nExpected: '#{attr}'"
+      end
+      
+      private
+      
+      def humanized_relation
+        relation_type.to_s.split('::').last
+      end
+    end
+  end
+end

data/lib/remarkable/mongoid/validate_association.rb

@@ -1,5 +1,14 @@
 module Remarkable::Mongoid
   module Matchers
+
+    # Specify the document validates the association
+    #
+    # examples:
+    #  it { should validate_association :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::ValidateAssociationMatcher]
     def validate_association(attr)
       ValidateAssociationMatcher.new(attr)
     end
@@ -28,4 +37,4 @@ module Remarkable::Mongoid
     end
     
   end
-end
+end

data/lib/remarkable/mongoid/validate_uniqueness_of.rb

@@ -1,5 +1,14 @@
 module Remarkable::Mongoid
   module Matchers
+
+    # Specify the document validates the uniqueness of the field's data
+    #
+    # examples:
+    #  it { should validate_uniqueness_of :dog }
+    #
+    # @param [Symbol]
+    #
+    # @return [Remarkable::Mongoid::Matchers::ValidateUniquenessOfMatcher]
     def validate_uniqueness_of(attr)
       ValidateUniquenessOfMatcher.new(attr)
     end
@@ -52,4 +61,4 @@ module Remarkable::Mongoid
     end
     
   end
-end
+end

data/lib/remarkable/mongoid/version.rb

@@ -0,0 +1,5 @@
+module Remarkable
+  module Mongoid
+    VERSION = '0.5.2'
+  end
+end

data/lib/remarkable/mongoid.rb

@@ -5,7 +5,7 @@ end
 
 require 'remarkable/active_model'
 require 'remarkable/mongoid/fields'
-require 'remarkable/mongoid/associations'
+require 'remarkable/mongoid/relations'
 require 'remarkable/mongoid/validate_uniqueness_of'
 require 'remarkable/mongoid/validate_association'
 

data/remarkable_mongoid.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'remarkable/mongoid/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'remarkable_mongoid'
+  s.version     = Remarkable::Mongoid::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Brian Cardarella']
+  s.email       = ['bcardarella@gmail.com']
+  s.homepage    = 'https://github.com/bcardarella/remarkable_mongoid'
+  s.description = 'RSpec Matchers for Mongoid'
+  s.summary     = 'RSpec Matchers for Mongoid'
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'remarkable_activemodel', '~> 4.0.0.alpha4'
+
+  s.add_development_dependency 'bson_ext'
+  s.add_development_dependency 'activesupport', '~> 3.0.0'
+  s.add_development_dependency 'mongoid', '~> 2.0.0.rc.6'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'bourne'
+
+  ruby_minor_version = RUBY_VERSION.split('.')[1].to_i
+  if ruby_minor_version == 8
+    s.add_development_dependency 'ruby-debug'
+  elsif ruby_minor_version == 9
+    s.add_development_dependency 'ruby-debug19'
+  end
+
+end

data/spec/.rspec

@@ -0,0 +1 @@
+--color --debugger

data/spec/fields_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe 'Mongoid Fields' do
+  before :all do
+    class Should
+      include Remarkable::Mongoid::Matchers
+    end
+
+    @should = Should.new
+  end
+
+  describe 'have_field' do
+    before :all do
+      class SingleBook
+        def self.add_dirty_methods(*args); end
+        include Mongoid::Fields
+        field :name
+        field :published_on, :type => Date
+      end
+    end
+
+    context 'without given type' do
+      it 'should be true for a book with field name' do
+        matcher = @should.have_field :name
+        matcher.matches?(SingleBook.new).should be_true
+      end
+
+      it 'should be true for a book without field author' do
+        matcher = @should.have_field :author
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+    
+    context 'with given type' do
+      it 'should be true for a book with field published_on of type Date' do
+        matcher = @should.have_field :published_on, :type => Date
+        matcher.matches?(SingleBook.new).should be_true
+      end
+
+      it 'should be true for a book with field published_on of type Array' do
+        matcher = @should.have_field :published_on, :type => Array
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+  end
+
+  context 'messages' do
+    before :all do
+      class Model
+        def self.add_dirty_methods(*args); end
+        include Mongoid::Fields
+        field :test
+      end
+    end
+
+    before do
+      @association_matcher = Remarkable::Mongoid::Matchers::HasFieldMatcher.new(:test, { :type => Date })
+      @association_matcher.matches?(Model)
+    end
+
+    describe 'description' do
+      subject { @association_matcher.description }
+      it { should == "have field test of type Date" }
+    end
+
+    describe 'failure_message_for_should' do
+      subject { @association_matcher.failure_message_for_should }
+      it { should == "expected Model to have field test of type Date" }
+    end
+
+    describe 'failure_message_for_should_not' do
+      subject { @association_matcher.failure_message_for_should_not }
+      it { should == "expected Model to not have field test of type Date" }
+    end
+  end
+end

data/spec/relations_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe 'Mongoid Relations' do
+  before :all do
+    class Should
+      include Remarkable::Mongoid::Matchers
+    end
+
+    @should = Should.new
+  end
+  
+  context 'embedding' do
+    before :all do
+      class SingleBook
+        include Mongoid::Document
+
+        embeds_many :pages,  :class_name => "SinglePage"
+        embeds_one  :author, :class_name => "SingleAuthor"
+      end
+      
+      class SinglePage
+        include Mongoid::Document
+
+        embedded_in :book, :clas_name => "SingleBook", :inverse_of => :pages
+      end
+    end
+
+    describe 'embeds_one' do
+      it 'should be true for a book embedding one author' do
+        matcher = @should.embed_one :author
+        matcher.matches?(SingleBook.new).should be_true
+      end
+      
+      it 'should be false for a book embedding one publisher' do
+        matcher = @should.embed_one :publisher
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+    
+    describe 'embed_many' do
+      it 'should be true for a book embedding many pages' do
+        matcher = @should.embed_many :pages
+        matcher.matches?(SingleBook.new).should be_true
+      end
+      
+      it 'should be false for a book embedding many words' do
+        matcher = @should.embed_many :words
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+    
+    describe 'embedded_in' do
+      it 'should be true for a page embedded in a book' do
+        matcher = @should.be_embedded_in :book
+        matcher.matches?(SinglePage.new).should be_true
+      end
+      
+      it 'should be false for a page embedded in a newspaper' do
+        matcher = @should.be_embedded_in :newspaper
+        matcher.matches?(SinglePage.new).should be_false
+      end
+    end
+  end
+  
+  context 'referencing' do
+    before :all do
+      class SingleOwner
+        include Mongoid::Document
+
+        references_many                   :dogs,    :class_name => "SingleDog", :inverse_of => :owner
+        references_one                    :friend,  :class_name => "SingleFriend"
+        references_and_referenced_in_many :turtles, :class_name => "SingleTurtle"
+      end
+      
+      class SingleDog
+        include Mongoid::Document
+
+        referenced_in :owner, :class_name => "SingleOwner", :inverse_of => :dogs
+      end
+
+      class SingleTurtle
+        include Mongoid::Document
+      end
+    end
+
+    describe 'reference_one' do
+      it 'should be true for an owner having one friend' do
+        matcher = @should.reference_one :friend
+        matcher.matches?(SingleOwner.new).should be_true
+      end
+      
+      it 'should be false for an owner having one boss' do
+        matcher = @should.reference_one :boss
+        matcher.matches?(SingleOwner.new).should be_false
+      end
+    end
+    
+    describe 'reference_many' do
+      it 'should be true for an owner having many dogs' do
+        matcher = @should.reference_many :dogs
+        matcher.matches?(SingleOwner.new).should be_true
+      end
+      
+      it 'should be false for an owner having many cats' do
+        matcher = @should.reference_many :cats
+        matcher.matches?(SingleOwner.new).should be_false
+      end
+    end
+
+    describe 'reference_many_and_be_referenced_in' do
+      it 'should be true for an owner having many turtles as an array' do
+        matcher = @should.reference_many_and_be_referenced_in :turtles
+        matcher.matches?(SingleOwner.new).should be_true
+      end
+      it 'should be false for an owner having many dogs as an array' do
+        matcher = @should.reference_many_and_be_referenced_in :dogs
+        matcher.matches?(SingleOwner.new).should be_false
+      end
+      it 'should be false for an owner having many cats as an array' do
+        matcher = @should.reference_many_and_be_referenced_in :cats
+        matcher.matches?(SingleOwner.new).should be_false
+      end
+    end
+    
+    describe 'be_referenced_in' do
+      it 'should be true for a dog belonging to an owner' do
+        matcher = @should.be_referenced_in :owner
+        matcher.matches?(SingleDog.new).should be_true
+      end
+      
+      it 'should be false for a dog belonging to a cat' do
+        matcher = @should.be_referenced_in :stranger
+        matcher.matches?(SingleDog.new).should be_false
+      end
+    end
+  end
+  
+  context 'messages' do
+    before do
+      @relation_matcher = Remarkable::Mongoid::Matchers::RelationMatcher.new(:test, "Some::Test")
+    end
+    
+    describe 'description' do
+      subject { @relation_matcher.description }
+      it { should == "has Test relation :test" }
+    end
+    
+    describe 'failure_message_for_should' do
+      subject { @relation_matcher.failure_message_for_should }
+      it { should == "\nTest relation failure\nExpected: 'test'"}
+    end
+  end
+end

data/spec/remarkable-mongoid_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe "Remarkable::Mongoid" do
+  it 'should define Remarkable::Mongoid' do
+    defined?(Remarkable::Mongoid).should be_true
+  end
+end
+
+describe 'Remarkable::ActiveModel' do
+  it 'should include the Remarkable ActiveModel validation matchers' do
+    defined?(Remarkable::ActiveModel).should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ruby-debug'
+require 'rubygems'
+require 'remarkable/mongoid'
+require 'mongoid'
+require 'rspec'
+require 'rspec/autorun'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/spec/validate_associated_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe 'Validates Associated' do
+  before :all do
+    class Should
+      include Remarkable::Mongoid::Matchers
+    end
+    
+    @should = Should.new
+  end
+  
+  describe 'validate_association' do
+    before do
+      class SingleBook
+        include Mongoid::Validations
+        validates_associated :pages
+      end
+    end
+    
+    after do
+      Object.send(:remove_const, :SingleBook)
+    end
+    
+    it 'should be true for a book validating the association :pages' do
+      matcher = @should.validate_association :pages
+      matcher.matches?(SingleBook.new).should be_true
+    end
+  
+    it 'should be false for a book validating the association :author' do
+      matcher = @should.validate_association :author
+      matcher.matches?(SingleBook.new).should be_false
+    end
+  end
+  
+  context 'messages' do
+    before do
+      matcher_subject = mock('SingleBook')
+      matcher_subject.stubs(:class).returns('SingleBook')
+      @association_matcher = Remarkable::Mongoid::Matchers::ValidateAssociationMatcher.new(:test)
+      @association_matcher.instance_variable_set('@subject', matcher_subject)
+    end
+    
+    describe 'description' do
+      subject { @association_matcher.description }
+      it { should == "validates the :test association" }
+    end
+    
+    describe 'failure_message_for_should' do
+      subject { @association_matcher.failure_message_for_should }
+      it { should == "\nAssociation validation failure\nExpected: SingleBook to validate the 'test' association" }
+    end
+  end
+  
+end

data/spec/validate_uniqueness_of_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'Validates Uniqueness Of' do
+  before :all do
+    class Should
+      include Remarkable::Mongoid::Matchers
+    end
+    
+    @should = Should.new
+  end
+  
+  describe 'validate_uniqueness_of' do
+    before do
+      class SingleBook
+        include Mongoid::Validations
+        validates_uniqueness_of :title, :message => 'Test message', :scope => :author_id
+      end
+    end
+    
+    after do
+      Object.send(:remove_const, :SingleBook)
+    end
+
+    it 'should be true for a book validating the uniqueness of title' do
+      matcher = @should.validate_uniqueness_of :title
+      matcher.matches?(SingleBook.new).should be_true
+    end
+    
+    it 'should be false for a book validating the uniqueness of author' do
+      matcher = @should.validate_uniqueness_of :author
+      matcher.matches?(SingleBook.new).should be_false
+    end
+    
+    context 'with message' do
+      it 'should be true for a book validating the uniqueness of title' do
+        matcher = @should.validate_uniqueness_of(:title).with_message('Test message')
+        matcher.matches?(SingleBook.new).should be_true
+      end
+
+      it 'should be false for a book validating the uniqueness of title with message "Bad message"' do
+        matcher = @should.validate_uniqueness_of(:author).with_message('Bad message')
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+    
+    context 'with scope' do
+      it 'should be true for a book validating the uniqueness scoped_to author_id' do
+        matcher = @should.validate_uniqueness_of(:title).scoped_to(:author_id)
+        matcher.matches?(SingleBook.new).should be_true
+      end
+      
+      it 'should be false for a book validating the uniqueness scoped_to reader_id' do
+        matcher = @should.validate_uniqueness_of(:title).scoped_to(:reader_id)
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+
+    context 'with scope and message' do
+      it 'should be true for a book validating the uniqueness with good scope and message' do
+        matcher = @should.validate_uniqueness_of(:title).scoped_to(:author_id).with_message('Test message')
+        matcher.matches?(SingleBook.new).should be_true
+      end
+      
+      it 'should be false for a book validating the uniqueness with good scope and bad message' do
+        matcher = @should.validate_uniqueness_of(:title).scoped_to(:author_id).with_message('Bad message')
+        matcher.matches?(SingleBook.new).should be_false
+      end
+
+      it 'should be false for a book validating the uniqueness with bad scope and good message' do
+        matcher = @should.validate_uniqueness_of(:title).scoped_to(:reader_id).with_message('Test message')
+        matcher.matches?(SingleBook.new).should be_false
+      end
+
+      it 'should be false for a book validating the uniqueness with bad scope and bad message' do
+        matcher = @should.validate_uniqueness_of(:title).scoped_to(:reader_id).with_message('Bad message')
+        matcher.matches?(SingleBook.new).should be_false
+      end
+    end
+
+  end
+  
+  context 'messages' do
+    before do
+      @association_matcher = Remarkable::Mongoid::Matchers::ValidateUniquenessOfMatcher.new(:test)
+    end
+    
+    describe 'description' do
+      subject { @association_matcher.description }
+      it { should == "validates that :test is unique" }
+    end
+    
+    describe 'failure_message_for_should' do
+      subject { @association_matcher.failure_message_for_should }
+      it { should == "\nUniqueness validation failure\nExpected: 'test' to be unique" }
+    end
+  end
+  
+end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: remarkable_mongoid
 version: !ruby/object:Gem::Version 
-  hash: 11
   prerelease: false
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 2
+  version: 0.5.2
 platform: ruby
 authors: 
 - Brian Cardarella
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-15 00:00:00 -04:00
+date: 2011-01-29 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,137 +23,138 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: -1710980496
         segments: 
         - 4
         - 0
         - 0
-        - alpha2
-        version: 4.0.0.alpha2
+        - alpha4
+        version: 4.0.0.alpha4
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: ruby-debug
+  name: bson_ext
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 0
         version: "0"
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: bson_ext
+  name: activesupport
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
+        - 3
         - 0
-        version: "0"
+        - 0
+        version: 3.0.0
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: activesupport
+  name: mongoid
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7712042
         segments: 
-        - 3
+        - 2
         - 0
         - 0
         - rc
-        version: 3.0.0.rc
+        - 6
+        version: 2.0.0.rc.6
   type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: mongoid
+  name: rspec
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 62196477
         segments: 
-        - 2
         - 0
-        - 0
-        - beta
-        - 15
-        version: 2.0.0.beta.15
+        version: "0"
   type: :development
   version_requirements: *id005
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: bourne
   prerelease: false
   requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 62196421
         segments: 
-        - 2
         - 0
-        - 0
-        - beta
-        - 19
-        version: 2.0.0.beta.19
+        version: "0"
   type: :development
   version_requirements: *id006
 - !ruby/object:Gem::Dependency 
-  name: bourne
+  name: ruby-debug19
   prerelease: false
   requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 15
         segments: 
-        - 1
         - 0
-        version: "1.0"
+        version: "0"
   type: :development
   version_requirements: *id007
 description: RSpec Matchers for Mongoid
-email: bcardarella@gmail.com
+email: 
+- bcardarella@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.markdown
+extra_rdoc_files: []
+
 files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- HISTORY.txt
 - LICENSE
 - README.markdown
+- Rakefile
 - lib/remarkable/mongoid.rb
-- lib/remarkable/mongoid/associations.rb
 - lib/remarkable/mongoid/fields.rb
+- lib/remarkable/mongoid/relations.rb
 - lib/remarkable/mongoid/validate_association.rb
 - lib/remarkable/mongoid/validate_uniqueness_of.rb
+- lib/remarkable/mongoid/version.rb
+- remarkable_mongoid.gemspec
+- spec/.rspec
+- spec/fields_spec.rb
+- spec/relations_spec.rb
+- spec/remarkable-mongoid_spec.rb
+- spec/spec_helper.rb
+- spec/validate_associated_spec.rb
+- spec/validate_uniqueness_of_spec.rb
 has_rdoc: true
-homepage: http://github.com/bcardarella/remarkable_mongoid
+homepage: https://github.com/bcardarella/remarkable_mongoid
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -162,7 +162,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -171,7 +170,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -182,5 +180,10 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: RSpec Matchers for Mongoid
-test_files: []
-
+test_files: 
+- spec/fields_spec.rb
+- spec/relations_spec.rb
+- spec/remarkable-mongoid_spec.rb
+- spec/spec_helper.rb
+- spec/validate_associated_spec.rb
+- spec/validate_uniqueness_of_spec.rb

data/lib/remarkable/mongoid/associations.rb

@@ -1,60 +0,0 @@
-module Remarkable::Mongoid
-  module Matchers
-    def reference_one(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::ReferencesOne)
-    end
-    
-    def reference_many(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::ReferencesMany)
-    end
-
-    def reference_many_as_array(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::ReferencesManyAsArray)
-    end
-    
-    def be_referenced_in(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::ReferencedIn)
-    end
-
-    def embed_one(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::EmbedsOne)
-    end
-    
-    def embed_many(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::EmbedsMany)
-    end
-    
-    def be_embedded_in(attr)
-      AssociationMatcher.new(attr, ::Mongoid::Associations::EmbeddedIn)
-    end
-    
-    class AssociationMatcher
-      attr_accessor :attr, :association_type
-
-      def initialize(attr, association_type)
-        self.attr             = attr.to_s
-        self.association_type = association_type
-      end
-
-      def matches?(subject)
-        @subject     = subject
-        associations = @subject.associations.select { |k,v| v.association == association_type }
-        associations.detect { |k| k.first == attr } != nil
-      end
-
-      def description
-        "has #{humanized_association} association :#{attr}"
-      end
-      
-      def failure_message_for_should
-        "\n#{humanized_association} association failure\nExpected: '#{attr}'"
-      end
-      
-      private
-      
-      def humanized_association
-        association_type.to_s.split('::').last
-      end
-    end
-  end
-end