db_text_search 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c4d97cd16283ff2c47726a56e36fee85c3eb922
-  data.tar.gz: 06b3ca789b57a423f9ffc33840903e8028377263
+  metadata.gz: 0b93fa5e6feaef447c7bd1e8580b42aafa2cca3d
+  data.tar.gz: d1ddab5bfe8ef8cb544c711ab1b4792882578eab
 SHA512:
-  metadata.gz: e1ef0f9d45289ed1623f73cded6a2bd3c2f7ad88928364af7b7e94077eb79bcb93c5842c9f772e64b003d5039c64d3028242395d4263ad7574ebdf41e7854231
-  data.tar.gz: 027a5ebcfc61f1d017aee0bd61b66e7327132667085556d60fe3453b92f266093bad59e9f248dde4ec9ff1e6539716a468b3e8805f9a3f8957cf3335c592acb6
+  metadata.gz: ffe48a13416b0dd7d820584d411c5a4e22806738e1bc3c36fd2be0121f890b621269f62a058b3791e0322e5f51edc05c255ab0ee87958c8b4e0e1846dba41ca9
+  data.tar.gz: b07cce34cda731a695d59da849cb0e62a0f2c2247584c32a21cf23c75afeba4382cad4d3fe2cff945e4ccd05bedcd114af44ed5248c1775c2fe5e4c3e148a016

data/CHANGES.md

@@ -1,3 +1,12 @@
+## v0.2.0
+
+* **Feature** Prefix matching via the new `CaseInsensitive#prefix` method.
+* PostgreSQL CI index now uses the `text_pattern_ops` [opclass] by default (for prefix matching).
+* Renamed `CaseInsensitiveEq` to `CaseInsensitive`, and `#find` to `#in`.
+* Renamed `FullTextSearch` to `FullText`, and `#find` to `#search`.
+
+[opclass]: http://www.postgresql.org/docs/9.5/static/indexes-opclass.html
+
 ## v0.1.2
 
 Tightened the API. Improved documentation.

data/README.md

@@ -3,7 +3,7 @@
 Different relational databases treat text search very differently.
 DbTextSearch provides a unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL to do:
 
-* Case-insensitive string-in-set querying, and CI index creation.
+* Case-insensitive string-in-set querying, prefix querying, and case-insensitive index creation.
 * Basic full-text search for a list of terms, and FTS index creation.
 
 ## Installation
@@ -11,33 +11,40 @@ DbTextSearch provides a unified interface on top of ActiveRecord for SQLite, MyS
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'db_text_search', '~> 0.1.1'
+gem 'db_text_search', '~> 0.2.0'
 ```
 
 ## Usage
 
 ### Case-insensitive string matching
 
-Add an index in a migration to an existing CI or CS column:
+Add an index in a migration to an existing CI (case-insensitive) or CS (case-sensitive) column:
 
 ```ruby
-DbTextSearch::CaseInsensitiveEq.add_index connection, :users, :username
+DbTextSearch::CaseInsensitive.add_index connection, :users, :username
 # Options: name, unique
 ```
 
 Or, create a new CI column:
 
 ```ruby
-DbTextSearch::CaseInsensitiveEq.add_ci_text_column connection, :users, :username
+DbTextSearch::CaseInsensitive.add_ci_text_column connection, :users, :username
 ```
 
 Perform a search for records with column that case-insensitively equals to one of the strings in a given set:
 
 ```ruby
-DbTextSearch::CaseInsensitiveEq.new(User.confirmed, :username).find(%w(Alice Bob))
+# Find all confirmed users that have either the username Alice or Bob (case-insensitively):
+DbTextSearch::CaseInsensitive.new(User.confirmed, :username).in(%w(Alice Bob))
  #=> ActiveRecord::Relation
 ```
 
+Perform a case-insensitive prefix search:
+ 
+```ruby
+DbTextSearch::CaseInsensitive.new(User.confirmed, :username).prefix('Jo')
+```
+
 See also: [API documentation][api-docs].
 
 ### Full text search
@@ -45,23 +52,25 @@ See also: [API documentation][api-docs].
 Add an index:
 
 ```ruby
-DbTextSearch::FullTextSearch.add_index connection, :posts, :content
+DbTextSearch::FullText.add_index connection, :posts, :content
 # Options: name
 ```
 
 Perform a full-text search:
 
 ```ruby
-DbTextSearch::FullTextSearch.new(Post.published, :content).find('peace')
-DbTextSearch::FullTextSearch.new(Post.published, :content).find(%w(love kaori))
+DbTextSearch::FullText.new(Post.published, :content).search('peace')
+DbTextSearch::FullText.new(Post.published, :content).search(%w(love kaori))
 ```
 
 ## Under the hood
 
+### Case-insensitive string matching
+
 <table>
-<caption>Case-insensitive string matching methods</caption>
+<caption>Case-insensitive equality methods</caption>
 <thead>
-  <tr><th rowspan="2">Column type</th><th colspan="2">SQLite</th><th colspan="2">MySQL</th><th colspan="2">PostgreSQL</th>
+  <tr><th rowspan="2">Column type</th><th colspan="2">SQLite</th><th colspan="2">MySQL</th><th colspan="2">PostgreSQL</th></tr>
   <tr><th>Detected types</th><th>Search / index</th><th>Detected types</th><th>Search / index</th><th>Detected types</th><th>Search / index</th></tr>
 </thead>
 <tbody style="text-align: center">
@@ -69,14 +78,36 @@ DbTextSearch::FullTextSearch.new(Post.published, :content).find(%w(love kaori))
       <td rowspan="2">always treated as CS</td> <td rowspan="2"><code>COLLATE&nbsp;NOCASE</code></td>
       <td><i>default</i></td> <td><i>default</i></td>
       <td><code>CITEXT</code></td> <td><i>default</i></td>
+  </tr>
   <tr><th>CS</th>
     <td>non-<code>ci</code> collations</td> <td><code>LOWER</code><br><b>no index</b></td>
     <td><i>default</i></td> <td><code>LOWER</code></td>
   </tr>
+</tbody>
+</table>
+
+<table>
+<caption>Case-insensitive prefix matching (using <code>LIKE</code>)</caption>
+<thead>
+  <tr><th>Column type</th><th>SQLite</th><th>MySQL</th><th>PostgreSQL</th></tr>  
+</thead>
+<tbody style="text-align: center">
+  <tr><th>CI</th>
+      <td rowspan="2">
+        <i>default</i>, <a href="https://www.sqlite.org/optoverview.html#prefix_opt"><b>cannot always use an index</b></a>,<br>
+        even for prefix queries
+      </td>
+      <td><i>default</i></td>
+      <td><b>cannot use an index</b></td>
+  </tr>
+  <tr><th>CS</th>
+    <td><b>cannot use an index</b></td>    
+    <td><code>LOWER(column text_pattern_ops)</code></td>
   </tr>
 </tbody>
 </table>
 
+
 ### Full-text search
 
 #### MySQL

data/db_text_search.gemspec

@@ -3,22 +3,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'db_text_search/version'
 
 Gem::Specification.new do |s|
-  s.name          = 'db_text_search'
-  s.version       = DbTextSearch::VERSION
-  s.authors       = ['Gleb Mazovetskiy']
-  s.email         = ['glex.spb@gmail.com']
+  s.name    = 'db_text_search'
+  s.version = DbTextSearch::VERSION
+  s.authors = ['Gleb Mazovetskiy']
+  s.email   = ['glex.spb@gmail.com']
 
-  s.summary       = %q{A unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL for case-insensitive string search and basic full-text search.}
-  s.description   = %q{Different relational databases treat text search very differently.
-DbTextSearch provides a unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL to do:
-* Case-insensitive string-in-set querying, and CI index creation.
-* Basic full-text search for a list of terms, and FTS index creation.
-}
-  s.homepage      = 'https://github.com/thredded/db_text_search'
-  s.license       = 'MIT'
+  s.summary     = 'A unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL'\
+                  'for case-insensitive string search and basic full-text search.'
+  s.description = 'Different relational databases treat text search very differently. DbTextSearch provides '\
+                  'a unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL to do '\
+                  'case-insensitive string-in-set querying and CI index creation, and '\
+                  'basic full-text search for a list of terms, and FTS index creation.'
+  s.homepage    = 'https://github.com/thredded/db_text_search'
+  s.license     = 'MIT'
 
-  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|bin|script)/|^\.|Rakefile|Gemfile}) }
-  s.require_paths = ['lib']
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|bin|script)/|^\.|Rakefile|Gemfile}) }
+
+  s.require_paths         = ['lib']
   s.required_ruby_version = '~> 2.1'
 
   s.add_dependency 'activerecord', '>= 4.1.15', '< 6.0'

data/lib/db_text_search.rb

@@ -1,14 +1,42 @@
+# frozen_string_literal: true
+
 require 'active_record'
 require 'active_support/core_ext/hash/keys'
 
 require 'db_text_search/version'
-require 'db_text_search/case_insensitive_eq'
-require 'db_text_search/full_text_search'
+require 'db_text_search/case_insensitive'
+require 'db_text_search/full_text'
 
 # DbTextSearch provides a unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL to do:
 # * Case-insensitive string-in-set querying, and CI index creation.
 # * Basic full-text search for a list of terms, and FTS index creation.
-# @see DbTextSearch::CaseInsensitiveEq
-# @see DbTextSearch::FullTextSearch
+# @see DbTextSearch::CaseInsensitive
+# @see DbTextSearch::FullText
 module DbTextSearch
+  # Call the appropriate proc based on the adapter name.
+  # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+  # @param mysql [Proc]
+  # @param postgres [Proc]
+  # @param sqlite [Proc]
+  # @return the called proc return value.
+  # @api private
+  def self.match_adapter(connection, mysql:, postgres:, sqlite:)
+    case connection.adapter_name
+      when /mysql/i
+        mysql.call
+      when /postgres/i
+        postgres.call
+      when /sqlite/i
+        sqlite.call
+      else
+        unsupported_adapter! connection
+    end
+  end
+
+  # Raises an ArgumentError with "Unsupported adapter #{connection.adapter_name}"
+  # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+  # @api private
+  def self.unsupported_adapter!(connection)
+    fail ArgumentError, "Unsupported adapter #{connection.adapter_name}"
+  end
 end

data/lib/db_text_search/{case_insensitive_eq.rb → case_insensitive.rb}

@@ -1,10 +1,12 @@
-require 'db_text_search/case_insensitive_eq/insensitive_column_adapter'
-require 'db_text_search/case_insensitive_eq/lower_adapter'
-require 'db_text_search/case_insensitive_eq/collate_nocase_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/case_insensitive/insensitive_column_adapter'
+require 'db_text_search/case_insensitive/lower_adapter'
+require 'db_text_search/case_insensitive/collate_nocase_adapter'
 
 module DbTextSearch
-  # Provides case-insensitive string-in-set querying, and CI index creation.
-  class CaseInsensitiveEq
+  # Provides case-insensitive string-in-set querying, LIKE querying, and CI index creation.
+  class CaseInsensitive
     # @param scope [ActiveRecord::Relation, Class<ActiveRecord::Base>]
     # @param column [Symbol] name
     def initialize(scope, column)
@@ -14,10 +16,17 @@ module DbTextSearch
 
     # @param value_or_values [String, Array<String>]
     # @return [ActiveRecord::Relation]
-    def find(value_or_values)
+    def in(value_or_values)
       values = Array(value_or_values)
       return @scope.none if values.empty?
-      @adapter.find(values)
+      @adapter.in(values)
+    end
+
+    # @param query [String]
+    # @return [ActiveRecord::Relation] the scope of records with matching prefix.
+    def prefix(query)
+      return @scope.none if query.empty?
+      @adapter.prefix(query)
     end
 
     # Adds a case-insensitive column to the given table.
@@ -26,25 +35,20 @@ module DbTextSearch
     # @param column_name [String, Symbol]
     # @param options [Hash] passed to ActiveRecord::ConnectionAdapters::SchemaStatements#add_index
     def self.add_ci_text_column(connection, table_name, column_name, options = {})
-      case connection.adapter_name.downcase
-        when /mysql/
-          connection.add_column(table_name, column_name, :text, options)
-        when /postgres/
-          connection.enable_extension 'citext'
-          if ActiveRecord::VERSION::STRING >= '4.2.0'
-            connection.add_column(table_name, column_name, :citext, options)
-          else
-            connection.add_column(table_name, column_name, 'CITEXT', options)
-          end
-        when /sqlite/
-          if ActiveRecord::VERSION::MAJOR >= 5
-            connection.add_column(table_name, column_name, :text, options.merge(collation: 'NOCASE'))
-          else
-            connection.add_column(table_name, column_name, 'TEXT COLLATE NOCASE', options)
-          end
-        else
-          fail ArgumentError.new("Unsupported adapter #{connection.adapter_name}")
-      end
+      connection.add_column table_name, column_name, *DbTextSearch.match_adapter(
+          connection,
+          mysql:    -> { [:text, options] },
+          postgres: -> {
+            connection.enable_extension 'citext'
+            [(ActiveRecord::VERSION::STRING >= '4.2.0' ? :citext : 'CITEXT'), options]
+          },
+          sqlite:   -> {
+            if ActiveRecord::VERSION::MAJOR >= 5
+              [:text, options.merge(collation: 'NOCASE')]
+            else
+              ['TEXT COLLATE NOCASE', options]
+            end
+          })
     end
 
     # Add an index for case-insensitive string search.
@@ -65,15 +69,16 @@ module DbTextSearch
     # @return [Class<AbstractAdapter>]
     # @api private
     def self.adapter_class(connection, table_name, column_name)
-      if connection.adapter_name.downcase =~ /sqlite/
-        # Always use COLLATE NOCASE for SQLite, as we can't check if the column is case-sensitive.
-        # It has no performance impact apart from slightly longer query strings for case-insensitive columns.
-        CollateNocaseAdapter
-      elsif column_case_sensitive?(connection, table_name, column_name)
-        LowerAdapter
-      else
-        InsensitiveColumnAdapter
-      end
+      lower_or_insensitive = -> {
+        column_case_sensitive?(connection, table_name, column_name) ? LowerAdapter : InsensitiveColumnAdapter
+      }
+      DbTextSearch.match_adapter(
+          connection,
+          mysql:    lower_or_insensitive,
+          postgres: lower_or_insensitive,
+          # Always use COLLATE NOCASE for SQLite, as we can't check if the column is case-sensitive.
+          # It has no performance impact apart from slightly longer query strings for case-insensitive columns.
+          sqlite:   -> { CollateNocaseAdapter })
     end
 
     # @param connection [ActiveRecord::ConnectionAdapters::AbstractAdapter]
@@ -84,14 +89,11 @@ module DbTextSearch
     # @api private
     def self.column_case_sensitive?(connection, table_name, column_name)
       column = connection.schema_cache.columns(table_name).detect { |c| c.name == column_name.to_s }
-      case connection.adapter_name.downcase
-        when /mysql/
-          column.case_sensitive?
-        when /postgres/
-          column.sql_type !~ /citext/i
-        else
-          fail ArgumentError.new("Unsupported adapter #{connection.adapter_name}")
-      end
+      DbTextSearch.match_adapter(
+          connection,
+          mysql:    -> { column.case_sensitive? },
+          postgres: -> { column.sql_type !~ /citext/i },
+          sqlite:   -> { DbTextSearch.unsupported_adapter! connection })
     end
   end
 end

data/lib/db_text_search/{case_insensitive_eq → case_insensitive}/abstract_adapter.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'db_text_search/query_building'
 module DbTextSearch
-  class CaseInsensitiveEq
+  class CaseInsensitive
     # A base class for CaseInsensitiveStringFinder adapters.
     # @abstract
     # @api private
@@ -17,7 +19,14 @@ module DbTextSearch
       # @param values [Array<String>]
       # @return [ActiveRecord::Relation]
       # @abstract
-      def find(values)
+      def in(values)
+        fail 'abstract'
+      end
+
+      # @param query [String]
+      # @return [ActiveRecord::Relation]
+      # @abstract
+      def prefix(query)
         fail 'abstract'
       end
 

data/lib/db_text_search/{case_insensitive_eq → case_insensitive}/collate_nocase_adapter.rb

@@ -1,15 +1,27 @@
-require 'db_text_search/case_insensitive_eq/abstract_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/case_insensitive/abstract_adapter'
 module DbTextSearch
-  class CaseInsensitiveEq
+  class CaseInsensitive
     # Provides case-insensitive string-in-set querying via COLLATE NOCASE.
     # @api private
     class CollateNocaseAdapter < AbstractAdapter
-      # (see AbstractAdapter#find)
-      def find(values)
+      # (see AbstractAdapter#in)
+      def in(values)
         conn = @scope.connection
         @scope.where "#{quoted_scope_column} COLLATE NOCASE IN (#{values.map { |v| conn.quote(v.to_s) }.join(', ')})"
       end
 
+      # (see AbstractAdapter#prefix)
+      def prefix(query)
+        escape        = '\\'
+        escaped_query = "#{sanitize_sql_like(query, escape)}%"
+        # assuming case_sensitive_prefix mode to be disabled, prefix it is by default.
+        # this is to avoid adding COLLATE NOCASE here, which prevents index use in SQLite LIKE.
+        @scope.where "#{quoted_scope_column} LIKE ?#{" ESCAPE '#{escape}'" if escaped_query.include?(escape)}",
+                     escaped_query
+      end
+
       # (see AbstractAdapter.add_index)
       def self.add_index(connection, table_name, column_name, options = {})
         # TODO: Switch to the native Rails solution once it's landed, as the current one requires SQL dump format.

data/lib/db_text_search/{case_insensitive_eq → case_insensitive}/insensitive_column_adapter.rb

@@ -1,14 +1,21 @@
-require 'db_text_search/case_insensitive_eq/abstract_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/case_insensitive/abstract_adapter'
 module DbTextSearch
-  class CaseInsensitiveEq
+  class CaseInsensitive
     # Provides case-insensitive string-in-set querying for case-insensitive columns.
     # @api private
     class InsensitiveColumnAdapter < AbstractAdapter
-      # (see AbstractAdapter#find)
-      def find(values)
+      # (see AbstractAdapter#in)
+      def in(values)
         @scope.where(@column => values)
       end
 
+      # (see AbstractAdapter#prefix)
+      def prefix(query)
+        @scope.where "#{quoted_scope_column} LIKE ?", "#{sanitize_sql_like(query)}%"
+      end
+
       # (see AbstractAdapter.add_index)
       def self.add_index(connection, table_name, column_name, options = {})
         connection.add_index table_name, column_name, options

data/lib/db_text_search/case_insensitive/lower_adapter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'db_text_search/case_insensitive/abstract_adapter'
+module DbTextSearch
+  class CaseInsensitive
+    # Provides case-insensitive string-in-set querying by applying the database LOWER function.
+    # @api private
+    class LowerAdapter < AbstractAdapter
+      # (see AbstractAdapter#in)
+      def in(values)
+        conn = @scope.connection
+        @scope.where "LOWER(#{quoted_scope_column}) IN (#{values.map { |v| "LOWER(#{conn.quote(v)})" }.join(', ')})"
+      end
+
+      # (see AbstractAdapter#prefix)
+      def prefix(query)
+        @scope.where "LOWER(#{quoted_scope_column}) LIKE LOWER(?)", "#{sanitize_sql_like(query)}%"
+      end
+
+      # (see AbstractAdapter.add_index)
+      def self.add_index(connection, table_name, column_name, options = {})
+        unsupported = -> { DbTextSearch.unsupported_adapter! connection }
+        DbTextSearch.match_adapter(
+            connection,
+            # TODO: Switch to native Rails support once it lands.
+            # https://github.com/rails/rails/pull/18499
+            postgres: -> {
+              options              = options.dup
+              options[:name]       ||= "#{table_name}_#{column_name}_lower"
+              options[:expression] = "(LOWER(#{connection.quote_column_name(column_name)}) text_pattern_ops)"
+              connection.exec_query(quoted_create_index(connection, table_name, **options))
+            },
+            mysql:    unsupported,
+            sqlite:   unsupported)
+      end
+    end
+  end
+end

data/lib/db_text_search/{full_text_search.rb → full_text.rb}

@@ -1,10 +1,12 @@
-require 'db_text_search/full_text_search/postgres_adapter'
-require 'db_text_search/full_text_search/mysql_adapter'
-require 'db_text_search/full_text_search/sqlite_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/full_text/postgres_adapter'
+require 'db_text_search/full_text/mysql_adapter'
+require 'db_text_search/full_text/sqlite_adapter'
 
 module DbTextSearch
   # Provides basic full-text search for a list of terms, and FTS index creation.
-  class FullTextSearch
+  class FullText
     # The default Postgres text search config.
     DEFAULT_PG_TS_CONFIG = %q('english')
 
@@ -18,10 +20,10 @@ module DbTextSearch
     # @param term_or_terms [String, Array<String>]
     # @param pg_ts_config [String] for Postgres, the TS config to use; ignored for non-postgres.
     # @return [ActiveRecord::Relation]
-    def find(term_or_terms, pg_ts_config: DEFAULT_PG_TS_CONFIG)
-      values  = Array(term_or_terms)
+    def search(term_or_terms, pg_ts_config: DEFAULT_PG_TS_CONFIG)
+      values = Array(term_or_terms)
       return @scope.none if values.empty?
-      @adapter.find(values, pg_ts_config: pg_ts_config)
+      @adapter.search(values, pg_ts_config: pg_ts_config)
     end
 
     # Add an index for full text search.
@@ -43,16 +45,11 @@ module DbTextSearch
     # @return [Class<AbstractAdapter>]
     # @api private
     def self.adapter_class(connection, _table_name, _column_name)
-      case connection.adapter_name
-        when /mysql/i
-          MysqlAdapter
-        when /postgres/i
-          PostgresAdapter
-        when /sqlite/i
-          SqliteAdapter
-        else
-          fail ArgumentError.new("Unsupported adapter #{connection.adapter_name}")
-      end
+      DbTextSearch.match_adapter(
+          connection,
+          mysql:    -> { MysqlAdapter },
+          postgres: -> { PostgresAdapter },
+          sqlite:   -> { SqliteAdapter })
     end
   end
 end

data/lib/db_text_search/{full_text_search → full_text}/abstract_adapter.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module DbTextSearch
-  class FullTextSearch
-    # A base class for FullTextSearch adapters.
+  class FullText
+    # A base class for FullText adapters.
     # @abstract
     # @api private
     class AbstractAdapter
@@ -17,7 +19,7 @@ module DbTextSearch
       # @param pg_ts_config [String] a pg text search config
       # @return [ActiveRecord::Relation]
       # @abstract
-      def find(terms, pg_ts_config:)
+      def search(terms, pg_ts_config:)
         fail 'abstract'
       end
 

data/lib/db_text_search/{full_text_search → full_text}/mysql_adapter.rb

@@ -1,6 +1,8 @@
-require 'db_text_search/full_text_search/abstract_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/full_text/abstract_adapter'
 module DbTextSearch
-  class FullTextSearch
+  class FullText
     # Provides basic FTS support for MySQL.
     #
     # Runs a `MATCH AGAINST` query against a `FULLTEXT` index.
@@ -8,8 +10,8 @@ module DbTextSearch
     # @note MySQL v5.6.4+ is required.
     # @api private
     class MysqlAdapter < AbstractAdapter
-      # (see AbstractAdapter#find)
-      def find(terms, pg_ts_config:)
+      # (see AbstractAdapter#search)
+      def search(terms, pg_ts_config:)
         @scope.where("MATCH (#{quoted_scope_column}) AGAINST (?)", terms.uniq.join(' '))
       end
 

data/lib/db_text_search/{full_text_search → full_text}/postgres_adapter.rb

@@ -1,15 +1,17 @@
-require 'db_text_search/full_text_search/abstract_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/full_text/abstract_adapter'
 module DbTextSearch
-  class FullTextSearch
+  class FullText
     # Provides basic FTS support for PostgreSQL.
     #
     # Runs a `@@ plainto_tsquery` query against a `gist(to_tsvector(...))` index.
     #
-    # @see DbTextSearch::FullTextSearch::DEFAULT_PG_TS_CONFIG
+    # @see DbTextSearch::FullText::DEFAULT_PG_TS_CONFIG
     # @api private
     class PostgresAdapter < AbstractAdapter
-      # (see AbstractAdapter#find)
-      def find(terms, pg_ts_config:)
+      # (see AbstractAdapter#search)
+      def search(terms, pg_ts_config:)
         @scope.where("to_tsvector(#{pg_ts_config}, #{quoted_scope_column}) @@ plainto_tsquery(#{pg_ts_config}, ?)",
                      terms.uniq.join(' '))
       end

data/lib/db_text_search/{full_text_search → full_text}/sqlite_adapter.rb

@@ -1,6 +1,8 @@
-require 'db_text_search/full_text_search/abstract_adapter'
+# frozen_string_literal: true
+
+require 'db_text_search/full_text/abstract_adapter'
 module DbTextSearch
-  class FullTextSearch
+  class FullText
     # Provides very basic FTS support for SQLite.
     #
     # Runs a `LIKE %term%` query for each term, joined with `AND`.
@@ -9,17 +11,16 @@ module DbTextSearch
     # @note .add_index is a no-op.
     # @api private
     class SqliteAdapter < AbstractAdapter
-      # (see AbstractAdapter#find)
-      def find(terms, pg_ts_config:)
+      # (see AbstractAdapter#search)
+      def search(terms, pg_ts_config:)
         quoted_col = quoted_scope_column
         terms.map(&:downcase).uniq.inject(@scope) do |scope, term|
           scope.where("#{quoted_col} COLLATE NOCASE LIKE ?", "%#{sanitize_sql_like term}%")
         end
       end
 
-      # (see AbstractAdapter.add_index)
-      def self.add_index(connection, table_name, column_name, name:, pg_ts_config:)
-        # A no-op, as we just use LIKE for sqlite.
+      # A no-op, as we just use LIKE for sqlite.
+      def self.add_index(_connection, _table_name, _column_name, name:, pg_ts_config:)
       end
     end
   end

data/lib/db_text_search/query_building.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DbTextSearch
   # Common methods for building SQL that use @scope and @column instance variables.
   # @api private
@@ -6,6 +8,12 @@ module DbTextSearch
       base.extend ClassMethods
     end
 
+    # @return [String] SQL-quoted string suitable for use in a LIKE statement, with % and _ escaped.
+    def sanitize_sql_like(string, escape_character = '\\')
+      pattern = Regexp.union(escape_character, '%', '_')
+      string.gsub(pattern) { |x| [escape_character, x].join }
+    end
+
     protected
 
     # @return [String] SQL-quoted scope table name.
@@ -23,12 +31,6 @@ module DbTextSearch
       "#{quoted_scope_table}.#{quoted_column}"
     end
 
-    # @return [String] SQL-quoted string suitable for use in a LIKE statement, with % and _ escaped.
-    def sanitize_sql_like(string, escape_character = "\\")
-      pattern = Regexp.union(escape_character, '%', '_')
-      string.gsub(pattern) { |x| [escape_character, x].join }
-    end
-
     # Common methods for building SQL
     # @api private
     module ClassMethods

data/lib/db_text_search/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module DbTextSearch
   # Gem version
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_text_search
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Gleb Mazovetskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-30 00:00:00.000000000 Z
+date: 2016-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -114,11 +114,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
-description: |
-  Different relational databases treat text search very differently.
-  DbTextSearch provides a unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL to do:
-  * Case-insensitive string-in-set querying, and CI index creation.
-  * Basic full-text search for a list of terms, and FTS index creation.
+description: Different relational databases treat text search very differently. DbTextSearch
+  provides a unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL
+  to do case-insensitive string-in-set querying and CI index creation, and basic full-text
+  search for a list of terms, and FTS index creation.
 email:
 - glex.spb@gmail.com
 executables: []
@@ -131,16 +130,16 @@ files:
 - README.md
 - db_text_search.gemspec
 - lib/db_text_search.rb
-- lib/db_text_search/case_insensitive_eq.rb
-- lib/db_text_search/case_insensitive_eq/abstract_adapter.rb
-- lib/db_text_search/case_insensitive_eq/collate_nocase_adapter.rb
-- lib/db_text_search/case_insensitive_eq/insensitive_column_adapter.rb
-- lib/db_text_search/case_insensitive_eq/lower_adapter.rb
-- lib/db_text_search/full_text_search.rb
-- lib/db_text_search/full_text_search/abstract_adapter.rb
-- lib/db_text_search/full_text_search/mysql_adapter.rb
-- lib/db_text_search/full_text_search/postgres_adapter.rb
-- lib/db_text_search/full_text_search/sqlite_adapter.rb
+- lib/db_text_search/case_insensitive.rb
+- lib/db_text_search/case_insensitive/abstract_adapter.rb
+- lib/db_text_search/case_insensitive/collate_nocase_adapter.rb
+- lib/db_text_search/case_insensitive/insensitive_column_adapter.rb
+- lib/db_text_search/case_insensitive/lower_adapter.rb
+- lib/db_text_search/full_text.rb
+- lib/db_text_search/full_text/abstract_adapter.rb
+- lib/db_text_search/full_text/mysql_adapter.rb
+- lib/db_text_search/full_text/postgres_adapter.rb
+- lib/db_text_search/full_text/sqlite_adapter.rb
 - lib/db_text_search/query_building.rb
 - lib/db_text_search/version.rb
 - shared.gemfile
@@ -167,7 +166,7 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: A unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQL
-  for case-insensitive string search and basic full-text search.
+summary: A unified interface on top of ActiveRecord for SQLite, MySQL, and PostgreSQLfor
+  case-insensitive string search and basic full-text search.
 test_files: []
 has_rdoc: 

data/lib/db_text_search/case_insensitive_eq/lower_adapter.rb

@@ -1,35 +0,0 @@
-require 'db_text_search/case_insensitive_eq/abstract_adapter'
-module DbTextSearch
-  class CaseInsensitiveEq
-    # Provides case-insensitive string-in-set querying by applying the database LOWER function.
-    # @api private
-    class LowerAdapter < AbstractAdapter
-      # (see AbstractAdapter#find)
-      def find(values)
-        conn = @scope.connection
-        @scope.where "LOWER(#{quoted_scope_column}) IN (#{values.map { |v| "LOWER(#{conn.quote(v.to_s)})" }.join(', ')})"
-      end
-
-      # (see AbstractAdapter.add_index)
-      def self.add_index(connection, table_name, column_name, options = {})
-        if connection.adapter_name =~ /postgres/i
-          # TODO: Switch to native Rails support once it lands.
-          # https://github.com/rails/rails/pull/18499
-          options              = options.dup
-          options[:name]       ||= "#{table_name}_#{column_name}_lower"
-          options[:expression] = "(LOWER(#{connection.quote_column_name(column_name)}))"
-          if defined?(::SchemaPlus)
-            connection.add_index(table_name, column_name, options)
-          else
-            connection.exec_query quoted_create_index(connection, table_name, **options)
-          end
-        elsif connection.adapter_name =~ /mysql/i
-          fail ArgumentError.new('MySQL case-insensitive index creation for case-sensitive columns is not supported.')
-        else
-          fail ArgumentError.new(
-              "Cannot create a case-insensitive index for case-sensitive column on #{connection.adapter_name}.")
-        end
-      end
-    end
-  end
-end