Add Regexp handler to predicate builder

This handler will expose basic regular expression conditions to
the query interface. `Regexp`s with modifiers are not supported.
`matches_regexp` was implemented in SQLite3 to support this for
all adapters.

    Book.where(title: /The/)

Author: jenshenny

activerecord/CHANGELOG.md

@@ -1,3 +1,15 @@
+*   Support Regexp values in query hash conditions.
+
+    Active Record now supports accepting a Regexp without modifiers in a
+    hash condition. This will generate SQL using per-database adapter
+    regular expression operators.
+
+    ```ruby
+      Book.where(title: /The/)
+    ```
+
+    *Jenny Shen*
+
 *   Allow bypassing primary key/constraint addition in `implicit_order_column`
 
     When specifying multiple columns in an array for `implicit_order_column`, adding

activerecord/lib/active_record/relation/predicate_builder.rb

@@ -5,6 +5,7 @@ class PredicateBuilder # :nodoc:
     require "active_record/relation/predicate_builder/array_handler"
     require "active_record/relation/predicate_builder/basic_object_handler"
     require "active_record/relation/predicate_builder/range_handler"
+    require "active_record/relation/predicate_builder/regexp_handler"
     require "active_record/relation/predicate_builder/relation_handler"
     require "active_record/relation/predicate_builder/association_query_value"
     require "active_record/relation/predicate_builder/polymorphic_array_value"
@@ -18,6 +19,7 @@ def initialize(table)
       register_handler(Relation, RelationHandler.new)
       register_handler(Array, ArrayHandler.new(self))
       register_handler(Set, ArrayHandler.new(self))
+      register_handler(Regexp, RegexpHandler.new(self))
     end
 
     def build_from_hash(attributes, &block)

activerecord/lib/active_record/relation/predicate_builder/regexp_handler.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class PredicateBuilder
+    class RegexpHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        unless value.options == 0
+          raise ArgumentError, "Regexp for #{attribute.name} must not have modifiers"
+        end
+
+        attribute.matches_regexp(value.source)
+      end
+
+      private
+        attr_reader :predicate_builder
+    end
+  end
+end

activerecord/lib/arel/visitors/sqlite.rb

@@ -71,6 +71,16 @@ def prepare_update_statement(o)
           end
         end
 
+        # REGEXP operator uses regexp() user function. This function is not defined by default.
+        # See: https://www.sqlite.org/lang_expr.html#the_like_glob_regexp_match_and_extract_operators
+        def visit_Arel_Nodes_Regexp(o, collector)
+          infix_value o, collector, " REGEXP "
+        end
+
+        def visit_Arel_Nodes_NotRegexp(o, collector)
+          infix_value o, collector, " NOT REGEXP "
+        end
+
         # Locks are not supported in SQLite
         def visit_Arel_Nodes_Lock(o, collector)
           collector

activerecord/test/cases/arel/visitors/sqlite_test.rb

@@ -70,6 +70,44 @@ def compile(node)
           _(sql).must_be_like %{ "users"."name" IS NOT NULL }
         end
       end
+
+      describe "Nodes::Regexp" do
+        it "should know how to visit" do
+          node = Table.new(:users)[:name].matches_regexp("foo.*")
+          _(node).must_be_kind_of Nodes::Regexp
+          _(compile(node)).must_be_like %{
+            "users"."name" REGEXP 'foo.*'
+          }
+        end
+
+        it "can handle subqueries" do
+          table = Table.new(:users)
+          subquery = table.project(:id).where(table[:name].matches_regexp("foo.*"))
+          node = table[:id].in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" REGEXP 'foo.*')
+          }
+        end
+      end
+
+      describe "Nodes::NotRegexp" do
+        it "should know how to visit" do
+          node = Table.new(:users)[:name].does_not_match_regexp("foo.*")
+          _(node).must_be_kind_of Nodes::NotRegexp
+          _(compile(node)).must_be_like %{
+            "users"."name" NOT REGEXP 'foo.*'
+          }
+        end
+
+        it "can handle subqueries" do
+          table = Table.new(:users)
+          subquery = table.project(:id).where(table[:name].does_not_match_regexp("foo.*"))
+          node = table[:id].in subquery
+          _(compile(node)).must_be_like %{
+            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT REGEXP 'foo.*')
+          }
+        end
+      end
     end
   end
 end

activerecord/test/cases/relation/where_test.rb

@@ -92,6 +92,23 @@ def test_rewhere_on_root
       assert_equal posts(:welcome), Post.rewhere(title: "Welcome to the weblog").first
     end
 
+    # SQLite does not support regexp() user function by default.
+    unless current_adapter?(:SQLite3Adapter)
+      def test_where_with_regexp
+        expected_comments = [comments(:greetings), comments(:more_greetings)]
+
+        assert_equal expected_comments, Comment.where(body: /Thank you( again)? for the welcome/).to_a
+      end
+
+      def test_where_with_regexp_with_options
+        error = assert_raise ArgumentError do
+          Comment.where(body: /Thank you( again)? for the welcome/i)
+        end
+
+        assert_equal "Regexp for body must not have modifiers", error.message
+      end
+    end
+
     def test_where_with_tuple_syntax
       first_topic = topics(:first)
       third_topic = topics(:third)