mongo_doc 0.6.20 → 0.6.21

data/.rvmrc

@@ -1,2 +1 @@
-rvm_gemset_create_on_use_flag=1
 rvm gemset use mongo_doc

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mongo_doc (0.6.20)
+    mongo_doc (0.6.21)
       activemodel (>= 3.0.0.beta.4)
       activesupport (>= 3.0.0.beta.4)
       bson (>= 1.0.0)

data/README.textile

@@ -1,6 +1,6 @@
 h1. MongoDoc
 
-Version: 0.6.20 2010/08/18
+Version: 0.6.21 2010/08/29
 
 h2. Notes
 

data/VERSION

@@ -1 +1 @@
-0.6.20
+0.6.21

data/lib/mongo_doc/references.rb

@@ -2,7 +2,7 @@ module MongoDoc
   module References
 
     # Dereference a DBRef and return the Object
-    def dereference(db_ref)
+    def self.dereference(db_ref)
       MongoDoc::Collection.new(db_ref.namespace).find_one(db_ref.object_id)
     end
 
@@ -77,7 +77,7 @@ module MongoDoc
           @#{name} ||= if #{name}_ref.nil?        # @address ||= if address_name_ref.nil?
               nil                                 #     nil
             else                                  #   else
-              self.class.dereference(#{name}_ref) #     self.class.dereference(address_name_ref)
+              References.dereference(#{name}_ref) #     References.dereference(address_name_ref)
             end                                   #   end
         end
 

data/lib/mongo_doc/references_many.rb

@@ -1,46 +1,134 @@
 module MongoDoc
   module ReferencesMany
-    # Declare an array of references to other +Document+s.
+
+    def self.ids_from_objects(objects)
+      if objects.blank?
+        []
+      else
+        objects.map {|obj| obj._id }
+      end
+    end
+
+    def self.ids_from_strings_or_ids(ids_or_strings)
+      if ids_or_strings.blank?
+        []
+      else
+        ids_or_strings.map do |item|
+          if String === item
+            ::BSON::ObjectID.cast_from_string(item)
+          else
+            item
+          end
+        end
+      end
+    end
+
+    def self.objects_from_ids(klass, ids)
+      if ids.blank?
+        []
+      else
+        klass.find(*ids).entries
+      end
+    end
+
+    def self.objects_from_refs(refs)
+      if refs.blank?
+        []
+      else
+        refs.map {|ref| References.dereference(ref) }
+      end
+    end
+
+    def self.refs_from_objects(objects)
+      if objects.blank?
+        []
+      else
+        objects.map {|obj| ::BSON::DBRef.new(obj.class.collection_name, obj._id) }
+      end
+    end
+
+    # Declare reference to an array of +Document+s. The references can be
+    # +ObjectID+ references or a +BSON::DBRef+, but cannot be both.
+    #
+    # Use an +ObjectID+ reference when you have a simple reference or will be
+    # referencing a single polymorphic collection. Example:
+    #
+    # +references_many :addresses
+    # +references_many :addresses, :as => :work_address+
     #
     # * classname:: name of +Document+ type as an +underscore+ symbol or string
-    # * options:: +:as+ specifies the name of the attribute
-    def references_many(classname, options = {})
-      klass = classname.to_s.camelize.singularize
-      objects_name = (options[:as] || klass.demodulize.downcase.pluralize).to_s
+    # * options:: +:as+ specifies the name of the attribute, defaults to
+    # classname
+    #
+    # Use a +BSON::DBRef+ when you need a reference to multiple collections.
+    # Example:
+    #
+    # +references_many :as_ref => :work_address+
+    #
+    # * required:: +:as_ref+ name of the attribute
+    def references_many(*args)
+      options = args.extract_options!
+
+      if options.has_key?(:as_ref)
+        references_many_by_dbref(options[:as_ref].to_s)
+      else
+        klass = args[0].to_s.singularize.camelize
+        references_many_by_id(klass, options[:as].try(:to_s) || klass.demodulize.downcase.pluralize)
+      end
+    end
+
+    private
+
+    def references_many_by_dbref(objects_name)
+      refs_name = "#{objects_name.singularize}_refs"
+
+      _keys << refs_name unless _keys.include?(refs_name)
+
+      module_eval(<<-RUBY, __FILE__, __LINE__)
+        def #{objects_name}=(objects)                                   # def addresses=(objects)
+          @#{objects_name} = objects                                    #   @addresses = objects
+          self.#{refs_name} = ReferencesMany.refs_from_objects(objects) # self.address_refs = ReferencesMany.refs_from_objects(objects)
+        end                                                             # end
+
+        def #{objects_name}                                                   # def addresses
+          @#{objects_name} ||= ReferencesMany.objects_from_refs(#{refs_name}) #   @addresses ||= ReferencesMany.objects_from_refs(address_refs)
+        end                                                                   # end
+
+        def #{refs_name}=(refs)  # def address_refs=(refs)
+          @#{objects_name} = nil #   @addresses = nil
+          @#{refs_name} = refs   #   @address_refs = refs
+        end                      # end
+
+        def #{refs_name}       # def address_refs
+          @#{refs_name} ||= [] #  @address_refs ||= []
+        end                    # end
+      RUBY
+    end
+
+    def references_many_by_id(klass, objects_name)
       ids_name = "#{objects_name.singularize}_ids"
 
       _keys << ids_name unless _keys.include?(ids_name)
 
       module_eval(<<-RUBY, __FILE__, __LINE__)
-        def #{objects_name}=(array)           # def addresses=(array)
-          @#{objects_name} = array            #   @addresses = array
-          self.#{ids_name} = array.map(&:_id) #   self.address_ids = array.map(&:_id)
-        end                                   # end
-
-        def #{objects_name}                          # def addresses
-          @#{objects_name} ||= if #{ids_name}.empty? #   @addresses ||= if address_ids.empty?
-              []                                     #     []
-            else                                     #   else
-              "#{klass}".constantize.                #     "Address".constantize.
-                find(*#{ids_name}).entries           #       find(*address_ids).entries
-            end                                      #   end
-        end
+        def #{objects_name}=(objects)                                 # def addresses=(objects)
+          @#{objects_name} = objects                                  #   @addresses = objects
+          self.#{ids_name} = ReferencesMany.ids_from_objects(objects) #   self.address_ids = ReferencesMany.ids_from_objects(objects)
+        end                                                           # end
+
+        def #{objects_name}                                                           # def addresses
+          @#{objects_name} ||= ReferencesMany.objects_from_ids(#{klass}, #{ids_name}) #   @addresses||= ReferencesMany.objects_from_ids(Address, address_ids)
+        end                                                                           # end
 
-        def #{ids_name}=(array)                           # def address_ids=(array)
-          @#{objects_name} = nil                          #   @addresses = nil
-          @#{ids_name} = ReferencesMany.cast_array(array) #   @address_ids = ReferencesMany.cast_array(array)
-        end                                               # end
+        def #{ids_name}=(ids_or_strings)                                        # def address_ids=(ids_or_strings)
+          @#{objects_name} = nil                                                #   @addresses = nil
+          @#{ids_name} = ReferencesMany.ids_from_strings_or_ids(ids_or_strings) #   @address_ids = ReferencesMany.ids_from_strings_or_ids(ids_or_strings)
+        end                                                                     # end
 
         def #{ids_name}       # def address_ids
           @#{ids_name} ||= [] #  @address_ids ||= []
         end                   # end
       RUBY
     end
-
-    def self.cast_array(array)
-      array.nil? ? [] : array.map do |item|
-        String === item ? ::BSON::ObjectID.cast_from_string(item) : item
-      end
-    end
   end
 end

data/lib/mongo_doc.rb

@@ -3,7 +3,7 @@ require 'active_support'
 require 'active_support/core_ext'
 
 module MongoDoc
-  VERSION = '0.6.20'
+  VERSION = '0.6.21'
 end
 
 require 'mongo_doc/connection'

data/mongo_doc.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mongo_doc}
-  s.version = "0.6.20"
+  s.version = "0.6.21"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Les Hill"]
-  s.date = %q{2010-08-18}
+  s.date = %q{2010-09-01}
   s.description = %q{ODM for MongoDB}
   s.email = %q{leshill@gmail.com}
   s.extra_rdoc_files = [

data/spec/references_many_spec.rb

@@ -8,20 +8,21 @@ describe MongoDoc::ReferencesMany do
   end
 
   context "Simple Reference" do
-    class Person
+    class PersonSimple
       include MongoDoc::Document
 
       references_many :addresses
     end
 
-    subject { Person.new }
+    let(:person) { PersonSimple.new }
+    subject { person }
 
     context "Object accessor" do
       it { should respond_to(:addresses) }
       it { should respond_to(:addresses=) }
 
       it "is not part of the persistent key set" do
-        Person._keys.should_not include('addresses')
+        PersonSimple._keys.should_not include('addresses')
       end
     end
 
@@ -30,26 +31,61 @@ describe MongoDoc::ReferencesMany do
       it { should respond_to(:address_ids=) }
 
       it "is part of the persistent key set" do
-        Person._keys.should include('address_ids')
+        PersonSimple._keys.should include('address_ids')
+      end
+    end
+
+    context "setting the ids" do
+      let(:address) { Address.new(:_id => BSON::ObjectID.new) }
+
+      before do
+        person.addresses = [address]
+      end
+
+      context "to nil" do
+        before do
+          person.address_ids = nil
+        end
+
+        its(:address_ids) { should == [] }
+        its(:addresses) { should == [] }
+      end
+
+      context "to []" do
+        before do
+          person.address_ids = []
+        end
+
+        its(:addresses) { should == [] }
+      end
+
+      context "to strings" do
+        before do
+          person.address_ids = [address._id.to_s]
+        end
+
+        its(:address_ids) { should == [address._id] }
       end
     end
   end
 
   context "Named Reference" do
-    class Person
+    class PersonNamed
       include MongoDoc::Document
 
       references_many :addresses, :as => :known_addresses
     end
 
-    subject { Person.new }
+    let(:person) { PersonNamed.new }
+
+    subject { person }
 
     context "Object accessor" do
       it { should respond_to(:known_addresses) }
       it { should respond_to(:known_addresses=) }
 
       it "is not part of the persistent key set" do
-        Person._keys.should_not include('known_addresses')
+        PersonNamed._keys.should_not include('known_addresses')
       end
     end
 
@@ -58,50 +94,120 @@ describe MongoDoc::ReferencesMany do
       it { should respond_to(:known_address_ids=) }
 
       it "is part of the persistent key set" do
-        Person._keys.should include('known_address_ids')
+        PersonNamed._keys.should include('known_address_ids')
+      end
+    end
+
+    context "setting the ids" do
+      let(:address) { Address.new(:_id => BSON::ObjectID.new) }
+
+      before do
+        person.known_addresses = [address]
+      end
+
+      context "to nil" do
+        before do
+          person.known_address_ids = nil
+        end
+
+        its(:known_address_ids) { should == [] }
+        its(:known_addresses) { should == [] }
+      end
+
+      context "to []" do
+        before do
+          person.known_address_ids = []
+        end
+
+        its(:known_addresses) { should == [] }
+      end
+
+      context "to strings" do
+        before do
+          person.known_address_ids = [address._id.to_s]
+        end
+
+        its(:known_address_ids) { should == [address._id] }
       end
     end
   end
 
-  describe "setting the ids" do
-    class Person
+  context "DBRef reference" do
+    class PersonDBRef
       include MongoDoc::Document
 
-      references_many :address
+      references_many :as_ref => :addresses
     end
 
     let(:address) { Address.new(:_id => BSON::ObjectID.new) }
-    let(:person) { Person.new }
+    let(:person) { PersonDBRef.new }
+
+    subject { person }
+
+    context "Object accessor" do
+      it { should respond_to(:addresses) }
+      it { should respond_to(:addresses=) }
+
+      it "is not part of the persistent key set" do
+        PersonDBRef._keys.should_not include('addresses')
+      end
+    end
+
+    context "DBRef accessor" do
+      it { should respond_to(:address_refs) }
+      it { should respond_to(:address_refs=) }
+
+      it "is part of the persistent key set" do
+        PersonDBRef._keys.should include('address_refs')
+      end
+    end
 
-    context "to" do
+    context "setting the collection" do
       before do
         person.addresses = [address]
       end
 
-      context "nil" do
+      it "sets the refs to an array of refs]" do
+        person.address_refs.first.namespace.should == Address.collection_name
+        person.address_refs.first.object_id.should == address._id
+      end
+    end
+
+    context "setting the refs" do
+      before do
+        person.addresses = [address]
+      end
+
+      context "to nil" do
         before do
-          person.address_ids = nil
+          person.address_refs = nil
         end
 
-        it "sets the ids to []" do
-          person.address_ids.should == []
+        it "sets the refs to []" do
+          person.address_refs.should == []
         end
 
-        it "resets the objects to nil" do
-          person.addresses.should == []
-        end
+        its(:addresses) { should == [] }
       end
 
-      it "[] resets the objects to []" do
-        person.address_ids = []
-        person.addresses.should == []
+      context "to []" do
+        before do
+          person.address_refs = []
+        end
+
+        its(:addresses) { should == [] }
       end
-    end
 
-    context "to strings" do
-      it "converts the strings to ids" do
-        person.address_ids = [address._id.to_s]
-        person.address_ids.should == [address._id]
+      context "to an array of references" do
+        let(:dbref) { ::BSON::DBRef.new(Address.collection_name, address._id) }
+
+        before do
+          person.address_refs = [dbref]
+        end
+
+        it "sets the addresses to nil" do
+          person.instance_variable_get('@addresses').should be_nil
+        end
       end
     end
   end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mongo_doc
 version: !ruby/object:Gem::Version 
+  hash: 45
   prerelease: false
   segments: 
   - 0
   - 6
-  - 20
-  version: 0.6.20
+  - 21
+  version: 0.6.21
 platform: ruby
 authors: 
 - Les Hill
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-18 00:00:00 -04:00
+date: 2010-09-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,6 +26,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 62196427
         segments: 
         - 3
         - 0
@@ -42,6 +44,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 62196427
         segments: 
         - 3
         - 0
@@ -59,6 +62,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 0
@@ -74,6 +78,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 0
@@ -89,6 +94,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 0
@@ -104,6 +110,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 63
         segments: 
         - 0
         - 3
@@ -119,6 +126,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 53
         segments: 
         - 0
         - 8
@@ -134,6 +142,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 1
         - 4
@@ -149,6 +158,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 62196423
         segments: 
         - 2
         - 0
@@ -345,6 +355,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -353,6 +364,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"