Add case sensitive parameter to string scopes

Author: alexisbernard

README.md

@@ -35,8 +35,13 @@ Transaction.amount_not_within(100, 200) # => where("amount <= 100 OR amount >= 2
 
 # String scopes
 Transaction.description_contains("foo") # => where("description LIKE '%foo%'")
+Transaction.description_contains("foo", sensitive: false) # => where("description ILIKE '%foo%'")
 Transaction.description_starts_with("foo") # => where("description LIKE 'foo%'")
+Transaction.description_starts_with("foo", sensitive: false) # => where("description ILIKE 'foo%'")
 Transaction.description_ends_with("foo") # => where("description LIKE '%foo'")
+Transaction.description_ends_with("foo", sensitive: false) # => where("description ILIKE '%foo'")
+Transaction.description_like("%foo%") # => where("description LIKE '%foo%'")
+Transaction.description_ilike("%foo%") # => where("description ILIKE '%foo%'")
 
 # Boolean scopes
 Transaction.non_profit # => where("non_profit = true")
@@ -49,7 +54,7 @@ Transaction.was_processed # => where("was_processed = true")
 Transaction.was_not_processed # => where("was_processed = false")
 ```
 
-For the string scope the pattern matching is escaped:
+For the string colums, the pattern matching is escaped. So it's safe to provide directly a user input. There is an exception for the `column_like` and `column_ilike` where the pattern is not escaped and you shouldn't provide untrusted strings.
 
 ```ruby
 Transaction.description_contains("%foo_") # => where("description LIKE '%[%]foo[_]%'")

lib/type_scopes/string.rb

@@ -13,8 +13,19 @@ def self.escape(string)
 
   def self.create_scopes_for_column(model, name)
     column = model.arel_table[name]
-    append_scope(model, :"#{name}_contains", lambda { |str| where(column.matches("%" + TypeScopes::String.escape(str) + "%")) })
-    append_scope(model, :"#{name}_starts_with", lambda { |str| where(column.matches(TypeScopes::String.escape(str) + "%")) })
-    append_scope(model, :"#{name}_ends_with", lambda { |str| where(column.matches("%" + TypeScopes::String.escape(str))) })
+    append_scope(model, :"#{name}_like", lambda { |str, sensitive: true| where(column.matches(str, nil, sensitive)) })
+    append_scope(model, :"#{name}_ilike", lambda { |str| where(column.matches(str)) })
+
+    append_scope(model, :"#{name}_contains", lambda { |str, sensitive: true|
+      send("#{name}_like", "%#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_starts_with", lambda { |str, sensitive: true|
+      send("#{name}_like", "#{TypeScopes::String.escape(str)}%", sensitive: sensitive)
+    })
+
+    append_scope(model, :"#{name}_ends_with", lambda { |str, sensitive: true|
+      send("#{name}_like", "%#{TypeScopes::String.escape(str)}", sensitive: sensitive)
+    })
   end
 end

test/test_helper.rb

@@ -29,6 +29,12 @@ def self.initialize_database
     TypeScopes::Transaction::Migration.new.up
     TypeScopes::Transaction.include(TypeScopes)
   end
+
+  def like_case_sensitive?
+    # By default SQLite's like is case insensitive.
+    # So it's not possible to have the exact same tests with other databases.
+    ActiveRecord::Base.connection.adapter_name != "SQLite"
+  end
 end
 
 TypeScopes::TestCase.initialize_database

test/type_scopes/string_test.rb

@@ -7,17 +7,35 @@ def setup
     TypeScopes::Transaction.create!(amount: 200, paid_at: "2021-06-24", description: "Last transaction")
   end
 
+  def test_like
+    assert_equal(1, TypeScopes::Transaction.description_like("%First%").count)
+    return unless like_case_sensitive?
+    assert_equal(0, TypeScopes::Transaction.description_like("%FIRST%").count)
+    assert_equal(1, TypeScopes::Transaction.description_like("%FIRST%", sensitive: false).count)
+  end
+
+  def test_ilike
+    assert_equal(1, TypeScopes::Transaction.description_ilike("%First%").count)
+    assert_equal(1, TypeScopes::Transaction.description_ilike("%FIRST%").count)
+  end
+
   def test_contains
     assert_equal(2, TypeScopes::Transaction.description_contains("t t").count)
     assert_equal(0, TypeScopes::Transaction.description_contains("xxx").count)
   end
 
   def test_starts_with
     assert_equal(1, TypeScopes::Transaction.description_starts_with("First").count)
+    assert_equal(1, TypeScopes::Transaction.description_starts_with("FIRST", sensitive: false).count)
+    return unless like_case_sensitive?
+    assert_equal(0, TypeScopes::Transaction.description_starts_with("FIRST").count)
   end
 
   def test_ends_with
     assert_equal(2, TypeScopes::Transaction.description_ends_with("tion").count)
+    assert_equal(2, TypeScopes::Transaction.description_ends_with("TION", sensitive: false).count)
+    return unless like_case_sensitive?
+    assert_equal(0, TypeScopes::Transaction.description_ends_with("TION").count)
   end
 
   def test_escaped_characters