sepastian-mongoid-rails4 4.0.0.alpha

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

data/lib/mongoid/railties/database.rake

@@ -0,0 +1,95 @@
+namespace :db do
+
+  unless Rake::Task.task_defined?("db:drop")
+    desc "Drops all the collections for the database for the current Rails.env"
+    task :drop => "mongoid:drop"
+  end
+
+  unless Rake::Task.task_defined?("db:purge")
+    desc "Drop all collections except the system collections"
+    task :purge => "mongoid:purge"
+  end
+
+  unless Rake::Task.task_defined?("db:seed")
+    # if another ORM has defined db:seed, don"t run it twice.
+    desc "Load the seed data from db/seeds.rb"
+    task :seed => :environment do
+      seed_file = File.join(Rails.root, "db", "seeds.rb")
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:setup")
+    desc "Create the database, and initialize with the seed data"
+    task :setup => [ "db:create", "db:mongoid:create_indexes", "db:seed" ]
+  end
+
+  unless Rake::Task.task_defined?("db:reset")
+    desc "Delete data and loads the seeds"
+    task :reset => [ "db:drop", "db:seed" ]
+  end
+
+  unless Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare => "mongoid:create_indexes"
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:create_indexes")
+    task :create_indexes => "mongoid:create_indexes"
+  end
+
+  unless Rake::Task.task_defined?("db:remove_indexes")
+    task :remove_indexes => "mongoid:remove_indexes"
+  end
+
+  namespace :mongoid do
+    desc "Create the indexes defined on your mongoid models"
+    task :create_indexes => :environment do
+      ::Rails.application.eager_load!
+      ::Rails::Mongoid.create_indexes
+    end
+
+    desc "Remove indexes that exist in the database but aren't specified on the models"
+    task :remove_undefined_indexes => :environment do
+      ::Rails.application.eager_load!
+      ::Rails::Mongoid.remove_undefined_indexes
+    end
+
+    desc "Remove the indexes defined on your mongoid models without questions!"
+    task :remove_indexes => :environment do
+      ::Rails.application.eager_load!
+      ::Rails::Mongoid.remove_indexes
+    end
+
+    desc "Drops the database for the current Rails.env"
+    task :drop => :environment do
+      ::Mongoid::Sessions.default.drop
+    end
+
+    desc "Drop all collections except the system collections"
+    task :purge => :environment do
+      ::Mongoid.purge!
+    end
+  end
+end

data/lib/mongoid/railties/document.rb

@@ -0,0 +1,12 @@
+module Mongoid
+  module Document
+    # Used in conjunction with fields_for to build a form element for the
+    # destruction of this association. Always returns false because Mongoid
+    # only supports immediate deletion of associations.
+    #
+    # See ActionView::Helpers::FormHelper::fields_for for more info.
+    def _destroy
+      false
+    end
+  end
+end

data/lib/mongoid/relations/accessors.rb

@@ -0,0 +1,280 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+
+    # This module contains all the behaviour related to accessing relations
+    # through the getters and setters, and how to delegate to builders to
+    # create new ones.
+    module Accessors
+      extend ActiveSupport::Concern
+
+      # Builds the related document and creates the relation unless the
+      # document is nil, then sets the relation on this document.
+      #
+      # @example Build the relation.
+      #   person.__build__(:addresses, { :id => 1 }, metadata)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ true, false ] building If we are in a build operation.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def __build__(name, object, metadata)
+        relation = create_relation(object, metadata)
+        set_relation(name, relation)
+      end
+
+      # Create a relation from an object and metadata.
+      #
+      # @example Create the relation.
+      #   person.create_relation(document, metadata)
+      #
+      # @param [ Document, Array<Document ] object The relation target.
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def create_relation(object, metadata)
+        type = @attributes[metadata.inverse_type]
+        target = metadata.builder(self, object).build(type)
+        target ? metadata.relation.new(self, target, metadata) : nil
+      end
+
+      # Determines if the relation exists or not.
+      #
+      # @example Does the relation exist?
+      #   person.relation_exists?(:people)
+      #
+      # @param [ String ] name The name of the relation to check.
+      #
+      # @return [ true, false ] True if set and not nil, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def relation_exists?(name)
+        ivar(name)
+      end
+
+      # Resets the criteria inside the relation proxy. Used by many to many
+      # relations to keep the underlying ids array in sync.
+      #
+      # @example Reset the relation criteria.
+      #   person.reset_relation_criteria(:preferences)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      #
+      # @since 3.0.14
+      def reset_relation_criteria(name)
+        if instance_variable_defined?("@_#{name}")
+          send(name).reset_unloaded
+        end
+      end
+
+      # Set the supplied relation to an instance variable on the class with the
+      # provided name. Used as a helper just for code cleanliness.
+      #
+      # @example Set the proxy on the document.
+      #   person.set(:addresses, addresses)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Proxy ] relation The relation to set.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def set_relation(name, relation)
+        instance_variable_set("@_#{name}", relation)
+      end
+
+      private
+
+      # Get the relation. Extracted out from the getter method to avoid
+      # infinite recursion when overriding the getter.
+      #
+      # @api private
+      #
+      # @example Get the relation.
+      #   document.get_relation(:name, metadata)
+      #
+      # @param [ Symbol ] name The name of the relation.
+      # @param [ Metadata ] metadata The relation metadata.
+      # @param [ true, false ] reload If the relation is to be reloaded.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 3.0.16
+      def get_relation(name, metadata, object, reload = false)
+        if !reload && (value = ivar(name)) != false
+          value
+        else
+          _building do
+            _loading do
+              if object && needs_no_database_query?(object, metadata)
+                __build__(name, object, metadata)
+              else
+                __build__(name, attributes[metadata.key], metadata)
+              end
+            end
+          end
+        end
+      end
+
+      def needs_no_database_query?(object, metadata)
+        object.is_a?(Document) && !object.embedded? &&
+          object.id == attributes[metadata.key]
+      end
+
+      # Is the current code executing without autobuild functionality?
+      #
+      # @example Is autobuild disabled?
+      #   document.without_autobuild?
+      #
+      # @return [ true, false ] If autobuild is disabled.
+      #
+      # @since 3.0.0
+      def without_autobuild?
+        Threaded.executing?(:without_autobuild)
+      end
+
+      # Yield to the block with autobuild functionality turned off.
+      #
+      # @example Execute without autobuild.
+      #   document.without_autobuild do
+      #     document.name
+      #   end
+      #
+      # @return [ Object ] The result of the yield.
+      #
+      # @since 3.0.0
+      def without_autobuild
+        Threaded.begin_execution("without_autobuild")
+        yield
+      ensure
+        Threaded.exit_execution("without_autobuild")
+      end
+
+      module ClassMethods
+
+        # Adds the existence check for relations.
+        #
+        # @example Add the existence check.
+        #   Person.existence_check(:name, meta)
+        #
+        # @example Check if a relation exists.
+        #   person = Person.new
+        #   person.has_game?
+        #   person.game?
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] The metadata.
+        #
+        # @return [ Class ] The model being set up.
+        #
+        # @since 3.0.0
+        def existence_check(name, metadata)
+          module_eval <<-END
+            def #{name}?
+              without_autobuild { !__send__(:#{name}).blank? }
+            end
+            alias :has_#{name}? :#{name}?
+          END
+          self
+        end
+
+        # Defines the getter for the relation. Nothing too special here: just
+        # return the instance variable for the relation if it exists or build
+        # the thing.
+        #
+        # @example Set up the getter for the relation.
+        #   Person.getter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def getter(name, metadata)
+          re_define_method(name) do |reload = false|
+            value = get_relation(name, metadata, nil, reload)
+            if value.nil? && metadata.autobuilding? && !without_autobuild?
+              value = send("build_#{name}")
+            end
+            value
+          end
+          self
+        end
+
+        # Defines the getter for the ids of documents in the relation. Should
+        # be specify only for referenced many relations.
+        #
+        # @example Set up the ids getter for the relation.
+        #   Person.ids_getter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        def ids_getter(name, metadata)
+          ids_method = "#{name.to_s.singularize}_ids"
+          re_define_method(ids_method) do
+            send(name).only(:id).map(&:id)
+          end
+          self
+        end
+
+
+        # Defines the setter for the relation. This does a few things based on
+        # some conditions. If there is an existing association, a target
+        # substitution will take place, otherwise a new relation will be
+        # created with the supplied target.
+        #
+        # @example Set up the setter for the relation.
+        #   Person.setter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def setter(name, metadata)
+          re_define_method("#{name}=") do |object|
+            without_autobuild do
+              if value = get_relation(name, metadata, object)
+                set_relation(name, value.substitute(object.substitutable))
+              else
+                __build__(name, object.substitutable, metadata)
+              end
+            end
+          end
+          self
+        end
+
+        # Defines the setter method that allows you to set documents
+        # in this relation by their ids. The defined setter, finds
+        # documents with given ids and invokes regular relation setter
+        # with found documents. Ids setters should be defined only for
+        # referenced many relations.
+        #
+        # @example Set up the id_setter for the relation.
+        #   Person.ids_setter("addesses", metadata)
+        #
+        #  @param [ String, Symbol ] name The name of the relation.
+        #  @param [ Metadata ] metadata The metadata for the relation.
+        #
+        #  @return [ Class ] The class being set up.
+        def ids_setter(name, metadata)
+          ids_method = "#{name.to_s.singularize}_ids="
+          re_define_method(ids_method) do |ids|
+            send(metadata.setter, metadata.klass.find(ids.reject(&:blank?)))
+          end
+          self
+        end
+      end
+    end
+  end
+end