mongoid-multi-db 3.0.0

data/lib/mongoid/reloading.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # This module handles reloading behaviour of documents.
+  module Reloading
+
+    # Reloads the +Document+ attributes from the database. If the document has
+    # not been saved then an error will get raised if the configuration option
+    # was set. This can reload root documents or embedded documents.
+    #
+    # @example Reload the document.
+    #   person.reload
+    #
+    # @raise [ Errors::DocumentNotFound ] If the document was deleted.
+    #
+    # @return [ Document ] The document, reloaded.
+    #
+    # @since 1.0.0
+    def reload
+      _reload.tap do |reloaded|
+        if Mongoid.raise_not_found_error && reloaded.empty?
+          raise Errors::DocumentNotFound.new(self.class, id)
+        end
+        @attributes = reloaded
+      end
+      tap do |doc|
+        doc.changed_attributes.clear
+        doc.apply_defaults
+        doc.reload_relations
+        doc.run_callbacks(:initialize)
+      end
+    end
+
+    private
+
+    # Reload the document, determining if it's embedded or not and what
+    # behaviour to use.
+    #
+    # @example Reload the document.
+    #   document._reload
+    #
+    # @return [ Hash ] The reloaded attributes.
+    #
+    # @since 2.3.2
+    def _reload
+      embedded? ? reload_embedded_document : reload_root_document
+    end
+
+    # Reload the root document.
+    #
+    # @example Reload the document.
+    #   document.reload_root_document
+    #
+    # @return [ Hash ] The reloaded attributes.
+    #
+    # @since 2.3.2
+    def reload_root_document
+      {}.merge(collection.find_one(:_id => id) || {})
+    end
+
+    # Reload the embedded document.
+    #
+    # @example Reload the document.
+    #   document.reload_embedded_document
+    #
+    # @return [ Hash ] The reloaded attributes.
+    #
+    # @since 2.3.2
+    def reload_embedded_document
+      extract_embedded_attributes({}.merge(
+        _root.collection.find_one(:_id => _root.id)
+      ))
+    end
+
+    # Extract only the desired embedded document from the attributes.
+    #
+    # @example Extract the embedded document.
+    #   document.extract_embedded_attributes(attributes)
+    #
+    # @param [ Hash ] attributes The document in the db.
+    #
+    # @return [ Hash ] The document's extracted attributes.
+    #
+    # @since 2.3.2
+    def extract_embedded_attributes(attributes)
+      atomic_position.split(".").inject(attributes) do |attrs, part|
+        attrs = attrs[part =~ /\d/ ? part.to_i : part]
+        attrs
+      end
+    end
+  end
+end

data/lib/mongoid/safety.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # The +Safety+ module is used to provide a DSL to execute database operations
+  # in safe mode on a per query basis, either from the +Document+ class level
+  # or instance level.
+  module Safety
+    extend ActiveSupport::Concern
+
+    # Execute the following instance-level persistence operation in safe mode.
+    #
+    # @example Upsert in safe mode.
+    #   person.safely.upsert
+    #
+    # @example Destroy in safe mode with w and fsync options.
+    #   person.safely(:w => 2, :fsync => true).destroy
+    #
+    # @param [ Hash ] options The safe mode options.
+    #
+    # @option options [ Integer ] :w The number of nodes to write to.
+    # @option options [ Integer ] :wtimeout Time to wait for return from all
+    #   nodes.
+    # @option options [ true, false ] :fsync Should a fsync occur.
+    #
+    # @return [ Proxy ] The safety proxy.
+    def safely(safety = true)
+      tap { Threaded.safety_options = safety }
+    end
+
+    # Execute the following instance-level persistence operation without safe mode.
+    # Allows per-request overriding of safe mode when the persist_in_safe_mode
+    # config option is turned on.
+    #
+    # @example Upsert in safe mode.
+    #   person.unsafely.upsert
+    #
+    # @return [ Proxy ] The safety proxy.
+    def unsafely
+      tap { Threaded.safety_options = false }
+    end
+
+    class << self
+
+      # Static class method of easily getting the desired safe mode options
+      # from anywhere in the framework.
+      #
+      # @example Get the options with safe mode included.
+      #   Safety.merge_safety_options({ :safe => false })
+      #
+      # @param [ Hash ] options The persistence options.
+      #
+      # @return [ Hash ] The options hash.
+      #
+      # @since 2.1.0
+      def merge_safety_options(options = {})
+        options ||= {}
+        return options if options[:safe]
+
+        unless Threaded.safety_options.nil?
+          safety = Threaded.safety_options
+        else
+          safety = Mongoid.persist_in_safe_mode
+        end
+        options.merge!({ :safe => safety })
+      end
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Execute the following class-level persistence operation in safe mode.
+      #
+      # @example Create in safe mode.
+      #   Person.safely.create(:name => "John")
+      #
+      # @example Delete all in safe mode with options.
+      #   Person.safely(:w => 2, :fsync => true).delete_all
+      #
+      # @param [ Hash ] options The safe mode options.
+      #
+      # @option options [ Integer ] :w The number of nodes to write to.
+      # @option options [ Integer ] :wtimeout Time to wait for return from all
+      #   nodes.
+      # @option options [ true, false ] :fsync Should a fsync occur.
+      #
+      # @return [ Proxy ] The safety proxy.
+      def safely(safety = true)
+        tap { Threaded.safety_options = safety }
+      end
+
+      # Execute the following class-level persistence operation without safe mode.
+      # Allows per-request overriding of safe mode when the persist_in_safe_mode
+      # config option is turned on.
+      #
+      # @example Upsert in safe mode.
+      #   Person.unsafely.create(:name => "John")
+      #
+      # @return [ Proxy ] The safety proxy.
+      #
+      # @since 2.3.0
+      def unsafely
+        tap { Threaded.safety_options = false }
+      end
+    end
+  end
+end

data/lib/mongoid/scope.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # This module handles behaviour for defining scopes on classes.
+  class Scope
+    attr_reader :conditions, :extensions
+
+    # Create the new +Scope+. If a block is passed in, this Scope will store
+    # the block for future calls to #extend.
+    #
+    # @example Create a new scope.
+    #   Scope.new(:title => "Sir")
+    #
+    # @param [ Hash ] conditions The scoping limitations.
+    def initialize(conditions = {}, &block)
+      @conditions = conditions
+      @extensions = Module.new(&block) if block_given?
+    end
+
+    # Extend a supplied criteria.
+    #
+    # @example Extend the criteria.
+    #   scope.extend(criteria)
+    #
+    # @param [ Criteria } criteria A mongoid criteria to extend.
+    #
+    # @return [ Criteria ] The new criteria object.
+    def extend(criteria)
+      extensions ? criteria.extend(extensions) : criteria
+    end
+  end
+end

data/lib/mongoid/serialization.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+
+  # This module provides the extra behaviour for including relations in JSON
+  # and XML serialization.
+  module Serialization
+    extend ActiveSupport::Concern
+
+    # Gets the document as a serializable hash, used by ActiveModel's JSON
+    # serializer.
+    #
+    # @example Get the serializable hash.
+    #   document.serializable_hash
+    #
+    # @example Get the serializable hash with options.
+    #   document.serializable_hash(:include => :addresses)
+    #
+    # @param [ Hash ] options The options to pass.
+    #
+    # @option options [ Symbol ] :include What relations to include.
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    # @option options [ Symbol ] :methods What methods to include.
+    #
+    # @return [ Hash ] The document, ready to be serialized.
+    #
+    # @since 2.0.0.rc.6
+    def serializable_hash(options = nil)
+      options ||= {}
+
+      only   = Array.wrap(options[:only]).map(&:to_s)
+      except = Array.wrap(options[:except]).map(&:to_s)
+
+      except |= ['_type']
+
+      field_names = fields.keys.map { |field| field.to_s }
+      attribute_names = (attributes.keys + field_names).sort
+      if only.any?
+        attribute_names &= only
+      elsif except.any?
+        attribute_names -= except
+      end
+
+      method_names = Array.wrap(options[:methods]).map { |n| n.to_s if respond_to?(n.to_s) }.compact
+      Hash[(attribute_names + method_names).map { |n| [n, send(n)] }].tap do |attrs|
+        serialize_relations(attrs, options) if options[:include]
+      end
+    end
+
+    class << self
+
+      # Serialize the provided object into a Mongo friendly value, using the
+      # field serialization method for the passed in type. If no type is
+      # given then we assume generic object serialization, which just returns
+      # the value itself.
+      #
+      # @example Mongoize the object.
+      #   Mongoid::Serialization.mongoize(time, Time)
+      #
+      # @param [ Object ] object The object to convert.
+      # @param [ Class ] klass The type of the object.
+      #
+      # @return [ Object ] The converted object.
+      #
+      # @since 2.1.0
+      def mongoize(object, klass = Object)
+        Fields::Mappings.for(klass).instantiate(:mongoize).serialize(object)
+      end
+    end
+
+    private
+
+    # For each of the provided include options, get the relation needed and
+    # provide it in the hash.
+    #
+    # @example Serialize the included relations.
+    #   document.serialize_relations({}, :include => :addresses)
+    #
+    # @param [ Hash ] attributes The attributes to serialize.
+    # @param [ Hash ] options The serialization options.
+    #
+    # @option options [ Symbol ] :include What relations to include
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    #
+    # @since 2.0.0.rc.6
+    def serialize_relations(attributes = {}, options = {})
+      inclusions = options[:include]
+      relation_names(inclusions).each do |name|
+        metadata = relations[name.to_s]
+        relation = send(metadata.name)
+        if relation
+          attributes[metadata.name.to_s] =
+            relation.serializable_hash(relation_options(inclusions, options, name))
+        end
+      end
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the names.
+    #
+    # @example Get the relation names.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash, Symbol, Array<Symbol ] inclusions The inclusions.
+    #
+    # @return [ Array<Symbol> ] The names of the included relations.
+    #
+    # @since 2.0.0.rc.6
+    def relation_names(inclusions)
+      inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the options.
+    #
+    # @example Get the relation options.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash, Symbol, Array<Symbol ] inclusions The inclusions.
+    # @param [ Symbol ] name The name of the relation.
+    #
+    # @return [ Hash ] The options for the relation.
+    #
+    # @since 2.0.0.rc.6
+    def relation_options(inclusions, options, name)
+      if inclusions.is_a?(Hash)
+        inclusions[name]
+      else
+        { :except => options[:except], :only => options[:only] }
+      end
+    end
+  end
+end

data/lib/mongoid/sharding.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # This module contains behaviour for adding shard key fields to updates.
+  module Sharding
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :shard_key_fields
+      self.shard_key_fields = []
+    end
+
+    # Get the shard key fields.
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Get the shard key fields.
+    #   model.shard_key_fields
+    #
+    # @return [ Array<String> ] The shard key field names.
+    def shard_key_fields
+      self.class.shard_key_fields
+    end
+
+    # Get the document selector with the defined shard keys.
+    #
+    # @example Get the selector for the shard keys.
+    #   person.shard_key_selector
+    #
+    # @return [ Hash ] The shard key selector.
+    #
+    # @since 2.0.0
+    def shard_key_selector
+      {}.tap do |selector|
+        shard_key_fields.each do |field|
+          selector[field.to_s] = send(field)
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc
+
+      # Specifies a shard key with the field(s) specified.
+      #
+      # @example Specify the shard key.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :first_name, :type => String
+      #     field :last_name, :type => String
+      #
+      #     shard_key :first_name, :last_name
+      #   end
+      #
+      # @since 2.0.0
+      def shard_key(*names)
+        self.shard_key_fields = names
+      end
+    end
+  end
+end

data/lib/mongoid/state.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module contains the behaviour for getting the various states a
+  # document can transition through.
+  module State
+
+    attr_writer :destroyed, :flagged_for_destroy, :new_record
+
+    # Returns true if the +Document+ has not been persisted to the database,
+    # false if it has. This is determined by the variable @new_record
+    # and NOT if the object has an id.
+    #
+    # @example Is the document new?
+    #   person.new_record?
+    #
+    # @return [ true, false ] True if new, false if not.
+    def new_record?
+      @new_record == true
+    end
+    alias :new? :new_record?
+
+    # Checks if the document has been saved to the database. Returns false
+    # if the document has been destroyed.
+    #
+    # @example Is the document persisted?
+    #   person.persisted?
+    #
+    # @return [ true, false ] True if persisted, false if not.
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    # Returns whether or not the document has been flagged for deletion, but
+    # not destroyed yet. Used for atomic pulls of child documents.
+    #
+    # @example Is the document flagged?
+    #   document.flagged_for_destroy?
+    #
+    # @return [ true, false ] If the document is flagged.
+    #
+    # @since 2.3.2
+    def flagged_for_destroy?
+      !!@flagged_for_destroy
+    end
+
+    # Returns true if the +Document+ has been succesfully destroyed, and false
+    # if it hasn't. This is determined by the variable @destroyed and NOT
+    # by checking the database.
+    #
+    # @example Is the document destroyed?
+    #   person.destroyed?
+    #
+    # @return [ true, false ] True if destroyed, false if not.
+    def destroyed?
+      @destroyed == true
+    end
+    alias :deleted? :destroyed?
+
+    # Determine if the document can be pushed.
+    #
+    # @example Is this pushable?
+    #   person.pushable?
+    #
+    # @return [ true, false ] Is the document new and embedded?
+    def pushable?
+      new? &&
+        embedded_many? &&
+        _parent.persisted? &&
+        !_parent.delayed_atomic_sets[atomic_path]
+    end
+
+    # Determine if the document can be set.
+    #
+    # @example Is this settable?
+    #   person.settable?
+    #
+    # @return [ true, false ] Is this document a new embeds one?
+    #
+    # @since 2.1.0
+    def settable?
+      new? && embedded_one? && _parent.persisted?
+    end
+
+    # Is the document updateable?
+    #
+    # @example Is the document updateable?
+    #   person.updateable?
+    #
+    # @return [ true, false ] If the document is changed and persisted.
+    #
+    # @since 2.1.0
+    def updateable?
+      persisted? && changed?
+    end
+  end
+end