mongoid-braxton 2.0.2

data/lib/mongoid/json.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # This module is for hooking in to +ActiveModel+s serialization to let
+  # configuring the ability to include the root in JSON happen from the Mongoid
+  # config.
+  module JSON
+    extend ActiveSupport::Concern
+
+    # We need to redefine where the JSON configuration is getting defined,
+    # similar to +ActiveRecord+.
+    included do
+      undef_method :include_root_in_json
+      delegate :include_root_in_json, :to => ::Mongoid
+    end
+  end
+end

data/lib/mongoid/keys.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module defines the behaviour for overriding the default ids on
+  # documents.
+  module Keys
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :primary_key, :object_ids
+      delegate :primary_key, :using_object_ids?, :to => "self.class"
+    end
+
+    private
+
+    # Determines if any field that the document id is composed of has changed.
+    #
+    # @example Has any key field changed?
+    #   document.key_field_changed?
+    #
+    # @return [ true, false ] Has a key field changed?
+    #
+    # @since 2.0.0
+    def key_field_changed?
+      primary_key.any? { |field| changed.include?(field.to_s) }
+    end
+
+    # Sits around a save when composite keys are in play to handle the id magic
+    # if a key field has changed.
+    #
+    # @example Set the composite key.
+    #   document.set_composite_key
+    #
+    # @param [ Proc ] block The block this surrounds.
+    #
+    # @since 2.0.0
+    def set_composite_key(&block)
+      if persisted? && key_field_changed?
+        swap_composite_keys(&block)
+      else
+        identify and block.call
+      end
+    end
+
+    # Swap out the composite key only after the document has been saved.
+    #
+    # @example Swap out the keys.
+    #   document.swap_composite_keys
+    #
+    # @param [ Proc ] block The save block getting called.
+    #
+    # @since 2.0.0
+    def swap_composite_keys(&block)
+      old_id, new_id = id.dup, identify
+      @attributes["_id"] = old_id
+      block.call
+      @attributes["_id"] = new_id
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Used for telling Mongoid on a per model basis whether to override the
+      # default +BSON::ObjectId+ and use a different type. This will be
+      # expanded in the future for requiring a PkFactory if the type is not a
+      # +BSON::ObjectId+ or +String+.
+      #
+      # @example Change the documents key type.
+      #   class Person
+      #     include Mongoid::Document
+      #     identity :type => String
+      #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @option options [ Class ] :type The type of the id.
+      #
+      # @since 2.0.0.beta.1
+      def identity(options = {})
+        fields["_id"].type = options[:type]
+        @object_ids = id_is_object
+      end
+
+      # Defines the field that will be used for the id of this +Document+. This
+      # set the id of this +Document+ before save to a parameterized version of
+      # the field that was supplied. This is good for use for readable URLS in
+      # web applications.
+      #
+      # @example Create a composite id.
+      #   class Person
+      #     include Mongoid::Document
+      #     key :first_name, :last_name
+      #   end
+      #
+      # @param [ Array<Symbol> ] The fields the key is composed of.
+      #
+      # @since 1.0.0
+      def key(*fields)
+        self.primary_key = fields
+        identity(:type => String)
+        set_callback(:save, :around, :set_composite_key)
+      end
+
+      # Convenience method for determining if we are using +BSON::ObjectIds+ as
+      # our id.
+      #
+      # @example Does this class use object ids?
+      #   person.using_object_ids?
+      #
+      # @return [ true, false ] If the class uses BSON::ObjectIds for the id.
+      #
+      # @since 1.0.0
+      def using_object_ids?
+        @object_ids ||= id_is_object
+      end
+
+      private
+
+      # Is the id field type an object id?
+      #
+      # @example Is type an object id.
+      #   Class.id_is_object
+      #
+      # @return [ true, false ] Is the id an object id.
+      #
+      # @since 2.0.0
+      def id_is_object
+        fields["_id"].type == BSON::ObjectId
+      end
+    end
+  end
+end

data/lib/mongoid/logger.rb

@@ -0,0 +1,18 @@
+module Mongoid
+  class Logger
+
+    delegate :info, :debug, :error, :fatal, :unknown, :to => :logger, :allow_nil => true
+
+    def warn(message)
+      logger.warn(message) if logger && logger.respond_to?(:warn)
+    end
+
+    def logger
+      Mongoid.logger
+    end
+
+    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,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class All < Default
+      # Return true if the attribute and first value in the hash are equal.
+      def matches?(value)
+        @attribute == value.values.first
+      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) ? 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,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    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.
+      def matches?(value)
+        @attribute.nil? != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gt < Default
+      # Return true if the attribute is greater than the value.
+      def matches?(value)
+        determine(value, :>)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gte < Default
+      # Return true if the attribute is greater than or equal to the value.
+      def matches?(value)
+        determine(value, :>=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/in.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class In < Default
+      # Return true if the attribute is in the values.
+      def matches?(value)
+        value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lt < Default
+      # Return true if the attribute is less than the value.
+      def matches?(value)
+        determine(value, :<)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lte < Default
+      # Return true if the attribute is less than or equal to the value.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/ne.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Ne < Default
+      # Return true if the attribute and first value are not equal.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/nin.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Nin < Default
+      # Return true if the attribute is not in the value list.
+      def matches?(value)
+        !value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/or.rb

@@ -0,0 +1,30 @@
+# 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|
+          key = condition.keys.first
+          value = condition.values.first
+          if Strategies.matcher(document, key, value).matches?(value)
+            return true
+          end
+        end
+        return false
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Size < Default
+      # Return true if the attribute size is equal to the first value.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/strategies.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+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,
+        "$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)
+          MATCHERS[value.keys.first].new(document.attributes[key.to_s])
+        else
+          if key == "$or"
+            Matchers::Or.new(value, document)
+          else
+            Default.new(document.attributes[key.to_s])
+          end
+        end
+      end
+    end
+  end
+end