Module: Mongoid::Criteria::Queryable::Mergeable

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 12

attr_accessor :strategy

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 106

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 140

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 123

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 160

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_expand_keys(expr)
      sel.store(operator, result_criteria.push(normalized))
    end
  end
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 343

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 369

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 185

private def _mongoid_add_top_level_operation(operator, criteria)
  # Flatten the criteria. The idea is that predicates in MongoDB
  # are always hashes and are never arrays. This method additionally
  # allows Criteria instances as predicates.
  # The flattening is existing Mongoid behavior but we could possibly
  # get rid of it as applications can splat their predicates, or
  # flatten if needed.
  clone.tap do |query|
    sel = query.selector
    _mongoid_flatten_arrays(criteria).each do |criterion|
      if criterion.is_a?(Selectable)
        expr = _mongoid_expand_keys(criterion.selector)
      else
        expr = _mongoid_expand_keys(criterion)
      end
      if sel.empty?
        sel.store(operator, [expr])
      elsif sel.keys == [operator]
        sel.store(operator, sel[operator] + [expr])
      else
        operands = [sel.dup] + [expr]
        sel.clear
        sel.store(operator, operands)
      end
    end
  end
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 259

private def _mongoid_expand_keys(expr)
  unless expr.is_a?(Hash)
    raise ArgumentError, 'Argument must be a Hash'
  end

  result = BSON::Document.new
  expr.each do |field, value|
    field.__expr_part__(value.__expand_complex__, negating?).each do |k, v|
      if existing = result[k]
        if existing.is_a?(Hash)
          # Existing value is an operator.
          # If new value is also an operator, ensure there are no
          # conflicts and add
          if v.is_a?(Hash)
            # The new value is also an operator.
            # If there are no conflicts, combine the hashes, otherwise
            # add new conditions to top level with $and.
            if (v.keys & existing.keys).empty?
              existing.update(v)
            else
              raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
              result['$and'] ||= []
              result['$and'] << {k => v}
            end
          else
            # The new value is a simple value.
            # Transform the implicit equality to either $eq or $regexp
            # depending on the type of the argument. See
            # https://www.mongodb.com/docs/manual/reference/operator/query/eq/#std-label-eq-usage-examples
            # for the description of relevant server behavior.
            op = case v
            when Regexp, BSON::Regexp::Raw
              '$regex'
            else
              '$eq'
            end
            # If there isn't an $eq/$regex operator already in the
            # query, transform the new value into an operator
            # expression and add it to the existing hash. Otherwise
            # add the new condition with $and to the top level.
            if existing.key?(op)
              raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
              result['$and'] ||= []
              result['$and'] << {k => v}
            else
              existing.update(op => v)
            end
          end
        else
          # Existing value is a simple value.
          # See the notes above about transformations to $eq/$regex.
          op = case existing
          when Regexp, BSON::Regexp::Raw
            '$regex'
          else
            '$eq'
          end
          if v.is_a?(Hash) && !v.key?(op)
            result[k] = {op => existing}.update(v)
          else
            raise NotImplementedError, 'Ruby does not allow same symbol operator with different values'
            result['$and'] ||= []
            result['$and'] << {k => v}
          end
        end
      else
        result[k] = v
      end
    end
  end
  result
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 216

private def _mongoid_flatten_arrays(array)
  out = []
  pending = array.dup
  until pending.empty?
    item = pending.shift
    if item.nil?
      # skip
    elsif item.is_a?(Array)
      pending += item
    else
      out << item
    end
  end
  out
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 62

def and_with_operator(criterion, operator)
  crit = self
  if criterion
    criterion.each_pair do |field, value|
      val = prepare(field, operator, value)
      # The prepare method already takes the negation into account. We
      # set negating to false here so that ``and`` doesn't also apply
      # negation and we have a double negative.
      crit.negating = false
      crit = crit.and(field => val)
    end
  end
  crit
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 20

def intersect
  use(:__intersect__)
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 30

def override
  use(:__override__)
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 421

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 50

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 40

def union
  use(:__union__)
end

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 383

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

# File 'lib/mongoid/criteria/queryable/mergeable.rb', line 401

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