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) 


18
19
20
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
 
# Arquivo 'lib/mongoid/matcher/field_expression.rb', linha 18

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 cond_v.is_a?(String)
              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 valor.is_a?(Hash)
        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