full_search 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a18ce04c25c9a2670d1ad9394594a277b78201e74e11585c63e1848d6d6cf343
-  data.tar.gz: 4d170670fd73af2e350ee427fce766658769612ea592772b29089ac395bc7b0c
+  metadata.gz: 025c498951cfbd1e531bb07c3994af9b195bf0411bfe65b65ff96aacedbc157a
+  data.tar.gz: f1c0d8eb49892d94f567ab162e8c94576b8f574848077d95d5942236d51b215a
 SHA512:
-  metadata.gz: d0276bef97a441548574747ddd7aeb67609b390bad8a8864618231cfac30d41f24e2d01cb55205b070d5c0f2249afbf4b7f0b133d51acb396e2a61a528923b18
-  data.tar.gz: 6e7808b9b6f3e8ccb8e3964c3494f42336c18975f6c79c335a397927aaf6ef3d920f84dd5548000182ddac652b376f71c1751c090f0c65191ccb62e4627dd5a7
+  metadata.gz: d3ea481bc2b665046432f415a6e892b4735b1aedee46716ac271b51cb873c490b002280000b02a92ba3369b8e3c6a27b98d8da18b876b4269a6a516cc51262b4
+  data.tar.gz: 93e2ed7136f1b20d7bb7025891d29c015b61db0d427c527eb4345e6bfd94ec0968562aba8528590737d89cbad2988c4d029ad114f3f18e6467d5a19f3ff8c4b2

data/lib/full_search/dsl.rb

@@ -2,17 +2,19 @@
 
 module FullSearch
   class Dsl
-    attr_reader :fields, :exact_matches, :filters, :model_class, :tokenize, :highlight_config
+    attr_reader :fields, :exact_matches, :filters, :model_class, :tokenize, :highlight_config, :rank_bys
 
     Field = Data.define(:name, :weight, :source, :reindex_on, :async)
     ExactMatch = Data.define(:name, :source)
     Filter = Data.define(:name, :required)
+    RankBy = Data.define(:column, :direction)
 
     def initialize(model_class)
       @model_class = model_class
       @fields = []
       @exact_matches = []
       @filters = []
+      @rank_bys = []
       @tokenize = FullSearch.config.default_tokenizer
       @soft_delete_column = nil
     end
@@ -31,6 +33,13 @@ module FullSearch
       @exact_matches << ExactMatch.new(name: name.to_s, source: source)
     end
 
+    def rank_by(column, direction = :desc)
+      unless valid_name?(column)
+        raise InvalidFieldError, "Invalid rank_by column: #{column.inspect}"
+      end
+      @rank_bys << RankBy.new(column: column.to_s, direction: direction.to_sym)
+    end
+
     def filter(name, required: false)
       unless valid_name?(name)
         raise InvalidFieldError, "Invalid filter name: #{name.inspect}"
@@ -81,7 +90,8 @@ module FullSearch
         typo_tolerance_min_term_length,
         fields.map { |f| [f.name, f.weight, f.source.nil? ? "column" : "source", f.reindex_on, f.async] },
         exact_matches.map { |e| [e.name] },
-        filters.map { |f| [f.name, f.required] }
+        filters.map { |f| [f.name, f.required] },
+        rank_bys.map { |r| [r.column, r.direction] }
       ].inspect)
     end
 

data/lib/full_search/highlighter.rb

@@ -3,19 +3,55 @@
 module FullSearch
   class Highlighter
     def self.apply!(records, model, query)
+      snippets = build_snippets(model, query)
+      records.each { |record| record.full_search_snippet = snippets[record.id] }
+      records
+    end
+
+    def self.apply_fields!(records, model, query)
+      fields = build_field_snippets(model, query)
+      records.each { |record| record.full_search_highlight_fields = fields[record.id] || {} }
+      records
+    end
+
+    private
+
+    def self.build_snippets(model, query)
+      rows = highlight_rows(model, query)
+      cols = model.full_search_dsl.fields.map(&:name)
+
+      rows.to_h do |row|
+        text = cols.map { |col| row["#{col}_snippet"] }.compact.join(" ").strip
+        [row["rowid"], text.presence]
+      end
+    end
+
+    def self.build_field_snippets(model, query)
+      rows = highlight_rows(model, query)
       dsl = model.full_search_dsl
-      config = dsl.highlight_config
-      return records unless config
+      cols = dsl.fields.map(&:name)
+      open_tag = (dsl.highlight_config || { open_tag: "<mark>" })[:open_tag]
 
+      rows.to_h do |row|
+        snippets = cols.each_with_object({}) do |col, hash|
+          snippet = row["#{col}_snippet"].to_s.strip
+          hash[col.to_s] = snippet if snippet.include?(open_tag)
+        end
+        [row["rowid"], snippets]
+      end
+    end
+
+    def self.highlight_rows(model, query)
+      dsl = model.full_search_dsl
+      config = dsl.highlight_config || { open_tag: "<mark>", close_tag: "</mark>" }
       match_expr = QueryParser.to_match_expression(QueryParser.parse(query))
-      return records if match_expr.empty?
+      return [] if match_expr.empty?
 
       table = FullSearch::Index.fts_table_name(model)
+      cols = dsl.fields.map(&:name)
+      return [] if cols.empty?
 
-      content_cols = dsl.fields.map(&:name)
-      return records if content_cols.empty?
-
-      highlight_parts = content_cols.each_with_index.map do |col, idx|
+      highlight_parts = cols.each_with_index.map do |col, idx|
         "highlight(#{table}, #{idx}, #{quote(config[:open_tag])}, #{quote(config[:close_tag])}) AS #{col}_snippet"
       end.join(", ")
 
@@ -25,21 +61,9 @@ module FullSearch
         WHERE #{table} MATCH #{quote(match_expr)}
       SQL
 
-      rows = connection.execute(sql)
-
-      snippets = rows.map do |r|
-        [r["rowid"], content_cols.map { |col| r["#{col}_snippet"] }.compact.join(" ").strip]
-      end.to_h
-
-      records.each do |record|
-        record.full_search_snippet = snippets[record.id]
-      end
-
-      records
+      connection.execute(sql)
     end
 
-    private
-
     def self.connection
       ActiveRecord::Base.connection
     end

data/lib/full_search/model.rb

@@ -5,7 +5,7 @@ module FullSearch
     extend ActiveSupport::Concern
 
     class_methods do
-      def full_search(query_or_options = nil, filters: {}, include_soft_deleted: false, limit: nil, offset: nil, highlight: false, &block)
+      def full_search(query_or_options = nil, filters: {}, include_soft_deleted: false, limit: nil, offset: nil, highlight: false, highlight_fields: false, &block)
         if block_given? || query_or_options.is_a?(Hash)
           @full_search_dsl ||= FullSearch::Dsl.new(self)
           @full_search_dsl.tokenize(query_or_options[:tokenize]) if query_or_options.is_a?(Hash) && query_or_options.key?(:tokenize)
@@ -16,7 +16,7 @@ module FullSearch
           FullSearch.models << self unless FullSearch.models.include?(self)
           @full_search_dsl
         else
-          FullSearch::Search.new(self, query_or_options, filters: filters, include_soft_deleted: include_soft_deleted, limit: limit, offset: offset, highlight: highlight).relation
+          FullSearch::Search.new(self, query_or_options, filters: filters, include_soft_deleted: include_soft_deleted, limit: limit, offset: offset, highlight: highlight, highlight_fields: highlight_fields).relation
         end
       end
 
@@ -30,7 +30,7 @@ module FullSearch
     end
 
     module InstanceMethods
-      attr_accessor :full_search_snippet
+      attr_accessor :full_search_snippet, :full_search_highlight_fields
 
       def full_search_text_for(field_name)
         dsl = self.class.full_search_dsl

data/lib/full_search/multi_search.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module FullSearch
+  class MultiSearch
+    def self.call(query:, groups:)
+      new(query: query, groups: groups).call
+    end
+
+    def initialize(query:, groups:)
+      @query = query.to_s.strip
+      @groups = groups
+    end
+
+    def call
+      searched = groups.map do |group|
+        model = fetch(group, :model)
+        filters = group[:filters] || {}
+        limit = positive_integer(group[:limit], 8)
+        offset = positive_integer(group[:offset], 0)
+        raw_limit = limit + 1
+
+        relation = model.full_search(
+          query,
+          filters: filters,
+          limit: raw_limit,
+          offset: offset,
+          highlight_fields: group[:highlight_fields]
+        )
+
+        relation = group[:scope].call(relation) if group[:scope]
+
+        records = relation.to_a
+        has_more = records.size > limit
+        records = records.first(limit) if has_more
+
+        group.slice(:key, :label, :icon, :model).merge(
+          results: records,
+          has_more: has_more,
+          total_count: records.size
+        )
+      end
+
+      { groups: searched, total_count: searched.sum { |g| g[:total_count] } }
+    end
+
+    private
+
+    attr_reader :query, :groups
+
+    def fetch(group, key)
+      group.fetch(key) { fail ArgumentError, "Missing group key: #{key}" }
+    end
+
+    def positive_integer(value, default)
+      value.to_i.positive? ? value.to_i : default
+    end
+  end
+
+  class << self
+    def multi_search(...)
+      MultiSearch.call(...)
+    end
+  end
+end

data/lib/full_search/search.rb

@@ -2,9 +2,9 @@
 
 module FullSearch
   class Search
-    attr_reader :model, :query, :filters, :include_soft_deleted, :limit, :offset, :highlight
+    attr_reader :model, :query, :filters, :include_soft_deleted, :limit, :offset, :highlight, :highlight_fields
 
-    def initialize(model, query, filters:, include_soft_deleted:, limit:, offset:, highlight: false)
+    def initialize(model, query, filters:, include_soft_deleted:, limit:, offset:, highlight: false, highlight_fields: false)
       @model = model
       @query = query.to_s.strip
       @filters = filters
@@ -12,6 +12,7 @@ module FullSearch
       @limit = limit
       @offset = offset
       @highlight = highlight
+      @highlight_fields = highlight_fields
     end
 
     def relation
@@ -30,11 +31,12 @@ module FullSearch
       rel = rel.limit(limit) if limit
       rel = rel.offset(offset) if offset
 
-      order_sql = case_clause(all_ids)
-      rel = rel.order(Arel.sql(order_sql))
+      rel = apply_ranking(rel, all_ids, exact_ids)
 
       if highlight
         Highlighter.apply!(rel.to_a, model, query)
+      elsif highlight_fields
+        Highlighter.apply_fields!(rel.to_a, model, query)
       else
         rel
       end
@@ -80,7 +82,11 @@ module FullSearch
       return [] if match_expr.empty?
 
       term = parsed.last rescue nil
-      return [] if term.nil? || term.length < dsl.typo_tolerance_min_term_length.to_i
+      return [] if term.nil?
+
+      if term.length < dsl.typo_tolerance_min_term_length.to_i
+        return like_prefix_ids(term)
+      end
 
       trigram_table = FullSearch::Index.trigram_table_name(model)
 
@@ -98,12 +104,57 @@ module FullSearch
       connection.execute("#{sql} #{filter_conditions}").map { |r| r["id"] }
     end
 
-    def bare_term?(parsed)
-      parsed.is_a?(Array) && parsed.size == 2 && parsed.first == :term
+    def like_prefix_ids(term)
+      column_fields = dsl.fields.select { |f| f.source.nil? }
+      return [] if column_fields.empty?
+
+      like_conditions = column_fields.map do |field|
+        "#{connection.quote_table_name(model.table_name)}.#{connection.quote_column_name(field.name)} LIKE #{connection.quote("#{term}%")}"
+      end.join(" OR ")
+
+      sql = <<~SQL
+        SELECT #{model.table_name}.id
+        FROM #{model.table_name}
+        WHERE (#{like_conditions})
+      SQL
+
+      filter_conditions = filters.map do |name, value|
+        "AND #{model.table_name}.#{name} = #{connection.quote(value)}"
+      end.join(" ")
+
+      connection.execute("#{sql} #{filter_conditions}").map { |r| r["id"] }
     end
 
-    def case_clause(ids)
-      "CASE id #{ids.map.with_index { |id, i| "WHEN #{id} THEN #{i}" }.join(" ")} END"
+    def apply_ranking(rel, all_ids, exact_ids)
+      return rel if all_ids.empty?
+
+      order_parts = []
+
+      if exact_ids.any?
+        order_parts << "CASE #{model.table_name}.id #{exact_ids.map { |id| "WHEN #{id} THEN 0" }.join(" ")} ELSE 1 END"
+      end
+
+      fts_table = FullSearch::Index.fts_table_name(model)
+      match_expr = QueryParser.to_match_expression(QueryParser.parse(query))
+
+      rank_subquery = <<~SQL
+        SELECT rowid, rank
+        FROM #{fts_table}
+        WHERE #{fts_table} MATCH #{connection.quote(match_expr)}
+      SQL
+
+      rel = rel
+        .select("#{model.table_name}.*, fts_rank.rank AS full_search_rank")
+        .joins("LEFT JOIN (#{rank_subquery}) AS fts_rank ON fts_rank.rowid = #{model.table_name}.id")
+
+      order_parts << "COALESCE(fts_rank.rank, 1)"
+
+      dsl.rank_bys.each do |rank_by|
+        col = "#{connection.quote_table_name(model.table_name)}.#{connection.quote_column_name(rank_by.column)}"
+        order_parts << "#{col} #{rank_by.direction.to_s.upcase} NULLS LAST"
+      end
+
+      rel.order(Arel.sql(order_parts.join(", ")))
     end
 
     def connection

data/lib/full_search/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FullSearch
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/full_search.rb

@@ -20,6 +20,7 @@ require "full_search/soft_delete"
 require "full_search/callbacks"
 require "full_search/reindex_job"
 require "full_search/test_helpers"
+require "full_search/multi_search"
 
 ActiveSupport.on_load(:active_record) do
   include FullSearch::Model

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: full_search
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Ben D'Angelo
@@ -108,6 +108,7 @@ files:
 - lib/full_search/highlighter.rb
 - lib/full_search/index.rb
 - lib/full_search/model.rb
+- lib/full_search/multi_search.rb
 - lib/full_search/query_parser.rb
 - lib/full_search/railtie.rb
 - lib/full_search/reindex_job.rb