Módulo: Mongoid::Matcher::EqImpl Privado

Definido en:
lib/mongoid/matcher/eq_impl.rb

Overview

Este módulo forma parte de una API privada. Debe evitar su uso siempre que sea posible, ya que podría eliminarse o modificarse en el futuro.

Este módulo lo utilizan $eq y otros operadores que necesitan realizar la coincidencia que realiza $eq (por ejemplo, $ne, que niega el resultado de $eq). A diferencia de $eq, este módulo toma un operador original como argumento adicional a matches? para proporcionar los mensajes de excepción correctos que reflejan el operador que se invocó primero.

Resumen del método de clase colapsar

Detalles del método de clase

.¿coincide?(existe, valor, condición, operador_original) ⇒ verdadero | falso, booleano

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Devuelve si un valor satisface una expresión $eq (o similar).

Parámetros:

  • exists (true | false) —

    No se utiliza.

  • Valor (objeto) —

    El valor a comprobar.

  • condición (Objeto| Rango) —

    El predicado de la condición de igualdad.

  • operador_original (string) —

    Operador para usar en los mensajes de excepción.

Devuelve:

  • (true | false) —

    Si el valor coincide.

  • (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
 
# Archivo 'lib/mongoid/matcher/eq_impl.rb', línea 24

module_function def coincide?(exists, Valor, condición, operador_original)
  caso condición
  Cuando Rango
    # Dado que $ne invoca $eq, el mensaje de excepción debe manejarse
    # ambos operadores.
    propagar Errors::Consulta no válida, "Elrango no se admite como argumento para '#{original_operator} ' "
=begin
    si value.is_a?(arreglo)
      valor.cualquiera? { |elt| condición.incluir?(elt) }
    else
      condición.include?(valor)
    end
=end
  else
    # Al hacer una comparación con objetos de tiempo, compara usando precisión de milisegundos
    si Valor.kind_of?(Tiempo) && condición.kind_of?(Tiempo)
      time_eq?(Valor, condición)
    elsif Valor.is_a?(Arreglo) && condición.kind_of?(Tiempo)
      Valor.map hacer |v|
        si v.kind_of?(Tiempo)
          time_rounded_to_millis(v)
        else
          v
        end
      end.incluir?(time_rounded_to_millis(condición))
    else
      Valor == condición ||
      Valor.is_a?(Arreglo) && Valor.incluir?(condición)
    end
  end
end

.time_eq?(tiempo_a, tiempo_b) ⇒ verdadero | falso, booleano

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Según www.mongodb.com/es/docs/ruby-driver/current/tutorials/bson-v4/#time-instances, los tiempos en BSON (y MongoDB) solo pueden tener una precisión de milisegundos. Cuando las instancias de Ruby Time se serializan a BSON o JSON extendido, los tiempos se redondean al milisegundo más cercano.

> Debido a este piso, se recomienda enfáticamente que las aplicaciones realicen todos los cálculos en tiempo real usando matemáticas enteras, ya que la inexactitud de los cálculos de punto flotante puede producir resultados inesperados.

Como tal, realice una operación similar a la que realiza la gema bson-ruby.

Parámetros:

  • time_a (Time) —

    El primer valor de tiempo.

  • time_b (Time) —

    El segundo valor del tiempo.

Devuelve:

  • (true | false) —

    Si los dos tiempos son iguales al milisegundo.

  • (booleano) 


70
71
72
 
# Archivo 'lib/mongoid/matcher/eq_impl.rb', línea 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(tiempo) ⇒ verdadero | falso

Este método forma parte de una API privada. Debe evitarlo si es posible, ya que podría eliminarse o modificarse en el futuro.

Redondea un valor de tiempo al milisegundo más cercano.

Parámetros:

  • hora (Time) —

    El valor temporal.

Devuelve:

  • (true | false) —

    El tiempo redondeado al milisegundo.



79
80
81
 
# Archivo 'lib/mongoid/matcher/eq_impl.rb', línea 79

module_function def time_rounded_to_millis(hora)
  return hora._bson_to_i * 1000 + hora.usec.divmod(1000).primero
end