Módulo: Mongoid::Matcher::FieldExpression Private

Definido em:
lib/mongoid/matcher/field_expression.rb

Visão geral

Este módulo faz parte de uma API privada. Você deve evitar usar este módulo, se possível, pois ele pode ser removido ou alterado no futuro.

Módulo Singleton usado para avaliar se um determinado valor na memória corresponde a uma expressão de query MSQL relacionada a um campo específico.

Recolhimento do Resumo do método de classe

Detalhes do método de classe

.correspondências?(existe, valor, condição) ➤ verdadeiro | false, booleano

Este método faz parte de uma API privada. Evite usar esse método, se possível, pois ele pode ser removido ou alterado no futuro.

Retorna se um valor satisfaz uma condição.

Parâmetros:

  • existe (verdadeiro | falso) —

    Se o valor existe.

  • valor (Objeto) —

    O valor a ser verificado.

  • Condição (Hash | Objeto) —

    O predicado de condição.

Retorna:

  • (verdadeiro | falso) —

    Se o valor corresponde.

  • (Booleano) 


21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# Arquivo 'lib/mongoid/matcher/field_expression.rb', linha 21

module_function def correspondências?(existe, valor, Condição)
  se Condição.is_a?(Hash)
    Condição.todos? fazer |k, cond_v|
      k = k.to_s
      se k.start_with?('$')
        se %w($regex $opções).incluir?(k)
          a menos que Condição.chave?('$regex')
            aumentar Errors::Query inválida, "$regex é necessário se $options for fornecido: #{Erros::InvalidQuery.truncate_expr(conditions)}"
          end

          se k == '$regex'
            se opções = Condição['$options']
              cond_v = caso cond_v
              quando regexp
                BSON::regexp::Cru.Novo(cond_v.Fonte, opções)
              quando BSON::regexp::Cru
                BSON::regexp::Cru.Novo(cond_v.padrão, opções)
              mais
                BSON::regexp::Cru.Novo(cond_v, opções)
              end
            elsif String === cond_v
              cond_v = BSON::regexp::Cru.Novo(cond_v)
            end

            FieldOperator.obter(k).correspondências?(existe, valor, cond_v)
          mais
            # $opções são correspondidas como parte de $regex
            true
          end
        mais
          FieldOperator.obter(k).correspondências?(existe, valor, cond_v)
        end
      elsif Hash === valor
        sub_values = Matcher.extract_attribute(valor, k)
        se sub_values.Tamanho > 0
          sub_values.algum? fazer |sub_v|
            Eq.correspondências?(true, sub_v, cond_v)
          end
        mais
          Eq.correspondências?(false, nada, cond_v)
        end
      mais
        false
      end
    end
  mais
    caso Condição
    quando ::regexp, BSON::regexp::Cru
      expressão regular.correspondências_array_or_scalar?(valor, Condição)
    mais
      Eq.correspondências?(existe, valor, Condição)
    end
  end
end