activekit 0.5.0.dev7 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e3830a0b0d888ffcd7a7f921b282fbf27dc0f2bdde5322772a71ed04755add3
-  data.tar.gz: abb0bbead8a270129c04dfb0998e15999df84a6daeb7c28a3237dac161211f43
+  metadata.gz: 71b9eb7bd5fc27d2794cd15b8ec08a68e9baae06e37e072188260ddbaaa25473
+  data.tar.gz: 33f906a96b417c86b8048a2f663dbac5d4a6b0595f9cea23b6a0db92f98982cb
 SHA512:
-  metadata.gz: a2f82ef282ec1226ac39d8ac42993f5ed621ea89407c22ebd6a0850d40157f32e20be968a946899c833bb041b2fe258914c64247c7746a968709f17da88db6af
-  data.tar.gz: baea0b85ab9b4adbd8e3c1f1eb1e37d62c673b83fc4858233a96cee9b7721a37f7985479a66a0848b16db33137dda1a48553a5d275da5ab0241aa85eee84ebd3
+  metadata.gz: 5172f9cb6b0aa0623a9e6f9a0263de7a5fadc016a25c6b92514f9916fca13653f8326479f4bc7fa8c54314c77c8d9d75435034b3c0e1e40054f7f002bf969d90
+  data.tar.gz: 65cb7a16747fb2281042dced7e1781bf0709437c470e8621b7ee232b6b205ab1ad021d8b1287a147abba85ddb96fe4f020e1ebb455b00a532d45488fbdf6d47f

data/README.md

@@ -3,6 +3,46 @@ Add the essential kit for rails ActiveRecord models and be happy.
 
 ## Usage
 
+### Search Attribute
+
+Add searching to your ActiveRecord models.
+Search Attribute provides full searching functionality for your model database records using redis search including search suggestions.
+
+You can define any number of model attributes in one model to search together.
+
+Define the search attributes in accordance with the column name in your model like below.
+```ruby
+class Product < ApplicationRecord
+  search_attribute :name, type: :text
+  search_attribute :permalink, type: :tag
+  search_attribute :short_description, type: :text
+  search_attribute :published, type: :tag, sortable: true
+end
+```
+
+You can also define a search_describer to describe the details of the search instead of using the defaults.
+```ruby
+class Product < ApplicationRecord
+  # search_describer method_name, database: -> { ActiveRecord::Base.connection_db_config.database }
+  search_describer :limit_by_search, database: -> { System::Current.tenant.database }
+  search_attribute :name, type: :text
+  search_attribute :permalink, type: :tag
+  search_attribute :short_description, type: :text
+  search_attribute :published, type: :tag, sortable: true
+end
+```
+
+The following class methods will be added to your model class to use in accordance with details provided for search_describer:
+```ruby
+Product.limit_by_search(term: "term", tags: { published: true }, order: "name asc", page: 1)
+Product.searcher.for(:limit_by_search).current_page
+Product.searcher.for(:limit_by_search).previous_page?
+Product.searcher.for(:limit_by_search).previous_page
+Product.searcher.for(:limit_by_search).next_page?
+Product.searcher.for(:limit_by_search).next_page
+Product.searcher.for(:limit_by_search).suggestions(prefix: "prefix_term").keys
+```
+
 ### Export Attribute
 
 Add exporting to your ActiveRecord models.
@@ -23,8 +63,8 @@ end
 You can also define an export_describer to describe the details of the export instead of using the defaults.
 ```ruby
 class Product < ApplicationRecord
-  # export_describer method_name, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym }
-  export_describer :to_csv, kind: :csv, database: -> { System::Current.tenant.database.to_sym }
+  # export_describer method_name, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database }
+  export_describer :to_csv, kind: :csv, database: -> { System::Current.tenant.database }
   export_attribute :name
   export_attribute :sku, heading: "SKU No."
   export_attribute :image_name, value: lambda { |record| record.image&.name }, includes: :image

data/lib/active_kit/bedrock/bedrockable.rb

@@ -0,0 +1,29 @@
+require 'active_support/concern'
+
+module ActiveKit
+  module Bedrock
+    module Bedrockable
+      def self.extended(base)
+        current_component = base.name.deconstantize.demodulize.downcase
+
+        base.module_eval <<-CODE, __FILE__, __LINE__ + 1
+          module ClassMethods
+            def #{current_component}er
+              @#{current_component}er ||= ActiveKit::#{current_component.to_s.titleize}::#{current_component.to_s.titleize}er.new(current_component: :#{current_component}, current_class: self)
+            end
+
+            private
+
+            def #{current_component}_describer(name, **options)
+              #{current_component}er.create_describer(name, options)
+            end
+
+            def #{current_component}_attribute(name, **options)
+              #{current_component}er.create_attribute(name, options)
+            end
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/active_kit/bedrock/bedrocker.rb

@@ -0,0 +1,148 @@
+module ActiveKit
+  module Bedrock
+    class Bedrocker
+      def initialize(current_component:, current_class:)
+        @current_component = current_component
+        @current_class = current_class
+        @describers = {}
+      end
+
+      def create_describer(name, options)
+        name = name.to_sym
+        options.deep_symbolize_keys!
+
+        unless find_describer_by(name: name)
+          options.store(:attributes, {})
+          @describers.store(name, options)
+          @current_class.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def self.#{name}(**params)
+              #{@current_component}er.run_describer_method("#{name}", params)
+            end
+          CODE
+        end
+      end
+
+      def create_attribute(name, options)
+        options.deep_symbolize_keys!
+
+        create_default_describer unless @describers.present?
+
+        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
+
+        describer_names
+      end
+
+      def run_describer_method(describer_name, params)
+        raise "Could not find describer while creating describer method." unless describer = find_describer_by(name: describer_name.to_sym)
+        describer_method(describer, params)
+      end
+
+      def describer_method(describer, params)
+        raise NotImplementedError
+      end
+
+      def for(describer_name)
+        describer_name = @describers.keys[0] if describer_name.nil?
+        raise "Could not find any describer name in #{@current_class.name}." if describer_name.blank?
+
+        describer_name = describer_name.to_sym
+        raise "Could not find describer '#{describer_name}' in #{@current_class.name}." unless @describers.dig(describer_name)
+        componenting = @describers.dig(describer_name, :componenting)
+        return componenting if componenting
+
+        @describers[describer_name][:componenting] = "ActiveKit::#{@current_component.to_s.titleize}::#{@current_component.to_s.titleize}ing".constantize.new(describer: find_describer_by(name: describer_name), current_class: @current_class)
+        @describers[describer_name][:componenting]
+      end
+
+      def get_describer_names
+        @describers.keys.map(&:to_s)
+      end
+
+      private
+
+      def create_default_describer
+        case @current_component
+        when :export
+          create_describer(:to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database })
+        when :search
+          create_describer(:limit_by_search, database: -> { ActiveRecord::Base.connection_db_config.database })
+        end
+      end
+
+      def find_describer_by(name:)
+        options = @describers.dig(name)
+        return nil unless options.present?
+
+        hash = {
+          name: name,
+          database: options[:database],
+          attributes: options[:attributes]
+        }
+
+        if @current_component == :export
+          hash.merge!(kind: options[:kind])
+          hash.merge!(includes: options[:attributes].values.map { |options| options.dig(:includes) }.compact.flatten(1).uniq)
+          hash.merge!(fields: build_describer_fields(options[:attributes]))
+        end
+        OpenStruct.new(hash)
+      end
+
+      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/bedrock/bedrocking.rb

@@ -0,0 +1,10 @@
+module ActiveKit
+  module Bedrock
+    class Bedrocking
+      def initialize(describer:, current_class:)
+        @describer = describer
+        @current_class = current_class
+      end
+    end
+  end
+end

data/lib/active_kit/bedrock.rb

@@ -0,0 +1,8 @@
+module ActiveKit
+  module Bedrock
+    extend ActiveSupport::Autoload
+
+    autoload :Bedrocker
+    autoload :Bedrocking
+  end
+end

data/lib/active_kit/engine.rb

@@ -10,12 +10,15 @@ module ActiveKit
     end
 
     initializer "active_kit.activekitable" do
+      require "active_kit/bedrock/bedrockable"
       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

@@ -3,48 +3,13 @@ require 'active_support/concern'
 module ActiveKit
   module Export
     module Exportable
+      extend Bedrock::Bedrockable
       extend ActiveSupport::Concern
 
       included do
       end
 
       class_methods do
-        def exporter
-          @exporter ||= ActiveKit::Export::Exporter.new(current_class: self)
-        end
-
-        def export_describer(name, **options)
-          exporter.create_describer(name, options)
-        end
-
-        def export_attribute(name, **options)
-          exporter.create_attribute(name, options)
-        end
-
-        def export_describer_method(describer)
-          case describer.kind
-          when :csv
-            # 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

data/lib/active_kit/export/exporter.rb

@@ -1,113 +1,30 @@
 module ActiveKit
   module Export
-    class Exporter
-      def initialize(current_class:)
-        @current_class = current_class
-        @describers = {}
-      end
-
-      def create_describer(name, options)
-        name = name.to_sym
-        options.deep_symbolize_keys!
-
-        unless find_describer_by(describer_name: name)
-          options.store(:attributes, {})
-          @describers.store(name, options)
-          @current_class.class_eval do
-            define_singleton_method name do
-              if describer = exporter.find_describer_by(describer_name: name)
-                export_describer_method(describer)
-              end
-            end
-          end
-        end
-      end
-
-      def create_attribute(name, options)
-        options.deep_symbolize_keys!
-
-        create_describer(:to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym }) unless @describers.present?
-
-        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 find_describer_by(name:)
-        options = @describers.dig(name)
-        return nil unless options.present?
-
-        hash = {
-          name: name,
-          kind: options[:kind],
-          database: options[:database],
-          attributes: options[:attributes],
-          includes: options[:attributes].values.map { |options| options.dig(:includes) }.compact.flatten(1).uniq,
-          fields: build_describer_fields(options[:attributes])
-        }
-        OpenStruct.new(hash)
-      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)
+    class Exporter < Bedrock::Bedrocker
+      def describer_method(describer, params)
+        case describer.kind
+        when :csv
+          # The 'all' relation must be captured outside the Enumerator,
+          # else it will get reset to all the records of the class.
+          all_activerecord_relation = @current_class.all.includes(describer.includes)
+
+          Enumerator.new do |yielder|
+            ActiveRecord::Base.connected_to(role: :writing, shard: describer.database.call.to_sym) do
+              exporting = self.for(describer.name)
+
+              # 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
-
-              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/export/exporting.rb

@@ -1,11 +1,6 @@
 module ActiveKit
   module Export
-    class Exporting
-
-      def initialize(describer:)
-        @describer = describer
-      end
-
+    class Exporting < Bedrock::Bedrocking
       def headings
         @headings ||= @describer.fields.keys.flatten
       end

data/lib/active_kit/search/index.rb

@@ -0,0 +1,183 @@
+module ActiveKit
+  module Search
+    class Index
+      attr_reader :prefix, :schema, :attribute_value_parser
+
+      def initialize(current_class:, describer:)
+        @redis = ActiveKit::Search.redis
+        @current_class = current_class
+        @describer = describer
+
+        current_class_name = current_class.to_s.parameterize.pluralize
+        describer_name = describer.name.to_s
+        @name = "activekit:search:index:#{current_class_name}:#{describer_name}"
+        @prefix = "activekit:search:#{current_class_name}:#{describer_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(@describer.database.call, 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,45 @@
+module ActiveKit
+  module Search
+    class Key
+      def initialize(index:, describer:)
+        @redis = ActiveKit::Search.redis
+        @index = index
+        @describer = describer
+      end
+
+      def reload(record:)
+        clear(record: record)
+
+        hash_key = key(record: record)
+        hash_value = { "database" => @describer.database.call, "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}:#{@describer.database.call}:#{record.id}"
+      end
+    end
+  end
+end

data/lib/active_kit/search/manager.rb

@@ -0,0 +1,44 @@
+module ActiveKit
+  module Search
+    class Manager
+      def initialize(given_class:, given_describer:)
+        @given_class = given_class
+        @given_describer = given_describer
+
+        Rails.application.eager_load!
+      end
+
+      def reload
+        task(name: :reload, log_name: "Reloading")
+      end
+
+      def clear
+        task(name: :clear, log_name: "Clearing")
+      end
+
+      def drop
+        task(name: :drop, log_name: "Dropping")
+      end
+
+      private
+
+      def task(name:, log_name: "Reloading")
+        models = @given_class.present? ? [@given_class] : ActiveRecord::Base.descendants.collect(&:name)
+        # Removing these models for efficiency as they will never contain searcher.
+        models -= ["ApplicationRecord", "ActionText::Record", "ActionText::RichText", "ActiveKit::ApplicationRecord", "ActionMailbox::Record", "ActionMailbox::InboundEmail", "ActiveStorage::Record", "ActiveStorage::Blob", "ActiveStorage::VariantRecord", "ActiveStorage::Attachment"]
+        models.each do |model|
+          model_const = model.constantize
+          if model_const.try(:searcher)
+            describer_names = @given_describer.present? ? [@given_describer] : model_const.searcher.get_describer_names
+            describer_names.each do |describer_name|
+              if model_const.searcher.for(describer_name).attributes_present?
+                puts "ActiveKit::Search | #{log_name}: #{model}"
+                model_const.searcher.for(describer_name).public_send(name)
+              end
+            end
+          end
+        end
+      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,16 @@
+require 'active_support/concern'
+
+module ActiveKit
+  module Search
+    module Searchable
+      extend Bedrock::Bedrockable
+      extend ActiveSupport::Concern
+
+      included do
+      end
+
+      class_methods do
+      end
+    end
+  end
+end

data/lib/active_kit/search/searcher.rb

@@ -0,0 +1,51 @@
+module ActiveKit
+  module Search
+    class Searcher < Bedrock::Bedrocker
+      def create_attribute(name, options)
+        describer_names = super
+
+        depends_on = options.delete(:depends_on) || {}
+        describer_names.each do |describer_name|
+          set_reload_callbacks(depends_on, describer_name)
+          self.for(describer_name).add_attribute(name: name, options: options.deep_dup)
+        end
+      end
+
+      def describer_method(describer, params)
+        params[:page] = 1 if params.key?(:page) && params[:page].blank?
+        self.for(describer.name).fetch(term: params.delete(:term), **params).records
+      end
+
+      private
+
+      # Set callbacks for current class and depending classes.
+      def set_reload_callbacks(depends_on, describer_name)
+        @current_class.class_eval do
+          unless searcher.for(describer_name).attributes_present?
+            after_commit do
+              self.class.searcher.for(describer_name).reload(record: self)
+              logger.info "ActiveKit::Search | Indexing from #{self.class.name}: Done."
+            end
+          end
+
+          unless depends_on.empty?
+            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.for(describer_name).reload(record: instance) }
+                  else
+                    inverse_assoc.class.searcher.for(describer_name).reload(record: inverse_assoc)
+                  end
+                  logger.info "ActiveKit::Search | Indexing from #{self.class.name}: Done."
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_kit/search/searching.rb

@@ -0,0 +1,68 @@
+module ActiveKit
+  module Search
+    class Searching < Bedrock::Bedrocking
+      attr_reader :current_page, :previous_page, :next_page
+
+      def initialize(describer:, current_class:)
+        super
+
+        @index = Index.new(current_class: @current_class, describer: describer)
+        @key = Key.new(index: @index, describer: describer)
+        @suggestion = Suggestion.new(current_class: @current_class, describer: describer)
+      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/suggestion.rb

@@ -0,0 +1,41 @@
+module ActiveKit
+  module Search
+    class Suggestion
+      def initialize(current_class:, describer:)
+        @redis = ActiveKit::Search.redis
+        @current_class = current_class
+        @describer = describer
+        @current_class_name = current_class.to_s.parameterize.pluralize
+        @describer_name = describer.name.to_s
+      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}:#{@describer_name}:#{@describer.database.call}"
+      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,16 @@
+module ActiveKit
+  module Search
+    extend ActiveSupport::Autoload
+
+    autoload :Index
+    autoload :Key
+    autoload :Manager
+    autoload :SearchResult
+    autoload :Searcher
+    autoload :Searching
+    autoload :Suggestion
+    autoload :SuggestionResult
+
+    mattr_accessor :redis, instance_accessor: false
+  end
+end

data/lib/active_kit/version.rb

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

data/lib/active_kit.rb

@@ -4,6 +4,8 @@ require "active_kit/engine"
 module ActiveKit
   extend ActiveSupport::Autoload
 
+  autoload :Bedrock
   autoload :Export
   autoload :Position
+  autoload :Search
 end

data/lib/tasks/search_tasks.rake

@@ -0,0 +1,21 @@
+namespace :active_kit do
+  namespace :search do
+    desc "bundle exec rails active_kit:search:reload CLASS='Article' DESCRIBER='limit_by_search'"
+    task :reload do
+      manager = ActiveKit::Search::Manager.new(given_class: ENV['CLASS'], given_describer: ENV['DESCRIBER'])
+      manager.reload
+    end
+
+    desc "bundle exec rails active_kit:search:clear CLASS='Article' DESCRIBER='limit_by_search'"
+    task :clear do
+      manager = ActiveKit::Search::Manager.new(given_class: ENV['CLASS'], given_describer: ENV['DESCRIBER'])
+      manager.clear
+    end
+
+    desc "bundle exec rails active_kit:search:drop CLASS='Article' DESCRIBER='limit_by_search'"
+    task :drop do
+      manager = ActiveKit::Search::Manager.new(given_class: ENV['CLASS'], given_describer: ENV['DESCRIBER'])
+      manager.drop
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activekit
 version: !ruby/object:Gem::Version
-  version: 0.5.0.dev7
+  version: 0.5.0
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-22 00:00:00.000000000 Z
+date: 2024-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -50,8 +50,10 @@ files:
 - app/views/layouts/active_kit/application.html.erb
 - config/routes.rb
 - lib/active_kit.rb
-- lib/active_kit/base/baseable.rb
-- lib/active_kit/base/baser.rb
+- lib/active_kit/bedrock.rb
+- lib/active_kit/bedrock/bedrockable.rb
+- lib/active_kit/bedrock/bedrocker.rb
+- lib/active_kit/bedrock/bedrocking.rb
 - lib/active_kit/engine.rb
 - lib/active_kit/export.rb
 - lib/active_kit/export/exportable.rb
@@ -63,9 +65,20 @@ 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/manager.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
+- lib/tasks/search_tasks.rake
 homepage: https://github.com/plainsource/activekit
 licenses:
 - MIT
@@ -82,9 +95,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.2
 signing_key: 

data/lib/active_kit/base/baseable.rb

@@ -1,39 +0,0 @@
-require 'active_support/concern'
-
-module ActiveKit
-  module Base
-    module Baseable
-      extend ActiveSupport::Concern
-
-      included do
-      end
-
-      class_methods do
-        def define_activekit_describer(baser, name, options)
-          name = name.to_sym
-          options.deep_symbolize_keys!
-
-          unless baser.find_describer_by(describer_name: name)
-            baser.new_describer(name: name, options: options)
-
-            define_singleton_method name do
-              describer = baser.find_describer_by(describer_name: name)
-              raise "could not find describer for the describer name '#{name}'" unless describer.present?
-
-              yield(describer) if block_given?
-            end
-          end
-        end
-
-        def define_activekit_attribute(baser, name, options)
-          define_activekit_describer(baser, :to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym }) unless baser.describers?
-
-          options.deep_symbolize_keys!
-          baser.new_attribute(name: name.to_sym, options: options)
-
-          yield if block_given?
-        end        
-      end
-    end
-  end
-end

data/lib/active_kit/base/baser.rb

@@ -1,27 +0,0 @@
-module ActiveKit
-  module Base
-    module Baser
-      attr_reader :describers
-
-      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
-    end
-  end
-end