mongoid 2.0.0.beta.20 → 2.0.0.rc.1

data/lib/mongoid/relations/bindings/referenced/in.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Referenced #:nodoc:
+
+        # Binding class for all referenced_in relations.
+        class In < Binding
+
+          # Binds the base object to the inverse of the relation. This is so we
+          # are referenced to the actual objects themselves on both sides.
+          #
+          # This case sets the metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind the documents.
+          #   game.person.bind(:continue => true)
+          #   game.person = Person.new
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind(options = {})
+            inverse = metadata.inverse(target)
+            base.send(metadata.foreign_key_setter, target.id)
+            if metadata.inverse_type
+              base.send(metadata.inverse_type_setter, target.class.name)
+            end
+            if inverse
+              base.metadata = target.reflect_on_association(inverse)
+              if options[:continue]
+                if base.referenced_many?
+                  target.do_or_do_not(
+                    inverse,
+                    false,
+                    :building => true,
+                    :continue => false
+                  ).push(base, :building => true, :continue => false)
+                else
+                  target.do_or_do_not(
+                    metadata.inverse_setter(target),
+                    base,
+                    :building => true,
+                    :continue => false
+                  )
+                end
+              end
+            end
+          end
+          alias :bind_one :bind
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   game.person.unbind(:continue => true)
+          #   game.person = nil
+          #
+          # @param [ Hash ] options The options to pass through.
+          #
+          # @option options [ true, false ] :continue Do we continue unbinding?
+          #
+          # @since 2.0.0.rc.1
+          def unbind(options = {})
+            base.do_or_do_not(metadata.foreign_key_setter, nil)
+            if options[:continue]
+              target.do_or_do_not(metadata.inverse_setter(target), nil, :continue => false)
+            end
+          end
+          alias :unbind_one :unbind
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/bindings/referenced/many.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Referenced #:nodoc:
+
+        # Binding class for references_many relations.
+        class Many < Binding
+
+          # Binds the base object to the inverse of the relation. This is so we
+          # are referenced to the actual objects themselves on both sides.
+          #
+          # This case sets the metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind all the documents.
+          #   person.posts.bind
+          #   person.posts = [ Post.new ]
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind(options = {})
+            target.each { |doc| bind_one(doc, options) }
+          end
+
+          # Binds a single document with the inverse relation. Used
+          # specifically when appending to the proxy.
+          #
+          # @example Bind one document.
+          #   person.posts.bind_one(post)
+          #
+          # @param [ Document ] doc The single document to bind.
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind_one(doc, options = {})
+            if options[:continue]
+              doc.do_or_do_not(metadata.foreign_key_setter, base.id)
+              doc.do_or_do_not(
+                metadata.inverse_setter,
+                base,
+                :building => true,
+                :continue => false
+              )
+            end
+          end
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the documents.
+          #   person.posts.unbind
+          #   person.posts = nil
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def unbind(options = {})
+            target.each { |doc| unbind_one(doc, options) }
+          end
+
+          # Unbind a single document.
+          #
+          # @example Unbind the document.
+          #   person.posts.unbind_one(document)
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def unbind_one(doc, options = {})
+            if options[:continue]
+              doc.do_or_do_not(metadata.foreign_key_setter, nil)
+              doc.do_or_do_not(metadata.inverse_setter, nil, :continue => false)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/bindings/referenced/many_to_many.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Referenced #:nodoc:
+
+        # Binding class for all references_and_referenced_in_many relations.
+        class ManyToMany < Binding
+
+          # Binds the base object to the inverse of the relation. This is so we
+          # are referenced to the actual objects themselves on both sides.
+          #
+          # This case sets the metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind all the documents.
+          #   person.preferences.bind
+          #   person.preferences = [ Preference.new ]
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind(options = {})
+            target.each { |doc| bind_one(doc, options) }
+          end
+
+          # Binds a single document with the inverse relation. Used
+          # specifically when appending to the proxy.
+          #
+          # @example Bind one document.
+          #   person.preferences.bind_one(preference)
+          #
+          # @param [ Document ] doc The single document to bind.
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind_one(doc, options = {})
+            keys = base.do_or_do_not(metadata.foreign_key)
+            keys.push(doc.id) unless keys.include?(doc.id)
+            if options[:continue]
+              doc.do_or_do_not(
+                metadata.inverse(target),
+                false,
+                :building => true,
+                :continue => false
+              ).push(base, :continue => false)
+            end
+          end
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the documents.
+          #   person.preferences.unbind
+          #   person.preferences = nil
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def unbind(options = {})
+            target.each { |doc| unbind_one(doc, options) }
+          end
+
+          # Unbind a single document.
+          #
+          # @example Unbind the document.
+          #   person.preferences.unbind_one(document)
+          #
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def unbind_one(doc, options = {})
+            base.do_or_do_not(metadata.foreign_key).delete(doc.id)
+            if options[:continue]
+              doc.do_or_do_not(metadata.inverse(target)).delete(base)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/bindings/referenced/one.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Bindings #:nodoc:
+      module Referenced #:nodoc:
+
+        # Binding class for references_one relations.
+        class One < Binding
+
+          # Binds the base object to the inverse of the relation. This is so we
+          # are referenced to the actual objects themselves on both sides.
+          #
+          # This case sets the metadata on the inverse object as well as the
+          # document itself.
+          #
+          # @example Bind the document.
+          #   person.game.bind(:continue => true)
+          #   person.game = Game.new
+          #
+          # @param [ Hash ] options The options to pass through.
+          #
+          # @option options [ true, false ] :continue Do we continue binding?
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind(options = {})
+            if options[:continue]
+              target.do_or_do_not(metadata.foreign_key_setter, base.id)
+              target.do_or_do_not(
+                metadata.inverse_setter,
+                base,
+                :building => true,
+                :continue => false
+              )
+            end
+          end
+          alias :bind_one :bind
+
+          # Unbinds the base object and the inverse, caused by setting the
+          # reference to nil.
+          #
+          # @example Unbind the document.
+          #   person.game.unbind(:continue => true)
+          #   person.game = nil
+          #
+          # @param [ Hash ] options The options to pass through.
+          #
+          # @option options [ true, false ] :continue Do we continue unbinding?
+          # @option options [ true, false ] :building Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def unbind(options = {})
+            if options[:continue]
+              target.do_or_do_not(metadata.foreign_key_setter, nil)
+              target.do_or_do_not(metadata.inverse_setter, nil, :continue => false)
+            end
+          end
+          alias :unbind_one :unbind
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builder.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # Superclass for all builder objects. Builders are responsible for either
+    # looking up a relation's target from the database, or creating them from a
+    # supplied attributes hash.
+    class Builder
+
+      attr_reader :metadata, :object
+      # Instantiate the new builder for a relation.
+      #
+      # @example Create the builder.
+      #   Builder.new(metadata, { :field => "value })
+      #
+      # @param [ Metdata ] metadata The metadata for the relation.
+      # @param [ Hash, BSON::ObjectId ] object The attributes to build from or
+      #   id to query with.
+      #
+      # @since 2.0.0.rc.1
+      def initialize(metadata, object)
+        @metadata, @object = metadata, object
+      end
+
+      protected
+      # Do we need to perform a database query? It will be so if the object we
+      # have is not a document.
+      #
+      # @example Should we query the database?
+      #   builder.query?
+      #
+      # @return [ true, false ] Whether a database query should happen.
+      #
+      # @since 2.0.0.rc.1
+      def query?
+        obj = object.to_a.first
+        !obj.respond_to?(:attributes) && !obj.nil?
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+require "mongoid/relations/builder"
+require "mongoid/relations/nested_builder"
+require "mongoid/relations/builders/embedded/in"
+require "mongoid/relations/builders/embedded/many"
+require "mongoid/relations/builders/embedded/one"
+require "mongoid/relations/builders/nested_attributes/one"
+require "mongoid/relations/builders/nested_attributes/many"
+require "mongoid/relations/builders/referenced/in"
+require "mongoid/relations/builders/referenced/many"
+require "mongoid/relations/builders/referenced/many_to_many"
+require "mongoid/relations/builders/referenced/one"
+
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module is responsible for defining the build and create methods used
+    # in one to one relations.
+    #
+    # @example Methods that get created.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #   end
+    #
+    #   # The following methods get created:
+    #   person.build_name({ :first_name => "Durran" })
+    #   person.create_name({ :first_name => "Durran" })
+    #
+    # @since 2.0.0.rc.1
+    module Builders
+      extend ActiveSupport::Concern
+
+      module ClassMethods #:nodoc:
+
+        # Defines a builder method for an embeds_one relation. This is
+        # defined as #build_name.
+        #
+        # @example
+        #   Person.builder("name")
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def builder(name)
+          tap do
+            define_method("build_#{name}") do |*args|
+              attributes = (args.any? ? args : []) + [{:building => true}]
+              send("#{name}=", *attributes)
+            end
+          end
+        end
+
+        # Defines a creator method for an embeds_one relation. This is
+        # defined as #create_name. After the object is built it will
+        # immediately save.
+        #
+        # @example
+        #   Person.creator("name")
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def creator(name)
+          tap do
+            define_method("create_#{name}") do |*args|
+              send("build_#{name}", *args).tap(&:save)
+            end
+          end
+        end
+      end
+    end
+  end
+end