mongoid_rails4 4.0.0

data/lib/mongoid/loggable.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+module Mongoid
+
+  # Contains logging behaviour.
+  module Loggable
+
+    # Get the logger.
+    #
+    # @note Will try to grab Rails' logger first before creating a new logger
+    #   with stdout.
+    #
+    # @example Get the logger.
+    #   Loggable.logger
+    #
+    # @return [ Logger ] The logger.
+    #
+    # @since 3.0.0
+    def logger
+      return @logger if defined?(@logger)
+      @logger = rails_logger || default_logger
+    end
+
+    # Set the logger.
+    #
+    # @example Set the logger.
+    #   Loggable.logger = Logger.new($stdout)
+    #
+    # @param [ Logger ] The logger to set.
+    #
+    # @return [ Logger ] The new logger.
+    #
+    # @since 3.0.0
+    def logger=(logger)
+      @logger = logger
+    end
+
+    private
+
+    # Gets the default Mongoid logger - stdout.
+    #
+    # @api private
+    #
+    # @example Get the default logger.
+    #   Loggable.default_logger
+    #
+    # @return [ Logger ] The default logger.
+    #
+    # @since 3.0.0
+    def default_logger
+      logger = Logger.new($stdout)
+      logger.level = Logger::INFO
+      logger
+    end
+
+    # Get the Rails logger if it's defined.
+    #
+    # @api private
+    #
+    # @example Get Rails' logger.
+    #   Loggable.rails_logger
+    #
+    # @return [ Logger ] The Rails logger.
+    #
+    # @since 3.0.0
+    def rails_logger
+      defined?(::Rails) && ::Rails.respond_to?(:logger) && ::Rails.logger
+    end
+  end
+end

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/matchable/all.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Checks that all values match.
+    class All < Default
+
+      # Return true if the attribute and first value in the hash are equal.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If the values match.
+      def matches?(value)
+        first = first(value)
+        return false if first.is_a?(Array) && first.empty?
+
+        attribute_array = Array.wrap(@attribute)
+        first.all? do |e|
+          attribute_array.any? { |_attribute| e === _attribute }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/and.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Defines behavior for handling $or expressions in embedded documents.
+    class And < Default
+
+      # Does the supplied query match the attribute?
+      #
+      # @example Does this match?
+      #   matcher.matches?([ { field => value } ])
+      #
+      # @param [ Array ] conditions The or expression.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      #
+      # @since 2.3.0
+      def matches?(conditions)
+        conditions.each do |condition|
+          condition.keys.each do |k|
+            key = k
+            value = condition[k]
+            return false unless Matchable.matcher(document, key, value).matches?(value)
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/default.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Contains all the default behavior for checking for matching documents
+    # given MongoDB expressions.
+    class Default
+
+      attr_accessor :attribute, :document
+
+      # Creating a new matcher only requires the value.
+      #
+      # @example Create a new matcher.
+      #   Default.new("attribute")
+      #
+      # @param [ Object ] attribute The current attribute to check against.
+      #
+      # @since 1.0.0
+      def initialize(attribute, document = nil)
+        @attribute, @document = attribute, document
+      end
+
+      # Return true if the attribute and value are equal, or if it is an array
+      # if the value is included.
+      #
+      # @example Does this value match?
+      #   default.matches?("value")
+      #
+      # @param [ Object ] value The value to check if it matches.
+      #
+      # @return [ true, false ] True if matches, false if not.
+      #
+      # @since 1.0.0
+      def matches?(value)
+        attribute.is_a?(Array) && !value.is_a?(Array) ? attribute.any? { |_attribute| value === _attribute } : value === attribute
+      end
+
+      protected
+
+      # Convenience method for getting the first value in a hash.
+      #
+      # @example Get the first value.
+      #   matcher.first(:test => "value")
+      #
+      # @param [ Hash ] hash The has to pull from.
+      #
+      # @return [ Object ] The first value.
+      #
+      # @since 1.0.0
+      def first(hash)
+        hash.values.first
+      end
+
+      # If object exists then compare the two, otherwise return false
+      #
+      # @example Determine if we can compare.
+      #   matcher.determine("test", "$in")
+      #
+      # @param [ Object ] value The value to compare with.
+      # @param [ Symbol, String ] operator The comparison operation.
+      #
+      # @return [ true, false ] The comparison or false.
+      #
+      # @since 1.0.0
+      def determine(value, operator)
+        attribute.__array__.any? {|attr|
+          attr ? attr.send(operator, first(value)) : false
+        }
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/exists.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Checks for existance.
+    class Exists < Default
+
+      # Return true if the attribute exists and checking for existence or
+      # return true if the attribute does not exist and checking for
+      # non-existence.
+      #
+      # @example Does anything exist?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        @attribute.nil? != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/gt.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs Greater Than matching.
+    class Gt < Default
+
+      # Return true if the attribute is greater than the value.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        determine(value, :>)
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/gte.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs Greater than or equal to matching.
+    class Gte < Default
+
+      # Return true if the attribute is greater than or equal to the value.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        determine(value, :>=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchable/in.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mongoid
+  module Matchable
+
+    # Performs matching for any value in an array.
+    class In < Default
+
+      # Return true if the attribute is in the values.
+      #
+      # @example Do the values match?
+      #   matcher.matches?({ :key => 10 })
+      #
+      # @param [ Hash ] value The values to check.
+      #
+      # @return [ true, false ] If a value exists.
+      def matches?(value)
+        attribute_array = Array.wrap(@attribute)
+        value.values.first.any? do |e|
+          attribute_array.any? { |_attribute| e === _attribute }
+        end
+      end
+    end
+  end
+end