activekit 0.4.0 → 0.5.0.dev1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2dffaf7d844bba5ea65c34b98f3872cf70cb44c76963fb0d7a96bb39df174acb
-  data.tar.gz: 5c64d866b07f8460145f0a8069ac316e96d9ee15985fcce13e9a598fd2f6dedc
+  metadata.gz: 20c474dd0fdd1ea839f9f6cb7a00e1c99c2f3f68aa40ae70fa273daf1bfa32a7
+  data.tar.gz: 318854b73241d7b45c6f123f91e78fd58dd394ff37383530579d48ae30083832
 SHA512:
-  metadata.gz: f704f847169d738fa9f708246661b1dfff4594349fd3c8297b9070542046684106b5f5a831505bc5160c544fcc79d13b2c2920520e5184191832f34ff3e62979
-  data.tar.gz: af2af6217c992fb16c4205b88e0172947b043c2f52c93f389570989444a4726aa0fa62392e7d27b4dc48450120cb943c0e7e38c9f4606a3719d0a868badc8608
+  metadata.gz: 3b6fc80b934fd2fdb7743cc72b45b18ee276cc129fd11731e5e10c2ab5b7acfda24d03b979b578f2e19bb054b5e357a3361688860bec9d0e3bb0d221229646e7
+  data.tar.gz: 9383e8c8deaf6a2e268cb8b7cf5a3c04204be745d7519b969d4bd151616266f915ac2f24543555a5d675fa409b979be03099026dda806669b200eed67a1b6af6

data/lib/active_kit/engine.rb

@@ -12,10 +12,12 @@ module ActiveKit
     initializer "active_kit.activekitable" do
       require "active_kit/export/exportable"
       require "active_kit/position/positionable"
+      require "active_kit/search/searchable"
 
       ActiveSupport.on_load(:active_record) do
         include ActiveKit::Export::Exportable
         include ActiveKit::Position::Positionable
+        include ActiveKit::Search::Searchable
       end
     end
   end

data/lib/active_kit/export/exportable.rb

@@ -19,7 +19,7 @@ module ActiveKit
 
           unless exporter.find_describer_by(describer_name: name)
             exporter.new_describer(name: name, options: options)
-            define_describer_method(kind: options[:kind], name: name)
+            define_export_describer_method(kind: options[:kind], name: name)
           end
         end
 
@@ -30,7 +30,7 @@ module ActiveKit
           exporter.new_attribute(name: name.to_sym, options: options)
         end
 
-        def define_describer_method(kind:, name:)
+        def define_export_describer_method(kind:, name:)
           case kind
           when :csv
             define_singleton_method name do

data/lib/active_kit/search/index.rb

@@ -0,0 +1,181 @@
+module ActiveKit
+  module Search
+    class Index
+      attr_reader :prefix, :schema, :attribute_value_parser
+
+      def initialize(current_class:)
+        @redis = ActiveKit::Search.redis
+        @current_class = current_class
+
+        current_class_name = current_class.to_s.parameterize.pluralize
+        @name = "activekit:search:index:#{current_class_name}"
+        @prefix = "activekit:search:#{current_class_name}"
+        @schema = {}
+        @attribute_value_parser = {}
+      end
+
+      def add_attribute_to_schema(name:, options:)
+        raise "Error: No type specified for the search attribute #{name}." unless options[:type].present?
+
+        attribute_schema = []
+
+        as = options.delete(:as)
+        attribute_schema.push("AS #{as}") unless as.nil?
+
+        type = options.delete(:type)
+        attribute_schema.push(type.to_s.upcase) unless type.nil?
+
+        options.each do |key, value|
+          if key == :value
+            @attribute_value_parser.store(name.to_s, value)
+          elsif key.is_a?(Symbol)
+            if value == true
+              attribute_schema.push(key.to_s.upcase)
+            elsif value != false
+              attribute_schema.push("#{key.to_s.upcase} #{value.to_s}")
+            end
+          else
+            raise "Invalid option provided to search attribute."
+          end
+        end
+
+        @schema.store(name.to_s, attribute_schema.join(" "))
+      end
+
+      def reload
+        current_command = @redis.get("#{@name}:command")
+        schema = { "database" => "TAG SORTABLE", "id" => "NUMERIC SORTABLE" }.merge(@schema)
+        command = "FT.CREATE #{@name} ON HASH PREFIX 1 #{@prefix}: SCHEMA #{schema.to_a.flatten.join(' ')}"
+        unless current_command == command
+          drop
+          @redis.call(command.split(' '))
+          @redis.set("#{@name}:command", command)
+          Rails.logger.info "ActiveKit::Search | Index Reloaded: " + "#{@name}:command"
+          Rails.logger.debug "=> " + @redis.get("#{@name}:command").to_s
+        end
+      end
+
+      def drop
+        if exists?
+          command = "FT.DROPINDEX #{@name}"
+          @redis.call(command.split(' '))
+          @redis.del("#{@name}:command")
+          Rails.logger.info "ActiveKit::Search | Index Dropped: " + @name
+        end
+      end
+
+      # Redis returns the results in the following form. Where first value is count of results, then every 2 elements are document_id, attributes respectively.
+      # [2, "doc:3", ["name", "Grape Juice", "stock_quantity", "4", "minimum_stock", "2"], "doc:4", ["name", "Apple Juice", "stock_quantity", "4", "minimum_stock", "2"]]
+      def fetch(term: nil, matching: "*", tags: {}, modifiers: {}, offset: nil, limit: nil, order: nil, page: nil, **options)
+        original_term = term
+
+        if term == ""
+          results = nil
+        elsif self.exists?
+          if term.present?
+            term.strip!
+            term = escape_separators(term)
+
+            case matching
+            when "*"
+              term = "#{term}*"
+            when "%"
+              term = "%#{term}%"
+            when "%%"
+              term = "%%#{term}%%"
+            when "%%%"
+              term = "%%%#{term}%%%"
+            end
+
+            term = " #{term}"
+          else
+            term = ""
+          end
+
+          if tags.present?
+            tags = tags.map do |key, value|
+              value = value.join("|") if value.is_a?(Array)
+              "@#{escape_separators(key)}:{#{escape_separators(value, include_space: true).presence || 'nil'}}"
+            end
+            tags = tags.join(" ")
+            tags = " #{tags}"
+          else
+            tags = ""
+          end
+
+          if modifiers.present?
+            modifiers = modifiers.map { |key, value| "@#{escape_separators(key)}:#{escape_separators(value)}" }.join(" ")
+            modifiers = " #{modifiers}"
+          else
+            modifiers = ""
+          end
+
+          if (offset.present? || limit.present?) && page.present?
+            raise "Error: Cannot specify page and offset/limit at the same time. Please specify one of either page or offset/limit."
+          end
+
+          if page.present?
+            page = page.to_i.abs
+
+            case page
+            when 0
+              page = 1
+              offset = 0
+              limit = 15
+            when 1
+              offset = 0
+              limit = 15
+            when 2
+              offset = 15
+              limit = 30
+            when 3
+              offset = 45
+              limit = 50
+            else
+              limit = 100
+              offset = 15 + 30 + 50 + (page - 4) * limit
+            end
+          end
+
+          query = "@database:{#{escape_separators(System::Current.tenant.database, include_space: true)}}#{term}#{tags}#{modifiers}"
+          command = [
+            "FT.SEARCH",
+            @name,
+            query,
+            "LIMIT",
+            offset ? offset.to_i : 0, # 0 is the default offset of redisearch in LIMIT 0 10. https://redis.io/commands/ft.search
+            limit ? limit.to_i : 10 # 10 is the default limit of redisearch in LIMIT 0 10. https://redis.io/commands/ft.search
+          ]
+          command.push("SORTBY", *order.split(' ')) if order.present?
+          results = @redis.call(command)
+          Rails.logger.info "ActiveKit::Search | Index Searched: " + command.to_s
+          Rails.logger.debug "=> " + results.to_s
+        else
+          results = nil
+        end
+
+        SearchResult.new(term: original_term, results: results, offset: offset, limit: limit, page: page, current_class: @current_class)
+      end
+
+      # List of characters from https://oss.redislabs.com/redisearch/Escaping/
+      # ,.<>{}[]"':;!@#$%^&*()-+=~
+      def escape_separators(value, include_space: false)
+        value = value.to_s
+
+        unless include_space
+          pattern = %r{(\'|\"|\.|\,|\;|\<|\>|\{|\}|\[|\]|\"|\'|\=|\~|\*|\:|\#|\+|\^|\$|\@|\%|\!|\&|\)|\(|/|\-|\\)}
+        else
+          pattern = %r{(\'|\"|\.|\,|\;|\<|\>|\{|\}|\[|\]|\"|\'|\=|\~|\*|\:|\#|\+|\^|\$|\@|\%|\!|\&|\)|\(|/|\-|\\|\s)}
+        end
+
+        value.gsub(pattern) { |match| '\\' + match }
+      end
+
+      private
+
+      def exists?
+        @redis.call("FT._LIST").include?(@name)
+      end
+    end
+  end
+end

data/lib/active_kit/search/key.rb

@@ -0,0 +1,44 @@
+module ActiveKit
+  module Search
+    class Key
+      def initialize(index:)
+        @redis = ActiveKit::Search.redis
+        @index = index
+      end
+
+      def reload(record:)
+        clear(record: record)
+
+        hash_key = key(record: record)
+        hash_value = { "database" => System::Current.tenant.database, "id" => record.id }
+        @index.schema.each do |field_name, field_value|
+          attribute_name = field_name
+          attribute_value = @index.attribute_value_parser[field_name]&.call(record) || record.public_send(field_name)
+          attribute_value = field_value.downcase.include?("tag") ? attribute_value : @index.escape_separators(attribute_value)
+          hash_value.store(attribute_name, attribute_value)
+        end
+        @redis.hset(hash_key, hash_value)
+        Rails.logger.info "ActiveKit::Search | Key Reloaded: " + hash_key
+        Rails.logger.debug "=> " + @redis.hgetall("#{hash_key}").to_s
+      end
+
+      def clear(record:)
+        hash_key = key(record: record)
+        drop(keys: hash_key)
+      end
+
+      def drop(keys:)
+        return unless keys.present?
+        if @redis.del(keys) > 0
+          Rails.logger.info "ActiveKit::Search | Keys Removed: " + keys.to_s
+        end
+      end
+
+      private
+
+      def key(record:)
+        "#{@index.prefix}:#{System::Current.tenant.database}:#{record.id}"
+      end
+    end
+  end
+end

data/lib/active_kit/search/search.rb

@@ -0,0 +1,68 @@
+module ActiveKit
+  module Search
+    class Search
+      attr_reader :current_page, :previous_page, :next_page
+
+      def initialize(current_class:)
+        @current_class = current_class
+
+        @index = Index.new(current_class: @current_class)
+        @key = Key.new(index: @index)
+        @suggestion = Suggestion.new(current_class: @current_class)
+      end
+
+      def reload(record: nil)
+        record ? @key.reload(record: record) : @current_class.all.each { |rec| @key.reload(record: rec) }
+        @index.reload
+      end
+
+      def clear(record: nil)
+        record ? @key.clear(record: record) : @current_class.all.each { |rec| @key.clear(record: rec) }
+        @index.reload
+      end
+
+      def fetch(**options)
+        search_result = @index.fetch(**options)
+
+        if search_result.keys.any?
+          @suggestion.add(term: search_result.term)
+        else
+          @suggestion.del(term: search_result.term)
+        end
+
+        @current_page = search_result.current_page
+        @previous_page = search_result.previous_page
+        @next_page = search_result.next_page
+
+        search_result
+      end
+
+      def suggestions(prefix:)
+        @suggestion.fetch(prefix: prefix)
+      end
+
+      def drop
+        total_count = @index.fetch(offset: 0, limit: 0).count
+        keys = @index.fetch(offset: 0, limit: total_count).keys
+        @key.drop(keys: keys)
+        @index.drop
+      end
+
+      def previous_page?
+        !!@previous_page
+      end
+
+      def next_page?
+        !!@next_page
+      end
+
+      def add_attribute(name:, options:)
+        @index.add_attribute_to_schema(name: name, options: options)
+      end
+
+      def attributes_present?
+        @index.schema.present?
+      end
+    end
+  end
+end

data/lib/active_kit/search/search_result.rb

@@ -0,0 +1,33 @@
+module ActiveKit
+  module Search
+    class SearchResult
+      attr_reader :term, :count, :documents, :keys, :ids, :records, :current_page, :previous_page, :next_page
+
+      def initialize(term:, results:, offset:, limit:, page:, current_class:)
+        @term = term
+
+        if results
+          @count = results.shift
+          @documents = results.each_slice(2).map { |key, attributes| [key, attributes.each_slice(2).to_h] }.to_h
+
+          if page.present?
+            @current_page = page
+            @previous_page = @current_page > 1 ? (@current_page - 1) : nil
+            @next_page = (offset + limit) < count ? (@current_page + 1) : nil
+          end
+        else
+          @count = 0
+          @documents = {}
+        end
+
+        @keys = @documents.keys
+        @ids = @documents.map { |key, value| key.split(":").last }
+
+        # Return records from database.
+        # This also ensures that any left over document_ids in redis that have been deleted in the database are left out of the results.
+        # This orders the records in the order of executed search.
+        @records = current_class.where(id: ids).reorder(Arel.sql("FIELD(#{current_class.table_name}.id, #{ids.join(', ')})"))
+      end
+    end
+  end
+end

data/lib/active_kit/search/searchable.rb

@@ -0,0 +1,126 @@
+require 'active_support/concern'
+
+module ActiveKit
+  module Search
+    module Searchable
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      class_methods do
+        def searcher
+          @searcher ||= ActiveKit::Search::Search.new(current_class: self)
+        end
+
+        def searching(term: nil, **options)
+          options[:page] = 1 if options.key?(:page) && options[:page].blank?
+          searcher.fetch(term: term, **options).records
+        end
+
+        def search_attribute(name, **options)
+          options.deep_symbolize_keys!
+
+          set_activekit_search_callbacks unless searcher.attributes_present?
+          depends_on = options.delete(:depends_on) || {}
+          set_activekit_search_depends_on_callbacks(depends_on: depends_on) unless depends_on.empty?
+
+          searcher.add_attribute(name: name, options: options)
+        end
+
+        def set_activekit_search_callbacks
+          after_commit do
+            self.class.searcher.reload(record: self)
+            logger.info "ActiveKit::Search | Indexing from #{self.class.name}: Done."
+          end
+        end
+
+        def set_activekit_search_depends_on_callbacks(depends_on:)
+          depends_on.each do |depends_on_association, depends_on_inverse|
+            klass = self.reflect_on_all_associations.map { |assoc| [assoc.name, assoc.klass.name] }.to_h[depends_on_association]
+            klass.constantize.class_eval do
+              after_commit do
+                inverse_assoc = self.public_send(depends_on_inverse)
+                if inverse_assoc.respond_to?(:each)
+                  inverse_assoc.each { |instance| instance.class.searcher.reload(record: instance) }
+                else
+                  inverse_assoc.class.searcher.reload(record: inverse_assoc)
+                end
+                logger.info "ActiveKit::Search | Indexing from #{self.class.name}: Done."
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+
+
+
+# require 'active_support/concern'
+
+# module ActiveKit
+#   module Search
+#     module Searchable
+#       extend ActiveSupport::Concern
+
+#       included do
+#       end
+
+#       class_methods do
+#         def searcher
+#           @searcher ||= ActiveKit::Search::Searcher.new(current_class: self)
+#         end
+
+#         def search_describer(name, **options)
+#           name = name.to_sym
+#           options.deep_symbolize_keys!
+
+#           unless searcher.find_describer_by(describer_name: name)
+#             searcher.new_describer(name: name, options: options)
+#             define_search_describer_method(kind: options[:kind], name: name)
+#           end
+#         end
+
+#         def search_attribute(name, **options)
+#           search_describer(:to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym }) unless searcher.describers?
+
+#           options.deep_symbolize_keys!
+#           searcher.new_attribute(name: name.to_sym, options: options)
+#         end
+
+#         def define_search_describer_method(kind:, name:)
+#           case kind
+#           when :csv
+#             define_singleton_method name do
+#               describer = exporter.find_describer_by(describer_name: name)
+#               raise "could not find describer for the describer name '#{name}'" unless describer.present?
+
+#               # The 'all' relation must be captured outside the Enumerator,
+#               # else it will get reset to all the records of the class.
+#               all_activerecord_relation = all.includes(describer.includes)
+
+#               Enumerator.new do |yielder|
+#                 ActiveRecord::Base.connected_to(role: :writing, shard: describer.database.call) do
+#                   exporting = exporter.new_exporting(describer: describer)
+
+#                   # Add the headings.
+#                   yielder << CSV.generate_line(exporting.headings) if exporting.headings?
+
+#                   # Add the values.
+#                   # find_each will ignore any order if set earlier.
+#                   all_activerecord_relation.find_each do |record|
+#                     lines = exporting.lines_for(record: record)
+#                     lines.each { |line| yielder << CSV.generate_line(line) }
+#                   end
+#                 end
+#               end
+#             end
+#           end
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/active_kit/search/searcher.rb

@@ -0,0 +1,106 @@
+# module ActiveKit
+#   module Search
+#     class Searcher
+#       attr_reader :describers
+
+#       def initialize(current_class:)
+#         @current_class = current_class
+#         @describers = {}
+#       end
+
+#       def find_describer_by(describer_name:)
+#         describer_options = @describers.dig(describer_name)
+#         return nil unless describer_options.present?
+
+#         describer_attributes = describer_options[:attributes]
+#         includes = describer_attributes.values.map { |options| options.dig(:includes) }.compact.flatten(1).uniq
+#         fields = build_describer_fields(describer_attributes)
+#         hash = {
+#           name: describer_name,
+#           kind: describer_options[:kind],
+#           database: describer_options[:database],
+#           attributes: describer_attributes,
+#           includes: includes,
+#           fields: fields
+#         }
+#         OpenStruct.new(hash)
+#       end
+
+#       def new_describer(name:, options:)
+#         options.store(:attributes, {})
+#         @describers.store(name, options)
+#       end
+
+#       def describers?
+#         @describers.present?
+#       end
+
+#       def new_attribute(name:, options:)
+#         describer_names = Array(options.delete(:describers))
+#         describer_names = @describers.keys if describer_names.blank?
+
+#         describer_names.each do |describer_name|
+#           if describer_options = @describers.dig(describer_name)
+#             describer_options[:attributes].store(name, options)
+#           end
+#         end
+#       end
+
+#       def new_exporting(describer:)
+#         Exporting.new(describer: describer)
+#       end
+
+#       private
+
+#       def build_describer_fields(describer_attributes)
+#         describer_attributes.inject({}) do |fields_hash, (name, options)|
+#           enclosed_attributes = Array(options.dig(:attributes))
+
+#           if enclosed_attributes.blank?
+#             field_key, field_value = (get_heading(options.dig(:heading))&.to_s || name.to_s.titleize), (options.dig(:value) || name)
+#           else
+#             field_key, field_value = get_nested_field(name, options, enclosed_attributes)
+#           end
+#           fields_hash.store(field_key, field_value)
+
+#           fields_hash
+#         end
+#       end
+
+#       def get_nested_field(name, options, enclosed_attributes, ancestor_heading = nil)
+#         parent_heading = ancestor_heading.present? ? ancestor_heading : ""
+#         parent_heading += (get_heading(options.dig(:heading))&.to_s || name.to_s.singularize.titleize) + " "
+#         parent_value = options.dig(:value) || name
+
+#         enclosed_attributes.inject([[], [parent_value]]) do |nested_field, enclosed_attribute|
+#           unless enclosed_attribute.is_a? Hash
+#             nested_field_key = parent_heading + enclosed_attribute.to_s.titleize
+#             nested_field_val = enclosed_attribute
+
+#             nested_field[0].push(nested_field_key)
+#             nested_field[1].push(nested_field_val)
+#           else
+#             enclosed_attribute.each do |enclosed_attribute_key, enclosed_attribute_value|
+#               wrapped_attributes = Array(enclosed_attribute_value.dig(:attributes))
+#               if wrapped_attributes.blank?
+#                 nested_field_key = parent_heading + (get_heading(enclosed_attribute_value.dig(:heading))&.to_s || enclosed_attribute_key.to_s.titleize)
+#                 nested_field_val = enclosed_attribute_value.dig(:value) || enclosed_attribute_key
+#               else
+#                 nested_field_key, nested_field_val = get_nested_field(enclosed_attribute_key, enclosed_attribute_value, wrapped_attributes, parent_heading)
+#               end
+
+#               nested_field[0].push(nested_field_key)
+#               nested_field[1].push(nested_field_val)
+#             end
+#           end
+
+#           nested_field
+#         end
+#       end
+
+#       def get_heading(options_heading)
+#         options_heading.is_a?(Proc) ? options_heading.call(@current_class) : options_heading
+#       end
+#     end
+#   end
+# end

data/lib/active_kit/search/searching.rb

@@ -0,0 +1,104 @@
+# module ActiveKit
+#   module Search
+#     class Searching
+
+#       def initialize(describer:)
+#         @describer = describer
+#       end
+
+#       def headings
+#         @headings ||= @describer.fields.keys.flatten
+#       end
+
+#       def headings?
+#         headings.present?
+#       end
+
+#       def lines_for(record:)
+#         row_counter, column_counter = 1, 0
+
+#         @describer.fields.inject([[]]) do |rows, (heading, value)|
+#           if value.is_a? Proc
+#             rows[0].push(value.call(record))
+#             column_counter += 1
+#           elsif value.is_a?(Symbol) || value.is_a?(String)
+#             rows[0].push(record.public_send(value))
+#             column_counter += 1
+#           elsif value.is_a? Array
+#             deeprows = get_deeprows(record, heading, value, column_counter)
+#             deeprows.each do |deeprow|
+#               rows[row_counter] = deeprow
+#               row_counter += 1
+#             end
+
+#             column_count = get_column_count_for(value)
+#             column_count.times { |i| rows[0].push(nil) }
+#             column_counter += column_count
+#           else
+#             raise "Could not identify '#{value}' for '#{heading}'."
+#           end
+
+#           rows
+#         end
+#       end
+
+#       private
+
+#       def get_deeprows(record, heading, value, column_counter)
+#         value_clone = value.clone
+#         assoc_value = value_clone.shift
+
+#         if assoc_value.is_a? Proc
+#           assoc_records = assoc_value.call(record)
+#         elsif assoc_value.is_a?(Symbol) || assoc_value.is_a?(String)
+#           assoc_records = record.public_send(assoc_value)
+#         else
+#           raise "Count not identity '#{assoc_value}' for '#{heading}'."
+#         end
+
+#         subrows = []
+#         assoc_records.each do |assoc_record|
+#           subrow, subrow_column_counter, deeprows = [], 0, []
+#           column_counter.times { |i| subrow.push(nil) }
+
+#           subrow = value_clone.inject(subrow) do |subrow, v|
+#             if v.is_a? Proc
+#               subrow.push(v.call(assoc_record))
+#               subrow_column_counter += 1
+#             elsif v.is_a?(Symbol) || v.is_a?(String)
+#               subrow.push(assoc_record.public_send(v))
+#               subrow_column_counter += 1
+#             elsif v.is_a? Array
+#               deeprows = get_deeprows(assoc_record, heading, v, (column_counter + subrow_column_counter))
+
+#               column_count = get_column_count_for(v)
+#               column_count.times { |i| subrow.push(nil) }
+#               subrow_column_counter += column_count
+#             end
+
+#             subrow
+#           end
+
+#           subrows.push(subrow)
+#           deeprows.each { |deeprow| subrows.push(deeprow) }
+#         end
+
+#         subrows
+#       end
+
+#       def get_column_count_for(value)
+#         count = 0
+
+#         value.each do |v|
+#           unless v.is_a? Array
+#             count += 1
+#           else
+#             count += get_column_count_for(v)
+#           end
+#         end
+
+#         count - 1
+#       end
+#     end
+#   end
+# end

data/lib/active_kit/search/suggestion.rb

@@ -0,0 +1,39 @@
+module ActiveKit
+  module Search
+    class Suggestion
+      def initialize(current_class:)
+        @redis = ActiveKit::Search.redis
+        @current_class = current_class
+        @current_class_name = current_class.to_s.parameterize.pluralize
+      end
+
+      def add(term:, score: 1, increment: true)
+        command = ["FT.SUGADD", key, term, score, (increment ? 'INCR' : '')]
+        @redis.call(command)
+      end
+
+      def fetch(prefix:)
+        command = ["FT.SUGGET", key, prefix, "FUZZY", "MAX", "10", "WITHSCORES"]
+        results = @redis.call(command)
+
+        SuggestionResult.new(prefix: prefix, results: results)
+      end
+
+      def del(term:)
+        command = ["FT.SUGDEL", key, term]
+        @redis.call(command)
+      end
+
+      def len
+        command = ["FT.SUGLEN", key]
+        @redis.call(command)
+      end
+
+      private
+
+      def key
+        "activekit:search:suggestions:#{@current_class_name}:#{System::Current.tenant.database}"
+      end
+    end
+  end
+end

data/lib/active_kit/search/suggestion_result.rb

@@ -0,0 +1,21 @@
+module ActiveKit
+  module Search
+    class SuggestionResult
+      attr_reader :prefix, :documents, :keys, :scores
+
+      def initialize(prefix:, results:)
+        @prefix = prefix
+
+        if results
+          @documents = results.each_slice(2).map { |key, value| [key, value] }.to_h
+          @keys = @documents.keys
+          @scores = @documents.values
+        else
+          @documents = {}
+          @keys = []
+          @scores = []
+        end
+      end
+    end
+  end
+end

data/lib/active_kit/search.rb

@@ -0,0 +1,10 @@
+module ActiveKit
+  module Search
+    extend ActiveSupport::Autoload
+
+    autoload :Searcher
+    autoload :Searching
+
+    mattr_accessor :redis, instance_accessor: false
+  end
+end

data/lib/active_kit/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.4.0'
+  VERSION = '0.5.0.dev1'
 end

data/lib/active_kit.rb

@@ -6,4 +6,5 @@ module ActiveKit
 
   autoload :Export
   autoload :Position
+  autoload :Search
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0.dev1
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-28 00:00:00.000000000 Z
+date: 2024-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -61,6 +61,16 @@ files:
 - lib/active_kit/position/positionable.rb
 - lib/active_kit/position/positioner.rb
 - lib/active_kit/position/positioning.rb
+- lib/active_kit/search.rb
+- lib/active_kit/search/index.rb
+- lib/active_kit/search/key.rb
+- lib/active_kit/search/search.rb
+- lib/active_kit/search/search_result.rb
+- lib/active_kit/search/searchable.rb
+- lib/active_kit/search/searcher.rb
+- lib/active_kit/search/searching.rb
+- lib/active_kit/search/suggestion.rb
+- lib/active_kit/search/suggestion_result.rb
 - lib/active_kit/version.rb
 - lib/activekit.rb
 - lib/tasks/active_kit_tasks.rake
@@ -80,9 +90,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.1.2
 signing_key: