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

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

attr_accessor :negating, :selector

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

def negating?
  !!negating
end

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

attr_accessor :negating, :selector

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

attr_accessor :negating, :selector

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

alias all_in all

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

alias all_of and

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

def and(*criteria)
  _mongoid_flatten_arrays(criteria).inject(clone) do |c, new_s|
    new_s = new_s.selector if new_s.is_a?(Selectable)
    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?('$') }
          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 312

alias any_in in

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

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 115

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

  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 143

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

  and_with_operator(criterion, '$elemMatch')
end

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

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

  and_with_operator(criterion, '$eq')
end

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

alias excludes ne

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

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

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

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

def expr_query(criterion)
  raise ArgumentError, 'Criterion cannot be nil here' if criterion.nil?
  unless criterion.is_a?(Hash)
    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 209

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

  __merge__(criterion)
end

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

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

  and_with_operator(criterion, '$gt')
end

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

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

  and_with_operator(criterion, '$gte')
end

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

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

  condition = expand_condition_to_array_values(condition)

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

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

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 326

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

  and_with_operator(criterion, '$lt')
end

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

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

  and_with_operator(criterion, '$lte')
end

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

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

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

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

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

  and_with_operator(criterion, '$mod')
end

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

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

  and_with_operator(criterion, '$ne')
end

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

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

  and_with_operator(criterion, '$near')
end

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

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

  and_with_operator(criterion, '$nearSphere')
end

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

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

  condition = expand_condition_to_array_values(condition)

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

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

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 480

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

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

def not(*criteria)
  if criteria.empty?
    dup.tap { |query| query.negating = !query.negating }
  else
    criteria.compact.inject(clone) do |c, new_s|
      new_s = new_s.selector if new_s.is_a?(Selectable)
      _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')
        elsif v.is_a?(Hash)
          c = c.send(:__multi__, [ { '$nor' => [ { k => v } ] } ], '$and')
        else
          negated_operator = if v.is_a?(Regexp)
                               '$not'
                             else
                               '$ne'
                             end
          c = c.send(:__override__, { k => v }, negated_operator)
        end
      end
      c
    end
  end
end

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

alias not_in nin

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

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

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

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 723

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

  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 850

def typed_override(criterion, operator, &block)
  criterion.transform_values!(&block) if criterion
  __override__(criterion, operator)
end

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

def where(*criteria)
  return clone.reset_strategies! if criteria.empty?

  criteria.inject(self) do |query, criterion|
    raise Errors::CriteriaArgumentRequired, :where if criterion.nil?

    # 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)
      query.js_query(criterion)
    else
      query.expr_query(criterion)
    end
  end
end

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

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

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

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

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

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