mongoid 3.1.6 → 4.0.2

data/lib/mongoid/{indexes → indexable}/validators/options.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Mongoid
-  module Indexes
+  module Indexable
     module Validators
 
       # Validates the options passed to the index macro.
@@ -10,6 +10,7 @@ module Mongoid
         VALID_OPTIONS = [
           :background,
           :database,
+          :default_language,
           :drop_dups,
           :name,
           :sparse,

data/lib/mongoid/{inspection.rb → inspectable.rb}

@@ -1,9 +1,10 @@
 # encoding: utf-8
 module Mongoid
 
-  # Contains the bahviour around inspecting documents via
-  # <tt>Object#inspect</tt>.
-  module Inspection
+  # 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.
@@ -12,6 +13,8 @@ module Mongoid
     #   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)
@@ -22,10 +25,14 @@ module Mongoid
 
     # 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"
@@ -37,19 +44,16 @@ module Mongoid
 
     # 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
-      if Mongoid.allow_dynamic_fields
-        keys = @attributes.keys - fields.keys - relations.keys - ["_id", "_type"]
-        return keys.map do |name|
-          "#{name}: #{@attributes[name].inspect}"
-        end
-      else
-        []
-      end
+      []
     end
   end
 end

data/lib/mongoid/{callbacks.rb → interceptable.rb}

@@ -2,7 +2,9 @@
 module Mongoid
 
   # This module contains all the callback hooks for Mongoid.
-  module Callbacks
+  #
+  # @since 4.0.0
+  module Interceptable
     extend ActiveSupport::Concern
 
     CALLBACKS = [
@@ -123,7 +125,13 @@ module Mongoid
     # @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)
+        # This is returning false for some destroy tests on 4.1.0.beta1,
+        # causing them to fail since 4.1.0 expects a block to be passed if the
+        # callbacks for the type are empty. If no block is passed then the nil
+        # return value gets interpreted as false and halts the chain.
+        #
+        # @see https://github.com/rails/rails/blob/master/activesupport/lib/active_support/callbacks.rb#L79
+        if child.run_callbacks(child_callback_type(kind, child), *args) == false
           return false
         end
       end
@@ -168,7 +176,7 @@ module Mongoid
           relation = send(name)
           Array.wrap(relation).each do |child|
             next if children.include?(child)
-            children.add(child) if cascadable_child?(kind, child)
+            children.add(child) if cascadable_child?(kind, child, metadata)
             child.send(:cascadable_children, kind, children)
           end
         end
@@ -187,10 +195,9 @@ module Mongoid
     # @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
+    def cascadable_child?(kind, child, metadata)
+      return false if kind == :initialize || kind == :find
+      return false if kind == :validate && metadata.validate?
       child.callback_executable?(kind) ? child.in_callback_state?(kind) : false
     end
 
@@ -250,65 +257,26 @@ module Mongoid
       unless respond_to?(name)
         chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
         send("_#{kind}_callbacks").each do |callback|
-          chain.push(callback) if callback.kind == place
+          chain.append(callback) if callback.kind == place
         end
-        class_eval <<-EOM
-          def #{name}() #{chain.compile} end
-          protected :#{name}
-        EOM
-      end
-      send(name)
-    end
-
-    class << self
-
-      # Get all callbacks that can be observed.
-      #
-      # @example Get the observables.
-      #   Callbacks.observables
-      #
-      # @return [ Array<Symbol> ] The names of the observables.
-      #
-      # @since 3.1.0
-      def observables
-        CALLBACKS + registered_observables
-      end
 
-      # Get all registered callbacks that can be observed, not included in
-      # Mongoid's defaults.
-      #
-      # @example Get the observables.
-      #   Callbacks.registered_observables
-      #
-      # @return [ Array<Symbol> ] The names of the registered observables.
-      #
-      # @since 3.1.0
-      def registered_observables
-        @registered_observables ||= []
-      end
-    end
-
-    module ClassMethods
-
-      # Set a custom callback as able to be observed.
-      #
-      # @example Set a custom callback as observable.
-      #   class Band
-      #     include Mongoid::Document
-      #
-      #     define_model_callbacks :notification
-      #     observable :notification
-      #   end
-      #
-      # @param [ Array<Symbol> ] args The names of the observable callbacks.
-      #
-      # @since 3.0.1
-      def observable(*args)
-        observables = args.flat_map do |name|
-          [ :"before_#{name}", :"after_#{name}", :"around_#{name}" ]
+        if Gem::Version.new("4.1.0") <= Gem::Version.new(ActiveSupport::VERSION::STRING)
+          self.class.send :define_method, name do
+            runner = ActiveSupport::Callbacks::Filters::Environment.new(self, false, nil)
+            chain.compile.call(runner).value
+          end
+          self.class.send :protected, name
+        else
+          class_eval <<-EOM
+            def #{name}()
+              #{chain.compile}
+            end
+            protected :#{name}
+          EOM
         end
-        Callbacks.registered_observables.concat(observables).uniq
+
       end
+      send(name)
     end
   end
 end

data/lib/mongoid/log_subscriber.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid
+  # A Log subscriber to the moped queries
+  #
+  # @since 4.0.0
+  class LogSubscriber < ActiveSupport::LogSubscriber
+
+    # Log the query operation on moped
+    #
+    # @since 4.0.0
+    def query(event)
+      return unless logger.debug?
+
+      payload = event.payload
+      runtime = ("%.4fms" % event.duration)
+      debug(payload[:prefix], payload[:ops], runtime)
+    end
+
+    def query_cache(event)
+      return unless logger.debug?
+
+      database, collection, selector = event.payload[:key]
+      operation = "%-12s database=%s collection=%s selector=%s" % ["QUERY CACHE", database, collection, selector.inspect]
+      logger.debug operation
+    end
+    # Log the provided operations.
+    #
+    # @example Delegates the operation to moped so it can log it.
+    #   subscriber.debug("MOPED", {}, 30)
+    #
+    # @param [ String ] prefix The prefix for all operations in the log.
+    # @param [ Array ] ops The operations.
+    # @param [ String ] runtime The runtime in formatted ms.
+    #
+    # @since 4.0.0
+    def debug(prefix, operations, runtime)
+      Moped::Loggable.log_operations(prefix, operations, runtime)
+    end
+
+    # Get the logger.
+    #
+    # @example Get the logger.
+    #   subscriber.logger
+    #
+    # @return [ Logger ] The logger.
+    #
+    # @since 4.0.0
+    def logger
+      Moped.logger
+    end
+  end
+end
+
+Mongoid::LogSubscriber.attach_to :moped
+Mongoid::LogSubscriber.attach_to :mongoid

data/lib/mongoid/matchable.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+require "mongoid/matchable/default"
+require "mongoid/matchable/all"
+require "mongoid/matchable/and"
+require "mongoid/matchable/exists"
+require "mongoid/matchable/gt"
+require "mongoid/matchable/gte"
+require "mongoid/matchable/in"
+require "mongoid/matchable/lt"
+require "mongoid/matchable/lte"
+require "mongoid/matchable/ne"
+require "mongoid/matchable/nin"
+require "mongoid/matchable/or"
+require "mongoid/matchable/size"
+
+module Mongoid
+
+  # This module contains all the behavior for ruby implementations of MongoDB
+  # selectors.
+  #
+  # @since 4.0.0
+  module Matchable
+    extend ActiveSupport::Concern
+
+    # Hash lookup for the matcher for a specific operation.
+    #
+    # @since 1.0.0
+    MATCHERS = {
+      "$all" => All,
+      "$and" => And,
+      "$exists" => Exists,
+      "$gt" => Gt,
+      "$gte" => Gte,
+      "$in" => In,
+      "$lt" => Lt,
+      "$lte" => Lte,
+      "$ne" => Ne,
+      "$nin" => Nin,
+      "$or" => Or,
+      "$size" => Size
+    }.with_indifferent_access.freeze
+
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    #
+    # @example Does the document match?
+    #   document.matches?(:title => { "$in" => [ "test" ] })
+    #
+    # @param [ Hash ] selector The MongoDB selector.
+    #
+    # @return [ true, false ] True if matches, false if not.
+    #
+    # @since 1.0.0
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        if value.is_a?(Hash)
+          value.each do |item|
+            return false unless matcher(self, key, Hash[*item]).matches?(Hash[*item])
+          end
+        else
+          return false unless matcher(self, key, value).matches?(value)
+        end
+      end
+      true
+    end
+
+    private
+
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    #
+    # @api private
+    #
+    # @example Get the matcher.
+    #   document.matcher(:title, { "$in" => [ "test" ] })
+    #
+    # @param [ Document ] document The document to check.
+    # @param [ Symbol, String ] key The field name.
+    # @param [ Object, Hash ] The value or selector.
+    #
+    # @return [ Matcher ] The matcher.
+    #
+    # @since 2.0.0.rc.7
+    def matcher(document, key, value)
+      Matchable.matcher(document, key, value)
+    end
+
+    class << self
+
+      # Get the matcher for the supplied key and value. Will determine the class
+      # name from the key.
+      #
+      # @api private
+      #
+      # @example Get the matcher.
+      #   document.matcher(:title, { "$in" => [ "test" ] })
+      #
+      # @param [ Document ] document The document to check.
+      # @param [ Symbol, String ] key The field name.
+      # @param [ Object, Hash ] The value or selector.
+      #
+      # @return [ Matcher ] The matcher.
+      #
+      # @since 2.0.0.rc.7
+      def matcher(document, key, value)
+        if value.is_a?(Hash)
+          matcher = MATCHERS[value.keys.first]
+          if matcher
+            matcher.new(extract_attribute(document, key))
+          else
+            Default.new(extract_attribute(document, key))
+          end
+        else
+          case key.to_s
+            when "$or" then Or.new(value, document)
+            when "$and" then And.new(value, document)
+            else Default.new(extract_attribute(document, key))
+          end
+        end
+      end
+
+      private
+
+      # Extract the attribute from the key, being smarter about dot notation.
+      #
+      # @api private
+      #
+      # @example Extract the attribute.
+      #   strategy.extract_attribute(doc, "info.field")
+      #
+      # @param [ Document ] document The document.
+      # @param [ String ] key The key.
+      #
+      # @return [ Object ] The value of the attribute.
+      #
+      # @since 2.2.1
+      def extract_attribute(document, key)
+        if (key_string = key.to_s) =~ /.+\..+/
+          key_string.split('.').inject(document.as_document) do |_attribs, _key|
+            if _attribs.is_a?(::Array)
+              _attribs.map { |doc| doc.try(:[], _key) }
+            else
+              _attribs.try(:[], _key)
+            end
+          end
+        else
+          document.attributes[key_string]
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/{matchers → matchable}/all.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Mongoid
-  module Matchers
+  module Matchable
 
     # Checks that all values match.
     class All < Default

data/lib/mongoid/{matchers → matchable}/and.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Mongoid
-  module Matchers
+  module Matchable
 
     # Defines behavior for handling $or expressions in embedded documents.
     class And < Default
@@ -20,7 +20,7 @@ module Mongoid
           condition.keys.each do |k|
             key = k
             value = condition[k]
-            return false unless Strategies.matcher(document, key, value).matches?(value)
+            return false unless Matchable.matcher(document, key, value).matches?(value)
           end
         end
         true

data/lib/mongoid/{matchers → matchable}/default.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Mongoid
-  module Matchers
+  module Matchable
 
     # Contains all the default behavior for checking for matching documents
     # given MongoDB expressions.