class BSON::Regexp::Raw

def ==(other)
  return false unless other.is_a?(::Regexp::Raw)
  pattern == other.pattern && options == other.options
end

def as_extended_json(**opts)
  if opts[:mode] == :legacy
    { '$regex' => source, '$options' => options }
  else
    { '$regularExpression' => { 'pattern' => source, 'options' => options } }
  end
end

def as_json(*)
  as_extended_json(mode: :legacy)
end

def compile
  @compile ||= ::Regexp.new(pattern, options_to_int)
end

def initialize(pattern, options = '')
  if pattern.include?(NULL_BYTE)
    raise Error::InvalidRegexpPattern, "Regexp pattern cannot contain a null byte: #{pattern}"
  elsif options.is_a?(String) || options.is_a?(Symbol)
    if options.to_s.include?(NULL_BYTE)
      raise Error::InvalidRegexpPattern, "Regexp options cannot contain a null byte: #{options}"
    end
  else
    raise ArgumentError, 'Regexp options must be a String or Symbol'
  end
  @pattern = pattern
  @options = options.to_s
end

def method_missing(method, *arguments)
  return super unless respond_to?(method)
  compile.send(method, *arguments)
end

def options_to_int
  opts = 0
  opts |= ::Regexp::IGNORECASE if options.include?(IGNORECASE_VALUE)
  opts |= ::Regexp::MULTILINE if options.include?(NEWLINE_VALUE)
  opts |= ::Regexp::EXTENDED if options.include?(EXTENDED_VALUE)
  opts
end

def respond_to_missing?(method, include_private = false)
  # YAML calls #respond_to? during deserialization, before the object
  # is initialized.
  defined?(@pattern) && compile.respond_to?(method, include_private)
end

def to_bson(buffer = ByteBuffer.new)
  buffer.put_cstring(source)
  buffer.put_cstring(options.chars.sort.join)
end