mongoid 3.1.7 → 4.0.0.alpha1

data/lib/mongoid/indexable/specification.rb

@@ -0,0 +1,104 @@
+# 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, :fields, :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 && key == other.key
+      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)
+        @fields = @key.keys
+        @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/{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 = [
@@ -259,56 +261,5 @@ module Mongoid
       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}" ]
-        end
-        Callbacks.registered_observables.concat(observables).uniq
-      end
-    end
   end
 end

data/lib/mongoid/log_subscriber.rb

@@ -0,0 +1,22 @@
+module Mongoid
+
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def query(event)
+      return unless logger.debug?
+
+      payload = event.payload
+      runtime = ("%.4fms" % event.duration)
+      debug(payload[:prefix], payload[:ops], runtime)
+    end
+
+    def debug(prefix, operations, runtime)
+      Moped::Loggable.log_operations(prefix, operations, runtime)
+    end
+
+    def logger
+      Moped.logger
+    end
+  end
+end
+
+Mongoid::LogSubscriber.attach_to :moped

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