Módulo: Mongoid::Matcher::EqImpl Private

Definido em:
lib/mongoid/matcher/eq_impl.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.

Este módulo é usado por $eq e outros operadores que precisam realizar a correspondência que $eq executa (por exemplo, $ne que nega o resultado de $eq). Ao contrário de $eq, este módulo usa um operador original como argumento adicional para matches? fornecer as mensagens de exceção corretas, refletindo o operador que foi invocado pela primeira vez.

Recolhimento do Resumo do método de classe

Detalhes do método de classe

.correspondências?(exists, valor, condição, original_operator) ➤ true | 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 expressão$eq (ou semelhante).

Parâmetros:

  • existe (verdadeiro | falso) —

    Não usado.

  • valor (Objeto) —

    O valor a ser verificado.

  • Condição (Objeto | Faixa) —

    O predicado da condição de igualdade.

  • original_operator (string) —

    Operador a ser usado em mensagens de exceção.

Retorna:

  • (verdadeiro | falso) —

    Se o valor corresponde.

  • (Booleano) 


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
 
# File 'lib/mongoid/matcher/eq_impl.rb', linha 24

module_function def correspondências?(existe, valor, Condição, original_operator)
  caso Condição
  quando faixa
    # Como $ne invoca $eq, a mensagem de exceção precisa lidar com
    # ambos os operadores.
    aumentar Errors::Query inválida, "A faixa não é suportada como um argumento para '#{original_operator}'"
=começar
    se valor.is_a?(Array)
      value.any? { |elt| conditions.include?(elt) }
    mais
      condição.include?(valor)
    end
=end
  mais
    # Ao fazer uma comparação com objetos de tempo, compare usando precisão de milissegundos
    se valor.kind_of?(Hora) && Condição.kind_of?(Hora)
      time_eq?(valor, Condição)
    elsif valor.is_a?(Array) && Condição.kind_of?(Hora)
      valor.map fazer |v|
        se v.kind_of?(Hora)
          time_rounded_to_millis(v)
        mais
          v
        end
      end.incluir?(time_rounded_to_millis(Condição))
    mais
      valor == Condição ||
      valor.is_a?(Array) && valor.incluir?(Condição)
    end
  end
end

.time_eq?(time_a, time_b) ➤ true | 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.

Por https://mongodb.com/pt-br/docs/ruby-driver/current/tutorials/bson-v4/#time-instances, > Os horários no BSON (e no MongoDB) só podem ter precisão de milissegundos. Quando as instâncias de Ruby Time são serializadas para BSON ou Extended JSON, os tempos são baseados no milissegundo mais próximo.

> Devido a esse padrão, é altamente recomendável que os aplicativos executem todos os cálculos de tempo usando matemática inteira, pois a inexatidão dos cálculos de ponto flutuante pode produzir resultados inesperados.

Como tal, execute uma operação semelhante à que a joia bson-ruby faz.

Parâmetros:

  • time_a (Tempo) —

    O valor da primeira vez.

  • time_b (Tempo) —

    O valor da segunda vez.

Retorna:

  • (verdadeiro | falso) —

    Se os dois tempos são iguais ao milissegundo.

  • (Booleano) 


70
71
72
 
# File 'lib/mongoid/matcher/eq_impl.rb', linha 70

module_function def time_eq?(time_a, time_b)
  time_rounded_to_millis(time_a) == time_rounded_to_millis(time_b)
end

.time_rounded_to_millis(tempo) ➤ true | false

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.

Arredonda um valor de tempo para o milissegundo mais próximo.

Parâmetros:

  • time (Tempo) —

    O valor do tempo.

Retorna:

  • (verdadeiro | falso) —

    O tempo arredondado para o milissegundo.



79
80
81
 
# File 'lib/mongoid/matcher/eq_impl.rb', linha 79

module_function def time_rounded_to_millis(time)
  Método time._bson_to_i * 1000 + time.usec.divmod(1000).primeiro
end