Class: Parse::Constraint::RegularExpressionConstraint

Inherits:
Constraint
  • Object
show all
Defined in:
lib/parse/query/constraints.rb

Overview

Equivalent to the $regex Parse query operation. Requires that a field value match a regular expression.

q.where :field.like => /ruby_regex/i :name.like => /Bob/i

Opt into Unicode-aware matching (Parse Server 8.3.0+ over REST,

MongoDB 6.1+ mongo-direct). The hash form compiles to the explicit

$regex/$options shape and adds the u flag:

q.where :name.like => { value: /café/i, unicode: true }

Generates: "name": { "$regex": "café", "$options": "iu" }

Instance Method Summary collapse

Instance Method Details

#build ⇒ Hash

Builds the regex constraint with security validation.

Returns:

  • (Hash) —

    the compiled constraint

Raises:

  • (ArgumentError) —

    if the pattern is potentially dangerous (ReDoS)



1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
 
# File 'lib/parse/query/constraints.rb', line 1665

def build
  # Opt-in `{ value:, unicode: true }` form. Unlike the bare form (which
  # stringifies a Ruby Regexp to its inline-flag source, e.g.
  # "(?i-mx:Bob)"), this compiles to the explicit $regex/$options shape so
  # the `u` flag can be appended for Unicode-aware matching.
  if @value.is_a?(Hash)
    raw, unicode = regex_unicode_option(@value)
    pattern_str = raw.is_a?(Regexp) ? raw.source : raw.to_s
    options = +""
    options << "i" if raw.is_a?(Regexp) && raw.casefold?
    options << "u" if unicode

    Parse::RegexSecurity.validate!(pattern_str)

    return options.empty? ?
             { @operation.operand => { key => pattern_str } } :
             { @operation.operand => { key => pattern_str, :$options => options } }
  end

  value = formatted_value
  pattern_str = value.is_a?(Regexp) ? value.source : value.to_s
  options = value.is_a?(Regexp) && value.casefold? ? "i" : nil

  # Validate the regex pattern for ReDoS vulnerabilities
  Parse::RegexSecurity.validate!(pattern_str)

  if options
    { @operation.operand => { key => pattern_str, :$options => options } }
  else
    { @operation.operand => { key => pattern_str } }
  end
end

#like ⇒ RegularExpressionConstraint

A registered method on a symbol to create the constraint. Maps to Parse operator "$regex".

Examples:

q.where :field.like => /ruby_regex/i

Returns:




# File 'lib/parse/query/constraints.rb', line 1649

#regex ⇒ RegularExpressionConstraint

Alias for #like

Returns:



1658
 
# File 'lib/parse/query/constraints.rb', line 1658

constraint_keyword :$regex