mongoid 2.8.1 → 3.0.0.rc

data/lib/mongoid/attributes/processing.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Attributes #:nodoc:
+module Mongoid
+  module Attributes
 
     # This module contains the behavior for processing attributes.
     module Processing
@@ -11,19 +11,21 @@ module Mongoid #:nodoc:
       # put into the document's attributes.
       #
       # @example Process the attributes.
-      #   person.process(:title => "sir", :age => 40)
+      #   person.process_attributes(:title => "sir", :age => 40)
       #
       # @param [ Hash ] attrs The attributes to set.
       # @param [ Symbol ] role A role for scoped mass assignment.
       # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
       #
       # @since 2.0.0.rc.7
-      def process(attrs = nil, role = :default, guard_protected_attributes = true)
+      def process_attributes(attrs = nil, role = :default, guard_protected_attributes = true)
         attrs ||= {}
-        attrs = sanitize_for_mass_assignment(attrs, role) if guard_protected_attributes
-        attrs.each_pair do |key, value|
-          next if pending_attribute?(key, value)
-          process_attribute(key, value)
+        if attrs.any?
+          attrs = sanitize_for_mass_assignment(attrs, role) if guard_protected_attributes
+          attrs.each_pair do |key, value|
+            next if pending_attribute?(key, value)
+            process_attribute(key, value)
+          end
         end
         yield self if block_given?
         process_pending
@@ -50,7 +52,7 @@ module Mongoid #:nodoc:
           pending_relations[name] = value
           return true
         end
-        if nested_attributes.include?("#{name}=")
+        if nested_attributes.has_key?(name)
           pending_nested[name] = value
           return true
         end
@@ -92,9 +94,11 @@ module Mongoid #:nodoc:
       #
       # @since 2.0.0.rc.7
       def process_attribute(name, value)
-        if Mongoid.allow_dynamic_fields && !respond_to?("#{name}=")
+        responds = respond_to?("#{name}=")
+        if Mongoid.allow_dynamic_fields && !responds
           write_attribute(name, value)
         else
+          raise Errors::UnknownAttribute.new(self.class, name) unless responds
           send("#{name}=", value)
         end
       end

data/lib/mongoid/attributes/readonly.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+module Mongoid
+  module Attributes
+
+    # This module defines behaviour for readonly attributes.
+    module Readonly
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :readonly_attributes
+        self.readonly_attributes = ::Set.new
+      end
+
+      # Are we able to write the attribute with the provided name?
+      #
+      # @example Can we write the attribute?
+      #   model.attribute_writable?(:title)
+      #
+      # @param [ String, Symbol ] name The name of the field.
+      #
+      # @return [ true, false ] If the document is new, or if the field is not
+      #   readonly.
+      #
+      # @since 3.0.0
+      def attribute_writable?(name)
+        new_record? || !readonly_attributes.include?(name.to_s)
+      end
+
+      module ClassMethods
+
+        # Defines an attribute as readonly. This will ensure that the value for
+        # the attribute is only set when the document is new or we are
+        # creating. In other cases, the field write will be ignored with the
+        # exception of #remove_attribute and #update_attribute, where an error
+        # will get raised.
+        #
+        # @example Flag fields as readonly.
+        #   class Band
+        #     include Mongoid::Document
+        #     field :name, type: String
+        #     field :genre, type: String
+        #     attr_readonly :name, :genre
+        #   end
+        #
+        # @param [ Array<Symbol> ] names The names of the fields.
+        #
+        # @since 3.0.0
+        def attr_readonly(*names)
+          names.each do |name|
+            readonly_attributes << name.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/callbacks.rb

@@ -1,40 +1,74 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
+module Mongoid
 
   # This module contains all the callback hooks for Mongoid.
   module Callbacks
     extend ActiveSupport::Concern
 
     CALLBACKS = [
-      :before_validation, :after_validation,
-      :after_initialize, :after_build,
-      :before_create, :around_create, :after_create,
-      :before_destroy, :around_destroy, :after_destroy,
-      :before_save, :around_save, :after_save,
-      :before_update, :around_update, :after_update,
+      :after_build,
+      :after_create,
+      :after_destroy,
+      :after_initialize,
+      :after_save,
+      :after_update,
+      :after_validation,
+      :around_create,
+      :around_destroy,
+      :around_save,
+      :around_update,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_validation
     ]
 
     included do
       extend ActiveModel::Callbacks
       include ActiveModel::Validations::Callbacks
 
-      define_model_callbacks :initialize, :only => :after
-      define_model_callbacks :build, :only => :after
+      define_model_callbacks :initialize, only: :after
+      define_model_callbacks :build, only: :after
       define_model_callbacks :create, :destroy, :save, :update
     end
 
-    # Is the provided type of callback executable by this document?
+    # Run only the after callbacks for the specific event.
     #
-    # @example Is the callback executable?
-    # document.callback_executable?(:save)
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
     #
-    # @param [ Symbol ] kin The type of callback.
+    # @example Run only the after save callbacks.
+    #   model.run_after_callbacks(:save)
     #
-    # @return [ true, false ] If the callback can be executed.
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
     #
-    # @since 2.5.1
-    def callback_executable?(kind)
-      respond_to?("_#{kind}_callbacks")
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_after_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:after, kind)
+      end
+    end
+
+    # Run only the before callbacks for the specific event.
+    #
+    # @note ActiveSupport does not allow this type of behaviour by default, so
+    #   Mongoid has to get around it and implement itself.
+    #
+    # @example Run only the before save callbacks.
+    #   model.run_before_callbacks(:save, :create)
+    #
+    # @param [ Array<Symbol> ] kinds The events that are occurring.
+    #
+    # @return [ Object ] The result of the chain executing.
+    #
+    # @since 3.0.0
+    def run_before_callbacks(*kinds)
+      kinds.each do |kind|
+        run_targeted_callbacks(:before, kind)
+      end
     end
 
     # Run the callbacks for the document. This overrides active support's
@@ -58,7 +92,7 @@ module Mongoid #:nodoc:
           return false
         end
       end
-      callback_executable?(kind) ? super(kind, *args, &block) : true
+      super(kind, *args, &block)
     end
 
     private
@@ -73,19 +107,21 @@ module Mongoid #:nodoc:
     # @return [ Array<Document> ] The children.
     #
     # @since 2.3.0
-    def cascadable_children(kind)
-      [].tap do |children|
-        relations.each_pair do |name, metadata|
-          next unless metadata.cascading_callbacks?
+    def cascadable_children(kind, children = Set.new)
+      embedded_relations.each_pair do |name, metadata|
+        next unless metadata.cascading_callbacks?
+        without_autobuild do
           delayed_pulls = delayed_atomic_pulls[name]
-          children.concat(delayed_pulls) if delayed_pulls
-          child = send(name)
-          Array.wrap(child).each do |doc|
-            children.push(doc) if cascadable_child?(kind, doc)
-            children.concat(doc.send(:cascadable_children, kind))
+          children.merge(delayed_pulls) if delayed_pulls
+          relation = send(name)
+          Array.wrap(relation).each do |child|
+            next if children.include?(child)
+            children.add(child) if cascadable_child?(kind, child)
+            children.merge(child.send(:cascadable_children, kind, children))
           end
         end
       end
+      children.to_a
     end
 
     # Determine if the child should fire the callback.
@@ -127,5 +163,32 @@ module Mongoid #:nodoc:
         kind
       end
     end
+
+    # Run only the callbacks for the target location (before, after, around)
+    # and kind (save, update, create).
+    #
+    # @example Run the targeted callbacks.
+    #   model.run_targeted_callbacks(:before, :save)
+    #
+    # @param [ Symbol ] place The time to run, :before, :after, :around.
+    # @param [ Symbol ] kind The type of callback, :save, :create, :update.
+    #
+    # @return [ Object ] The result of the chain execution.
+    #
+    # @since 3.0.0
+    def run_targeted_callbacks(place, kind)
+      name = "_run__#{place}__#{kind}__callbacks"
+      unless respond_to?(name)
+        chain = ActiveSupport::Callbacks::CallbackChain.new(name, {})
+        send("_#{kind}_callbacks").each do |callback|
+          chain.push(callback) if callback.kind == place
+        end
+        class_eval <<-EOM
+          def #{name}() #{chain.compile} end
+          protected :#{name}
+        EOM
+      end
+      send(name)
+    end
   end
 end

data/lib/mongoid/collections/retry.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc:
-  module Collections #:nodoc:
+module Mongoid
+  module Collections
 
     # Provides behaviour for retrying commands on connection failure.
     module Retry
@@ -32,7 +32,6 @@ module Mongoid #:nodoc:
           retry
         rescue Mongo::OperationFailure => ex
           if ex.message =~ /not master/
-            Mongoid.reconnect!
             retries = increase_retry_attempts(retries, ex)
             retry
           else

data/lib/mongoid/components.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
-module Mongoid #:nodoc
-  module Components #:nodoc
+module Mongoid
+  module Components
     extend ActiveSupport::Concern
 
     # All modules that a +Document+ is composed of are defined in this
@@ -21,22 +21,19 @@ module Mongoid #:nodoc
     include Mongoid::Atomic
     include Mongoid::Dirty
     include Mongoid::Attributes
-    include Mongoid::Collections
-    include Mongoid::DefaultScope
-    include Mongoid::Extras
+    include Mongoid::Copyable
     include Mongoid::Fields
     include Mongoid::Hierarchy
     include Mongoid::Indexes
     include Mongoid::Inspection
     include Mongoid::JSON
-    include Mongoid::Keys
     include Mongoid::Matchers
-    include Mongoid::NamedScope
     include Mongoid::NestedAttributes
     include Mongoid::Persistence
     include Mongoid::Relations
     include Mongoid::Reloading
-    include Mongoid::Safety
+    include Mongoid::Scoping
+    include Mongoid::Sessions
     include Mongoid::Serialization
     include Mongoid::Sharding
     include Mongoid::State
@@ -44,36 +41,29 @@ module Mongoid #:nodoc
     include Mongoid::Timestamps::Timeless
     include Mongoid::Validations
     include Mongoid::Callbacks
-    include Mongoid::Copyable
-    include Mongoid::MultiDatabase
 
     MODULES = [
       Mongoid::Atomic,
       Mongoid::Attributes,
-      Mongoid::Collections,
       Mongoid::Copyable,
-      Mongoid::DefaultScope,
       Mongoid::Dirty,
-      Mongoid::Extras,
       Mongoid::Fields,
       Mongoid::Hierarchy,
       Mongoid::Indexes,
       Mongoid::Inspection,
       Mongoid::JSON,
-      Mongoid::Keys,
+      Mongoid::Loggable,
       Mongoid::Matchers,
-      Mongoid::NamedScope,
       Mongoid::NestedAttributes,
       Mongoid::Persistence,
       Mongoid::Relations,
       Mongoid::Relations::Proxy,
-      Mongoid::Safety,
+      Mongoid::Scoping,
       Mongoid::Serialization,
       Mongoid::Sharding,
       Mongoid::State,
       Mongoid::Validations,
-      Mongoid::Callbacks,
-      Mongoid::MultiDatabase,
+      Mongoid::Callbacks
     ]
 
     class << self
@@ -88,11 +78,9 @@ module Mongoid #:nodoc
       #
       # @since 2.1.8
       def prohibited_methods
-        @prohibited_methods ||= MODULES.inject([]) do |methods, mod|
-          methods.tap do |mets|
-            mets << mod.instance_methods.map{ |m| m.to_sym }
-          end
-        end.flatten
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map{ |m| m.to_sym }
+        end
       end
     end
   end

data/lib/mongoid/config.rb

@@ -1,90 +1,29 @@
 # encoding: utf-8
-require "uri"
-require "mongoid/config/database"
 require "mongoid/config/environment"
-require "mongoid/config/replset_database"
+require "mongoid/config/inflections"
 require "mongoid/config/options"
+require "mongoid/config/validators"
 
-module Mongoid #:nodoc
+module Mongoid
 
   # This module defines all the configuration options for Mongoid, including the
   # database connections.
-  #
-  # @todo Durran: This module needs an overhaul, remove singleton, etc.
   module Config
     extend self
     extend Options
     include ActiveModel::Observing
 
-    # @attribute [rw] master The master database.
-    attr_accessor :master
-
-    option :allow_dynamic_fields, :default => true
-    option :autocreate_indexes, :default => false
-    option :identity_map_enabled, :default => false
-    option :include_root_in_json, :default => false
-    option :include_type_for_serialization, :default => false
-    option :max_retries_on_connection_failure, :default => 0
-    option :parameterize_keys, :default => true
-    option :scope_overwrite_exception, :default => false
-    option :persist_in_safe_mode, :default => false
-    option :preload_models, :default => false
-    option :raise_not_found_error, :default => true
-    option :skip_version_check, :default => false
-    option :time_zone, :default => nil
-    option :use_utc, :default => false
-
-    # Adds a new I18n locale file to the load path.
-    #
-    # @example Add a portuguese locale.
-    #   Mongoid::Config.add_language('pt')
-    #
-    # @example Add all available languages.
-    #   Mongoid::Config.add_language('*')
-    #
-    # @param [ String ] language_code The language to add.
-    def add_language(language_code = nil)
-      Dir[
-        File.join(
-          File.dirname(__FILE__), "..", "config", "locales", "#{language_code}.yml"
-      )
-      ].each do |file|
-        I18n.load_path << File.expand_path(file)
-      end
-    end
-
-    # keys to remove from self to not pass through to Mongo::Connection
-    PRIVATE_OPTIONS =
-      %w(uri host hosts port database databases username
-         password logger use_activesupport_time_zone)
-
-    # Get the blacklisted options from passing through to the driver.
-    #
-    # @example Get the blacklisted options.
-    #   Config.blacklisted_options
-    #
-    # @return [ Array<String> ] The blacklist.
-    #
-    # @since 2.4.7
-    def blacklisted_options
-      PRIVATE_OPTIONS + settings.keys.map(&:to_s)
-    end
-
-    # Get any extra databases that have been configured.
-    #
-    # @example Get the extras.
-    #   config.databases
-    #
-    # @return [ Hash ] A hash of secondary databases.
-    def databases
-      configure_extras(@settings["databases"]) unless @databases || !@settings
-      @databases || {}
-    end
-
-    # @todo Durran: There were no tests around the databases setter, not sure
-    # what the exact expectation was. Set with a hash?
-    def databases=(databases)
-    end
+    option :allow_dynamic_fields, default: true
+    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 :protect_sensitive_fields, default: true
+    option :raise_not_found_error, default: true
+    option :scope_overwrite_exception, default: false
+    option :skip_version_check, default: false
+    option :use_activesupport_time_zone, default: true
+    option :use_utc, default: false
 
     # Return field names that could cause destructive things to happen if
     # defined in a Mongoid::Document.
@@ -97,21 +36,6 @@ module Mongoid #:nodoc
       Components.prohibited_methods
     end
 
-    # Configure mongoid from a hash. This is usually called after parsing a
-    # yaml config file such as mongoid.yml.
-    #
-    # @example Configure Mongoid.
-    #   config.from_hash({})
-    #
-    # @param [ Hash ] options The settings to use.
-    def from_hash(options = {})
-      options.except("database", "slaves", "databases").each_pair do |name, value|
-        send("#{name}=", value) if respond_to?("#{name}=")
-      end
-      @master, @slaves = configure_databases(options)
-      configure_extras(options["databases"])
-    end
-
     # Load the settings from a compliant mongoid.yml file. This can be used for
     # easy setup with frameworks other than Rails.
     #
@@ -119,48 +43,32 @@ module Mongoid #:nodoc
     #   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.load_yaml(path).tap do |settings|
-        from_hash(settings) if settings.present?
-      end
-    end
-
-    # Returns the default logger, which is either a Rails logger of stdout logger
-    #
-    # @example Get the default logger
-    #   config.default_logger
-    #
-    # @return [ Logger ] The default Logger instance.
-    def default_logger
-      defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : ::Logger.new($stdout)
+    def load!(path, environment = nil)
+      settings = Environment.load_yaml(path, environment)
+      load_configuration(settings) if settings.present?
+      settings
     end
 
-    # Returns the logger, or defaults to Rails logger or stdout logger.
+    # Connect to the provided database name on the default session.
     #
-    # @example Get the logger.
-    #   config.logger
+    # @note Use only in development or test environments for convenience.
     #
-    # @return [ Logger ] The configured logger or a default Logger instance.
-    def logger
-      @logger = default_logger unless defined?(@logger)
-      @logger
-    end
-
-    # Sets the logger for Mongoid to use.
+    # @example Set the database to connect to.
+    #   config.connect_to("mongoid_test")
     #
-    # @example Set the logger.
-    #   config.logger = Logger.new($stdout, :warn)
+    # @param [ String ] name The database name.
     #
-    # @return [ Logger ] The newly set logger.
-    def logger=(logger)
-      case logger
-      when false, nil then @logger = nil
-      when true then @logger = default_logger
-      else
-        @logger = logger if logger.respond_to?(:info)
-      end
+    # @since 3.0.0
+    def connect_to(name)
+      self.sessions = {
+        default: {
+          database: name,
+          hosts: [ "localhost:27017" ]
+        }
+      }
     end
 
     # Purge all data in all collections, including indexes.
@@ -168,143 +76,89 @@ module Mongoid #:nodoc
     # @example Purge all data.
     #   Mongoid::Config.purge!
     #
+    # @return [ true ] true.
+    #
     # @since 2.0.2
     def purge!
-      master.collections.map do |collection|
-        collection.drop if collection.name !~ /system/
-      end
+      session = Sessions.default
+      collections = session["system.namespaces"].find(name: { "$not" => /system|\$/ }).to_a
+      collections.each do |collection|
+        _, name = collection["name"].split(".", 2)
+        session[name].drop
+      end and true
     end
 
-    # Sets whether the times returned from the database use the ruby or
-    # the ActiveSupport time zone.
+    # Set the configuration options. Will validate each one individually.
     #
-    # @note If you omit this setting, then times will use the ruby time zone.
+    # @example Set the options.
+    #   config.options = { raise_not_found_error: true }
     #
-    # @example Set the time zone config.
-    #   Config.use_activesupport_time_zone = true
+    # @param [ Hash ] options The configuration options.
     #
-    # @param [ true, false ] value Whether to use Active Support time zones.
-    #
-    # @return [ true, false ] The supplied value or false if nil.
-    def use_activesupport_time_zone=(value)
-      @use_activesupport_time_zone = value || false
+    # @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
-    attr_reader :use_activesupport_time_zone
-    alias_method :use_activesupport_time_zone?, :use_activesupport_time_zone
 
-    # Sets the Mongo::DB master database to be used. If the object trying to be
-    # set is not a valid +Mongo::DB+, then an error will be raised.
-    #
-    # @example Set the master database.
-    #   config.master = Mongo::Connection.new.db("test")
+    # Get the session configuration or an empty hash.
     #
-    # @param [ Mongo::DB ] db The master database.
+    # @example Get the sessions configuration.
+    #   config.sessions
     #
-    # @raise [ Errors::InvalidDatabase ] If the master isnt a valid object.
+    # @return [ Hash ] The sessions configuration.
     #
-    # @return [ Mongo::DB ] The master instance.
-    def master=(db)
-      check_database!(db)
-      @master = db
+    # @since 3.0.0
+    def sessions
+      @sessions ||= {}
     end
-    alias :database= :master=
 
-    # Returns the master database, or if none has been set it will raise an
-    # error.
+    # Set the session configuration options.
     #
-    # @example Get the master database.
-    #   config.master
-    #
-    # @raise [ Errors::InvalidDatabase ] If the database was not set.
-    #
-    # @return [ Mongo::DB ] The master database.
-    def master
-      unless @master
-        @master, @slaves = configure_databases(@settings) unless @settings.blank?
-        raise Errors::InvalidDatabase.new(nil) unless @master
-      end
-      if @reconnect
-        @reconnect = false
-        reconnect!
-      end
-      @master
-    end
-    alias :database :master
-
-    # Convenience method for connecting to the master database after forking a
-    # new process.
+    # @example Set the session configuration options.
+    #   config.sessions = { default: { hosts: [ "localhost:27017" ] }}
     #
-    # @example Reconnect to the master.
-    #   Mongoid.reconnect!
+    # @param [ Hash ] sessions The configuration options.
     #
-    # @param [ true, false ] now Perform the reconnection immediately?
-    def reconnect!(now = true)
-      if now
-        master.connection.connect
-      else
-        # We set a @reconnect flag so that #master knows to reconnect the next
-        # time the connection is accessed.
-        @reconnect = true
-      end
+    # @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
 
-    protected
-
-    # Check if the database is valid and the correct version.
+    # Get the time zone to use.
     #
-    # @example Check if the database is valid.
-    #   config.check_database!
+    # @example Get the time zone.
+    #   Config.time_zone
     #
-    # @param [ Mongo::DB ] database The db to check.
+    # @return [ String ] The time zone.
     #
-    # @raise [ Errors::InvalidDatabase ] If the object is not valid.
-    # @raise [ Errors::UnsupportedVersion ] If the db version is too old.
-    def check_database!(database)
-      raise Errors::InvalidDatabase.new(database) unless database.kind_of?(Mongo::DB)
-      unless skip_version_check
-        version = database.connection.server_version
-        raise Errors::UnsupportedVersion.new(version) if version < Mongoid::MONGODB_VERSION
-      end
+    # @since 3.0.0
+    def time_zone
+      use_utc? ? "UTC" : ::Time.zone
     end
 
-    # Get a database from settings.
-    #
-    # @example Configure the master and slave dbs.
-    #   config.configure_databases("database" => "mongoid")
-    #
-    # @param [ Hash ] options The options to use.
-    #
-    # @option options [ String ] :database The database name.
-    # @option options [ String ] :host The database host.
-    # @option options [ String ] :password The password for authentication.
-    # @option options [ Integer ] :port The port for the database.
-    # @option options [ Array<Hash> ] :slaves The slave db options.
-    # @option options [ String ] :uri The uri for the database.
-    # @option options [ String ] :username The user for authentication.
-    #
-    # @since 2.0.0.rc.1
-    def configure_databases(options)
-      if options.has_key?('hosts')
-        ReplsetDatabase.new(options).configure
-      else
-        Database.new(options).configure
-      end
-    end
+    private
 
-    # Get the secondary databases from settings.
+    # From a hash of settings, load all the configuration.
     #
-    # @example Configure the master and slave dbs.
-    #   config.configure_extras("databases" => settings)
+    # @example Load the configuration.
+    #   config.load_configuration(settings)
     #
-    # @param [ Hash ] options The options to use.
+    # @param [ Hash ] settings The configuration settings.
     #
-    # @since 2.0.0.rc.1
-    def configure_extras(extras)
-      @databases = (extras || []).inject({}) do |dbs, (name, options)|
-        dbs.tap do |extra|
-        dbs[name], dbs["#{name}_slaves"] = configure_databases(options)
-        end
-      end
+    # @since 3.0.0
+    def load_configuration(settings)
+      configuration = settings.with_indifferent_access
+      self.options = configuration[:options]
+      self.sessions = configuration[:sessions]
     end
   end
 end