mongoid-multi-db 3.0.0

data/lib/mongoid/logger.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # The Mongoid logger which wraps some other ruby compliant logger class.
+  class Logger
+
+    delegate :info, :debug, :error, :fatal, :unknown, :to => :logger, :allow_nil => true
+
+    # Emit a warning log message.
+    #
+    # @example Log a warning.
+    #   logger.warn("Danger")
+    #
+    # @param [ String ] message The warning message.
+    def warn(message)
+      logger.warn(message) if logger && logger.respond_to?(:warn)
+    end
+
+    # Get the mongoid logger.
+    #
+    # @example Get the global logger.
+    #   logger.logger
+    #
+    # @return [ Logger ] The logger.
+    def logger
+      Mongoid.logger
+    end
+
+    # Inspect the logger.
+    #
+    # @example Inspect the logger.
+    #   logger.inspect
+    #
+    # @return [ String ] The logger, inspected.
+    def inspect
+      "#<Mongoid::Logger:0x#{object_id.to_s(16)} @logger=#{logger.inspect}>"
+    end
+  end
+end

data/lib/mongoid/matchers.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+require "mongoid/matchers/strategies"
+
+module Mongoid #:nodoc:
+
+  # This module contains all the behavior for ruby implementations of MongoDB
+  # selectors.
+  module Matchers
+
+    # 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.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        if value.is_a?(Hash)
+          value.each do |item|
+            return false unless Strategies.matcher(self, key, Hash[*item]).matches?(Hash[*item])
+          end
+        else
+          return false unless Strategies.matcher(self, key, value).matches?(value)
+        end
+      end
+      return true
+    end
+  end
+end

data/lib/mongoid/matchers/all.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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)
+        @attribute == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/and.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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?("$and" => [ { 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 Strategies.matcher(document, key, value).matches?(value)
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/default.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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.include?(value) : 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 ? attribute.send(operator, first(value)) : false
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/exists.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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/matchers/gt.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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/matchers/gte.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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/matchers/in.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # 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)
+        Array.wrap(@attribute).any? { |e| value.values.first.include?(e) }
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lt.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # Performs less than matching.
+    class Lt < Default
+
+      # Return true if the attribute is less 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/matchers/lte.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # Performs less than or equal to matching.
+    class Lte < Default
+
+      # Return true if the attribute is less 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/matchers/ne.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # Performs non-equivalency checks.
+    class Ne < Default
+
+      # Return true if the attribute and first value are not equal.
+      #
+      # @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 != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/nin.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # Performs not in checking.
+    class Nin < Default
+
+      # Return true if the attribute is not in the value list.
+      #
+      # @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)
+        Array.wrap(@attribute).none? { |e| value.values.first.include?(e) }
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/or.rb

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

data/lib/mongoid/matchers/size.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # Performs size checking.
+    class Size < Default
+
+      # Return true if the attribute size is equal to the first 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)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/strategies.rb

@@ -0,0 +1,93 @@
+# encoding: utf-8
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+require "mongoid/matchers/and"
+require "mongoid/matchers/exists"
+require "mongoid/matchers/gt"
+require "mongoid/matchers/gte"
+require "mongoid/matchers/in"
+require "mongoid/matchers/lt"
+require "mongoid/matchers/lte"
+require "mongoid/matchers/ne"
+require "mongoid/matchers/nin"
+require "mongoid/matchers/or"
+require "mongoid/matchers/size"
+
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+
+    # This module is responsible for returning the correct matcher given a
+    # MongoDB query expression.
+    module Strategies
+      extend self
+
+      MATCHERS = {
+        "$all" => Matchers::All,
+        "$and" => Matchers::And,
+        "$exists" => Matchers::Exists,
+        "$gt" => Matchers::Gt,
+        "$gte" => Matchers::Gte,
+        "$in" => Matchers::In,
+        "$lt" => Matchers::Lt,
+        "$lte" => Matchers::Lte,
+        "$ne" => Matchers::Ne,
+        "$nin" => Matchers::Nin,
+        "$or" => Matchers::Or,
+        "$size" => Matchers::Size
+      }
+
+      # Get the matcher for the supplied key and value. Will determine the class
+      # name from the key.
+      #
+      # @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
+            when "$or" then Matchers::Or.new(value, document)
+            when "$and" then Matchers::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.
+      #
+      # @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.attributes) do |attribs, key|
+            attribs.try(:[], key)
+          end
+        else
+          document.attributes[key_string]
+        end
+      end
+    end
+  end
+end