mongoid-multi-db 3.0.0

data/lib/mongoid/criterion/inspection.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    module Inspection #:nodoc:
+
+      # Get a pretty string representation of the criteria, including the
+      # selector, options, matching count and documents for inspection.
+      #
+      # @example Inspect the criteria.
+      #   criteria.inspect
+      #
+      # @return [ String ] The inspection string.
+      def inspect
+        "#<Mongoid::Criteria\n" <<
+        "  selector: #{selector.inspect},\n" <<
+        "  options:  #{options.inspect},\n" <<
+        "  class:    #{klass},\n" <<
+        "  embedded: #{embedded}>\n"
+      end
+    end
+  end
+end

data/lib/mongoid/criterion/optional.rb

@@ -0,0 +1,232 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    module Optional
+
+      # Adds fields to be sorted in ascending order. Will add them in the order
+      # they were passed into the method.
+      #
+      # @example Sort in ascending order.
+      #   criteria.ascending(:title, :dob)
+      #   criteria.asc(:title, :dob)
+      #
+      # @param [ Array<Symbol> ] fields The fields to sort on.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def ascending(*fields)
+        clone.tap do |crit|
+          crit.options[:sort] = [] unless options[:sort] || fields.first.nil?
+          fields.flatten.each { |field| merge_options(crit.options[:sort], [ field, :asc ]) }
+        end
+      end
+      alias :asc :ascending
+
+      # Tells the criteria that the cursor that gets returned needs to be
+      # cached. This is so multiple iterations don't hit the database multiple
+      # times, however this is not advisable when working with large data sets
+      # as the entire results will get stored in memory.
+      #
+      # @example Flag the criteria as cached.
+      #   criteria.cache
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def cache
+        clone.tap { |crit| crit.options.merge!(:cache => true) }
+      end
+
+      # Will return true if the cache option has been set.
+      #
+      # @example Is the criteria cached?
+      #   criteria.cached?
+      #
+      # @return [ true, false ] If the criteria is flagged as cached.
+      def cached?
+        options[:cache] == true
+      end
+
+      # Adds fields to be sorted in descending order. Will add them in the order
+      # they were passed into the method.
+      #
+      # @example Sort the criteria in descending order.
+      #   criteria.descending(:title, :dob)
+      #   criteria.desc(:title, :dob)
+      #
+      # @param [ Array<Symbol> ] fields The fields to sort on.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def descending(*fields)
+        clone.tap do |crit|
+          crit.options[:sort] = [] unless options[:sort] || fields.first.nil?
+          fields.flatten.each { |field| merge_options(crit.options[:sort], [ field, :desc ]) }
+        end
+      end
+      alias :desc :descending
+
+      # Adds a criterion to the +Criteria+ that specifies additional options
+      # to be passed to the Ruby driver, in the exact format for the driver.
+      #
+      # @example Add extra params to the criteria.
+      #   criteria.extras(:limit => 20, :skip => 40)
+      #
+      # @param [ Hash ] extras The extra driver options.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def extras(extras)
+        clone.tap do |crit|
+          crit.options.merge!(extras)
+        end
+      end
+
+      # Adds a criterion to the +Criteria+ that specifies an id that must be matched.
+      #
+      # @example Add a single id criteria.
+      #   criteria.for_ids("4ab2bc4b8ad548971900005c")
+      #
+      # @example Add multiple id criteria.
+      #   criteria.for_ids(["4ab2bc4b8ad548971900005c", "4c454e7ebf4b98032d000001"])
+      #
+      # @param [ Array ] ids: A single id or an array of ids.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def for_ids(*ids)
+        ids.flatten!
+        if ids.size > 1
+          where(:_id.in => ::BSON::ObjectId.convert(klass, ids))
+        else
+          where(:_id => ids.first)
+        end
+      end
+
+      # Adds a criterion to the +Criteria+ that specifies the maximum number of
+      # results to return. This is mostly used in conjunction with skip()
+      # to handle paginated results.
+      #
+      # @example Limit the result set size.
+      #   criteria.limit(100)
+      #
+      # @param [ Integer ] value The max number of results.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def limit(value = 20)
+        clone.tap { |crit| crit.options[:limit] = value }
+      end
+
+      # Returns the offset option. If a per_page option is in the list then it
+      # will replace it with a skip parameter and return the same value. Defaults
+      # to 20 if nothing was provided.
+      #
+      # @example Get the offset.
+      #   criteria.offset(10)
+      #
+      # @return [ Integer ] The number of documents to skip.
+      def offset(*args)
+        args.size > 0 ? skip(args.first) : options[:skip]
+      end
+
+      # Adds a criterion to the +Criteria+ that specifies the sort order of
+      # the returned documents in the database. Similar to a SQL "ORDER BY".
+      #
+      # @example Order by specific fields.
+      #   criteria.order_by([[:field1, :asc], [:field2, :desc]])
+      #
+      # @param [ Array ] params: An +Array+ of [field, direction] sorting pairs.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def order_by(*args)
+        clone.tap do |crit|
+          arguments = args.size == 1 ? args.first : args
+          crit.options[:sort] = [] unless options[:sort] || args.first.nil?
+          if arguments.is_a?(Array)
+            #[:name, :asc]
+            if arguments.size == 2 && (arguments.first.is_a?(Symbol) || arguments.first.is_a?(String))
+              build_order_options(arguments, crit)
+            else
+              arguments.each { |argument| build_order_options(argument, crit) }
+            end
+          else
+            build_order_options(arguments, crit)
+          end
+        end
+      end
+      alias :order :order_by
+
+      # Adds a criterion to the +Criteria+ that specifies how many results to skip
+      # when returning Documents. This is mostly used in conjunction with
+      # limit() to handle paginated results, and is similar to the
+      # traditional "offset" parameter.
+      #
+      # @example Skip a specified number of documents.
+      #   criteria.skip(20)
+      #
+      # @param [ Integer ] value The number of results to skip.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def skip(value = 0)
+        clone.tap { |crit| crit.options[:skip] = value }
+      end
+
+      # Adds a criterion to the +Criteria+ that specifies a type or an Array of
+      # types that must be matched.
+      #
+      # @example Match only specific models.
+      #   criteria.type('Browser')
+      #   criteria.type(['Firefox', 'Browser'])
+      #
+      # @param [ Array<String> ] types The types to match against.
+      #
+      # @return [ Criteria ] The cloned criteria.
+      def type(types)
+        types = [types] unless types.is_a?(Array)
+        any_in(:_type => types)
+      end
+
+      private
+
+      # Build ordering options from given arguments on given criteria
+      #
+      # @example build order options
+      #   criteria.build_order_options(:name.asc, criteria)
+      #
+      #
+      # @param [ <Hash>, <Array>, <Complex> ] argument to build criteria from
+      # @param [ Criterion ] criterion to change
+      def build_order_options(arguments, crit)
+        case arguments
+        when Hash
+          if arguments.size > 1
+            raise ArgumentError, "Please don't use hash to define multiple orders " +
+                "due to the fact that hash doesn't have order this may cause unpredictable results"
+          end
+          arguments.each_pair do |field, direction|
+            merge_options(crit.options[:sort], [ field, direction ])
+          end
+        when Array
+          merge_options(crit.options[:sort],arguments)
+        when Complex
+          merge_options(crit.options[:sort], [ arguments.key, arguments.operator.to_sym ])
+        end
+      end
+
+      # Merge options for order_by criterion
+      # Allow only one order direction for same field
+      #
+      # @example Merge ordering options
+      #   criteria.merge_options([[:title, :asc], [:created_at, :asc]], [:title, :desc])
+      #
+      #
+      # @param [ Array<Array> ] Existing options
+      # @param [ Array ] New option for merge.
+      #
+      # @since 2.1.0
+      def merge_options(options, new_option)
+        old_option = options.assoc(new_option.first)
+
+        if old_option
+          options[options.index(old_option)] = new_option.flatten
+        else
+          options << new_option.flatten
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criterion/selector.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # The selector is a hash-like object that has special behaviour for merging
+    # mongoid criteria selectors.
+    class Selector < Hash
+
+      attr_reader :fields, :klass
+
+      # Create the new selector.
+      #
+      # @example Create the selector.
+      #   Selector.new(Person)
+      #
+      # @param [ Class ] klass The class the selector is for.
+      #
+      # @since 1.0.0
+      def initialize(klass)
+        @fields, @klass = klass.fields.except("_id", "_type"), klass
+      end
+
+      # Set the value for the supplied key, attempting to typecast the value.
+      #
+      # @example Set the value for the key.
+      #   selector["$ne"] = { :name => "Zorg" }
+      #
+      # @param [ String, Symbol ] key The hash key.
+      # @param [ Object ] value The value to set.
+      #
+      # @since 2.0.0
+      def []=(key, value)
+        key = "#{key}.#{::I18n.locale}" if klass.fields[key.to_s].try(:localized?)
+        super(key, try_to_typecast(key, value))
+      end
+
+      # Merge the selector with another hash.
+      #
+      # @example Merge the objects.
+      #   selector.merge!({ :key => "value" })
+      #
+      # @param [ Hash, Selector ] other The object to merge with.
+      #
+      # @return [ Selector ] The merged selector.
+      #
+      # @since 1.0.0
+      def merge!(other)
+        tap do |selector|
+          other.each_pair do |key, value|
+            selector[key] = value
+          end
+        end
+      end
+      alias :update :merge!
+
+      if RUBY_VERSION < '1.9'
+
+        # Generate pretty inspection for old ruby versions.
+        #
+        # @example Inspect the selector.
+        #   selector.inspect
+        #
+        # @return [ String ] The inspected selector.
+        def inspect
+          ret = self.keys.inject([]) do |ret, key|
+            ret << "#{key.inspect}=>#{self[key].inspect}"
+          end
+          "{#{ret.sort.join(', ')}}"
+        end
+      end
+
+      private
+
+      # If the key is defined as a field, then attempt to typecast it.
+      #
+      # @example Try to cast.
+      #   selector.try_to_typecast(:id, 1)
+      #
+      # @param [ String, Symbol ] key The field name.
+      # @param [ Object ] value The value.
+      #
+      # @return [ Object ] The typecasted value.
+      #
+      # @since 1.0.0
+      def try_to_typecast(key, value)
+        access = key.to_s
+        return value unless fields.has_key?(access)
+        field = fields[access]
+        typecast_value_for(field, value)
+      end
+
+      # Get the typecast value for the defined field.
+      #
+      # @example Get the typecast value.
+      #   selector.typecast_value_for(:name, "Corbin")
+      #
+      # @param [ Field ] field The defined field.
+      # @param [ Object ] value The value to cast.
+      #
+      # @return [ Object ] The cast value.
+      #
+      # @since 1.0.0
+      def typecast_value_for(field, value)
+        return field.serialize(value) if field.type === value
+        case value
+        when Hash
+          value = value.dup
+          value.each_pair do |k, v|
+            value[k] = typecast_hash_value(field, k, v)
+          end
+        when Array
+          value.map { |v| typecast_value_for(field, v) }
+        when Regexp
+          value
+        when Range
+          {
+            "$gte" => typecast_value_for(field, value.first),
+            "$lte" => typecast_value_for(field, value.last)
+          }
+        else
+          if field.type == Array
+            Serialization.mongoize(value, value.class)
+          else
+            field.serialize(value)
+          end
+        end
+      end
+
+      # Typecast the value for booleans and integers in hashes.
+      #
+      # @example Typecast the hash values.
+      #   selector.typecast_hash_value(field, "$exists", "true")
+      #
+      # @param [ Field ] field The defined field.
+      # @param [ String ] key The modifier key.
+      # @param [ Object ] value The value to cast.
+      #
+      # @return [ Object ] The cast value.
+      #
+      # @since 1.0.0
+      def typecast_hash_value(field, key, value)
+        case key
+        when "$exists"
+          Serialization.mongoize(value, Boolean)
+        when "$size"
+          Serialization.mongoize(value, Integer)
+        else
+          typecast_value_for(field, value)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/cursor.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # Mongoid wrapper of the Ruby Driver cursor.
+  class Cursor
+    include Mongoid::Collections::Retry
+    include Enumerable
+
+    # Operations on the Mongo::Cursor object that will not get overriden by the
+    # Mongoid::Cursor are defined here.
+    OPERATIONS = [
+      :close,
+      :closed?,
+      :count,
+      :explain,
+      :fields,
+      :full_collection_name,
+      :hint,
+      :limit,
+      :order,
+      :query_options_hash,
+      :query_opts,
+      :selector,
+      :skip,
+      :snapshot,
+      :sort,
+      :timeout
+    ]
+
+    attr_reader :collection, :cursor, :klass
+
+    # The operations above will all delegate to the proxied Mongo::Cursor.
+    OPERATIONS.each do |name|
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{name}(*args)
+          retry_on_connection_failure do
+            cursor.#{name}(*args)
+          end
+        end
+      EOS
+    end
+
+    # Iterate over each document in the cursor and yield to it.
+    #
+    # @example Iterate over the cursor.
+    #   cursor.each { |doc| p doc.title }
+    def each
+      cursor.each do |document|
+        yield Mongoid::Factory.from_db(klass, document)
+      end
+    end
+
+    # Create the new +Mongoid::Cursor+.
+    #
+    # @example Instantiate the cursor.
+    #   Mongoid::Cursor.new(Person, cursor)
+    #
+    # @param [ Class ] klass The class associated with the cursor.
+    # @param [ Collection ] collection The Mongoid::Collection instance.
+    # @param [ Mongo::Cursor ] cursor The Mongo::Cursor to be proxied.
+    def initialize(klass, collection, cursor)
+      @klass, @collection, @cursor = klass, collection, cursor
+    end
+
+    # Return the next document in the cursor. Will instantiate a new Mongoid
+    # document with the attributes.
+    #
+    # @example Get the next document.
+    #   cursor.next_document
+    #
+    # @return [ Document ] The next document in the cursor.
+    def next_document
+      Mongoid::Factory.from_db(klass, cursor.next_document)
+    end
+
+    # Returns an array of all the documents in the cursor.
+    #
+    # @example Get the cursor as an array.
+    #   cursor.to_a
+    #
+    # @return [ Array<Document> ] An array of documents.
+    def to_a
+      cursor.to_a.collect { |attrs| Mongoid::Factory.from_db(klass, attrs) }
+    end
+  end
+end