Class: Mongoid::Criteria::Queryable::Selector

# File 'lib/mongoid/criteria/queryable/selector.rb', line 153

def evolve(serializer, value)
  case value
  when Mongoid::RawValue
    value.raw_value
  when Hash
    evolve_hash(serializer, value)
  when Array
    evolve_array(serializer, value)
  when Range
    value.__evolve_range__(serializer: serializer)
  else
    (serializer || value.class).evolve(value)
  end
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 179

def evolve_array(serializer, value)
  value.map do |_value|
    evolve(serializer, _value)
  end
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 196

def evolve_hash(serializer, value)
  value.each_pair do |operator, _value|
    if operator =~ /exists|type|size/
      value[operator] = _value
    else
      value[operator] = evolve(serializer, _value)
    end
  end
end

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

def evolve_multi(specs)
  unless specs.is_a?(Array)
    raise ArgumentError, "specs is not an array: #{specs.inspect}"
  end
  specs.map do |spec|
    Hash[spec.map do |key, value|
      # If an application nests conditionals, e.g.
      # {'$or' => [{'$or' => {...}}]},
      # when evolve_multi is called for the top level hash,
      # this call recursively transforms the bottom level $or.
      if multi_selection?(key)
        value = evolve_multi(value)
      end

      # storage_pair handles field aliases but not localization for
      # some reason, although per its documentation Smash supposedly
      # owns both.
      name, serializer = storage_pair(key)
      # This performs type conversions on the value and transformations
      # that depend on the type of the field that the value is stored
      # in, but not transformations that have to do with query shape.
      final_key, evolved_value = store_creds(name, serializer, value)

      # This builds a query shape around the value, when the query
      # involves complex keys. For example, {:foo.lt => 5} produces
      # {'foo' => {'$lt' => 5}}. This step should be done after all
      # value-based processing is complete.
      if key.is_a?(Key)
        evolved_value = key.transform_value(evolved_value)
      end

      [ final_key, evolved_value ]
    end]
  end.uniq
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 239

def evolve_range(key, serializer, value)
  v = value.__evolve_range__(serializer: serializer)
  assocs = []
  Fields.traverse_association_tree(key, serializers, associations, aliased_associations) do |meth, obj, is_field|
    assocs.push([meth, obj, is_field])
  end

  # Iterate backwards until you get a field with type
  # Array or an embeds_many association.
  inner_key = ""
  loop do
    # If there are no arrays or embeds_many associations, just return
    # the key and value without $elemMatch.
    return [ key, v ] if assocs.empty?

    meth, obj, is_field = assocs.last
    break if (is_field && obj.type == Array) || (!is_field && obj.is_a?(Association::Embedded::EmbedsMany))

    assocs.pop
    inner_key = "#{meth}.#{inner_key}"
  end

  # If the last array or embeds_many association is the last field,
  # the inner key (2) is ignored, and the outer key (1) is the original
  # key.
  if inner_key.blank?
    [ key, { "$elemMatch" => v }]
  else
    store_key = assocs.map(&:first).join('.')
    store_value = { "$elemMatch" => { inner_key.chop => v } }
    [ store_key,  store_value ]
  end
end

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

def merge!(other)
  other.each_pair do |key, value|
    if value.is_a?(Hash) && self[key.to_s].is_a?(Hash)
      value = self[key.to_s].merge(value) do |_key, old_val, new_val|
        case _key.to_s
        when '$in'
          new_val & old_val
        when '$nin'
          (old_val + new_val).uniq
        else
          new_val
        end
      end
    end
    if multi_selection?(key)
      value = (self[key.to_s] || []).concat(value)
    end
    store(key, value)
  end
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 284

def multi_selection?(key)
  %w($and $or $nor).include?(key)
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 51

def store(key, value)
  name, serializer = storage_pair(key)
  if multi_selection?(name)
    store_name = name
    store_value = evolve_multi(value)
  else
    store_name, store_value = store_creds(name, serializer, value)
  end
  super(store_name, store_value)
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 86

def store_creds(name, serializer, value)
  store_name = localized_key(name, serializer)
  if Range === value
    evolve_range(store_name, serializer, value)
  else
    [ store_name, evolve(serializer, value) ]
  end
end

# File 'lib/mongoid/criteria/queryable/selector.rb', line 69

def to_pipeline
  pipeline = []
  pipeline.push({ "$match" => self }) unless empty?
  pipeline
end