Module: Mongoid::Criteria::Queryable::Selectable

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 25

attr_accessor :negating, :selector

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 535

def negating?
  !!negating
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 25

attr_accessor :negating, :selector

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 25

attr_accessor :negating, :selector

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 65

alias :all_in :all

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 111

alias :all_of :and

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 78

def and(*criteria)
  _mongoid_flatten_arrays(criteria).inject(self.clone) do |c, new_s|
    if new_s.is_a?(Selectable)
      new_s = new_s.selector
    end
    normalized = _mongoid_expand_keys(new_s)
    normalized.each do |k, v|
      k = k.to_s
      if c.selector[k]
        # There is already a condition on k.
        # If v is an operator, and all existing conditions are
        # also operators, and v isn't present in existing conditions,
        # we can add to existing conditions.
        # Otherwise use $and.
        if v.is_a?(Hash) &&
          v.length == 1 &&
          (new_k = v.keys.first).start_with?('$') &&
          (existing_kv = c.selector[k]).is_a?(Hash) &&
          !existing_kv.key?(new_k) &&
          existing_kv.keys.all? { |sub_k| sub_k.start_with?('$') }
        then
          merged_v = c.selector[k].merge(v)
          c.selector.store(k, merged_v)
        else
          c = c.send(:__multi__, [k => v], '$and')
        end
      else
        c.selector.store(k, v)
      end
    end
    c
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 339

alias :any_in :in

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 674

def any_of(*criteria)
  criteria = _mongoid_flatten_arrays(criteria)
  case criteria.length
  when 0
    clone
  when 1
    # When we have a single criteria, any_of behaves like and.
    # Note: criteria can be a Query object, which #where method does
    # not support.
    self.and(*criteria)
  else
    # When we have multiple criteria, combine them all with $or
    # and add the result to self.
    exprs = criteria.map do |criterion|
      if criterion.is_a?(Selectable)
        _mongoid_expand_keys(criterion.selector)
      else
        Hash[criterion.map do |k, v|
          if k.is_a?(Symbol)
            [k.to_s, v]
          else
            [k, v]
          end
        end]
      end
    end
    self.and('$or' => exprs)
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 124

def between(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :between
  end

  selection(criterion) do |selector, field, value|
    selector.store(
      field,
      { "$gte" => value.min, "$lte" => value.max }
    )
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 154

def elem_match(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :elem_match
  end

  and_with_operator(criterion, "$elemMatch")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 257

def eq(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :eq
  end

  and_with_operator(criterion, "$eq")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 437

alias :excludes :ne

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 177

def exists(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :exists
  end

  typed_override(criterion, "$exists") do |value|
    Mongoid::Boolean.evolve(value)
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 852

def expr_query(criterion)
  if criterion.nil?
    raise ArgumentError, 'Criterion cannot be nil here'
  end
  unless Hash === criterion
    raise Errors::InvalidQuery, "Expression must be a Hash: #{Errors::InvalidQuery.truncate_expr(criterion)}"
  end

  normalized = _mongoid_expand_keys(criterion)
  clone.tap do |query|
    normalized.each do |field, value|
      field_s = field.to_s
      if field_s.start_with?('$')
        # Query expression-level operator, like $and or $where
        query.add_operator_expression(field_s, value)
      else
        query.add_field_expression(field, value)
      end
    end
    query.reset_strategies!
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 224

def geo_spatial(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :geo_spatial
  end

  __merge__(criterion)
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 277

def gt(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :gt
  end

  and_with_operator(criterion, "$gt")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 297

def gte(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :gte
  end

  and_with_operator(criterion, "$gte")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 320

def in(condition)
  if condition.nil?
    raise Errors::CriteriaArgumentRequired, :in
  end

  condition = expand_condition_to_array_values(condition)

  if strategy
    send(strategy, condition, "$in")
  else
    condition.inject(clone) do |query, (field, value)|
      v = {'$in' => value}
      if negating?
        v = {'$not' => v}
      end
      query.add_field_expression(field.to_s, v)
    end.reset_strategies!
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 904

def js_query(criterion)
  clone.tap do |query|
    if negating?
      query.add_operator_expression('$and',
        [{'$nor' => [{'$where' => criterion}]}])
    else
      query.add_operator_expression('$where', criterion)
    end
    query.reset_strategies!
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 353

def lt(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :lt
  end

  and_with_operator(criterion, "$lt")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 373

def lte(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :lte
  end

  and_with_operator(criterion, "$lte")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 390

def max_distance(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :max_distance
  end

  # $maxDistance must be given together with $near
  __add__(criterion, "$maxDistance")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 410

def mod(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :mod
  end

  and_with_operator(criterion, "$mod")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 430

def ne(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :ne
  end

  and_with_operator(criterion, "$ne")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 451

def near(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :near
  end

  and_with_operator(criterion, "$near")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 471

def near_sphere(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :near_sphere
  end

  and_with_operator(criterion, "$nearSphere")
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 494

def nin(condition)
  if condition.nil?
    raise Errors::CriteriaArgumentRequired, :nin
  end

  condition = expand_condition_to_array_values(condition)

  if strategy
    send(strategy, condition, "$nin")
  else
    condition.inject(clone) do |query, (field, value)|
      v = {'$nin' => value}
      if negating?
        v = {'$not' => v}
      end
      query.add_field_expression(field.to_s, v)
    end.reset_strategies!
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 601

def none_of(*criteria)
  criteria = _mongoid_flatten_arrays(criteria)
  return dup if criteria.empty?

  exprs = criteria.map do |criterion|
    _mongoid_expand_keys(
        criterion.is_a?(Selectable) ?
          criterion.selector : criterion)
  end

  self.and('$nor' => exprs)
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 525

def nor(*criteria)
  _mongoid_add_top_level_operation('$nor', criteria)
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 554

def not(*criteria)
  if criteria.empty?
    dup.tap { |query| query.negating = !query.negating }
  else
    criteria.compact.inject(self.clone) do |c, new_s|
      if new_s.is_a?(Selectable)
        new_s = new_s.selector
      end
      _mongoid_expand_keys(new_s).each do |k, v|
        k = k.to_s
        if c.selector[k] || k.start_with?('$')
          c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
        else
          if v.is_a?(Hash)
            c = c.send(:__multi__, [{'$nor' => [{k => v}]}], '$and')
          else
            if v.is_a?(Regexp)
              negated_operator = '$not'
            else
              negated_operator = '$ne'
            end
            c = c.send(:__override__, {k => v}, negated_operator)
          end
        end
      end
      c
    end
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 513

alias :not_in :nin

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 644

def or(*criteria)
  _mongoid_add_top_level_operation('$or', criteria)
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 926

def selection(criterion = nil)
  clone.tap do |query|
    if criterion
      criterion.each_pair do |field, value|
        yield(query.selector, field.is_a?(Key) ? field : field.to_s, value)
      end
    end
    query.reset_strategies!
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 776

def text_search(terms, opts = nil)
  if terms.nil?
    raise Errors::CriteriaArgumentRequired, :terms
  end

  clone.tap do |query|
    criterion = {'$text' => { '$search' => terms }}
    criterion['$text'].merge!(opts) if opts
    if query.selector['$text']
      # Per https://www.mongodb.com/docs/manual/reference/operator/query/text/
      # multiple $text expressions are not currently supported by
      # MongoDB server, but build the query correctly instead of
      # overwriting previous text search condition with the currently
      # given one.
      Mongoid.logger.warn('Multiple $text expressions per query are not currently supported by the server')
      query.selector = {'$and' => [query.selector]}.merge(criterion)
    else
      query.selector = query.selector.merge(criterion)
    end
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 885

def typed_override(criterion, operator)
  if criterion
    criterion.transform_values! do |value|
      yield(value)
    end
  end
  __override__(criterion, operator)
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 812

def where(*criteria)
  criteria.inject(clone) do |query, criterion|
    if criterion.nil?
      raise Errors::CriteriaArgumentRequired, :where
    end

    # We need to save the criterion in an instance variable so
    # Modifiable methods know how to create a polymorphic object.
    # Note that this method in principle accepts multiple criteria,
    # but only the first one will be stored in @criterion. This
    # works out to be fine because first_or_create etc. methods
    # only ever specify one criterion to #where.
    @criterion = criterion
    if criterion.is_a?(String)
      js_query(criterion)
    else
      expr_query(criterion)
    end
  end.reset_strategies!
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 718

def with_size(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :with_size
  end

  typed_override(criterion, "$size") do |value|
    ::Integer.evolve(value)
  end
end

# File 'lib/mongoid/criteria/queryable/selectable.rb', line 744

def with_type(criterion)
  if criterion.nil?
    raise Errors::CriteriaArgumentRequired, :with_type
  end

  typed_override(criterion, "$type") do |value|
    ::Integer.evolve(value)
  end
end