mongoid_rails4 4.0.0

data/lib/mongoid/composable.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+require "mongoid/changeable"
+require "mongoid/findable"
+require "mongoid/indexable"
+require "mongoid/inspectable"
+require "mongoid/interceptable"
+require "mongoid/matchable"
+require "mongoid/persistable"
+require "mongoid/reloadable"
+require "mongoid/selectable"
+require "mongoid/scopable"
+require "mongoid/serializable"
+require "mongoid/shardable"
+require "mongoid/traversable"
+require "mongoid/validatable"
+
+module Mongoid
+
+  # This module provides inclusions of all behaviour in a Mongoid document.
+  #
+  # @since 4.0.0
+  module Composable
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend ActiveModel::Translation
+      extend Findable
+    end
+
+    include ActiveModel::Conversion
+    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::Naming
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Atomic
+    include Changeable
+    include Attributes
+    include Evolvable
+    include Fields
+    include Indexable
+    include Inspectable
+    include Matchable
+    include Persistable
+    include Relations
+    include Reloadable
+    include Scopable
+    include Selectable
+    include Serializable
+    include Sessions
+    include Shardable
+    include State
+    include Threaded::Lifecycle
+    include Traversable
+    include Validatable
+    include Interceptable
+    include Copyable
+    include Equality
+
+    MODULES = [
+      Atomic,
+      Attributes,
+      Copyable,
+      Changeable,
+      Evolvable,
+      Fields,
+      Indexable,
+      Inspectable,
+      Interceptable,
+      Matchable,
+      Persistable,
+      Relations,
+      Reloadable,
+      Scopable,
+      Serializable,
+      Sessions,
+      Shardable,
+      State,
+      Threaded::Lifecycle,
+      Traversable,
+      Validatable,
+      Equality
+    ]
+
+    class << self
+
+      # Get a list of methods that would be a bad idea to define as field names
+      # or override when including Mongoid::Document.
+      #
+      # @example Bad thing!
+      #   Mongoid::Components.prohibited_methods
+      #
+      # @return [ Array<Symbol> ]
+      #
+      # @since 2.1.8
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map{ |m| m.to_sym }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/config.rb

@@ -0,0 +1,263 @@
+# encoding: utf-8
+require "mongoid/config/environment"
+require "mongoid/config/options"
+require "mongoid/config/validators"
+
+module Mongoid
+
+  # This module defines all the configuration options for Mongoid, including the
+  # database connections.
+  module Config
+    extend self
+    extend Options
+
+    delegate :logger=, to: ::Mongoid
+    delegate :logger, to: ::Mongoid
+
+    LOCK = Mutex.new
+
+    option :identity_map_enabled, default: false
+    option :include_root_in_json, default: false
+    option :include_type_for_serialization, default: false
+    option :preload_models, default: false
+    option :raise_not_found_error, default: true
+    option :scope_overwrite_exception, default: false
+    option :duplicate_fields_exception, default: false
+    option :use_activesupport_time_zone, default: true
+    option :use_utc, default: false
+
+    # Has Mongoid been configured? This is checking that at least a valid
+    # session config exists.
+    #
+    # @example Is Mongoid configured?
+    #   config.configured?
+    #
+    # @return [ true, false ] If Mongoid is configured.
+    #
+    # @since 3.0.9
+    def configured?
+      sessions.has_key?(:default)
+    end
+
+    # Connect to the provided database name on the default session.
+    #
+    # @note Use only in development or test environments for convenience.
+    #
+    # @example Set the database to connect to.
+    #   config.connect_to("mongoid_test")
+    #
+    # @param [ String ] name The database name.
+    #
+    # @since 3.0.0
+    def connect_to(name, options = { consistency: :eventual })
+      self.sessions = {
+        default: {
+          database: name,
+          hosts: [ "localhost:27017" ],
+          options: options
+        }
+      }
+    end
+
+    # Return field names that could cause destructive things to happen if
+    # defined in a Mongoid::Document.
+    #
+    # @example Get the destructive fields.
+    #   config.destructive_fields
+    #
+    # @return [ Array<String> ] An array of bad field names.
+    def destructive_fields
+      Composable.prohibited_methods
+    end
+
+    # Load the settings from a compliant mongoid.yml file. This can be used for
+    # easy setup with frameworks other than Rails.
+    #
+    # @example Configure Mongoid.
+    #   Mongoid.load!("/path/to/mongoid.yml")
+    #
+    # @param [ String ] path The path to the file.
+    # @param [ String, Symbol ] environment The environment to load.
+    #
+    # @since 2.0.1
+    def load!(path, environment = nil)
+      settings = Environment.load_yaml(path, environment)
+      if settings.present?
+        Sessions.disconnect
+        Sessions.clear
+        load_configuration(settings)
+      end
+      settings
+    end
+
+    # Get all the models in the application - this is everything that includes
+    # Mongoid::Document.
+    #
+    # @example Get all the models.
+    #   config.models
+    #
+    # @return [ Array<Class> ] All the models in the application.
+    #
+    # @since 3.1.0
+    def models
+      @models ||= []
+    end
+
+    # Register a model in the application with Mongoid.
+    #
+    # @example Register a model.
+    #   config.register_model(Band)
+    #
+    # @param [ Class ] klass The model to register.
+    #
+    # @since 3.1.0
+    def register_model(klass)
+      LOCK.synchronize do
+        models.push(klass) unless models.include?(klass)
+      end
+    end
+
+    # From a hash of settings, load all the configuration.
+    #
+    # @example Load the configuration.
+    #   config.load_configuration(settings)
+    #
+    # @param [ Hash ] settings The configuration settings.
+    #
+    # @since 3.1.0
+    def load_configuration(settings)
+      configuration = settings.with_indifferent_access
+      self.options = configuration[:options]
+      self.sessions = configuration[:sessions]
+    end
+
+    # Override the database to use globally.
+    #
+    # @example Override the database globally.
+    #   config.override_database(:optional)
+    #
+    # @param [ String, Symbol ] name The name of the database.
+    #
+    # @return [ String, Symbol ] The global override.
+    #
+    # @since 3.0.0
+    def override_database(name)
+      Threaded.database_override = name
+    end
+
+    # Override the session to use globally.
+    #
+    # @example Override the session globally.
+    #   config.override_session(:optional)
+    #
+    # @param [ String, Symbol ] name The name of the session.
+    #
+    # @return [ String, Symbol ] The global override.
+    #
+    # @since 3.0.0
+    def override_session(name)
+      Threaded.session_override = name ? name.to_s : nil
+    end
+
+    # Purge all data in all collections, including indexes.
+    #
+    # @example Purge all data.
+    #   Mongoid::Config.purge!
+    #
+    # @note This is the fastest way to drop all data.
+    #
+    # @return [ true ] true.
+    #
+    # @since 2.0.2
+    def purge!
+      Sessions.default.collections.each do |collection|
+        collection.drop
+      end and true
+    end
+
+    # Truncate all data in all collections, but not the indexes.
+    #
+    # @example Truncate all collection data.
+    #   Mongoid::Config.truncate!
+    #
+    # @note This will be slower than purge!
+    #
+    # @return [ true ] true.
+    #
+    # @since 2.0.2
+    def truncate!
+      Sessions.default.collections.each do |collection|
+        collection.find.remove_all
+      end and true
+    end
+
+    # Set the configuration options. Will validate each one individually.
+    #
+    # @example Set the options.
+    #   config.options = { raise_not_found_error: true }
+    #
+    # @param [ Hash ] options The configuration options.
+    #
+    # @since 3.0.0
+    def options=(options)
+      if options
+        options.each_pair do |option, value|
+          Validators::Option.validate(option)
+          send("#{option}=", value)
+        end
+      end
+    end
+
+    # Get the session configuration or an empty hash.
+    #
+    # @example Get the sessions configuration.
+    #   config.sessions
+    #
+    # @return [ Hash ] The sessions configuration.
+    #
+    # @since 3.0.0
+    def sessions
+      @sessions ||= {}
+    end
+
+    # Set the session configuration options.
+    #
+    # @example Set the session configuration options.
+    #   config.sessions = { default: { hosts: [ "localhost:27017" ] }}
+    #
+    # @param [ Hash ] sessions The configuration options.
+    #
+    # @since 3.0.0
+    def sessions=(sessions)
+      raise Errors::NoSessionsConfig.new unless sessions
+      sess = sessions.with_indifferent_access
+      Validators::Session.validate(sess)
+      @sessions = sess
+      sess
+    end
+
+    # Get the time zone to use.
+    #
+    # @example Get the time zone.
+    #   Config.time_zone
+    #
+    # @return [ String ] The time zone.
+    #
+    # @since 3.0.0
+    def time_zone
+      use_utc? ? "UTC" : ::Time.zone
+    end
+
+    # Is the application running under passenger?
+    #
+    # @example Is the application using passenger?
+    #   config.running_with_passenger?
+    #
+    # @return [ true, false ] If the app is deployed on Passenger.
+    #
+    # @since 3.0.11
+    def running_with_passenger?
+      @running_with_passenger ||= defined?(PhusionPassenger)
+    end
+  end
+end

data/lib/mongoid/config/environment.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid
+  module Config
+
+    # Encapsulates logic for getting environment information.
+    module Environment
+      extend self
+
+      # Get the name of the environment that we are running under. This first
+      # looks for Rails, then Sinatra, then a RACK_ENV environment variable,
+      # and if none of those are found raises an error.
+      #
+      # @example Get the env name.
+      #   Environment.env_name
+      #
+      # @raise [ Errors::NoEnvironment ] If no environment was set.
+      #
+      # @return [ String ] The name of the current environment.
+      #
+      # @since 2.3.0
+      def env_name
+        return Rails.env if defined?(Rails)
+        return Sinatra::Base.environment.to_s if defined?(Sinatra)
+        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] || raise(Errors::NoEnvironment.new)
+      end
+
+      # Load the yaml from the provided path and return the settings for the
+      # current environment.
+      #
+      # @example Load the yaml.
+      #   Environment.load_yaml("/work/mongoid.yml")
+      #
+      # @param [ String ] path The location of the file.
+      #
+      # @return [ Hash ] The settings.
+      #
+      # @since 2.3.0
+      def load_yaml(path, environment = nil)
+        env = environment ? environment.to_s : env_name
+        YAML.load(ERB.new(File.new(path).read).result)[env]
+      end
+    end
+  end
+end

data/lib/mongoid/config/options.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+module Mongoid
+  module Config
+
+    # Encapsulates logic for setting options.
+    module Options
+
+      # Get the defaults or initialize a new empty hash.
+      #
+      # @example Get the defaults.
+      #   options.defaults
+      #
+      # @return [ Hash ] The default options.
+      #
+      # @since 2.3.0
+      def defaults
+        @defaults ||= {}
+      end
+
+      # Define a configuration option with a default.
+      #
+      # @example Define the option.
+      #   Options.option(:persist_in_safe_mode, :default => false)
+      #
+      # @param [ Symbol ] name The name of the configuration option.
+      # @param [ Hash ] options Extras for the option.
+      #
+      # @option options [ Object ] :default The default value.
+      #
+      # @since 2.0.0.rc.1
+      def option(name, options = {})
+        defaults[name] = settings[name] = options[:default]
+
+        class_eval <<-RUBY
+          def #{name}
+            settings[#{name.inspect}]
+          end
+
+          def #{name}=(value)
+            settings[#{name.inspect}] = value
+          end
+
+          def #{name}?
+            #{name}
+          end
+        RUBY
+      end
+
+      # Reset the configuration options to the defaults.
+      #
+      # @example Reset the configuration options.
+      #   config.reset
+      #
+      # @return [ Hash ] The defaults.
+      #
+      # @since 2.3.0
+      def reset
+        settings.replace(defaults)
+      end
+
+      # Get the settings or initialize a new empty hash.
+      #
+      # @example Get the settings.
+      #   options.settings
+      #
+      # @return [ Hash ] The setting options.
+      #
+      # @since 2.3.0
+      def settings
+        @settings ||= {}
+      end
+    end
+  end
+end