Módulo: Mongoid::Matcher::FieldExpression Privado

Definido en:
lib/mongoid/matcher/expresión_de_campo.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.

Módulo singleton utilizado para evaluar si un valor dado en la memoria coincide con una expresión de consulta MSQL relacionada con un campo específico.

Colapso delresumen del método de clase

Detalles del método de clase

.¿coincide?(existe, valor, condición) ⇒ 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 condición.

Parámetros:

  • exists (verdadero | falso) —

    Si el valor existe.

  • valor (Objeto) -

    El valor a comprobar.

  • condición (Hash | Objeto) —

    El predicado de la condición.

Devuelve:

  • (verdadero | falso) —

    Si el valor coincide.

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

module_function def ¿partidos?(exists, valor, condición)
  Si condición.is_a?(Picadillo)
    condición.¿todo? hacer |k, cond_v|
      k = k.a_s
      Si k.empezar_con?('$')
        Si %w($regex $opciones).¿incluir?(k)
          a no ser que condición.key?('$regex')
            propagar Errors::Consulta no válida, "Se requiere $regex si se proporciona $options: #{Errors::InvalidQuery.truncate_expr(condition)}"
          end

          Si k == '$regex'
            Si opciones = condición['$options']
              cond_v = caso cond_v
              Cuando Regexp
                BSON::Regexp::Crudo.Nuevo(cond_v.fuente, opciones)
              Cuando BSON::Regexp::Crudo
                BSON::Regexp::Crudo.Nuevo(cond_v.patrón, opciones)
              else
                BSON::Regexp::Crudo.Nuevo(cond_v, opciones)
              end
            elsif String === cond_v
              cond_v = BSON::Regexp::Crudo.Nuevo(cond_v)
            end

            Operador de campo.Obtener(k).¿partidos?(exists, valor, cond_v)
          else
            # Las $opciones se corresponden como parte de $regex
            true
          end
        else
          Operador de campo.Obtener(k).¿partidos?(exists, valor, cond_v)
        end
      elsif Picadillo === valor
        sub_values = Comparador.extraer_atributo(valor, k)
        Si sub_values.longitud > 0
          sub_values.any? hacer |sub_v|
            Eq.¿partidos?(true, sub_v, cond_v)
          end
        else
          Eq.¿partidos?(false, nulo, cond_v)
        end
      else
        false
      end
    end
  else
    caso condición
    Cuando ::Regexp, BSON::Regexp::Crudo
      Regex.matches_array_or_scalar?(valor, condición)
    else
      Eq.¿partidos?(exists, valor, condición)
    end
  end
end