mongo_doc_rails2 0.6.1

data/mongod.example.yml

@@ -0,0 +1,2 @@
+mongod: /usr/local/bin/mongod
+dbpath: /data/db

data/mongodb.example.yml

@@ -0,0 +1,14 @@
+development:
+  name: development
+  host: localhost
+  port: 27017
+  options:
+    auto_reconnect: true
+
+test:
+  name: test
+  host: localhost
+  port: 27017
+  options:
+    auto_reconnect: true
+

data/perf/mongo_doc_object.rb

@@ -0,0 +1,83 @@
+require "rubygems"
+require "ruby-prof"
+require "mongo_doc"
+
+class Person
+  attr_accessor :address, :birth_date, :name, :phones
+end
+
+class Name
+  attr_accessor :family, :given, :middle
+end
+
+class Address
+  attr_accessor :city, :post_code, :state, :street, :type
+end
+
+class Phone
+  attr_accessor :country_code, :number, :type
+end
+
+class MongoDocObject
+  attr_accessor :collection
+  attr_accessor :objects
+  attr_accessor :ids
+
+  def initialize
+    MongoDoc::Connection.name = 'mongo_doc_object_test'
+    self.collection = MongoDoc::Collection.new 'people'
+    collection.drop
+  end
+
+  def generate(count)
+    self.objects = []
+    self.ids = []
+    count.times do |i|
+      person = Person.new
+      person.birth_date = Date.new(1970, 1, 1)
+      person.phones = []
+
+      name = Name.new
+      name.given = "James #{i}"
+      name.family = "Kirk"
+      name.middle = "Tiberius"
+
+      address = Address.new
+      address.street = "1 Starfleet Command Way"
+      address.city = "San Francisco"
+      address.state = "CA"
+      address.post_code = "94133"
+      address.type = "Work"
+
+      phone = Phone.new
+      phone.country_code = 1
+      phone.number = "415-555-1212"
+      phone.type = "Mobile"
+
+      person.name = name
+      person.address = address
+      person.phones << phone
+
+      objects << person
+    end
+  end
+
+  def writes(count)
+    count.times do |i|
+      ids[i] = collection.save(objects[i])
+    end
+  end
+
+  def reads(count)
+    count.times do |i|
+      obj = collection.find_one(ids[i])
+      raise 'Not found' unless obj.name.given == objects[i].name.given
+    end
+  end
+
+  def query_all
+    collection.find.each do |obj|
+      given_name = obj.name.given
+    end
+  end
+end

data/perf/mongo_document.rb

@@ -0,0 +1,84 @@
+require "benchmark"
+require "ruby-prof"
+require "mongo_doc"
+
+class Person
+  include MongoDoc::Document
+
+  attr_accessor :birth_date, :type => Date
+
+  embed :name
+  embed :address
+  embed_many :phones
+end
+
+class Name
+  include MongoDoc::Document
+
+  attr_accessor :given
+  attr_accessor :family
+  attr_accessor :middle
+end
+
+class Address
+  include MongoDoc::Document
+
+  attr_accessor :street
+  attr_accessor :city
+  attr_accessor :state
+  attr_accessor :post_code
+  attr_accessor :type
+end
+
+class Phone
+  include MongoDoc::Document
+
+  attr_accessor :country_code
+  attr_accessor :number
+  attr_accessor :type
+end
+
+class MongoDocument
+  attr_accessor :collection
+  attr_accessor :documents
+
+  def initialize
+    MongoDoc::Connection.name = 'mongo_doc_object_test'
+    self.collection = MongoDoc::Collection.new 'people'
+    collection.drop
+  end
+
+  def generate(count)
+    self.documents = []
+    count.times do |i|
+      person = Person.new(:birth_date => Date.new(1970, 1, 1))
+      name = Name.new(:given => "James #{i}", :family => "Kirk", :middle => "Tiberius")
+      address = Address.new(:street => "1 Starfleet Command Way", :city => "San Francisco", :state => "CA", :post_code => "94133", :type => "Work")
+      phone = Phone.new(:country_code => 1, :number => "415-555-1212", :type => "Mobile")
+      person.name = name
+      person.address = address
+      person.phones << phone
+
+      documents << person
+    end
+  end
+
+  def writes(count)
+    count.times do |i|
+      documents[i].save
+    end
+  end
+
+  def reads(count)
+    count.times do |i|
+      doc = collection.find_one(documents[i]._id)
+      raise 'Not found' unless doc.name.given == documents[i].name.given
+    end
+  end
+
+  def query_all
+    collection.find.each do |doc|
+      given_name = doc.name.given
+    end
+  end
+end

data/perf/ruby_driver.rb

@@ -0,0 +1,49 @@
+require "rubygems"
+require "ruby-prof"
+require "mongo_doc"
+
+class RubyDriver
+  attr_accessor :collection
+  attr_accessor :objects
+  attr_accessor :ids
+
+  def initialize
+    MongoDoc::Connection.name = 'ruby_driver_test'
+    self.collection = MongoDoc::Connection.database.collection 'people'
+    collection.drop
+  end
+
+  def generate(count)
+    self.objects = []
+    self.ids = []
+    count.times do |i|
+      person = {:birth_date => Date.new(1970, 1, 1).to_bson, :phones => []}
+      name = {:given => "James #{i}", :family => "Kirk", :middle => "Tiberius"}
+      address = {:street => "1 Starfleet Command Way", :city => "San Francisco", :state => "CA", :post_code => "94133", :type => "Work"}
+      phone = {:country_code => 1, :number => "415-555-1212", :type => "Mobile"}
+      person[:name] = name
+      person[:address] = address
+      person[:phones] << phone
+      objects << person
+    end
+  end
+
+  def writes(count)
+    count.times do |i|
+      ids[i] = collection.save(objects[i])
+    end
+  end
+
+  def reads(count)
+    count.times do |i|
+      obj = collection.find_one(ids[i])
+      raise 'Not found' unless obj and obj['name']['given'] == objects[i][:name][:given]
+    end
+  end
+
+  def query_all
+    collection.find().each do |obj|
+      given_name = obj['name']['given']
+    end
+  end
+end

data/script/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'irb'
+require 'mongo_doc'
+
+IRB.start(__FILE__)

data/spec/array_including_argument_matcher.rb

@@ -0,0 +1,62 @@
+# From http://gist.github.com/62943
+# Author http://github.com/trotter
+module Spec
+  module Mocks
+    module ArgumentMatchers
+
+      class ArrayIncludingMatcher
+        # We'll allow an array of arguments to be passed in, so that you can do
+        # things like obj.should_receive(:blah).with(array_including('a', 'b'))
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        # actual is the array (hopefully) passed to the method by the user.
+        # We'll check that it includes all the expected values, and return false
+        # if it doesn't or if we blow up because #include? is not defined.
+        def ==(actual)
+          @expected.each do |expected|
+            return false unless actual.include?(expected)
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "array_including(#{@expected.join(', ')})"
+        end
+      end
+
+      class ArrayNotIncludingMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do |expected|
+            return false if actual.include?(expected)
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "array_not_including(#{@expected.join(', ')})"
+        end
+      end
+
+      # array_including is a helpful wrapper that allows us to actually type
+      # #with(array_including(...)) instead of ArrayIncludingMatcher.new(...)
+      def array_including(*args)
+        ArrayIncludingMatcher.new(*args)
+      end
+
+      def array_not_including(*args)
+        ArrayNotIncludingMatcher.new(*args)
+      end
+
+    end
+  end
+end

data/spec/associations/collection_proxy_spec.rb

@@ -0,0 +1,233 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '/spec_helper'))
+
+describe MongoDoc::Associations::CollectionProxy do
+  class CollectionProxyTest
+    include MongoDoc::Document
+
+    attr_accessor :name
+  end
+
+  let(:name) { 'embed_many_name' }
+  let(:root) { CollectionProxyTest.new }
+  let(:proxy) { MongoDoc::Associations::CollectionProxy.new(:assoc_name => name, :assoc_class => CollectionProxyTest, :root => root, :parent => root) }
+  let(:item) { CollectionProxyTest.new }
+
+  describe "#_modifier_path" do
+    it "cascades to child documents with our assoc name and $" do
+      document = stub
+      proxy.stub(:collection => [document])
+      document.should_receive(:_modifier_path=).with("new.path.#{name}.$")
+      MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
+      proxy._modifier_path = 'new.path'
+    end
+  end
+
+  describe "#_selector_path=" do
+    it "cascades to child documents" do
+      document = stub
+      proxy.stub(:collection => [document])
+      document.should_receive("_selector_path=").with("new.path.#{name}")
+      MongoDoc::Associations::ProxyBase.stub(:is_document?).and_return(true)
+      proxy._selector_path = 'new.path'
+    end
+  end
+
+  context "#attach_document" do
+    it "sets the Document's modifier path to our modifier path" do
+      item.should_receive(:_modifier_path=).with('embed_many_name.$')
+      proxy.send(:attach_document, item)
+    end
+
+    it "sets the Document's selector path to our selector path" do
+      item.should_receive(:_selector_path=).with('embed_many_name')
+      proxy.send(:attach_document, item)
+    end
+  end
+
+  context "#<<" do
+    it "appends the item to the collection" do
+      (proxy << item).should include(item)
+    end
+
+    context "when the item is a Hash" do
+      let(:hash) {{:name => 'hash'}}
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy << hash
+      end
+
+      it "does not set the root" do
+        hash.should_not_receive(:_root=)
+        proxy << hash
+      end
+
+      it "adds the hash to the collection" do
+        proxy << hash
+        proxy.should include(hash)
+      end
+    end
+
+    context "when the item is not a MongoDoc::Document" do
+      let(:other_item) {'not a doc'}
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy << other_item
+      end
+
+      it "does not set the root" do
+        other_item.should_not_receive(:_root=)
+        proxy << other_item
+      end
+
+      it "adds the item to the collection" do
+        proxy << other_item
+        proxy.should include(other_item)
+      end
+    end
+
+    context "when the item is a MongoDoc::Document" do
+      it "registers a save observer" do
+        root.should_receive(:register_save_observer)
+        proxy << item
+      end
+
+      it "sets the root" do
+        proxy << item
+        item._root.should == root
+      end
+    end
+
+    context "when the item is an array" do
+      it "adds the array" do
+        array = ['something else']
+        proxy << array
+        proxy.should include(array)
+      end
+    end
+  end
+
+  context "#[]=" do
+    it "sets the item at the index" do
+      proxy[1] = item
+      proxy[1].should == item
+    end
+
+    context "when the item is not a MongoDoc::Document" do
+      let(:other_item) {'not a doc'}
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy[1] = other_item
+      end
+
+      it "does not set the root" do
+        other_item.should_not_receive(:_root=)
+        proxy[1] = other_item
+      end
+
+      it "adds the item to the collection" do
+        proxy[1] = other_item
+        proxy.should include(other_item)
+      end
+    end
+
+    context "when the item is a MongoDoc::Document" do
+      it "registers a save observer" do
+        root.should_receive(:register_save_observer)
+        proxy[1] = item
+      end
+
+      it "sets the root" do
+        proxy[1] = item
+        item._root.should == root
+      end
+    end
+  end
+
+  context "#concat" do
+    it "appends the items from the array to self" do
+      proxy.concat([item])
+      proxy.should include(item)
+    end
+  end
+
+  context "#replace" do
+    it "clears the existing collection" do
+      proxy.should_receive(:clear)
+      proxy.replace([item])
+    end
+
+    it "concats the other onto self" do
+      other = [item]
+      proxy.should_receive(:concat).with(other)
+      proxy.replace(other)
+    end
+  end
+
+  context "#unshift" do
+    let(:proxy_with_item) { proxy << 'other' }
+
+    it "adds the item to the front of the collection" do
+      proxy_with_item.unshift(item)
+      proxy_with_item[0].should == item
+    end
+
+    context "when the item is not a MongoDoc::Document" do
+      let(:other_item) {'not a doc'}
+
+      it "does not register a save observer" do
+        root.should_not_receive(:register_save_observer)
+        proxy_with_item.unshift(other_item)
+      end
+
+      it "does not set the root" do
+        other_item.should_not_receive(:_root=)
+        proxy_with_item.unshift(other_item)
+      end
+
+      it "adds the item to the front of the collection" do
+        proxy_with_item.unshift(other_item)
+        proxy_with_item[0].should == other_item
+      end
+    end
+
+    context "when the item is a MongoDoc::Document" do
+      let(:new_item) { CollectionProxyTest.new }
+
+      it "registers a save observer" do
+        root.should_receive(:register_save_observer)
+        proxy_with_item.unshift(new_item)
+      end
+
+      it "sets the root" do
+        proxy_with_item.unshift(new_item)
+        new_item._root.should == root
+      end
+
+      it "adds the item to the front of the collection" do
+        proxy_with_item.unshift(new_item)
+        proxy_with_item[0].should == new_item
+      end
+    end
+  end
+
+  context "#build" do
+    let(:name) {'built'}
+
+    it "adds a built item to the collection" do
+      proxy.build({:name => name}).last.name.should == name
+    end
+
+    it "registers a save observer" do
+      root.should_receive(:register_save_observer)
+      proxy.build({:name => name})
+    end
+
+    it "sets the root" do
+      proxy.build({:name => name})
+      proxy.last._root.should == root
+    end
+  end
+end