Class: Mongoid::Contextual::Mongo

# File 'lib/mongoid/contextual/mongo.rb', line 902

def acknowledged_write?
  collection.write_concern.nil? || collection.write_concern.acknowledged?
end

# File 'lib/mongoid/contextual/mongo.rb', line 54

attr_reader :documents_loader

# File 'lib/mongoid/contextual/mongo.rb', line 42

attr_reader :view

# File 'lib/mongoid/contextual/mongo.rb', line 42

attr_reader :view

# File 'lib/mongoid/contextual/mongo.rb', line 805

def apply_fields
  if spec = criteria.options[:fields]
    @view = view.projection(spec)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 833

def apply_option(name)
  if spec = criteria.options[name]
    @view = view.send(name, spec)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 817

def apply_options
  apply_fields
  OPTIONS.each do |name|
    apply_option(name)
  end
  if criteria.options[:timeout] == false
    @view = view.no_cursor_timeout
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 73

def count(options = {}, &block)
  return super(&block) if block_given?

  if valid_for_count_documents?
    view.count_documents(options)
  else
    # TODO: Remove this when we remove the deprecated for_js API.
    # https://jira.mongodb.org/browse/MONGOID-5681
    view.count(options)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 114

def delete
  view.delete_many.deleted_count
end

# File 'lib/mongoid/contextual/mongo.rb', line 117

alias :delete_all :delete

# File 'lib/mongoid/contextual/mongo.rb', line 1009

def demongoize_hash(klass, hash)
  return nil unless hash

  hash.each_key do |key|
    value = hash[key]

    # does the key represent a declared field on the document?
    if (field = klass.fields[key])
      hash[key] = field.demongoize(value)
      next
    end

    # does the key represent an emebedded relation on the document?
    aliased_name = klass.aliased_associations[key] || key
    if (assoc = klass.relations[aliased_name])
      case value
      when Array then value.each { |h| demongoize_hash(assoc.klass, h) }
      when Hash then demongoize_hash(assoc.klass, value)
      end
    end
  end

  hash
end

# File 'lib/mongoid/contextual/mongo.rb', line 1045

def demongoize_with_field(field, value, is_translation)
  if field
    # If it's a localized field that's not a hash, don't demongoize
    # again, we already have the translation. If it's an _translations
    # field, don't demongoize, we want the full hash not just a
    # specific translation.
    # If it is a hash, and it's not a translations field, we need to
    # demongoize to get the correct translation.
    if field.localized? && (!value.is_a?(Hash) || is_translation)
      value.class.demongoize(value)
    else
      field.demongoize(value)
    end
  else
    value.class.demongoize(value)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 125

def destroy
  each.inject(0) do |count, doc|
    doc.destroy
    count += 1 if acknowledged_write?
    count
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 132

alias :destroy_all :destroy

# File 'lib/mongoid/contextual/mongo.rb', line 142

def distinct(field)
  name = klass.cleanse_localized_field_names(field)

  view.distinct(name).map do |value|
    is_translation = "#{name}_translations" == field.to_s
    recursive_demongoize(name, value, is_translation)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 855

def documents_for_iteration
  if @documents_loader
    if @documents_loader.started?
      @documents_loader.value!
    else
      @documents_loader.unschedule
      @documents_loader.execute
    end
  else
    return view unless eager_loadable?
    docs = view.map do |doc|
      Factory.from_db(klass, doc, criteria)
    end
    eager_load(docs)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 160

def each(&block)
  if block_given?
    documents_for_iteration.each do |doc|
      yield_document(doc, &block)
    end
    self
  else
    to_enum
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 97

def estimated_count(options = {})
  unless self.criteria.selector.empty?
    if klass.default_scoping?
      raise Mongoid::Errors::InvalidEstimatedCountScoping.new(self.klass)
    else
      raise Mongoid::Errors::InvalidEstimatedCountCriteria.new(self.klass)
    end
  end
  view.estimated_document_count(options)
end

# File 'lib/mongoid/contextual/mongo.rb', line 190

def exists?(id_or_conditions = :none)
  return false if self.view.limit == 0
  case id_or_conditions
  when :none then !!(view.projection(_id: 1).limit(1).first)
  when nil, false then false
  when Hash then Mongo.new(criteria.where(id_or_conditions)).exists?
  else Mongo.new(criteria.where(_id: id_or_conditions)).exists?
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 933

def extract_value(attrs, field_name)
  i = 1
  num_meths = field_name.count('.') + 1
  curr = attrs.dup

  klass.traverse_association_tree(field_name) do |meth, obj, is_field|
    field = obj if is_field
    is_translation = false
    # If no association or field was found, check if the meth is an
    # _translations field.
    if obj.nil? & tr = meth.match(/(.*)_translations\z/)&.captures&.first
      is_translation = true
      meth = tr
    end

    # 1. If curr is an array fetch from all elements in the array.
    # 2. If the field is localized, and is not an _translations field
    #    (_translations fields don't show up in the fields hash).
    #    - If this is the end of the methods, return the translation for
    #      the current locale.
    #    - Otherwise, return the whole translations hash so the next method
    #      can select the language it wants.
    # 3. If the meth is an _translations field, do not demongoize the
    #    value so the full hash is returned.
    # 4. Otherwise, fetch and demongoize the value for the key meth.
    curr = if curr.is_a? Array
      res = fetch_and_demongoize(curr, meth, field)
      res.empty? ? nil : res
    elsif !is_translation && field&.localized?
      if i < num_meths
        curr.try(:fetch, meth, nil)
      else
        fetch_and_demongoize(curr, meth, field)
      end
    elsif is_translation
      curr.try(:fetch, meth, nil)
    else
      fetch_and_demongoize(curr, meth, field)
    end

    i += 1
  end
  curr
end

# File 'lib/mongoid/contextual/mongo.rb', line 917

def fetch_and_demongoize(obj, meth, field)
  if obj.is_a?(Array)
    obj.map { |doc| fetch_and_demongoize(doc, meth, field) }
  else
    res = obj.try(:fetch, meth, nil)
    field ? field.demongoize(res) : res.class.demongoize(res)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 699

def fifth
  retrieve_nth(4)
end

# File 'lib/mongoid/contextual/mongo.rb', line 713

def fifth!
  fifth || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 256

def find_first
  if raw_doc = view.first
    doc = Factory.from_db(klass, raw_doc, criteria)
    eager_load([doc]).first
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 247

def find_one_and_delete
  if doc = view.find_one_and_delete
    Factory.from_db(klass, doc)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 234

def find_one_and_replace(replacement, options = {})
  if doc = view.find_one_and_replace(replacement, options)
    Factory.from_db(klass, doc)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 214

def find_one_and_update(update, options = {})
  if doc = view.find_one_and_update(update, options)
    Factory.from_db(klass, doc)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 550

def first(limit = nil)
  if limit.nil?
    retrieve_nth(0)
  else
    retrieve_nth_with_limit(0, limit)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 575

def first!
  first || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 675

def fourth
  retrieve_nth(3)
end

# File 'lib/mongoid/contextual/mongo.rb', line 689

def fourth!
  fourth || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 842

def inverse_sorting
  sort = view.sort || { _id: 1 }
  Hash[sort.map{|k, v| [k, -1*v]}]
end

# File 'lib/mongoid/contextual/mongo.rb', line 593

def last(limit = nil)
  if limit.nil?
    retrieve_nth_to_last(0)
  else
    retrieve_nth_to_last_with_limit(0, limit)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 617

def last!
  last || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 287

def length
  self.count
end

# File 'lib/mongoid/contextual/mongo.rb', line 300

def limit(value)
  @view = view.limit(value) and self
end

# File 'lib/mongoid/contextual/mongo.rb', line 776

def load_async
  @documents_loader ||= DocumentsLoader.new(view, klass, criteria)
end

# File 'lib/mongoid/contextual/mongo.rb', line 313

def map_reduce(map, reduce)
  MapReduce.new(collection, criteria, map, reduce)
end

# File 'lib/mongoid/contextual/mongo.rb', line 557

alias :one :first

# File 'lib/mongoid/contextual/mongo.rb', line 361

def pick(*fields)
  limit(1).pluck(*fields).first
end

# File 'lib/mongoid/contextual/mongo.rb', line 333

def pluck(*fields)
  # Multiple fields can map to the same field name. For example, plucking
  # a field and its _translations field map to the same field in the database.
  # because of this, we need to keep track of the fields requested.
  normalized_field_names = []
  normalized_select = fields.inject({}) do |hash, f|
    db_fn = klass.database_field_name(f)
    normalized_field_names.push(db_fn)
    hash[klass.cleanse_localized_field_names(f)] = true
    hash
  end

  view.projection(normalized_select).reduce([]) do |plucked, doc|
    values = normalized_field_names.map do |n|
      extract_value(doc, n)
    end
    plucked << (values.size == 1 ? values.first : values)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 1067

def process_raw_docs(raw_docs, limit)
  docs = if criteria.raw_results?
           if criteria.typecast_results?
             raw_docs.map { |doc| demongoize_hash(klass, doc) }
           else
             raw_docs
           end
         else
           mapped = raw_docs.map { |doc| Factory.from_db(klass, doc, criteria) }
           eager_load(mapped)
         end

  limit ? docs : docs.first
end

# File 'lib/mongoid/contextual/mongo.rb', line 1103

def raise_document_not_found_error
  raise Errors::DocumentNotFound.new(klass, nil, nil)
end

# File 'lib/mongoid/contextual/mongo.rb', line 987

def recursive_demongoize(field_name, value, is_translation)
  field = klass.traverse_association_tree(field_name)
  demongoize_with_field(field, value, is_translation)
end

# File 'lib/mongoid/contextual/mongo.rb', line 1107

def retrieve_nth(n)
  retrieve_nth_with_limit(n, 1).first
end

# File 'lib/mongoid/contextual/mongo.rb', line 1120

def retrieve_nth_to_last(n)
  retrieve_nth_to_last_with_limit(n, 1).first
end

# File 'lib/mongoid/contextual/mongo.rb', line 1124

def retrieve_nth_to_last_with_limit(n, limit)
  v = view.sort(inverse_sorting).skip(n).limit(limit || 1)
  v = v.skip(n) if n > 0
  raw_docs = v.to_a.reverse
  process_raw_docs(raw_docs, limit)
end

# File 'lib/mongoid/contextual/mongo.rb', line 1111

def retrieve_nth_with_limit(n, limit)
  sort = view.sort || { _id: 1 }
  v = view.sort(sort).limit(limit || 1)
  v = v.skip(n) if n > 0
  if raw_docs = v.to_a
    process_raw_docs(raw_docs, limit)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 627

def second
  retrieve_nth(1)
end

# File 'lib/mongoid/contextual/mongo.rb', line 641

def second!
  second || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 725

def second_to_last
  retrieve_nth_to_last(1)
end

# File 'lib/mongoid/contextual/mongo.rb', line 739

def second_to_last!
  second_to_last || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 290

alias :size :length

# File 'lib/mongoid/contextual/mongo.rb', line 480

def skip(value)
  @view = view.skip(value) and self
end

# File 'lib/mongoid/contextual/mongo.rb', line 493

def sort(values = nil, &block)
  if block_given?
    super(&block)
  else
    # update the criteria
    @criteria = criteria.order_by(values)
    apply_option(:sort)
    self
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 374

def take(limit = nil)
  if limit
    limit(limit).to_a
  else
    # Do to_a first so that the Mongo#first method is not used and the
    # result is not sorted.
    limit(1).to_a.first
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 393

def take!
  # Do to_a first so that the Mongo#first method is not used and the
  # result is not sorted.
  if fst = limit(1).to_a.first
    fst
  else
    raise Errors::DocumentNotFound.new(klass, nil, nil)
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 440

def tally(field)
  name = klass.cleanse_localized_field_names(field)

  fld = klass.traverse_association_tree(name)
  pipeline = [ { "$group" => { _id: "$#{name}", counts: { "$sum": 1 } } } ]
  pipeline.unshift("$match" => view.filter) unless view.filter.blank?

  collection.aggregate(pipeline).reduce({}) do |tallies, doc|
    is_translation = "#{name}_translations" == field.to_s
    val = doc["_id"]

    key = if val.is_a?(Array)
      val.map do |v|
        demongoize_with_field(fld, v, is_translation)
      end
    else
      demongoize_with_field(fld, val, is_translation)
    end

    # The only time where a key will already exist in the tallies hash
    # is when the values are stored differently in the database, but
    # demongoize to the same value. A good example of when this happens
    # is when using localized fields. While the server query won't group
    # together hashes that have other values in different languages, the
    # demongoized value is just the translation in the current locale,
    # which can be the same across multiple of those unequal hashes.
    tallies[key] ||= 0
    tallies[key] += doc["counts"]
    tallies
  end
end

# File 'lib/mongoid/contextual/mongo.rb', line 651

def third
  retrieve_nth(2)
end

# File 'lib/mongoid/contextual/mongo.rb', line 665

def third!
  third || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 751

def third_to_last
  retrieve_nth_to_last(2)
end

# File 'lib/mongoid/contextual/mongo.rb', line 765

def third_to_last!
  third_to_last || raise_document_not_found_error
end

# File 'lib/mongoid/contextual/mongo.rb', line 516

def update(attributes = nil, opts = {})
  update_documents(attributes, :update_one, opts)
end

# File 'lib/mongoid/contextual/mongo.rb', line 532

def update_all(attributes = nil, opts = {})
  update_documents(attributes, :update_many, opts)
end

# File 'lib/mongoid/contextual/mongo.rb', line 793

def update_documents(attributes, method = :update_one, opts = {})
  return false unless attributes

  view.send(method, AtomicUpdatePreparer.prepare(attributes, klass), opts)
end

# File 'lib/mongoid/contextual/mongo.rb', line 1091

def valid_for_count_documents?(hash = view.filter)
  # Note that `view.filter` is a BSON::Document, and all keys in a
  # BSON::Document are strings; we don't need to worry about symbol
  # representations of `$where`.
  hash.keys.each do |key|
    return false if key == '$where'
    return false if hash[key].is_a?(Hash) && !valid_for_count_documents?(hash[key])
  end

  true
end

# File 'lib/mongoid/contextual/mongo.rb', line 882

def yield_document(document, &block)
  doc = if document.respond_to?(:_id)
          document
        elsif criteria.raw_results?
          if criteria.typecast_results?
            demongoize_hash(klass, document)
          else
            document
          end
        else
          Factory.from_db(klass, document, criteria)
        end

  yield(doc)
end