mongoid_heroku_stable 4.0.0

data/lib/mongoid/indexable/specification.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+module Mongoid
+  module Indexable
+
+    # Encapsulates behaviour around an index specification.
+    #
+    # @since 4.0.0
+    class Specification
+
+      # The mappings of nice Ruby-style names to the corresponding MongoDB
+      # name.
+      #
+      # @since 4.0.0
+      MAPPINGS = {
+        bucket_size: :bucketSize,
+        drop_dups: :dropDups,
+        expire_after_seconds: :expireAfterSeconds
+      }
+
+      # @!attribute klass
+      #   @return [ Class ] The class the index is defined on.
+      # @!attribute key
+      #   @return [ Hash ] The index key.
+      # @!attribute options
+      #   @return [ Hash ] The index options.
+      attr_reader :klass, :key, :options
+
+      # Is this index specification equal to another?
+      #
+      # @example Check equality of the specifications.
+      #   specification == other
+      #
+      # @param [ Specification ] other The spec to compare against.
+      #
+      # @return [ true, false ] If the specs are equal.
+      #
+      # @since 4.0.0
+      def ==(other)
+        fields == other.fields
+      end
+
+      # Get an array of the fields, in order, that are part of the index.
+      #
+      # @example Get the index fields.
+      #   specification.fields
+      #
+      # @return [ Array<Symbol> ] The names of the fields.
+      #
+      # @since 4.0.0
+      def fields
+        key.keys
+      end
+
+      # Instantiate a new index specification.
+      #
+      # @example Create the new specification.
+      #   Specification.new(Band, { name: 1 }, background: true)
+      #
+      # @param [ Class ] klass The class the index is defined on.
+      # @param [ Hash ] key The hash of name/direction pairs.
+      # @param [ Hash ] opts the index options.
+      #
+      # @since 4.0.0
+      def initialize(klass, key, opts = nil)
+        options = opts || {}
+        Validators::Options.validate(klass, key, options)
+        @klass = klass
+        @key = normalize_key(key)
+        @options = normalize_options(options.dup)
+      end
+
+      private
+
+      # Normalize the spec, in case aliased fields are provided.
+      #
+      # @api private
+      #
+      # @example Normalize the spec.
+      #   specification.normalize_key(name: 1)
+      #
+      # @param [ Hash ] key The index key(s).
+      #
+      # @return [ Hash ] The normalized specification.
+      #
+      # @since 4.0.0
+      def normalize_key(key)
+        normalized = {}
+        key.each_pair do |name, direction|
+          normalized[klass.database_field_name(name).to_sym] = direction
+        end
+        normalized
+      end
+
+      # Normalize the index options, if any are provided.
+      #
+      # @api private
+      #
+      # @example Normalize the index options.
+      #   specification.normalize_options(drop_dups: true)
+      #
+      # @param [ Hash ] options The index options.
+      #
+      # @return [ Hash ] The normalized options.
+      #
+      # @since 4.0.0
+      def normalize_options(opts)
+        options = {}
+        opts.each_pair do |option, value|
+          options[MAPPINGS[option] || option] = value
+        end
+        options
+      end
+    end
+  end
+end

data/lib/mongoid/indexable/validators/options.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Mongoid
+  module Indexable
+    module Validators
+
+      # Validates the options passed to the index macro.
+      module Options
+        extend self
+
+        VALID_OPTIONS = [
+          :background,
+          :database,
+          :default_language,
+          :drop_dups,
+          :name,
+          :sparse,
+          :unique,
+          :max,
+          :min,
+          :bits,
+          :bucket_size,
+          :expire_after_seconds,
+          :weights
+        ]
+
+        VALID_TYPES = [
+          1,
+          -1,
+          "2d",
+          "2dsphere",
+          "geoHaystack",
+          "text",
+          "hashed"
+        ]
+
+        # Validate the index specification.
+        #
+        # @example Validate the index spec.
+        #   Options.validate(Band, name: 1)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash ] spec The index specification.
+        # @param [ Hash ] options The index options.
+        #
+        # @raise [ Errors::InvalidIndex ] If validation failed.
+        #
+        # @since 3.0.0
+        def validate(klass, spec, options)
+          validate_spec(klass, spec, options)
+          validate_options(klass, spec, options)
+        end
+
+        private
+
+        # Validates the options of the index spec.
+        #
+        # @api private
+        #
+        # @example Validate the options.
+        #   Options.validate_options(Band, name: 1)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash ] spec The index specification.
+        # @param [ Hash ] options The index options.
+        #
+        # @raise [ Errors::InvalidIndex ] If validation failed.
+        #
+        # @since 3.0.0
+        def validate_options(klass, spec, options)
+          options.each_pair do |name, value|
+            unless VALID_OPTIONS.include?(name)
+              raise Errors::InvalidIndex.new(klass, spec, options)
+            end
+          end
+        end
+
+        # Validates the index spec.
+        #
+        # @api private
+        #
+        # @example Validate the spec.
+        #   Options.validate_spec(Band, name: 1)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash ] spec The index specification.
+        # @param [ Hash ] options The index options.
+        #
+        # @raise [ Errors::InvalidIndex ] If validation failed.
+        #
+        # @since 3.0.0
+        def validate_spec(klass, spec, options)
+          raise Errors::InvalidIndex.new(klass, spec, options) if !spec.is_a?(::Hash)
+          spec.each_pair do |name, value|
+            next if name == :options
+            unless VALID_TYPES.include?(value)
+              raise Errors::InvalidIndex.new(klass, spec, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/inspectable.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+module Mongoid
+
+  # Contains the bahviour around inspecting documents via inspect.
+  #
+  # @since 4.0.0
+  module Inspectable
+
+    # Returns the class name plus its attributes. If using dynamic fields will
+    # include those as well.
+    #
+    # @example Inspect the document.
+    #   person.inspect
+    #
+    # @return [ String ] A nice pretty string to look at.
+    #
+    # @since 1.0.0
+    def inspect
+      inspection = []
+      inspection.concat(inspect_fields).concat(inspect_dynamic_fields)
+      "#<#{self.class.name} _id: #{id}, #{inspection * ', '}>"
+    end
+
+    private
+
+    # Get an array of inspected fields for the document.
+    #
+    # @api private
+    #
+    # @example Inspect the defined fields.
+    #   document.inspect_fields
+    #
+    # @return [ String ] An array of pretty printed field values.
+    #
+    # @since 1.0.0
+    def inspect_fields
+      fields.map do |name, field|
+        unless name == "_id"
+          as = field.options[:as]
+          "#{name}#{as ? "(#{as})" : nil}: #{@attributes[name].inspect}"
+        end
+      end.compact
+    end
+
+    # Get an array of inspected dynamic fields for the document.
+    #
+    # @api private
+    #
+    # @example Inspect the dynamic fields.
+    #   document.inspect_dynamic_fields
+    #
+    # @return [ String ] An array of pretty printed dynamic field values.
+    #
+    # @since 1.0.0
+    def inspect_dynamic_fields
+      []
+    end
+  end
+end

data/lib/mongoid/interceptable.rb

@@ -0,0 +1,265 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module contains all the callback hooks for Mongoid.
+  #
+  # @since 4.0.0
+  module Interceptable
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :after_build,
+      :after_create,
+      :after_destroy,
+      :after_find,
+      :after_initialize,
+      :after_save,
+      :after_touch,
+      :after_update,
+      :after_upsert,
+      :after_validation,
+      :around_create,
+      :around_destroy,
+      :around_save,
+      :around_update,
+      :around_upsert,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_upsert,
+      :before_validation
+    ].freeze
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :build, :find, :initialize, :touch, only: :after
+      define_model_callbacks :create, :destroy, :save, :update, :upsert
+
+      attr_accessor :before_callback_halted
+    end
+
+    # Is the provided type of callback executable by this document?
+    #
+    # @example Is the callback executable?
+    #   document.callback_executable?(:save)
+    #
+    # @param [ Symbol ] kin The type of callback.
+    #
+    # @return [ true, false ] If the callback can be executed.
+    #
+    # @since 3.0.6
+    def callback_executable?(kind)
+      respond_to?("_#{kind}_callbacks")
+    end
+
+    # Is the document currently in a state that could potentially require
+    # callbacks to be executed?
+    #
+    # @example Is the document in a callback state?
+    #   document.in_callback_state?(:update)
+    #
+    # @param [ Symbol ] kind The callback kind.
+    #
+    # @return [ true, false ] If the document is in a callback state.
+    #
+    # @since 3.1.0
+    def in_callback_state?(kind)
+      [ :create, :destroy ].include?(kind) || new_record? || flagged_for_destroy? || changed?
+    end
+
+    # Run only the after callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the after save callbacks.
+    #   model.run_after_callbacks(:save)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_after_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:after, kind)
+      end
+    end
+
+    # Run only the before callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the before save callbacks.
+    #   model.run_before_callbacks(:save, :create)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_before_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:before, kind)
+      end
+    end
+
+    # Run the callbacks for the document. This overrides active support's
+    # functionality to cascade callbacks to embedded documents that have been
+    # flagged as such.
+    #
+    # @example Run the callbacks.
+    #   run_callbacks :save do
+    #     save!
+    #   end
+    #
+    # @param [ Symbol ] kind The type of callback to execute.
+    # @param [ Array ] *args Any options.
+    #
+    # @return [ Document ] The document
+    #
+    # @since 2.3.0
+    def run_callbacks(kind, *args, &block)
+      cascadable_children(kind).each do |child|
+        unless child.run_callbacks(child_callback_type(kind, child), *args)
+          return false
+        end
+      end
+      callback_executable?(kind) ? super(kind, *args, &block) : true
+    end
+
+    private
+
+    # We need to hook into this for autosave, since we don't want it firing if
+    # the before callbacks were halted.
+    #
+    # @api private
+    #
+    # @example Was a before callback halted?
+    #   document.before_callback_halted?
+    #
+    # @return [ true, false ] If a before callback was halted.
+    #
+    # @since 3.0.3
+    def before_callback_halted?
+      !!@before_callback_halted
+    end
+
+    # Get all the child embedded documents that are flagged as cascadable.
+    #
+    # @example Get all the cascading children.
+    #   document.cascadable_children(:update)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @since 2.3.0
+    def cascadable_children(kind, children = Set.new)
+      embedded_relations.each_pair do |name, metadata|
+        next unless metadata.cascading_callbacks?
+        without_autobuild do
+          delayed_pulls = delayed_atomic_pulls[name]
+          delayed_unsets = delayed_atomic_unsets[name]
+          children.merge(delayed_pulls) if delayed_pulls
+          children.merge(delayed_unsets) if delayed_unsets
+          relation = send(name)
+          Array.wrap(relation).each do |child|
+            next if children.include?(child)
+            children.add(child) if cascadable_child?(kind, child)
+            child.send(:cascadable_children, kind, children)
+          end
+        end
+      end
+      children.to_a
+    end
+
+    # Determine if the child should fire the callback.
+    #
+    # @example Should the child fire the callback?
+    #   document.cascadable_child?(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document.
+    #
+    # @return [ true, false ] If the child should fire the callback.
+    #
+    # @since 2.3.0
+    def cascadable_child?(kind, child)
+      if kind == :initialize || kind == :find
+        return false
+      end
+      child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
+    end
+
+    # Get the name of the callback that the child should fire. This changes
+    # depending on whether or not the child is new. A persisted parent with a
+    # new child would fire :update from the parent, but needs to fire :create
+    # on the child.
+    #
+    # @example Get the callback type.
+    #   document.child_callback_type(:update, doc)
+    #
+    # @param [ Symbol ] kind The type of callback.
+    # @param [ Document ] child The child document
+    #
+    # @return [ Symbol ] The name of the callback.
+    #
+    # @since 2.3.0
+    def child_callback_type(kind, child)
+      if kind == :update
+        return :create if child.new_record?
+        return :destroy if child.flagged_for_destroy?
+        kind
+      else
+        kind
+      end
+    end
+
+    # We need to hook into this for autosave, since we don't want it firing if
+    # the before callbacks were halted.
+    #
+    # @api private
+    #
+    # @example Hook into the halt.
+    #   document.halted_callback_hook(filter)
+    #
+    # @param [ Symbol ] filter The callback that halted.
+    #
+    # @since 3.0.3
+    def halted_callback_hook(filter)
+      @before_callback_halted = true
+    end
+
+    # Run only the callbacks for the target location (before, after, around)
+    # and kind (save, update, create).
+    #
+    # @example Run the targeted callbacks.
+    #   model.run_targeted_callbacks(:before, :save)
+    #
+    # @param [ Symbol ] place The time to run, :before, :after, :around.
+    # @param [ Symbol ] kind The type of callback, :save, :create, :update.
+    #
+    # @return [ Object ] The result of the chain execution.
+    #
+    # @since 3.0.0
+    def run_targeted_callbacks(place, kind)
+      name = "_run__#{place}__#{kind}__callbacks"
+      unless respond_to?(name)
+        chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
+        send("_#{kind}_callbacks").each do |callback|
+          chain.push(callback) if callback.kind == place
+        end
+        class_eval <<-EOM
+          def #{name}() #{chain.compile} end
+          protected :#{name}
+        EOM
+      end
+      send(name)
+    end
+  end
+end