module Mongoid::Criteria::Queryable::Mergeable

def __add__(criterion, operator)
  with_strategy(:__add__, criterion, operator)
end

def __expanded__(criterion, outer, inner)
  selection(criterion) do |selector, field, value|
    selector.store(field, { outer => { inner => value }})
  end
end

def __intersect__(criterion, operator)
  with_strategy(:__intersect__, criterion, operator)
end

def __merge__(criterion)
  selection(criterion) do |selector, field, value|
    selector.merge!(field.__expr_part__(value))
  end
end

def __multi__(criteria, operator)
  clone.tap do |query|
    sel = query.selector
    criteria.flatten.each do |expr|
      next unless expr
      result_criteria = sel[operator] || []
      if expr.is_a?(Selectable)
        expr = expr.selector
      end
      normalized = _mongoid_normalize_expr(expr)
      sel.store(operator, result_criteria.push(normalized))
    end
  end
end

def __override__(criterion, operator)
  if criterion.is_a?(Selectable)
    criterion = criterion.selector
  end
  selection(criterion) do |selector, field, value|
    expression = prepare(field, operator, value)
    existing = selector[field]
    if existing.respond_to?(:merge!)
      selector.store(field, existing.merge!(expression))
    else
      selector.store(field, expression)
    end
  end
end

def __union__(criterion, operator)
  with_strategy(:__union__, criterion, operator)
end

def _mongoid_add_top_level_operation(operator, criteria)
ten the criteria. The idea is that predicates in MongoDB
always hashes and are never arrays. This method additionally
ws Criteria instances as predicates.
flattening is existing Mongoid behavior but we could possibly
rid of it as applications can splat their predicates, or
ten if needed.
tap do |query|
= query.selector
goid_flatten_arrays(criteria).each do |criterion|
 criterion.is_a?(Selectable)
expr = _mongoid_normalize_expr(criterion.selector)
se
expr = criterion
d
 sel.empty?
sel.store(operator, [expr])
sif sel.keys == [operator]
sel.store(operator, sel[operator] + [expr])
se
operands = [sel.dup] + [expr]
sel.clear
sel.store(operator, operands)
d

def _mongoid_flatten_arrays(array)
[]
g = array
pending.empty?
 = pending.shift
tem.nil?
skip
f item.is_a?(Array)
nding += item

t << item

def _mongoid_normalize_expr(expr)
nject({}) do |hash, (field, value)|
.merge!(field.__expr_part__(value.__expand_complex__))

def intersect
  use(:__intersect__)
end

def override
  use(:__override__)
end

def prepare(field, operator, value)
  unless operator =~ /exists|type|size/
    value = value.__expand_complex__
    field = field.to_s
    name = aliases[field] || field
    serializer = serializers[name]
    value = serializer ? serializer.evolve(value) : value
  end
  selection = { operator => value }
  negating? ? { "$not" => selection } : selection
end

def reset_strategies!
  self.strategy = nil
  self.negating = nil
  self
end

def union
  use(:__union__)
end

def use(strategy)
  tap do |mergeable|
    mergeable.strategy = strategy
  end
end

def with_strategy(strategy, criterion, operator)
  selection(criterion) do |selector, field, value|
    selector.store(
      field,
      selector[field].send(strategy, prepare(field, operator, value))
    )
  end
end