activekit 0.5.0.dev8 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fe66b1b57a945fa39f8d3daad8daa1dd3d564d190fb302453e1e1d9b4bc64e8
-  data.tar.gz: '0026541966d64d4fb509ae32dbd69715cf86d8dd79abd51537aee335bb0da393'
+  metadata.gz: 8622adf4eedf9b9fa1b4f31b70e8f9fb588560248d25a2f2dd571bd6a49472e9
+  data.tar.gz: cc1adb9159fffe8865e7c907a684c22d991cccd5c3ff2e773e436c779eb8cb76
 SHA512:
-  metadata.gz: ebc4d83438c610266f4de8c72395199f71282f5e8b00cfdebcf9e532950094997f520b0dd3e65a85e05f5e62fae365e5eaebc770691c4fcb2131a0ce3225bbc1
-  data.tar.gz: bbb51f533e437c2de942dcc5a8d9120b3f1cf0317b138c0b924cd433a48bbe6c145b4c77e3eaf0160c2a37d47d0d35df07916a090fbd237bc4929c7de8b0d790
+  metadata.gz: 8be02259a5fa52ea71fed586d7843f0e42c9045f818ded4476746ab5e483ec4183132164eb112268dcf1a16d44b783b3a549071ad91acc6c500e45c1644a592e
+  data.tar.gz: 224b675066b9134bc3ca74f225e602fcc66eabeda580f07f7affa2538b22e0fc781ede082cccdea9bfa4b97d0088011d86949e5e80d7525dd02622722869d3fc

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

@@ -8,12 +8,12 @@ module ActiveKit
 
         base.module_eval <<-CODE, __FILE__, __LINE__ + 1
           module ClassMethods
-            private
-
             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
@@ -21,10 +21,6 @@ module ActiveKit
             def #{current_component}_attribute(name, **options)
               #{current_component}er.create_attribute(name, options)
             end
-
-            def #{current_component}_describer_method(describer)
-              raise NotImplementedError
-            end
           end
         CODE
       end

data/lib/active_kit/bedrock/bedrocker.rb

@@ -15,10 +15,8 @@ module ActiveKit
           options.store(:attributes, {})
           @describers.store(name, options)
           @current_class.class_eval <<-CODE, __FILE__, __LINE__ + 1
-            def self.#{name}
-              if describer = #{@current_component}er.find_describer_by(name: "#{name}".to_sym)
-                #{@current_component}_describer_method(describer)
-              end
+            def self.#{name}(**params)
+              #{@current_component}er.run_describer_method("#{name}", params)
             end
           CODE
         end
@@ -37,6 +35,45 @@ module ActiveKit
             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:)
@@ -57,8 +94,6 @@ module ActiveKit
         OpenStruct.new(hash)
       end
 
-      private
-
       def build_describer_fields(describer_attributes)
         describer_attributes.inject({}) do |fields_hash, (name, options)|
           enclosed_attributes = Array(options.dig(:attributes))
@@ -108,13 +143,6 @@ module ActiveKit
       def get_heading(options_heading)
         options_heading.is_a?(Proc) ? options_heading.call(@current_class) : options_heading
       end
-
-      def create_default_describer
-        case @current_component
-        when :export
-          create_describer(:to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym })
-        end
-      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

@@ -3,5 +3,6 @@ module ActiveKit
     extend ActiveSupport::Autoload
 
     autoload :Bedrocker
+    autoload :Bedrocking
   end
 end

data/lib/active_kit/export/exportable.rb

@@ -10,30 +10,6 @@ module ActiveKit
       end
 
       class_methods do
-        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,8 +1,29 @@
 module ActiveKit
   module Export
     class Exporter < Bedrock::Bedrocker
-      def new_exporting(describer:)
-        Exporting.new(describer: describer)
+      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
+            end
+          end
+        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

@@ -3,19 +3,21 @@ module ActiveKit
     class Index
       attr_reader :prefix, :schema, :attribute_value_parser
 
-      def initialize(current_class:)
+      def initialize(current_class:, describer:)
         @redis = ActiveKit::Search.redis
         @current_class = current_class
+        @describer = describer
 
         current_class_name = current_class.to_s.parameterize.pluralize
-        @name = "activekit:search:index:#{current_class_name}"
-        @prefix = "activekit:search:#{current_class_name}"
+        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?
+        raise "Error: No type specified for the search attribute '#{name}'." unless options[:type].present?
 
         attribute_schema = []
 
@@ -137,7 +139,7 @@ module ActiveKit
             end
           end
 
-          query = "@database:{#{escape_separators(System::Current.tenant.database, include_space: true)}}#{term}#{tags}#{modifiers}"
+          query = "@database:{#{escape_separators(@describer.database.call, include_space: true)}}#{term}#{tags}#{modifiers}"
           command = [
             "FT.SEARCH",
             @name,

data/lib/active_kit/search/key.rb

@@ -1,16 +1,17 @@
 module ActiveKit
   module Search
     class Key
-      def initialize(index:)
+      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" => System::Current.tenant.database, "id" => record.id }
+        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)
@@ -37,7 +38,7 @@ module ActiveKit
       private
 
       def key(record:)
-        "#{@index.prefix}:#{System::Current.tenant.database}:#{record.id}"
+        "#{@index.prefix}:#{@describer.database.call}:#{record.id}"
       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/searchable.rb

@@ -3,124 +3,14 @@ require 'active_support/concern'
 module ActiveKit
   module Search
     module Searchable
+      extend Bedrock::Bedrockable
       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

@@ -1,106 +1,76 @@
-# 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
+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_callbacks(describer_name, depends_on)
+          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 depending classes and then current class.
+      def set_callbacks(describer_name, depends_on)
+        depends_on.each do |depends_on_association, depends_on_inverse|
+          klass = @current_class.reflect_on_all_associations.map { |assoc| [assoc.name, assoc.klass.name] }.to_h[depends_on_association]
+
+          next if klass.constantize.private_method_defined?(after_commit_depends_callback_method_name(describer_name))
+          klass.constantize.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            after_commit :#{after_commit_depends_callback_method_name(describer_name)}
+
+            private
+
+            def #{after_commit_depends_callback_method_name(describer_name)}
+              inverse_assoc = self.public_send("#{depends_on_inverse}")
+              if inverse_assoc.respond_to?(:each)
+                inverse_assoc.each do |instance|
+                  if instance.class.name == "#{@current_class.name}"
+                    instance.class.searcher.for("#{describer_name}").reload(record: instance)
+                  end
+                end
+              else
+                if inverse_assoc.class.name == "#{@current_class.name}"
+                  inverse_assoc.class.searcher.for("#{describer_name}").reload(record: inverse_assoc)
+                end
+              end
+              logger.info "ActiveKit::Search | Indexing Done. (Class: " + self.class.name + " | Reloading: #{@current_class.name} | Describer: #{describer_name})"
+            end
+          CODE
+        end
+
+        return if @current_class.private_method_defined?(after_commit_callback_method_name(describer_name))
+        @current_class.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          after_commit :#{after_commit_callback_method_name(describer_name)}
+
+          private
+
+          def #{after_commit_callback_method_name(describer_name)}
+            self.class.searcher.for("#{describer_name}").reload(record: self)
+            logger.info "ActiveKit::Search | Indexing Done. (Class: " + self.class.name + " | Reloading: #{@current_class.name} | Describer: #{describer_name})"
+          end
+        CODE
+      end
+
+      def after_commit_callback_method_name(describer_name)
+        "#{callback_method_name(describer_name)}_callback"
+      end
+
+      def after_commit_depends_callback_method_name(describer_name)
+        "#{callback_method_name(describer_name)}_depends_callback"
+      end
+
+      def callback_method_name(describer_name)
+        "activekit_search_#{@current_class.model_name.singular}_#{describer_name}"
+      end
+    end
+  end
+end

data/lib/active_kit/search/searching.rb

@@ -1,104 +1,68 @@
-# 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
+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

@@ -1,10 +1,12 @@
 module ActiveKit
   module Search
     class Suggestion
-      def initialize(current_class:)
+      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)
@@ -32,7 +34,7 @@ module ActiveKit
       private
 
       def key
-        "activekit:search:suggestions:#{@current_class_name}:#{System::Current.tenant.database}"
+        "activekit:search:suggestions:#{@current_class_name}:#{@describer_name}:#{@describer.database.call}"
       end
     end
   end

data/lib/active_kit/search.rb

@@ -4,7 +4,7 @@ module ActiveKit
 
     autoload :Index
     autoload :Key
-    autoload :Search
+    autoload :Manager
     autoload :SearchResult
     autoload :Searcher
     autoload :Searching

data/lib/active_kit/version.rb

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

data/lib/tasks/search_tasks.rake

@@ -1,84 +1,21 @@
 namespace :active_kit do
-  desc "bundle exec rails active_kit:boot DOMAIN='www.yourdomain.com'"
-  task boot: [:environment] do
-    # Database & Preferences
-    domain = ENV['DOMAIN'] || raise("DOMAIN not specified")
-
-    tenant = nil
-    shard_name = nil
-
-    # Returns the first db config for a specific environment where it is assumed that all tenants data is stored.
-    default_shard_name = ActiveRecord::Base.configurations.find_db_config(Rails.env).name
-
-    ActiveRecord::Base.connected_to(role: :writing, shard: default_shard_name.to_sym) do
-      tenant = System::Tenant.where(domain: domain).or(System::Tenant.where(custom_domain: domain)).select(:database, :storage, :domain, :custom_domain).first
-      shard_name = tenant.database
-      raise RuntimeError, 'Could not set shard name.' unless shard_name.present? # TODO: In future, redirect this to "Nothing Here Yet" page
-    end
-
-    ApplicationRecord.connects_to database: { writing: "#{shard_name}".to_sym }
-
-    System::Current.tenant = OpenStruct.new(tenant.serializable_hash)
-    System::Current.preferences = System::Preference.revealed
-    System::Current.integrations = System::Integration.revealed
-  end
-
   namespace :search do
-    desc "bundle exec rails active_kit:search:reload CLASS='Article' DOMAIN='www.yourdomain.com'"
-    task reload: [:boot] do
-      if ENV['CLASS']
-        if ENV['CLASS'].constantize.searcher.attributes_present?
-          puts "ActiveKit::Search | Reloading: #{ENV['CLASS']}"
-          ENV['CLASS'].constantize.searcher.reload
-        end
-      else
-        Rails.application.eager_load!
-        models = ApplicationRecord.descendants.collect(&:name)
-        models.each do |model|
-          if model.constantize.searcher.attributes_present?
-            puts "ActiveKit::Search | Reloading: #{model}"
-            model.constantize.searcher.reload
-          end
-        end
-      end
+    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' DOMAIN='www.yourdomain.com'"
-    task clear: [:boot] do
-      if ENV['CLASS']
-        if ENV['CLASS'].constantize.searcher.attributes_present?
-          puts "ActiveKit::Search | Clearing: #{ENV['CLASS']}"
-          ENV['CLASS'].constantize.searcher.clear
-        end
-      else
-        Rails.application.eager_load!
-        models = ApplicationRecord.descendants.collect(&:name)
-        models.each do |model|
-          if model.constantize.searcher.attributes_present?
-            puts "ActiveKit::Search | Clearing: #{model}"
-            model.constantize.searcher.clear
-          end
-        end
-      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' DOMAIN='www.yourdomain.com'"
-    task drop: [:boot] do
-      if ENV['CLASS']
-        if ENV['CLASS'].constantize.searcher.attributes_present?
-          puts "ActiveKit::Search | Dropping: #{ENV['CLASS']}"
-          ENV['CLASS'].constantize.searcher.drop
-        end
-      else
-        Rails.application.eager_load!
-        models = ApplicationRecord.descendants.collect(&:name)
-        models.each do |model|
-          if model.constantize.searcher.attributes_present?
-            puts "ActiveKit::Search | Dropping: #{model}"
-            model.constantize.searcher.drop
-          end
-        end
-      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.dev8
+  version: 0.5.1
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -53,6 +53,7 @@ files:
 - 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
@@ -67,7 +68,7 @@ files:
 - 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/manager.rb
 - lib/active_kit/search/search_result.rb
 - lib/active_kit/search/searchable.rb
 - lib/active_kit/search/searcher.rb
@@ -94,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/search/search.rb

@@ -1,68 +0,0 @@
-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