mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/criterion/optional.rb

@@ -1,259 +0,0 @@
-# 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|
-          setup_sort_options(crit.options) unless fields.first.nil?
-          fields.flatten.each { |field| merge_options(crit.options[:sort], [ localize(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|
-          setup_sort_options(crit.options) unless fields.first.nil?
-          fields.flatten.each { |field| merge_options(crit.options[:sort], [ localize(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)
-        field = klass.fields["_id"]
-        ids.flatten!
-        if ids.size > 1
-          any_in(:_id => ids.map{ |id| field.serialize(id) })
-        else
-          where(:_id => field.serialize(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.to_i }
-      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
-          setup_sort_options(crit.options) unless 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.to_i }
-      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], [ localize(field), direction ])
-          end
-        when Array
-          merge_options(crit.options[:sort], arguments.map{ |field| localize(field) })
-        when Complex
-          merge_options(crit.options[:sort], [ localize(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
-
-      # Initialize the sort options
-      # Set options[:sort] to an empty array if it does not exist, or dup it if
-      # it already has been defined
-      #
-      # @example criteria.setup_sort_options(crit.options)
-      #
-      # @param [ Array<Array> ] Existing options
-      #
-      # @since 2.4.0
-      def setup_sort_options(options)
-        options[:sort] = options[:sort] ? options[:sort].dup : []
-      end
-
-      # Check if field is localized and return localized version if it is.
-      #
-      # @example localize
-      #   criteria.localize(:description)
-      #
-      # @param [ <Symbol> ] field to localize
-      def localize(field)
-        if klass.fields[field.to_s].try(:localized?)
-          field = "#{field}.#{::I18n.locale}".to_sym
-        end
-        field
-      end
-    end
-  end
-end

data/lib/mongoid/criterion/selector.rb

@@ -1,177 +0,0 @@
-# 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 :aliased_fields, :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)
-        @aliased_fields, @fields, @klass =
-          klass.aliased_fields, 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
-        if field = fields[key.to_s] || fields[aliased_fields[key.to_s]]
-          typecast_value_for(field, value)
-        elsif proper_and_or_value?(key, value)
-          handle_and_or_value(value)
-        else
-          value
-        end
-      end
-
-      def proper_and_or_value?(key, value)
-        ["$and", "$or"].include?(key) &&
-          value.is_a?(Array) &&
-          value.all?{ |e| e.is_a?(Hash) }
-      end
-
-      def handle_and_or_value(values)
-        [].tap do |result|
-           result.push(*values.map do |value|
-            Hash[value.map do |_key, _value|
-              if klass.fields[_key.to_s].try(:localized?)
-                _key = "#{_key}.#{::I18n.locale}"
-              end
-              [_key, try_to_typecast(_key, _value)]
-            end]
-          end)
-        end
-      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.selection(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.selection(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

@@ -1,88 +0,0 @@
-# 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
-      retry_on_connection_failure do
-        while document = cursor.next_document
-          yield Factory.from_db(klass, document)
-        end
-      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