Class: Mongoid::PersistenceContext

# File 'lib/mongoid/persistence_context.rb', line 316

def context_store
  Threaded.get(PERSISTENCE_CONTEXT_KEY) { {} }
end

# File 'lib/mongoid/persistence_context.rb', line 288

def get(object)
  get_context(object)
end

# File 'lib/mongoid/persistence_context.rb', line 329

def get_context(object)
  context_store[object.object_id]
end

# File 'lib/mongoid/persistence_context.rb', line 267

def set(object, options_or_context)
  existing_context = get_context(object)
  existing_options = if existing_context
                       existing_context.options
                     else
                       {}
                     end
  options_or_context = options_or_context.options if options_or_context.is_a?(PersistenceContext)
  new_options = existing_options.merge(options_or_context)
  context = PersistenceContext.new(object, new_options)
  store_context(object, context)
end

# File 'lib/mongoid/persistence_context.rb', line 340

def store_context(object, context)
  if context.nil?
    context_store.delete(object.object_id)
  else
    context_store[object.object_id] = context
  end
end

# File 'lib/mongoid/persistence_context.rb', line 172

def reusable_client?
  @options.keys == [ :client ]
end

# File 'lib/mongoid/persistence_context.rb', line 198

def __evaluate__(name)
  return nil unless name

  name.respond_to?(:call) ? name.call.to_sym : name.to_sym
end

# File 'lib/mongoid/persistence_context.rb', line 116

def client
  @client ||= begin
    client = Clients.with_name(client_name)
    options = client_options

    if database_name_option
      client = client.use(database_name)
      options = options.except(:database, 'database')
    end

    client = client.with(options) unless options.empty?

    verify_encryption_schema!(client)

    client
  end
end

# File 'lib/mongoid/persistence_context.rb', line 141

def client_name
  @client_name ||= __evaluate__(options[:client]) ||
                   Threaded.client_override ||
                   __evaluate__(storage_options[:client])
end

# File 'lib/mongoid/persistence_context.rb', line 237

def client_options
  @client_options ||= begin
    opts = options.select do |k, _v|
      Mongo::Client::VALID_OPTIONS.include?(k.to_sym)
    end
    opts[:read] = { mode: opts[:read] } if opts[:read].is_a?(Symbol)
    opts
  end
end

# File 'lib/mongoid/persistence_context.rb', line 78

def collection(parent = nil)
  if parent
    parent.collection.with(client_options.except(:database, 'database'))
  else
    client[collection_name.to_sym]
  end
end

# File 'lib/mongoid/persistence_context.rb', line 93

def collection_name
  @collection_name ||= __evaluate__(options[:collection] ||
                         storage_options[:collection])
end

# File 'lib/mongoid/persistence_context.rb', line 105

def database_name
  __evaluate__(database_name_option) || client.database.name
end

# File 'lib/mongoid/persistence_context.rb', line 247

def database_name_option
  @database_name_option ||= options[:database] ||
                            Threaded.database_override ||
                            storage_options[:database]
end

# File 'lib/mongoid/persistence_context.rb', line 56

def for_child(document)
  if document.is_a?(Class)
    return self if document == (@object.is_a?(Class) ? @object : @object.class)
  elsif document.is_a?(Mongoid::Document)
    return self if document.class == (@object.is_a?(Class) ? @object : @object.class)
  else
    raise ArgumentError, 'must specify a class or a document instance'
  end

  PersistenceContext.new(document, options.merge(document.storage_options))
end

# File 'lib/mongoid/persistence_context.rb', line 183

def requested_storage_options
  slice = @options.slice(*Mongoid::Clients::Validators::Storage::VALID_OPTIONS)
  slice.any? ? slice : nil
end

# File 'lib/mongoid/persistence_context.rb', line 190

def set_options!(opts)
  @options ||= opts.each.reduce({}) do |_options, (key, value)|
    raise Errors::InvalidPersistenceOption.new(key.to_sym, VALID_OPTIONS) unless VALID_OPTIONS.include?(key.to_sym)

    value ? _options.merge!(key => value) : _options
  end
end

# File 'lib/mongoid/persistence_context.rb', line 218

def verify_encryption_schema!(client)
  klass = @object.is_a?(Class) ? @object : @object.class
  # A model whose encrypted fields all live on embedded models declares no
  # encryption of its own, and still needs a schema for its collection.
  return unless klass.respond_to?(:requires_encryption_schema?) && klass.requires_encryption_schema?
  # An embedded document is persisted as part of its parent, so the
  # parent's context is what governs the namespace.
  return if klass.embedded?
  # Collection and index management sends no document data, so it does not
  # need an encryption-capable client.
  return if Threaded.managing_collection?

  schema_map = client.options.dig(:auto_encryption_options, :schema_map)
  namespace = "#{client.database.name}.#{collection_name}"
  return if schema_map&.key?(namespace)

  raise Errors::NoEncryptionSchema.new(klass, namespace, client_name)
end