mongoid_rails4 4.0.0

data/lib/mongoid/fields/validators.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "mongoid/fields/validators/macro"

data/lib/mongoid/fields/validators/macro.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+module Mongoid
+  module Fields
+    module Validators
+
+      # Validates the params passed to the field macro.
+      module Macro
+        extend self
+
+        OPTIONS = [
+          :as,
+          :default,
+          :identity,
+          :label,
+          :localize,
+          :metadata,
+          :pre_processed,
+          :subtype,
+          :type,
+          :overwrite
+        ]
+
+        # Validate the field definition.
+        #
+        # @example Validate the field definition.
+        #   Macro.validate(Model, :name, { localized: true })
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        # @param [ Hash ] options The provided options.
+        #
+        # @since 3.0.0
+        def validate(klass, name, options)
+          validate_name(klass, name, options)
+          validate_options(klass, name, options)
+        end
+
+        private
+
+        # Determine if the field name is allowed, if not raise an error.
+        #
+        # @api private
+        #
+        # @example Check the field name.
+        #   Macro.validate_name(Model, :name)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        #
+        # @raise [ Errors::InvalidField ] If the name is not allowed.
+        #
+        # @since 3.0.0
+        def validate_name(klass, name, options)
+          if Mongoid.destructive_fields.include?(name)
+            raise Errors::InvalidField.new(klass, name)
+          end
+
+          # if field alredy defined
+          if !options[:overwrite] && klass.fields.keys.include?(name.to_s)
+            if Mongoid.duplicate_fields_exception
+              raise Errors::InvalidField.new(klass, name)
+            else
+              Mongoid.logger.warn("Overwriting existing field #{name}.") if Mongoid.logger
+            end
+          end
+        end
+
+        # Validate that the field options are allowed.
+        #
+        # @api private
+        #
+        # @example Validate the field options.
+        #   Macro.validate_options(Model, :name, { localized: true })
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        # @param [ Hash ] options The provided options.
+        #
+        # @raise [ Errors::InvalidFieldOption ] If an option is invalid.
+        #
+        # @since 3.0.0
+        def validate_options(klass, name, options)
+          options.keys.each do |option|
+            if !OPTIONS.include?(option) && !Fields.options.include?(option)
+              raise Errors::InvalidFieldOption.new(klass, name, option, OPTIONS)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/findable.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module defines the finder methods that hang off the document at the
+  # class level.
+  #
+  # @since 4.0.0
+  module Findable
+    extend Origin::Forwardable
+
+    select_with :with_default_scope
+
+    # These are methods defined on the criteria that should also be accessible
+    # directly from the the class level.
+    delegate \
+      :aggregates,
+      :avg,
+      :distinct,
+      :each,
+      :each_with_index,
+      :extras,
+      :find_and_modify,
+      :find_or_create_by,
+      :find_or_initialize_by,
+      :first_or_create,
+      :first_or_create!,
+      :first_or_initialize,
+      :for_js,
+      :geo_near,
+      :includes,
+      :map_reduce,
+      :max,
+      :min,
+      :pluck,
+      :sum,
+      :text_search,
+      :update,
+      :update_all, to: :with_default_scope
+
+    # Returns a count of records in the database.
+    # If you want to specify conditions use where.
+    #
+    # @example Get the count of matching documents.
+    #   Person.count
+    #   Person.where(title: "Sir").count
+    #
+    # @return [ Integer ] The number of matching documents.
+    def count
+      with_default_scope.count
+    end
+
+    # Returns true if count is zero
+    #
+    # @example Are there no saved documents for this model?
+    #   Person.empty?
+    #
+    # @return [ true, false ] If the collection is empty.
+    def empty?
+      count == 0
+    end
+
+    # Returns true if there are on document in database based on the
+    # provided arguments.
+    #
+    # @example Do any documents exist for the conditions?
+    #   Person.exists?
+    #
+    # @param [ Array ] args The conditions.
+    def exists?
+      with_default_scope.exists?
+    end
+
+    # Find a +Document+ in several different ways.
+    #
+    # If a +String+ is provided, it will be assumed that it is a
+    # representation of a Mongo::ObjectID and will attempt to find a single
+    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
+    # it will attempt to find either a single +Document+ or multiples based
+    # on the conditions provided and the first parameter.
+    #
+    # @example Find a single document by an id.
+    #   Person.find(Moped::BSON::ObjectId)
+    #
+    # @param [ Array ] args An assortment of finder options.
+    #
+    # @return [ Document, nil, Criteria ] A document or matching documents.
+    def find(*args)
+      with_default_scope.find(*args)
+    end
+
+    # Find the first +Document+ given the conditions, or raises
+    # Mongoid::Errors::DocumentNotFound
+    #
+    # @example Find the document by attribute other than id
+    #   Person.find_by(:username => "superuser")
+    #
+    # @param [ Hash ] attrs The attributes to check.
+    #
+    # @raise [ Errors::DocumentNotFound ] If no document found.
+    #
+    # @return [ Document ] A matching document.
+    #
+    # @since 3.0.0
+    def find_by(attrs = {})
+      result = where(attrs).first
+      if result.nil? && Mongoid.raise_not_found_error
+        raise(Errors::DocumentNotFound.new(self, attrs))
+      end
+      yield(result) if result && block_given?
+      result
+    end
+
+    # Find the first +Document+ given the conditions.
+    #
+    # @example Find the first document.
+    #   Person.first
+    #
+    # @return [ Document ] The first matching document.
+    def first
+      with_default_scope.first
+    end
+
+    # Find the last +Document+ given the conditions.
+    #
+    # @example Find the last document.
+    #   Person.last
+    #
+    # @return [ Document ] The last matching document.
+    def last
+      with_default_scope.last
+    end
+  end
+end

data/lib/mongoid/identity_map.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+module Mongoid
+
+  # Defines behaviour for the identity map in Mongoid.
+  class IdentityMap < Hash
+
+    # Clear out the loaded documents for the provided selector.
+    #
+    # @example Clear out the documents.
+    #   map.clear_many(Post, { person_id: person.id })
+    #
+    # @param [ Class ] klass The class of the relation.
+    # @param [ Hash ] selector The selector.
+    #
+    # @return [ Array ] An empty array.
+    #
+    # @since 2.4.10
+    def clear_many(klass, selector)
+      documents_for(klass)[selector] = {}
+    end
+
+    # Get a document from the identity map by its id.
+    #
+    # @example Get the document from the map.
+    #   map.get(Person, id)
+    #
+    # @param [ Class ] klass The class of the document.
+    # @param [ Object, Hash ] idenfier The document id or selector.
+    #
+    # @return [ Document ] The matching document.
+    #
+    # @since 2.1.0
+    def get(klass, identifier)
+      if Mongoid.using_identity_map? && klass
+        if identifier.is_a?(::Array)
+          documents = documents_for(klass)
+          identifier.map do |id|
+            documents[id] || (return nil)
+          end
+        else
+          documents_for(klass)[identifier]
+        end
+      end
+    end
+
+    # Get many documents from the map via the selector
+    #
+    # @example Get the document from the map.
+    #   map.get(Person, { post_id: post })
+    #
+    # @param [ Class ] klass The class of the document.
+    # @param [ Hash ] idenfier The selector.
+    #
+    # @return [ Array<Document> ] The matching documents.
+    #
+    # @since 3.0.0
+    def get_many(klass, identifier)
+      if Mongoid.using_identity_map? && klass
+        documents_for(klass)[identifier].try(:values)
+      end
+    end
+
+    # Remove the document from the identity map.
+    #
+    # @example Remove the document.
+    #   map.removed(person)
+    #
+    # @param [ Document ] document The document to remove.
+    #
+    # @return [ Document, nil ] The removed document.
+    #
+    # @since 2.1.0
+    def remove(document)
+      if Mongoid.using_identity_map? && document && document.id
+        documents_for(document.class).delete(document.id)
+      end
+    end
+
+    # Puts a document in the identity map, accessed by its id.
+    #
+    # @example Put the document in the map.
+    #   identity_map.set(document)
+    #
+    # @param [ Document ] document The document to place in the map.
+    #
+    # @return [ Document ] The provided document.
+    #
+    # @since 2.1.0
+    def set(document)
+      if Mongoid.using_identity_map? && document && document.id
+        documents_for(document.class)[document.id] = document
+      end
+    end
+
+    # Set a document in the identity map for the provided selector.
+    #
+    # @example Set the document in the map.
+    #   identity_map.set_selector(document, { :person_id => person.id })
+    #
+    # @param [ Document ] document The document to set.
+    # @param [ Hash ] selector The selector to identify it.
+    #
+    # @return [ Array<Document> ] The documents.
+    #
+    # @since 2.2.0
+    def set_many(document, selector)
+      (documents_for(document.class)[selector] ||= {})[document.id] = document
+    end
+
+    # Set a document in the identity map for the provided selector.
+    #
+    # @example Set the document in the map.
+    #   identity_map.set_selector(document, { :person_id => person.id })
+    #
+    # @param [ Document ] document The document to set.
+    # @param [ Hash ] selector The selector to identify it.
+    #
+    # @return [ Document ] The matching document.
+    #
+    # @since 2.2.0
+    def set_one(document, selector)
+      documents_for(document.class)[selector] = document
+    end
+
+    private
+
+    # Get the documents in the identity map for a specific class.
+    #
+    # @example Get the documents for the class.
+    #   map.documents_for(Person)
+    #
+    # @param [ Class ] klass The class to retrieve.
+    #
+    # @return [ Hash ] The documents.
+    #
+    # @since 2.1.0
+    def documents_for(klass)
+      if klass
+        self[klass.collection_name] ||= {}
+      end
+    end
+
+    class << self
+
+      # For ease of access we provide the same API to the identity map on the
+      # class level, which in turn just gets the identity map that is on the
+      # current thread.
+      #
+      # @example Get a document from the current identity map by id.
+      #   IdentityMap.get(id)
+      #
+      # @example Set a document in the current identity map.
+      #   IdentityMap.set(document)
+      #
+      # @since 2.1.0
+      delegate(*(
+        Hash.public_instance_methods(false) +
+        IdentityMap.public_instance_methods(false) <<
+        { to: :"Mongoid::Threaded.identity_map" }
+      ))
+    end
+  end
+end

data/lib/mongoid/indexable.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+require "mongoid/indexable/specification"
+require "mongoid/indexable/validators/options"
+
+module Mongoid
+
+  # Encapsulates behaviour around defining indexes.
+  #
+  # @since 4.0.0
+  module Indexable
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :index_specifications
+      self.index_specifications = []
+    end
+
+    module ClassMethods
+
+      # Send the actual index creation comments to the MongoDB driver
+      #
+      # @example Create the indexes for the class.
+      #   Person.create_indexes
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 1.0.0
+      def create_indexes
+        return unless index_specifications
+        index_specifications.each do |spec|
+          key, options = spec.key, spec.options
+          if database = options[:database]
+            with(consistency: :strong, database: database).
+              collection.indexes.create(key, options.except(:database))
+          else
+            with(consistency: :strong).collection.indexes.create(key, options)
+          end
+        end and true
+      end
+
+      # Send the actual index removal comments to the MongoDB driver,
+      # but lets _id untouched.
+      #
+      # @example Remove the indexes for the class.
+      #   Person.remove_indexes
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 3.0.0
+      def remove_indexes
+        indexed_database_names.each do |database|
+          collection = with(consistency: :strong, database: database).collection
+          collection.indexes.each do |spec|
+            unless spec["name"] == "_id_"
+              collection.indexes.drop(spec["key"])
+            end
+          end
+        end and true
+      end
+
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      #
+      # @example Add Mongoid internal indexes.
+      #   Person.add_indexes
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 1.0.0
+      def add_indexes
+        if hereditary? && !index_keys.include?(_type: 1)
+          index({ _type: 1 }, unique: false, background: true)
+        end
+        true
+      end
+
+      # Adds an index definition for the provided single or compound keys.
+      #
+      # @example Create a basic index.
+      #   class Person
+      #     include Mongoid::Document
+      #     field :name, type: String
+      #     index({ name: 1 }, { background: true })
+      #   end
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The index options.
+      #
+      # @return [ Hash ] The index options.
+      #
+      # @since 1.0.0
+      def index(spec, options = nil)
+        specification = Specification.new(self, spec, options)
+        if !index_specifications.include?(specification)
+          index_specifications.push(specification)
+        end
+      end
+
+      # Get an index specification for the provided key.
+      #
+      # @example Get the index specification.
+      #   Model.index_specification(name: 1)
+      #
+      # @param [ Hash ] key The index key/direction pair.
+      #
+      # @return [ Specification ] The found specification.
+      #
+      # @since 4.0.0
+      def index_specification(key)
+        index_specifications.detect{ |spec| spec.fields == key.keys }
+      end
+
+      private
+
+      # Get the names of all databases for this model that have index
+      # definitions.
+      #
+      # @api private
+      #
+      # @example Get the indexed database names.
+      #   Model.indexed_database_names
+      #
+      # @return [ Array<String> ] The names.
+      #
+      # @since 3.1.0
+      def indexed_database_names
+        index_specifications.map do |spec|
+          spec.options[:database] || database_name
+        end.uniq
+      end
+
+      # Gets a list of index specification keys.
+      #
+      # @api private
+      #
+      # @example Get the specification key list.
+      #   Model.index_keys
+      #
+      # @return [ Array<Hash> ] The specification keys.
+      #
+      # @since 4.0.0
+      def index_keys
+        index_specifications.map{ |spec| spec.key }
+      end
+    end
+  end
+end