activekit 0.5.0.dev2 → 0.5.0.dev4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e2eea75f42af6dee1472a45419f36d2ac503c1aaa30745e0a513728bca2a7de
-  data.tar.gz: 4a377406bcfab283361ce08307989ee06a4753af4470524a2d0cc3ef3e0a0f50
+  metadata.gz: eff7a049cd21979e76253d095e0d0ba722b289370a15426cf4b87c922d2bab66
+  data.tar.gz: 27b310f65547d08961b9044fe43bc606cfb78f0766487052c9488a2fa3e78ed8
 SHA512:
-  metadata.gz: 03727406b7acdd0257e723fe771c0cb5f85b2c0a72e57b6d63735e9ad92ef4634b3e500233ec4cc585f450ae952d7f0802d4e86b9a9dbadb8bb51ea8e894baf2
-  data.tar.gz: 5a518d157ac540f007be8c7b9c57010f68934ed9ad74ab8ba2fbce38a51517d3d2a0c90c74b616299f66e3e256dc1b7a467ee5d8ef258689e8c92e4e76fa66bd
+  metadata.gz: ce4750f37977c8e2a63a6ec85ad4def621877f3789eb64e598d214066f840463c3cbe7a60b5e4853d9a639a2f83cd480a953c0436535547acf8a9b55b5113de9
+  data.tar.gz: c3813bb2b5df232389c25c8bc0ecf35f5875d6fdc34060d67993643f728bca9c0b6d0d81c85abed349dfb52bef8b0ac2a392ce88ce72a37adc722c3d533e1f64

data/lib/active_kit/base/baseable.rb

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

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

data/lib/active_kit/engine.rb

@@ -12,12 +12,10 @@ 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

@@ -14,50 +14,11 @@ module ActiveKit
         end
 
         def export_describer(name, **options)
-          name = name.to_sym
-          options.deep_symbolize_keys!
-
-          unless exporter.find_describer_by(describer_name: name)
-            exporter.new_describer(name: name, options: options)
-            define_export_describer_method(kind: options[:kind], name: name)
-          end
+          exporter.create_export_describer(name, options)
         end
 
         def export_attribute(name, **options)
-          export_describer(:to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym }) unless exporter.describers?
-
-          options.deep_symbolize_keys!
-          exporter.new_attribute(name: name.to_sym, options: options)
-        end
-
-        def define_export_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
+          exporter.create_export_attribute(name, options)
         end
       end
     end

data/lib/active_kit/export/exporter.rb

@@ -1,41 +1,27 @@
 module ActiveKit
   module Export
     class Exporter
-      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?
+      def create_export_describer(name, options)
+        name = name.to_sym
+        options.deep_symbolize_keys!
 
-        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)
+        unless find_describer_by(describer_name: name)
+          options.store(:attributes, {})
+          @describers.store(name, options)
+          define_describer_method(kind: options[:kind], name: name)
+        end
       end
 
-      def new_describer(name:, options:)
-        options.store(:attributes, {})
-        @describers.store(name, options)
-      end
+      def create_export_attribute(name, options)
+        create_export_describer(:to_csv, kind: :csv, database: -> { ActiveRecord::Base.connection_db_config.database.to_sym }) unless @describers.present?
 
-      def describers?
-        @describers.present?
-      end
+        options.deep_symbolize_keys!
 
-      def new_attribute(name:, options:)
         describer_names = Array(options.delete(:describers))
         describer_names = @describers.keys if describer_names.blank?
 
@@ -46,11 +32,61 @@ module ActiveKit
         end
       end
 
+      private
+
+      def define_describer_method(kind:, name:)
+        case kind
+        when :csv
+          @current_class.class_eval do
+            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
+
       def new_exporting(describer:)
         Exporting.new(describer: describer)
       end
 
-      private
+      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 build_describer_fields(describer_attributes)
         describer_attributes.inject({}) do |fields_hash, (name, options)|

data/lib/active_kit/version.rb

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

data/lib/active_kit.rb

@@ -6,5 +6,4 @@ 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.5.0.dev2
+  version: 0.5.0.dev4
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-19 00:00:00.000000000 Z
+date: 2024-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -50,6 +50,8 @@ 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/engine.rb
 - lib/active_kit/export.rb
 - lib/active_kit/export/exportable.rb
@@ -61,16 +63,6 @@ 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

data/lib/active_kit/search/index.rb

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

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

@@ -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

data/lib/active_kit/search/search_result.rb

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

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

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

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

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

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

@@ -1,16 +0,0 @@
-module ActiveKit
-  module Search
-    extend ActiveSupport::Autoload
-
-    autoload :Index
-    autoload :Key
-    autoload :Search
-    autoload :SearchResult
-    autoload :Searcher
-    autoload :Searching
-    autoload :Suggestion
-    autoload :SuggestionResult
-
-    mattr_accessor :redis, instance_accessor: false
-  end
-end