mongoid 3.1.5 → 8.0.2

data/lib/mongoid/clients/sessions.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+
+    # Encapsulates behavior for getting a session from the client of a model class or instance,
+    # setting the session on the current thread, and yielding to a block.
+    # The session will be closed after the block completes or raises an error.
+    module Sessions
+
+      # Execute a block within the context of a session.
+      #
+      # @example Execute some operations in the context of a session.
+      #   band.with_session(causal_consistency: true) do
+      #     band.records << Record.create
+      #     band.name = 'FKA Twigs'
+      #     band.save
+      #     band.reload
+      #   end
+      #
+      # @param [ Hash ] options The session options. Please see the driver
+      #   documentation for the available session options.
+      #
+      # @note You cannot do any operations in the block using models or objects
+      #   that use a different client; the block will execute all operations
+      #   in the context of the implicit session and operations on any models using
+      #   another client will fail. For example, if you set a client using store_in on a
+      #   particular model and execute an operation on it in the session context block,
+      #   that operation can't use the block's session and an error will be raised.
+      #   An error will also be raised if sessions are nested.
+      #
+      # @raise [ Errors::InvalidSessionUse ] If an operation is attempted on a model using another
+      #   client from which the session was started or if sessions are nested.
+      #
+      # @return [ Object ] The result of calling the block.
+      #
+      # @yieldparam [ Mongo::Session ] The session being used for the block.
+      def with_session(options = {})
+        if Threaded.get_session
+          raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting)
+        end
+        session = persistence_context.client.start_session(options)
+        Threaded.set_session(session)
+        yield(session)
+      rescue Mongo::Error::InvalidSession => ex
+        if Mongo::Error::SessionsNotSupported === ex
+          raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
+        end
+        raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
+      ensure
+        Threaded.clear_session
+      end
+
+      private
+
+      def _session
+        Threaded.get_session
+      end
+
+      module ClassMethods
+
+        # Execute a block within the context of a session.
+        #
+        # @example Execute some operations in the context of a session.
+        #   Band.with_session(causal_consistency: true) do
+        #     band = Band.create
+        #     band.records << Record.new
+        #     band.save
+        #     band.reload.records
+        #   end
+        #
+        # @param [ Hash ] options The session options. Please see the driver
+        #   documentation for the available session options.
+        #
+        # @note You cannot do any operations in the block using models or objects
+        #   that use a different client; the block will execute all operations
+        #   in the context of the implicit session and operations on any models using
+        #   another client will fail. For example, if you set a client using store_in on a
+        #   particular model and execute an operation on it in the session context block,
+        #   that operation can't use the block's session and an error will be raised.
+        #   You also cannot nest sessions.
+        #
+        # @raise [ Errors::InvalidSessionUse ] If an operation is attempted on a model using another
+        #   client from which the session was started or if sessions are nested.
+        #
+        # @return [ Object ] The result of calling the block.
+        #
+        # @yieldparam [ Mongo::Session ] The session being used for the block.
+        def with_session(options = {})
+          if Threaded.get_session
+            raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_nesting)
+          end
+          session = persistence_context.client.start_session(options)
+          Threaded.set_session(session)
+          yield(session)
+        rescue Mongo::Error::InvalidSession => ex
+          if Mongo::Error::SessionsNotSupported === ex
+            raise Mongoid::Errors::InvalidSessionUse.new(:sessions_not_supported)
+          end
+          raise Mongoid::Errors::InvalidSessionUse.new(:invalid_session_use)
+        ensure
+          Threaded.clear_session
+        end
+
+        private
+
+        def _session
+          Threaded.get_session
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/storage_options.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+    module StorageOptions
+      extend ActiveSupport::Concern
+
+      included do
+
+        cattr_accessor :storage_options, instance_writer: false do
+          storage_options_defaults
+        end
+      end
+
+      module ClassMethods
+
+        # Give this model specific custom default storage options.
+        #
+        # @example Store this model by default in "artists"
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in collection: "artists"
+        #   end
+        #
+        # @example Store this model by default in the sharded db.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in database: "echo_shard"
+        #   end
+        #
+        # @example Store this model by default in a different client.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in client: "analytics"
+        #   end
+        #
+        # @example Store this model with a combination of options.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in collection: "artists", database: "music"
+        #   end
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String | Symbol ] :collection The collection name.
+        # @option options [ String | Symbol ] :database The database name.
+        # @option options [ String | Symbol ] :client The client name.
+        #
+        # @return [ Class ] The model class.
+        def store_in(options)
+          Validators::Storage.validate(self, options)
+          storage_options.merge!(options)
+        end
+
+        # Reset the store_in options
+        #
+        # @example Reset the store_in options
+        #   Model.reset_storage_options!
+        def reset_storage_options!
+          self.storage_options = storage_options_defaults.dup
+          PersistenceContext.clear(self)
+        end
+
+        # Get the default storage options.
+        #
+        # @example Get the default storage options.
+        #   Model.storage_options_defaults
+        #
+        # @return [ Hash ] Default storage options.
+        def storage_options_defaults
+          {
+            collection: name.collectionize.to_sym,
+            client: :default
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/validators/storage.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+    module Validators
+
+      # Validates the options passed to :store_in.
+      module Storage
+        extend self
+
+        # The valid options for storage.
+        VALID_OPTIONS = [ :collection, :database, :client ].freeze
+
+        # Validate the options provided to :store_in.
+        #
+        # @example Validate the options.
+        #   Storage.validate(:collection_name)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash | String | Symbol ] options The provided options.
+        def validate(klass, options)
+          valid_keys?(options) or raise Errors::InvalidStorageOptions.new(klass, options)
+          valid_parent?(klass) or raise Errors::InvalidStorageParent.new(klass)
+        end
+
+        private
+        # Determine if the current klass is valid to change store_in
+        # options
+        #
+        # @api private
+        #
+        # @param [ Class ] klass
+        #
+        # @return [ true | false ] If the class is valid.
+        def valid_parent?(klass)
+          !klass.superclass.include?(Mongoid::Document)
+        end
+
+        # Determine if all keys in the options hash are valid.
+        #
+        # @api private
+        #
+        # @example Are all keys valid?
+        #   validator.valid_keys?({ collection: "name" })
+        #
+        # @param [ Hash ] options The options hash.
+        #
+        # @return [ true | false ] If all keys are valid.
+        def valid_keys?(options)
+          return false unless options.is_a?(::Hash)
+          options.keys.all? do |key|
+            VALID_OPTIONS.include?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/validators.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "mongoid/clients/validators/storage"

data/lib/mongoid/clients.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "mongoid/clients/factory"
+require "mongoid/clients/validators"
+require "mongoid/clients/storage_options"
+require "mongoid/clients/options"
+require "mongoid/clients/sessions"
+
+module Mongoid
+  module Clients
+    extend ActiveSupport::Concern
+    include StorageOptions
+    include Options
+    include Sessions
+
+    class << self
+
+      # Clear all clients from the current thread.
+      #
+      # @example Clear all clients.
+      #   Mongoid::Clients.clear
+      #
+      # @return [ Array ] The empty clients.
+      def clear
+        clients.clear
+      end
+
+      # Get the default client.
+      #
+      # @example Get the default client.
+      #   Mongoid::Clients.default
+      #
+      # @return [ Mongo::Client ] The default client.
+      def default
+        with_name(:default)
+      end
+
+      # Disconnect all active clients.
+      #
+      # @example Disconnect all active clients.
+      #   Mongoid::Clients.disconnect
+      #
+      # @return [ true ] True.
+      def disconnect
+        clients.values.each do |client|
+          client.close
+        end
+      end
+
+      # Get a client with the provided name.
+      #
+      # @example Get a client with the name.
+      #   Mongoid::Clients.with_name(:replica)
+      #
+      # @param [ String | Symbol ] name The name of the client.
+      #
+      # @return [ Mongo::Client ] The named client.
+      def with_name(name)
+        name_as_symbol = name.to_sym
+        return clients[name_as_symbol] if clients[name_as_symbol]
+        CREATE_LOCK.synchronize do
+          clients[name_as_symbol] ||= Clients::Factory.create(name)
+        end
+      end
+
+      def set(name, client)
+        clients[name.to_sym] = client
+      end
+
+      def clients
+        @clients ||= {}
+      end
+
+      private
+
+      CREATE_LOCK = Mutex.new
+    end
+  end
+end

data/lib/mongoid/composable.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "mongoid/changeable"
+require "mongoid/findable"
+require "mongoid/indexable"
+require "mongoid/inspectable"
+require "mongoid/interceptable"
+require "mongoid/matcher"
+require "mongoid/matchable"
+require "mongoid/persistable"
+require "mongoid/reloadable"
+require "mongoid/selectable"
+require "mongoid/scopable"
+require "mongoid/serializable"
+require "mongoid/shardable"
+require "mongoid/stateful"
+require "mongoid/cacheable"
+require "mongoid/traversable"
+require "mongoid/validatable"
+
+module Mongoid
+
+  # This module provides inclusions of all behavior in a Mongoid document.
+  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 Findable
+    end
+
+    include ActiveModel::Model
+    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::Serializers::JSON
+    include Atomic
+    include Changeable
+    include Clients
+    include Attributes
+    include Evolvable
+    include Fields
+    include Indexable
+    include Inspectable
+    include Matchable
+    include Persistable
+    include Association
+    include Reloadable
+    include Scopable
+    include Selectable
+    include Serializable
+    include Shardable
+    include Stateful
+    include Cacheable
+    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,
+      Association,
+      Reloadable,
+      Scopable,
+      Serializable,
+      Clients,
+      Clients::Options,
+      Shardable,
+      Stateful,
+      Cacheable,
+      Threaded::Lifecycle,
+      Traversable,
+      Validatable,
+      Equality,
+      Association::Referenced::Syncable,
+      Association::Macros,
+      ActiveModel::Model,
+      ActiveModel::Validations
+    ]
+
+    # These are methods names defined in included blocks that may conflict
+    # with user-defined association or field names.
+    # They won't be in the list of Module.instance_methods on which the
+    # #prohibited_methods code below is dependent so we must track them
+    # separately.
+    #
+    # @return [ Array<Symbol> ] A list of reserved method names.
+    RESERVED_METHOD_NAMES = [ :fields,
+                              :aliased_fields,
+                              :localized_fields,
+                              :index_specifications,
+                              :shard_key_fields,
+                              :nested_attributes,
+                              :readonly_attributes,
+                              :storage_options,
+                              :cascades,
+                              :cyclic,
+                              :cache_timestamp_format
+                            ]
+
+    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> ]
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map(&:to_sym)
+        end + RESERVED_METHOD_NAMES
+      end
+    end
+  end
+end

data/lib/mongoid/config/environment.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Config
 
@@ -6,38 +7,75 @@ module Mongoid
     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.
+      # Get the name of the environment that Mongoid is running under.
+      #
+      # Uses the following sources in order:
+      # - If +::Rails+ is defined, +Rails.env+.
+      # - If +::Sinatra+ is defined, +Sinatra::Base.environment+.
+      # - +RACK_ENV+
+      # - +MONGOID_ENV*
       #
       # @example Get the env name.
       #   Environment.env_name
       #
-      # @raise [ Errors::NoEnvironment ] If no environment was set.
+      # @raise [ Errors::NoEnvironment ] If environment name cannot be
+      #   determined because none of the sources was set.
       #
       # @return [ String ] The name of the current environment.
-      #
-      # @since 2.3.0
+      # @api public
       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)
+        if defined?(::Rails)
+          return ::Rails.env
+        end
+        if defined?(::Sinatra)
+          return ::Sinatra::Base.environment.to_s
+        end
+        ENV["RACK_ENV"] || ENV["MONGOID_ENV"] or raise Errors::NoEnvironment
       end
 
       # Load the yaml from the provided path and return the settings for the
-      # current environment.
+      # specified environment, or for the current Mongoid environment.
       #
       # @example Load the yaml.
       #   Environment.load_yaml("/work/mongoid.yml")
       #
       # @param [ String ] path The location of the file.
+      # @param [ String | Symbol ] environment Optional environment name to
+      #   override the current Mongoid environment.
       #
       # @return [ Hash ] The settings.
       #
-      # @since 2.3.0
+      # @api private
       def load_yaml(path, environment = nil)
         env = environment ? environment.to_s : env_name
-        YAML.load(ERB.new(File.new(path).read).result)[env]
+
+        contents = File.read(path)
+        if contents.empty?
+          raise Mongoid::Errors::EmptyConfigFile.new(path)
+        end
+
+        # These are the classes that can be used in a Mongoid
+        # configuration file in addition to standard YAML types.
+        permitted_classes = [
+          # Symbols occur as values for read preference, for example.
+          Symbol,
+          # BSON::Binary occur as keyId values for FLE (more precisely,
+          # the keyIds are UUIDs).
+          BSON::Binary,
+        ]
+
+        result = ERB.new(contents).result
+        data = if RUBY_VERSION < '2.6'
+          YAML.safe_load(result, permitted_classes, [], true)
+        else
+          YAML.safe_load(result, permitted_classes: permitted_classes, aliases: true)
+        end
+
+        unless data.is_a?(Hash)
+          raise Mongoid::Errors::InvalidConfigFile.new(path)
+        end
+
+        data[env]
       end
     end
   end

data/lib/mongoid/config/options.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
   module Config
 
@@ -11,8 +12,6 @@ module Mongoid
       #   options.defaults
       #
       # @return [ Hash ] The default options.
-      #
-      # @since 2.3.0
       def defaults
         @defaults ||= {}
       end
@@ -20,30 +19,31 @@ module Mongoid
       # Define a configuration option with a default.
       #
       # @example Define the option.
-      #   Options.option(:persist_in_safe_mode, :default => false)
+      #   Options.option(:logger, :default => Logger.new(STDERR, :warn))
       #
       # @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}]
+        class_eval do
+          # log_level accessor is defined specially below
+          unless name.to_sym == :log_level
+            define_method(name) do
+              settings[name]
+            end
           end
 
-          def #{name}=(value)
-            settings[#{name.inspect}] = value
+          define_method("#{name}=") do |value|
+            settings[name] = value
           end
 
-          def #{name}?
-            #{name}
+          define_method("#{name}?") do
+            !!send(name)
           end
-        RUBY
+        end
       end
 
       # Reset the configuration options to the defaults.
@@ -52,8 +52,6 @@ module Mongoid
       #   config.reset
       #
       # @return [ Hash ] The defaults.
-      #
-      # @since 2.3.0
       def reset
         settings.replace(defaults)
       end
@@ -64,11 +62,25 @@ module Mongoid
       #   options.settings
       #
       # @return [ Hash ] The setting options.
-      #
-      # @since 2.3.0
       def settings
         @settings ||= {}
       end
+
+      # Get the log level.
+      #
+      # @example Get the log level.
+      #   config.log_level
+      #
+      # @return [ Integer ] The log level.
+      def log_level
+        if level = settings[:log_level]
+          unless level.is_a?(Integer)
+            level = level.upcase.to_s
+            level = "Logger::#{level}".constantize
+          end
+          level
+        end
+      end
     end
   end
 end