mongoid-multi-db 3.0.0

data/lib/mongoid/database_proxy.rb

@@ -0,0 +1,97 @@
+require 'thread'
+require 'mongoid/collection_proxy'
+
+#
+# Proxy that enables runtime swapping of a MongoDB database, as it
+# appears to be cached at several points within Mongoid.
+#
+# This proxy is generated by the ConnectionProxy when asked for a
+# specific database.
+#
+class DatabaseProxy
+    #
+    # Semaphore for preventing badness when multithreading.
+    #
+    @mutex = Mutex.new
+
+    #
+    # All connections that we know about, and then the databases tied to
+    # them get stored in here.
+    #
+    @pool = Hash.new
+
+    #
+    # Accessor for class-level instance variable that holds all the
+    # connection-database pairs that we know about, so that we can
+    # switch all of them globally.
+    #
+    def DatabaseProxy.pool
+        @pool
+    end
+
+    #
+    # Global mutex... for great thread safety!
+    #
+    def DatabaseProxy.mutex
+        @mutex
+    end
+
+    #
+    # Set our default connection and name.
+    #
+    def initialize(connection, name)
+        @connection = connection
+        switch(name)
+    end
+
+    #
+    # Convenience method for synchronizing threads.
+    #
+    def synchronize(&block)
+        DatabaseProxy.mutex.synchronize(&block)
+    end
+
+    #
+    # Switch to a different database on the same connection.
+    #
+    def switch(name)
+        synchronize do
+            # Connect to the cached database if available.
+            pool = (DatabaseProxy.pool[@connection] ||= {})
+            database = (pool[name] || (pool[name] = @connection.db(name)))
+
+            # Set the default if we haven't, and away we go (for this
+            # thread only).
+            @default ||= database 
+            Thread.current[:mongo_database] = database
+        end
+    end
+
+    #
+    # Resets back to the default database connections.
+    #
+    def reset!
+        synchronize { Thread.current[:mongo_database] = nil }
+    end
+
+    #
+    # Returns the raw Mongo::DB object.
+    #
+    def target
+        synchronize { Thread.current[:mongo_database] || @default }
+    end
+
+    #
+    # Create a proxied collection.
+    #
+    def create_collection(name, opts)
+        CollectionProxy.new(self, name, opts)
+    end
+
+    #
+    # Proxy methods to the correct database.
+    #
+    def method_missing(*args, &block)
+        target.send(*args, &block)
+    end
+end

data/lib/mongoid/default_scope.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module handles functionality for creating default scopes.
+  module DefaultScope
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_scoping
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Creates a default_scope for the +Document+, similar to ActiveRecord's
+      # default_scope. +DefaultScopes+ are proxied +Criteria+ objects that are
+      # applied by default to all queries for the class.
+      #
+      # @example Create a default scope.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, :type => Boolean
+      #     field :count, :type => Integer
+      #
+      #     default_scope :where => { :active => true }
+      #   end
+      #
+      # @param [ Hash ] conditions The conditions to create with.
+      #
+      # @since 2.0.0.rc.1
+      def default_scope(conditions = {})
+        self.default_scoping = Scope.new(conditions).conditions.scoped
+      end
+    end
+  end
+end

data/lib/mongoid/dirty.rb

@@ -0,0 +1,110 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Dirty #:nodoc:
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    # Call this method after save, so the changes can be properly switched.
+    #
+    # This will unset the memoized children array, set new record to
+    # false, set the document as validated, and move the dirty changes.
+    #
+    # @example Move the changes to previous.
+    #   person.move_changes
+    #
+    # @since 2.1.0
+    def move_changes
+      @_children = nil
+      @previously_changed = changes
+      atomic_pulls.clear
+      atomic_unsets.clear
+      delayed_atomic_sets.clear
+      delayed_atomic_pulls.clear
+      changed_attributes.clear
+    end
+
+    # Remove a change from the dirty attributes hash. Used by the single field
+    # atomic updators.
+    #
+    # @example Remove a flagged change.
+    #   model.remove_change(:field)
+    #
+    # @param [ Symbol, String ] name The name of the field.
+    #
+    # @since 2.1.0
+    def remove_change(name)
+      changed_attributes.delete(name.to_s)
+    end
+
+    # Gets all the new values for each of the changed fields, to be passed to
+    # a MongoDB $set modifier.
+    #
+    # @example Get the setters for the atomic updates.
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.setters # returns { "title" => "Madam" }
+    #
+    # @return [ Hash ] A +Hash+ of atomic setters.
+    def setters
+      {}.tap do |modifications|
+        changes.each_pair do |field, changes|
+          if changes
+            key = embedded? ? "#{atomic_position}.#{field}" : field
+            modifications[key] = changes[1]
+          end
+        end
+      end
+    end
+
+    private
+
+    # Get the current value for the specified attribute, if the attribute has changed.
+    #
+    # @note This is overriding the AM::Dirty implementation to read from the mongoid
+    #   attributes hash, which may contain a serialized version of the attributes data. It is
+    #   necessary to read the serialized version as the changed value, to allow updates to
+    #   the MongoDB document to persist correctly. For example, if a DateTime field is updated
+    #   it must be persisted as a UTC Time.
+    #
+    # @return [ Object ] The current value of the field, or nil if no change made.
+    #
+    # @since 2.1.0
+    def attribute_change(attr)
+      [changed_attributes[attr], attributes[attr]] if attribute_changed?(attr)
+    end
+
+    # Determine if a specific attribute has changed.
+    #
+    # @note Overriding AM::Dirty once again since their implementation is not
+    #   friendly to fields that can be changed in place.
+    #
+    # @param [ String ] attr The name of the attribute.
+    #
+    # @return [ true, false ] Whether the attribute has changed.
+    #
+    # @since 2.1.6
+    def attribute_changed?(attr)
+      return false unless changed_attributes.include?(attr)
+      changed_attributes[attr] != attributes[attr]
+    end
+
+    # Override Active Model's behaviour here in order to stay away from
+    # infinite loops on getter/setter overrides.
+    #
+    # @example Flag an attribute as changing.
+    #   document.attribute_will_change!(:name)
+    #
+    # @param [ Symbol ] attr The attribute.
+    #
+    # @return [ Object ] The value of the attribute.
+    #
+    # @since 2.3.0
+    def attribute_will_change!(attr)
+      unless changed_attributes.include?(attr)
+        value = read_attribute(attr)
+        value = value.duplicable? ? value.clone : value
+        changed_attributes[attr] = value
+      end
+    end
+  end
+end

data/lib/mongoid/document.rb

@@ -0,0 +1,280 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This is the base module for all domain objects that need to be persisted to
+  # the database as documents.
+  module Document
+    extend ActiveSupport::Concern
+    include Mongoid::Components
+
+    attr_reader :new_record
+
+    # Default comparison is via the string version of the id.
+    #
+    # @example Compare two documents.
+    #   person <=> other_person
+    #
+    # @param [ Document ] other The document to compare with.
+    #
+    # @return [ Integer ] -1, 0, 1.
+    def <=>(other)
+      attributes["_id"].to_s <=> other.attributes["_id"].to_s
+    end
+
+    # Performs equality checking on the document ids. For more robust
+    # equality checking please override this method.
+    #
+    # @example Compare for equality.
+    #   document == other
+    #
+    # @param [ Document, Object ] other The other object to compare with.
+    #
+    # @return [ true, false ] True if the ids are equal, false if not.
+    def ==(other)
+      self.class == other.class &&
+        attributes["_id"] == other.attributes["_id"]
+    end
+
+    # Performs class equality checking.
+    #
+    # @example Compare the classes.
+    #   document === other
+    #
+    # @param [ Document, Object ] other The other object to compare with.
+    #
+    # @return [ true, false ] True if the classes are equal, false if not.
+    def ===(other)
+      other.is_a?(self.class)
+    end
+
+    # Delegates to ==. Used when needing checks in hashes.
+    #
+    # @example Perform equality checking.
+    #   document.eql?(other)
+    #
+    # @param [ Document, Object ] other The object to check against.
+    #
+    # @return [ true, false ] True if equal, false if not.
+    def eql?(other)
+      self == (other)
+    end
+
+    # Freezes the internal attributes of the document.
+    #
+    # @example Freeze the document
+    #   document.freeze
+    #
+    # @return [ Document ] The document.
+    #
+    # @since 2.0.0
+    def freeze
+      attributes.freeze
+      self
+    end
+
+    # Checks if the document is frozen
+    #
+    # @example Check if frozen
+    #   document.frozen?
+    #
+    # @return [ true, false ] True if frozen, else false.
+    #
+    # @since 2.0.0
+    def frozen?
+      raw_attributes.frozen?
+    end
+
+    # Delegates to id in order to allow two records of the same type and id to
+    # work with something like:
+    #
+    #   [ Person.find(1), Person.find(2), Person.find(3) ] &
+    #   [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+    #
+    # @example Get the hash.
+    #   document.hash
+    #
+    # @return [ Integer ] The hash of the document's id.
+    def hash
+      raw_attributes["_id"].hash
+    end
+
+    # Generate an id for this +Document+.
+    #
+    # @example Create the id.
+    #   person.identify
+    #
+    # @return [ BSON::ObjectId, String ] A newly created id.
+    def identify
+      Identity.new(self).create
+    end
+
+    # Instantiate a new +Document+, setting the Document's attributes if
+    # given. If no attributes are provided, they will be initialized with
+    # an empty +Hash+.
+    #
+    # If a primary key is defined, the document's id will be set to that key,
+    # otherwise it will be set to a fresh +BSON::ObjectId+ string.
+    #
+    # @example Create a new document.
+    #   Person.new(:title => "Sir")
+    #
+    # @param [ Hash ] attrs The attributes to set up the document with.
+    # @param [ Hash ] options A mass-assignment protection options. Supports
+    #   :as and :without_protection
+    #
+    # @return [ Document ] A new document.
+    def initialize(attrs = nil, options = nil)
+      _building do
+        @new_record = true
+        @attributes ||= {}
+        options ||= {}
+        process(attrs, options[:as] || :default, !options[:without_protection]) do
+          identify
+          apply_defaults
+          yield(self) if block_given?
+        end
+        run_callbacks(:initialize) { self }
+      end
+    end
+
+    # Return an array with this +Document+ only in it.
+    #
+    # @example Return the document in an array.
+    #   document.to_a
+    #
+    # @return [ Array<Document> ] An array with the document as its only item.
+    def to_a
+      [ self ]
+    end
+
+    # Return a hash of the entire document hierarchy from this document and
+    # below. Used when the attributes are needed for everything and not just
+    # the current document.
+    #
+    # @example Get the full hierarchy.
+    #   person.as_document
+    #
+    # @return [ Hash ] A hash of all attributes in the hierarchy.
+    def as_document
+      attributes.tap do |attrs|
+        relations.each_pair do |name, meta|
+          if meta.embedded?
+            relation = send(name)
+            attrs[name] = relation.as_document unless relation.blank?
+          end
+        end
+      end
+    end
+
+    # Returns an instance of the specified class with the attributes
+    # and errors of the current document.
+    #
+    # @example Return a subclass document as a superclass instance.
+    #   manager.becomes(Person)
+    #
+    # @raise [ ArgumentError ] If the class doesn't include Mongoid::Document
+    #
+    # @param [ Class ] klass The class to become.
+    #
+    # @return [ Document ] An instance of the specified class.
+    def becomes(klass)
+      unless klass.include?(Mongoid::Document)
+        raise ArgumentError, "A class which includes Mongoid::Document is expected"
+      end
+      klass.instantiate(frozen? ? attributes.dup : attributes).tap do |became|
+        became.instance_variable_set(:@errors, errors)
+        became.instance_variable_set(:@new_record, new_record?)
+        became.instance_variable_set(:@destroyed, destroyed?)
+        became._type = klass.to_s
+      end
+    end
+
+    private
+
+    # Returns the logger
+    #
+    # @return [ Logger ] The configured logger or a default Logger instance.
+    #
+    # @since 2.2.0
+    def logger
+      Mongoid.logger
+    end
+
+    # Implement this for calls to flatten on array.
+    #
+    # @example Get the document as an array.
+    #   document.to_ary
+    #
+    # @return [ nil ] Always nil.
+    #
+    # @since 2.1.0
+    def to_ary
+      nil
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Performs class equality checking.
+      #
+      # @example Compare the classes.
+      #   document === other
+      #
+      # @param [ Document, Object ] other The other object to compare with.
+      #
+      # @return [ true, false ] True if the classes are equal, false if not.
+      #
+      # @since 2.0.0.rc.4
+      def ===(other)
+        self == (other.is_a?(Class) ? other : other.class)
+      end
+
+      # Instantiate a new object, only when loaded from the database or when
+      # the attributes have already been typecast.
+      #
+      # @example Create the document.
+      #   Person.instantiate(:title => "Sir", :age => 30)
+      #
+      # @param [ Hash ] attrs The hash of attributes to instantiate with.
+      #
+      # @return [ Document ] A new document.
+      def instantiate(attrs = nil)
+        attributes = attrs || {}
+        allocate.tap do |doc|
+          doc.instance_variable_set(:@attributes, attributes)
+          doc.send(:apply_defaults)
+          IdentityMap.set(doc) unless _loading_revision?
+          doc.run_callbacks(:initialize) { doc }
+        end
+      end
+
+      # Returns all types to query for when using this class as the base.
+      #
+      # @example Get the types.
+      #   document._types
+      #
+      # @return [ Array<Class> ] All subclasses of the current document.
+      def _types
+        @_type ||= [descendants + [self]].flatten.uniq.map { |t| t.to_s }
+      end
+
+      # Set the i18n scope to overwrite ActiveModel.
+      #
+      # @return [ Symbol ] :mongoid
+      def i18n_scope
+        :mongoid
+      end
+
+      # Returns the logger
+      #
+      # @example Get the logger.
+      #   Person.logger
+      #
+      # @return [ Logger ] The configured logger or a default Logger instance.
+      #
+      # @since 2.2.0
+      def logger
+        Mongoid.logger
+      end
+    end
+  end
+end