polysearch 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e36fbf04831569261179657e616072e846db1f69ee69ac177fb573913563a21
-  data.tar.gz: 5c54be09188c3cf6fe2b370770e6e506e712280dfcee3dca05406a37612bb8a9
+  metadata.gz: cbd94171f65db5d6d0e92c6ad1198716c8fe689c395f82b2f15d59adec6b8ce7
+  data.tar.gz: 720f9f7ea37e863dff3d05631abc61ff2ff09d0b5b2af2f68b53444cb42eba3c
 SHA512:
-  metadata.gz: 0ff0320bf6b4feb3f859faf6717bd27bfb7537f2e00186348dbef096da6a937110f91a904df8ec5929dda5242d3e2c2fb940517dbde24a6081afcabb177408a5
-  data.tar.gz: 5cd2653801702e0d1e37fe7ef8e93ff86193afe0788e8fe62a875bbf53d3a2ff4e29837cf49495d538d8ba9ae7639ceaa708845308535e767078109ba7be0e2d
+  metadata.gz: 2dbc836cb1279c2ae3ee5c7d2fc9a1bedb1ea2bbad8f7b2974369d6c48ff646bf7038f409902047b69f782821ca7a6e135ef0670282d732b366dcccb2cf2a37f
+  data.tar.gz: 8e2b04099b36fc14c9fc4f4247414b44d020c153a8510184114d5607b5fe48b89f165c1f2d098aed4c58dcb67c29e72279c6e0a0233f0b91c3fa5baaf327d67c

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polysearch (0.1.1)
+    polysearch (0.2.0)
       rails (>= 6.0)
 
 GEM
@@ -84,12 +84,8 @@ GEM
     marcel (1.0.1)
     method_source (1.0.0)
     mini_mime (1.0.3)
-    mini_portile2 (2.5.1)
     minitest (5.14.4)
     nio4r (2.5.7)
-    nokogiri (1.11.5)
-      mini_portile2 (~> 2.5.0)
-      racc (~> 1.4)
     nokogiri (1.11.5-arm64-darwin)
       racc (~> 1.4)
     parallel (1.20.1)

data/README.md

@@ -1,8 +1,8 @@
-[![Lines of Code](http://img.shields.io/badge/lines_of_code-218-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
+[![Lines of Code](http://img.shields.io/badge/lines_of_code-237-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
 
 # Polysearch
 
-Simplified polymorphic full text + similarity search based on postgres
+Simplified polymorphic full text + similarity search based on postgres.
 
 > NOTE: This project is narrower in scope and more opinionated than [pg_search](https://github.com/Casecommons/pg_search).
 
@@ -50,7 +50,7 @@ Simplified polymorphic full text + similarity search based on postgres
         [
           make_tsvector(first_name, weight: "A"),
           make_tsvector(last_name, weight: "A"),
-          make_tsvector(email, weight: "B")
+          make_tsvector(nickname, weight: "B")
         ]
       end
     end
@@ -65,12 +65,25 @@ Simplified polymorphic full text + similarity search based on postgres
 1. Start searching
 
     ```ruby
-    User.create first_name: "Nate", last_name: "Hopkins", email: "nhopkins@mailinator.com"
+    User.create first_name: "Shawn", last_name: "Spencer", nickname: "Maverick"
 
-    User.polysearch("nate")
-    User.polysearch("ntae") # misspellings also return results
-    User.polysearch("nate").where(created_at: 1.day.ago..Current.time) # active record chaining
-    User.polysearch("nate").order(created_at: :desc) # chain additional ordering after the polysearch scope
+    # find natural language matches (faster)
+    User.full_text_search("shawn")
+
+    # find similarity matches, best for misspelled search terms (slower)
+    User.similarity_search("shwn")
+
+    # perform a combined full text search and a similarity search
+    User.combined_search("shwn")
+
+    # perform a full text search and fall back to similarity (faster than combined_search)
+    User.polysearch("shwn")
+
+    # calculate counts (explicitly pass :id to omit search rankings)
+    User.full_text_search("shawn").count(:id)
+    User.similarity_search("shwn").count(:id)
+    User.combined_search("shwn").count(:id)
+    User.polysearch("shwn").count(:id)
     ```
 
 ## License

data/app/models/concerns/searchable.rb

@@ -36,27 +36,26 @@ module Polysearch
       has_one :polysearch, as: :searchable, class_name: "Polysearch::Record", inverse_of: "searchable"
       after_destroy :destroy_polysearch
 
+      scope :full_text_search, ->(value) {
+        value.blank? ? all : joins(:polysearch).merge(Polysearch::Record.full_text_search(value).select_full_text_search_rank(value))
+      }
+
+      scope :similarity_search, ->(value) {
+        value.blank? ? all : joins(:polysearch).merge(Polysearch::Record.similarity_search(value).select_similarity_rank(value))
+      }
+
+      scope :combined_search, ->(value) {
+        subquery = <<~SQL
+          (
+            SELECT #{table_name}.*, searchable_polysearches.search_rank from (#{Polysearch::Record.combined_search(value).except(:order).to_sql}) searchable_polysearches
+            LEFT JOIN LATERAL (select * from #{table_name} WHERE id = searchable_polysearches.searchable_id) #{table_name} ON TRUE
+          ) #{table_name}
+        SQL
+        from(subquery).order("search_rank desc")
+      }
+
       scope :polysearch, ->(value) {
-        if value.blank?
-          all
-        else
-          fts_rank_alias = "#{table_name.singularize}_fts_rank"
-          similarity_rank_alias = "#{table_name.singularize}_similarity_rank"
-
-          fts = Polysearch::Record
-            .select_fts_rank(value, :searchable_id, rank_alias: fts_rank_alias)
-            .select_similarity_rank(value, :searchable_id, rank_alias: similarity_rank_alias)
-            .where(searchable_type: name)
-            .fts(value).or(Polysearch::Record.where(searchable_type: name).similar(value))
-
-          query = <<~SQL
-            SELECT searchables.*, fts.#{fts_rank_alias}, fts.#{similarity_rank_alias} from (#{fts.to_sql}) fts
-            LEFT JOIN LATERAL (select * from #{table_name} WHERE id = fts.searchable_id) searchables ON TRUE
-          SQL
-
-          select(Arel.star).from(Arel::Nodes::SqlLiteral.new("(#{query})").as(table_name))
-            .reorder(fts_rank_alias => :desc, similarity_rank_alias => :desc)
-        end
+        value.blank? ? all : joins(:polysearch).merge(Polysearch::Record.polysearch(value))
       }
     end
 

data/app/models/record.rb

@@ -33,39 +33,57 @@ module Polysearch
 
     # scopes ....................................................................
 
-    scope :select_fts_rank, ->(value, *selects, rank_alias: nil) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-      plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), value])
+    scope :select_full_text_search_rank, ->(value, *selects) {
+      plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), arel_search_value(value)])
       ts_rank = Arel::Nodes::NamedFunction.new("ts_rank", [arel_table[:value], plainto_tsquery])
-
-      rank_alias ||= "fts_rank"
       selects << Arel.star if selects.blank?
-      selects << ts_rank.as(rank_alias)
-      select(*selects).order("#{rank_alias} desc")
+      selects << ts_rank.as("search_rank")
+      select(*selects).reorder("search_rank desc")
     }
 
-    scope :fts, ->(value) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-      plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), value])
-      where(Arel::Nodes::InfixOperation.new("@@", arel_table[:value], plainto_tsquery))
+    scope :full_text_search, ->(value) {
+      if value.blank?
+        all
+      else
+        plainto_tsquery = Arel::Nodes::NamedFunction.new("plainto_tsquery", [Arel::Nodes::SqlLiteral.new("'simple'"), arel_search_value(value)])
+        where(Arel::Nodes::InfixOperation.new("@@", arel_table[:value], plainto_tsquery))
+      end
     }
 
-    scope :select_similarity_rank, ->(value, *selects, rank_alias: nil) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-
-      rank_alias ||= "similarity_rank"
+    scope :select_similarity_rank, ->(value, *selects) {
+      similarity = Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], arel_search_value(value)])
       selects << Arel.star if selects.blank?
-      selects << Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], value]).as(rank_alias)
-      select(*selects).order("#{rank_alias} desc")
+      selects << similarity.as("search_rank")
+      select(*selects).order("search_rank desc")
+    }
+
+    scope :similarity_search, ->(value) {
+      if value.blank?
+        all
+      else
+        where Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], arel_search_value(value)]).gt(0)
+      end
+    }
+
+    scope :combined_search, ->(value) {
+      subquery = <<~SQL
+        (
+          #{select_full_text_search_rank(value).full_text_search(value).except(:order).to_sql}
+          UNION ALL
+          #{select_similarity_rank(value).similarity_search(value).except(:order).to_sql}
+        ) AS #{table_name}
+      SQL
+      from(subquery).order("search_rank desc")
     }
 
-    scope :similar, ->(value, range: 0.01) {
-      value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
-      value = Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value.to_s]))
-      where Arel::Nodes::NamedFunction.new("similarity", [arel_table[:words], value]).gteq(range)
+    scope :polysearch, ->(value) {
+      if value.blank?
+        all
+      else
+        full_text_search(value).exists? ?
+          select_full_text_search_rank(value).full_text_search(value) :
+          select_similarity_rank(value).similarity_search(value)
+      end
     }
 
     # additional config (i.e. accepts_nested_attribute_for etc...) ..............
@@ -74,6 +92,10 @@ module Polysearch
 
     # class methods .............................................................
     class << self
+      def arel_search_value(value)
+        value = value.to_s.gsub(/\W/, " ").squeeze(" ").downcase.strip
+        Arel::Nodes::SqlLiteral.new(sanitize_sql_array(["?", value]))
+      end
     end
 
     # public instance methods ...................................................

data/bin/loc

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+cloc --exclude-dir=test --include-ext=rb .

data/lib/polysearch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polysearch
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polysearch
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Nathan Hopkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-20 00:00:00.000000000 Z
+date: 2021-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -95,6 +95,7 @@ files:
 - app/models/concerns/searchable.rb
 - app/models/record.rb
 - bin/console
+- bin/loc
 - bin/setup
 - bin/standardize
 - lib/generators/polysearch/migration_generator.rb