mongoid-multi-db 3.0.0

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

@@ -0,0 +1,54 @@
+# 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 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.
+          #
+          # @since 2.0.0.rc.1
+          def bind_one(doc)
+            unless _binding?
+              _binding do
+                doc.you_must(metadata.foreign_key_setter, base.id)
+                if metadata.type
+                  doc.you_must(metadata.type_setter, base.class.model_name)
+                end
+                doc.send(metadata.inverse_setter, base)
+              end
+            end
+          end
+
+          # Unbind a single document.
+          #
+          # @example Unbind the document.
+          #   person.posts.unbind_one(document)
+          #
+          # @param [ Document ] document The document to unbind.
+          #
+          # @since 2.0.0.rc.1
+          def unbind_one(doc)
+            unless _binding?
+              _binding do
+                doc.you_must(metadata.foreign_key_setter, nil)
+                if metadata.type
+                  doc.you_must(metadata.type_setter, nil)
+                end
+                doc.send(metadata.inverse_setter, nil)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# 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 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.
+          #
+          # @since 2.0.0.rc.1
+          def bind_one(doc)
+            unless _binding?
+              _binding do
+                inverse_keys = doc.you_must(metadata.inverse_foreign_key)
+                inverse_keys.push(base.id) if inverse_keys
+                base.synced[metadata.foreign_key] = true
+                doc.synced[metadata.inverse_foreign_key] = true
+              end
+            end
+          end
+
+          # Unbind a single document.
+          #
+          # @example Unbind the document.
+          #   person.preferences.unbind_one(document)
+          #
+          # @since 2.0.0.rc.1
+          def unbind_one(doc)
+            unless _binding?
+              _binding do
+                base.send(metadata.foreign_key).delete_one(doc.id)
+                inverse_keys = doc.you_must(metadata.inverse_foreign_key)
+                inverse_keys.delete_one(base.id) if inverse_keys
+                base.synced[metadata.foreign_key] = true
+                doc.synced[metadata.inverse_foreign_key] = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# 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
+          #
+          # @since 2.0.0.rc.1
+          def bind
+            unless _binding?
+              _binding do
+                target.you_must(metadata.foreign_key_setter, base.id)
+                target.send(metadata.inverse_setter, base)
+                if metadata.type
+                  target.you_must(metadata.type_setter, base.class.model_name)
+                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.
+          #   person.game.unbind(:continue => true)
+          #   person.game = nil
+          #
+          # @since 2.0.0.rc.1
+          def unbind
+            unless _binding?
+              _binding do
+                target.you_must(metadata.foreign_key_setter, nil)
+                target.send(metadata.inverse_setter, nil)
+                if metadata.type
+                  target.you_must(metadata.type_setter, nil)
+                end
+              end
+            end
+          end
+          alias :unbind_one :unbind
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builder.rb

@@ -0,0 +1,57 @@
+# 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
+      include Threaded::Lifecycle
+
+      attr_reader :base, :metadata, :object
+
+      # Instantiate the new builder for a relation.
+      #
+      # @example Create the builder.
+      #   Builder.new(metadata, { :field => "value })
+      #
+      # @param [ Document ] base The base document.
+      # @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(base, metadata, object)
+        @base, @metadata, @object = base, metadata, object
+      end
+
+      protected
+
+      # Get the class from the metadata.
+      #
+      # @example Get the class.
+      #   builder.klass
+      #
+      # @return [ Class ] The class from the metadata.
+      #
+      # @since 2.3.2
+      def klass
+        @klass ||= metadata.klass
+      end
+
+      # 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 = Array(object).first
+        !obj.is_a?(Mongoid::Document) && !obj.nil?
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders.rb

@@ -0,0 +1,83 @@
+# 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, metadata)
+          tap do
+            define_method("build_#{name}") do |*args|
+              attributes = args.first || {}
+              options = args.size > 1 ? args[1] : {}
+              document = Factory.build(metadata.klass, attributes, options)
+              _building do
+                send("#{name}=", document)
+              end
+            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 { |doc| doc.save }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders/embedded/in.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Embedded #:nodoc:
+        class In < Builder #:nodoc:
+
+          # This builder doesn't actually build anything, just returns the
+          # parent since it should already be instantiated.
+          #
+          # @example Build the document.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type Not used in this context.
+          #
+          # @return [ Document ] A single document.
+          def build(type = nil)
+            return object unless object.is_a?(Hash)
+            if _loading?
+              Factory.from_db(klass, object)
+            else
+              Factory.build(klass, object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders/embedded/many.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require "mongoid/relations/embedded/sort"
+
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Embedded #:nodoc:
+        class Many < Builder #:nodoc:
+          include Relations::Embedded::Sort
+
+          # Builds the document out of the attributes using the provided
+          # metadata on the relation. Instantiates through the factory in order
+          # to make sure subclasses and allocation are used if fitting. This
+          # case will return many documents.
+          #
+          # @example Build the documents.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type Not used in this context.
+          #
+          # @return [ Array<Document ] The documents.
+          def build(type = nil)
+            return [] if object.blank?
+            return object if object.first.is_a?(Document)
+            [].tap do |docs|
+              object.each do |attrs|
+                if _loading?
+                  docs << Factory.from_db(klass, attrs)
+                else
+                  docs << Factory.build(klass, attrs)
+                end
+              end
+              sort_documents!(docs, metadata) if metadata.order
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders/embedded/one.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module Embedded #:nodoc:
+        class One < Builder #:nodoc:
+
+          # Builds the document out of the attributes using the provided
+          # metadata on the relation. Instantiates through the factory in order
+          # to make sure subclasses and allocation are used if fitting.
+          #
+          # @example Build the document.
+          #   Builder.new(meta, attrs).build
+          #
+          # @param [ String ] type Not used in this context.
+          #
+          # @return [ Document ] A single document.
+          def build(type = nil)
+            return object unless object.is_a?(Hash)
+            if _loading?
+              Factory.from_db(klass, object)
+            else
+              Factory.build(klass, object)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/builders/nested_attributes/many.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+    module Builders #:nodoc:
+      module NestedAttributes #:nodoc:
+        class Many < NestedBuilder
+
+          # Builds the relation depending on the attributes and the options
+          # passed to the macro.
+          #
+          # This attempts to perform 3 operations, either one of an update of
+          # the existing relation, a replacement of the relation with a new
+          # document, or a removal of the relation.
+          #
+          # @example Build the nested attrs.
+          #   many.build(person)
+          #
+          # @param [ Document ] parent The parent document of the relation.
+          #
+          # @return [ Array ] The attributes.
+          def build(parent)
+            @existing = parent.send(metadata.name)
+            if over_limit?(attributes)
+              raise Errors::TooManyNestedAttributeRecords.new(existing, options[:limit])
+            end
+            attributes.each do |attrs|
+              if attrs.respond_to?(:with_indifferent_access)
+                process(parent, attrs)
+              else
+                process(parent, attrs[1])
+              end
+            end
+          end
+
+          # Create the new builder for nested attributes on one-to-many
+          # relations.
+          #
+          # @example Initialize the builder.
+          #   One.new(metadata, attributes, options)
+          #
+          # @param [ Metadata ] metadata The relation metadata.
+          # @param [ Hash ] attributes The attributes hash to attempt to set.
+          # @param [ Hash ] options The options defined.
+          def initialize(metadata, attributes, options = {})
+            if attributes.respond_to?(:with_indifferent_access)
+              @attributes = attributes.with_indifferent_access.sort do |a, b|
+                a[0].to_i <=> b[0].to_i
+              end
+            else
+              @attributes = attributes
+            end
+            @metadata = metadata
+            @options = options
+          end
+
+          private
+
+          # Can the existing relation potentially be deleted?
+          #
+          # @example Is the document destroyable?
+          #   destroyable?({ :_destroy => "1" })
+          #
+          # @parma [ Hash ] attributes The attributes to pull the flag from.
+          #
+          # @return [ true, false ] If the relation can potentially be deleted.
+          def destroyable?(attributes)
+            destroy = attributes.delete(:_destroy)
+            [ 1, "1", true, "true" ].include?(destroy) && allow_destroy?
+          end
+
+          # Are the supplied attributes of greater number than the supplied
+          # limit?
+          #
+          # @example Are we over the set limit?
+          #   builder.over_limit?({ "street" => "Bond" })
+          #
+          # @param [ Hash ] attributes The attributes being set.
+          #
+          # @return [ true, false ] If the attributes exceed the limit.
+          def over_limit?(attributes)
+            limit = options[:limit]
+            limit ? attributes.size > limit : false
+          end
+
+          # Process each set of attributes one at a time for each potential
+          # new, existing, or ignored document.
+          #
+          # @example Process the attributes
+          #   builder.process({ "id" => 1, "street" => "Bond" })
+          #
+          # @param [ Hash ] attrs The single document attributes to process.
+          def process(parent, attrs)
+            return if reject?(parent, attrs)
+            if id = attrs.extract_id
+              doc = existing.find(convert_id(id))
+              if destroyable?(attrs)
+                existing.delete(doc)
+                doc.destroy unless doc.embedded?
+              else
+                metadata.embedded? ? doc.attributes = attrs : doc.update_attributes(attrs)
+              end
+            else
+              existing.push(Factory.build(metadata.klass, attrs)) unless destroyable?(attrs)
+            end
+          end
+        end
+      end
+    end
+  end
+end