mongoid_rails4 4.0.0

data/lib/mongoid/persistable/savable.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that save documents.
+    #
+    # @since 4.0.0
+    module Savable
+
+      # Save the document - will perform an insert if the document is new, and
+      # update if not.
+      #
+      # @example Save the document.
+      #   document.save
+      #
+      # @param [ Hash ] options Options to pass to the save.
+      #
+      # @return [ true, false ] True is success, false if not.
+      #
+      # @since 1.0.0
+      def save(options = {})
+        if new_record?
+          !insert(options).new_record?
+        else
+          update_document(options)
+        end
+      end
+
+      # Save the document - will perform an insert if the document is new, and
+      # update if not. If a validation error occurs an error will get raised.
+      #
+      # @example Save the document.
+      #   document.save!
+      #
+      # @param [ Hash ] options Options to pass to the save.
+      #
+      # @raise [ Errors::Validations ] If validation failed.
+      # @raise [ Errors::Callback ] If a callback returns false.
+      #
+      # @return [ true, false ] True if validation passed.
+      #
+      # @since 1.0.0
+      def save!(options = {})
+        unless save(options)
+          fail_due_to_validation! unless errors.empty?
+          fail_due_to_callback!(:save!)
+        end
+        true
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/settable.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $set operations.
+    #
+    # @since 4.0.0
+    module Settable
+      extend ActiveSupport::Concern
+
+      # Perform a $set operation on the provided field/value pairs and set the
+      # values in the document in memory.
+      #
+      # @example Set the values.
+      #   document.set(title: "sir", dob: Date.new(1970, 1, 1))
+      #
+      # @param [ Hash ] setters The field/value pairs to set.
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def set(setters)
+        prepare_atomic_operation do |ops|
+          process_atomic_operations(setters) do |field, value|
+            send("#{field}=", value)
+            ops[atomic_attribute_name(field)] = attributes[field]
+          end
+          { "$set" => ops }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/unsettable.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for $unset operations.
+    #
+    # @since 4.0.0
+    module Unsettable
+      extend ActiveSupport::Concern
+
+      # Perform an $unset operation on the provided fields and in the
+      # values in the document in memory.
+      #
+      # @example Unset the values.
+      #   document.unset(:first_name, :last_name, :middle)
+      #
+      # @param [ Array<String, Symbol> ] fields The names of the fields to
+      #   unset.
+      #
+      # @return [ true ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def unset(*fields)
+        prepare_atomic_operation do |ops|
+          fields.flatten.each do |field|
+            normalized = database_field_name(field)
+            attributes.delete(normalized)
+            ops[atomic_attribute_name(normalized)] = true
+          end
+          { "$unset" => ops }
+        end
+      end
+    end
+  end
+end
+

data/lib/mongoid/persistable/updatable.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that update existing
+    # documents.
+    #
+    # @since 4.0.0
+    module Updatable
+
+      # Update the document in the database.
+      #
+      # @example Update an existing document.
+      #   document.update
+      #
+      # @param [ Hash ] options Options to pass to update.
+      #
+      # @option options [ true, false ] :validate Whether or not to validate.
+      #
+      # @return [ true, false ] True if succeeded, false if not.
+      #
+      # @since 1.0.0
+      def update_document(options = {})
+        prepare_update(options) do
+          updates, conflicts = init_atomic_updates
+          unless updates.empty?
+            coll = _root.collection
+            selector = atomic_selector
+            coll.find(selector).update(positionally(selector, updates))
+            conflicts.each_pair do |key, value|
+              coll.find(selector).update(positionally(selector, { key => value }))
+            end
+          end
+        end
+      end
+
+      # Update a single attribute and persist the entire document.
+      # This skips validation but fires the callbacks.
+      #
+      # @example Update the attribute.
+      #   person.update_attribute(:title, "Sir")
+      #
+      # @param [ Symbol, String ] name The name of the attribute.
+      # @param [ Object ] value The new value of the attribute.a
+      #
+      # @raise [ Errors::ReadonlyAttribute ] If the field cannot be changed due
+      #   to being flagged as reaodnly.
+      #
+      # @return [ true, false ] True if save was successfull, false if not.
+      #
+      # @since 2.0.0
+      def update_attribute(name, value)
+        normalized = name.to_s
+        unless attribute_writable?(normalized)
+          raise Errors::ReadonlyAttribute.new(normalized, value)
+        end
+        setter = "#{normalized}="
+        if respond_to?(setter)
+          send(setter, value)
+        else
+          write_attribute(database_field_name(normalized), value)
+        end
+        save(validate: false)
+      end
+
+      # Update the document attributes in the database.
+      #
+      # @example Update the document's attributes
+      #   document.update(:title => "Sir")
+      #
+      # @param [ Hash ] attributes The attributes to update.
+      #
+      # @return [ true, false ] True if validation passed, false if not.
+      #
+      # @since 1.0.0
+      def update(attributes = {})
+        assign_attributes(attributes)
+        save
+      end
+      alias :update_attributes :update
+
+      # Update the document attributes in the database and raise an error if
+      # validation failed.
+      #
+      # @example Update the document's attributes.
+      #   document.update!(:title => "Sir")
+      #
+      # @param [ Hash ] attributes The attributes to update.
+      #
+      # @raise [ Errors::Validations ] If validation failed.
+      # @raise [ Errors::Callbacks ] If a callback returns false.
+      #
+      # @return [ true, false ] True if validation passed.
+      #
+      # @since 1.0.0
+      def update!(attributes = {})
+        result = update_attributes(attributes)
+        unless result
+          fail_due_to_validation! unless errors.empty?
+          fail_due_to_callback!(:update_attributes!)
+        end
+        result
+      end
+      alias :update_attributes! :update!
+
+      private
+
+      # Initialize the atomic updates.
+      #
+      # @api private
+      #
+      # @example Initialize the atomic updates.
+      #   document.init_atomic_updates
+      #
+      # @return [ Array<Hash> ] The updates and conflicts.
+      #
+      # @since 4.0.0
+      def init_atomic_updates
+        updates = atomic_updates
+        conflicts = updates.delete(:conflicts) || {}
+        [ updates, conflicts ]
+      end
+
+      # Prepare the update for execution. Validates and runs callbacks, etc.
+      #
+      # @api private
+      #
+      # @example Prepare for update.
+      #   document.prepare_update do
+      #     collection.update(atomic_selector)
+      #   end
+      #
+      # @param [ Hash ] options The options.
+      #
+      # @return [ true, false ] The result of the update.
+      #
+      # @since 4.0.0
+      def prepare_update(options = {})
+        return false if performing_validations?(options) && invalid?(:update)
+        process_flagged_destroys
+        result = run_callbacks(:save) do
+          run_callbacks(:update) do
+            yield(self)
+            true
+          end
+        end
+        post_process_persist(result, options) and result
+      end
+    end
+  end
+end

data/lib/mongoid/persistable/upsertable.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+module Mongoid
+  module Persistable
+
+    # Defines behaviour for persistence operations that upsert documents.
+    #
+    # @since 4.0.0
+    module Upsertable
+
+      # Perform an upsert of the document. If the document does not exist in the
+      # database, then Mongo will insert a new one, otherwise the fields will get
+      # overwritten with new values on the existing document.
+      #
+      # @example Upsert the document.
+      #   document.upsert
+      #
+      # @param [ Hash ] options The validation options.
+      #
+      # @return [ true ] True.
+      #
+      # @since 3.0.0
+      def upsert(options = {})
+        prepare_upsert(options) do
+          collection.find(atomic_selector).update(as_document, [ :upsert ])
+        end
+      end
+
+      private
+
+      # Prepare the upsert for execution.
+      #
+      # @api private
+      #
+      # @example Prepare the upsert
+      #   document.prepare_upsert do
+      #     collection.find(selector).update(as_document)
+      #   end
+      #
+      # @param [ Hash ] options The options hash.
+      #
+      # @return [ true, false ] If the operation succeeded.
+      #
+      # @since 4.0.0
+      def prepare_upsert(options = {})
+        return false if performing_validations?(options) && invalid?(:upsert)
+        result = run_callbacks(:upsert) do
+          yield(self)
+          true
+        end
+        self.new_record = false
+        post_process_persist(result, options) and result
+      end
+    end
+  end
+end

data/lib/mongoid/positional.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module is responsible for taking update selectors and switching out
+  # the indexes for the $ positional operator where appropriate.
+  #
+  # @since 4.0.0
+  module Positional
+
+    # Takes the provided selector and atomic operations and replaces the
+    # indexes of the embedded documents with the positional operator when
+    # needed.
+    #
+    # @note The only time we can accurately know when to use the positional
+    #   operator is at the exact time we are going to persist something. So
+    #   we can tell by the selector that we are sending if it is actually
+    #   possible to use the positional operator at all. For example, if the
+    #   selector is: { "_id" => 1 }, then we could not use the positional
+    #   operator for updating embedded documents since there would never be a
+    #   match - we base whether we can based on the number of levels deep the
+    #   selector goes, and if the id values are not nil.
+    #
+    # @example Process the operations.
+    #   positionally(
+    #     { "_id" => 1, "addresses._id" => 2 },
+    #     { "$set" => { "addresses.0.street" => "hobrecht" }}
+    #   )
+    #
+    # @param [ Hash ] selector The selector.
+    # @param [ Hash ] operations The update operations.
+    # @param [ Hash ] processed The processed update operations.
+    #
+    # @return [ Hash ] The new operations.
+    #
+    # @since 3.1.0
+    def positionally(selector, operations, processed = {})
+      if selector.size == 1 || selector.values.any? { |val| val.nil? }
+        return operations
+      end
+      keys = selector.keys.map{ |m| m.sub('._id','') } - ['_id']
+      keys = keys.sort_by { |s| s.length*-1 }
+      process_operations(keys, operations, processed)
+    end
+
+    private
+
+    def process_operations(keys, operations, processed)
+      operations.each_pair do |operation, update|
+        processed[operation] = process_updates(keys, update)
+      end
+      processed
+    end
+
+    def process_updates(keys, update, updates = {})
+      update.each_pair do |position, value|
+        updates[replace_index(keys, position)] = value
+      end
+      updates
+    end
+
+    def replace_index(keys, position)
+      # replace to $ only if that key is on the selector
+      keys.each do |kk|
+        if position =~ /^#{kk}\.\d+\.(.*)/
+          return "#{kk}.$.#{$1}"
+        end
+      end
+      position
+    end
+  end
+end

data/lib/mongoid/railtie.rb

@@ -0,0 +1,156 @@
+# encoding: utf-8
+require "mongoid"
+require "mongoid/config"
+require "mongoid/railties/document"
+require "rails"
+require "rails/mongoid"
+
+module Rails
+  module Mongoid
+
+    # Hooks Mongoid into Rails 3 and higher.
+    #
+    # @since 2.0.0
+    class Railtie < Rails::Railtie
+
+      # Determine which generator to use. app_generators was introduced after
+      # 3.0.0.
+      #
+      # @example Get the generators method.
+      #   railtie.generators
+      #
+      # @return [ Symbol ] The method name to use.
+      #
+      # @since 2.0.0.rc.4
+      def self.generator
+        config.respond_to?(:app_generators) ? :app_generators : :generators
+      end
+
+      # Mapping of rescued exceptions to HTTP responses
+      #
+      # @example
+      #   railtie.rescue_responses
+      #
+      # @ return [Hash] rescued responses
+      #
+      # @since 2.4.3
+      def self.rescue_responses
+        {
+          "Mongoid::Errors::DocumentNotFound" => :not_found,
+          "Mongoid::Errors::Validations" => 422
+        }
+      end
+
+      config.send(generator).orm :mongoid, migration: false
+
+      if config.action_dispatch.rescue_responses
+        config.action_dispatch.rescue_responses.merge!(rescue_responses)
+      end
+
+      rake_tasks do
+        load "mongoid/railties/database.rake"
+      end
+
+      # Exposes Mongoid's configuration to the Rails application configuration.
+      #
+      # @example Set up configuration in the Rails app.
+      #   module MyApplication
+      #     class Application < Rails::Application
+      #       config.mongoid.logger = Logger.new($stdout, :warn)
+      #       config.mongoid.persist_in_safe_mode = true
+      #     end
+      #   end
+      #
+      # @since 2.0.0
+      config.mongoid = ::Mongoid::Config
+
+      # Initialize Mongoid. This will look for a mongoid.yml in the config
+      # directory and configure mongoid appropriately.
+      #
+      # @since 2.0.0
+      initializer "mongoid.load-config" do
+        config_file = Rails.root.join("config", "mongoid.yml")
+        if config_file.file?
+          begin
+            ::Mongoid.load!(config_file)
+          rescue ::Mongoid::Errors::NoSessionsConfig => e
+            handle_configuration_error(e)
+          rescue ::Mongoid::Errors::NoDefaultSession => e
+            handle_configuration_error(e)
+          rescue ::Mongoid::Errors::NoSessionDatabase => e
+            handle_configuration_error(e)
+          rescue ::Mongoid::Errors::NoSessionHosts => e
+            handle_configuration_error(e)
+          end
+        end
+      end
+
+      # Set the proper error types for Rails. DocumentNotFound errors should be
+      # 404s and not 500s, validation errors are 422s.
+      #
+      # @since 2.0.0
+      config.after_initialize do
+        unless config.action_dispatch.rescue_responses
+          ActionDispatch::ShowExceptions.rescue_responses.update(Railtie.rescue_responses)
+        end
+      end
+
+      # Due to all models not getting loaded and messing up inheritance queries
+      # and indexing, we need to preload the models in order to address this.
+      #
+      # This will happen every request in development, once in ther other
+      # environments.
+      #
+      # @since 2.0.0
+      initializer "mongoid.preload-models" do |app|
+        config.to_prepare do
+          ::Rails::Mongoid.preload_models(app)
+        end
+      end
+
+      # Need to include the Mongoid identity map middleware.
+      #
+      # @since 3.0.0
+      initializer "mongoid.use-identity-map-middleware" do |app|
+        app.config.middleware.use "Rack::Mongoid::Middleware::IdentityMap"
+      end
+
+      config.after_initialize do
+        # Unicorn clears the START_CTX when a worker is forked, so if we have
+        # data in START_CTX then we know we're being preloaded. Unicorn does
+        # not provide application-level hooks for executing code after the
+        # process has forked, so we reconnect lazily.
+        if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
+          ::Mongoid.default_session.disconnect if ::Mongoid.configured?
+        end
+
+        # Passenger provides the :starting_worker_process event for executing
+        # code after it has forked, so we use that and reconnect immediately.
+        if ::Mongoid.running_with_passenger?
+          PhusionPassenger.on_event(:starting_worker_process) do |forked|
+            ::Mongoid.default_session.disconnect if forked
+          end
+        end
+      end
+
+      # Rails runs all initializers first before getting into any generator
+      # code, so we have no way in the intitializer to know if we are
+      # generating a mongoid.yml. So instead of failing, we catch all the
+      # errors and print them out.
+      #
+      # @since 3.0.0
+      def handle_configuration_error(e)
+        puts "There is a configuration error with the current mongoid.yml."
+        puts e.message
+      end
+
+      # Clears the idenity map on console reload. Identity map is on a thread
+      # local so it's safe to clear it in all environments.
+      #
+      # @since 4.0.0
+      ActionDispatch::Reloader.to_cleanup do
+        ::Mongoid::IdentityMap.clear
+      end
+    end
+  end
+end