activekit 0.5.0.dev7 → 0.5.0.dev8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e3830a0b0d888ffcd7a7f921b282fbf27dc0f2bdde5322772a71ed04755add3
-  data.tar.gz: abb0bbead8a270129c04dfb0998e15999df84a6daeb7c28a3237dac161211f43
+  metadata.gz: 7fe66b1b57a945fa39f8d3daad8daa1dd3d564d190fb302453e1e1d9b4bc64e8
+  data.tar.gz: '0026541966d64d4fb509ae32dbd69715cf86d8dd79abd51537aee335bb0da393'
 SHA512:
-  metadata.gz: a2f82ef282ec1226ac39d8ac42993f5ed621ea89407c22ebd6a0850d40157f32e20be968a946899c833bb041b2fe258914c64247c7746a968709f17da88db6af
-  data.tar.gz: baea0b85ab9b4adbd8e3c1f1eb1e37d62c673b83fc4858233a96cee9b7721a37f7985479a66a0848b16db33137dda1a48553a5d275da5ab0241aa85eee84ebd3
+  metadata.gz: ebc4d83438c610266f4de8c72395199f71282f5e8b00cfdebcf9e532950094997f520b0dd3e65a85e05f5e62fae365e5eaebc770691c4fcb2131a0ce3225bbc1
+  data.tar.gz: bbb51f533e437c2de942dcc5a8d9120b3f1cf0317b138c0b924cd433a48bbe6c145b4c77e3eaf0160c2a37d47d0d35df07916a090fbd237bc4929c7de8b0d790

data/lib/active_kit/bedrock/bedrockable.rb

@@ -0,0 +1,33 @@
+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
+            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
+
+            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
+
+            def #{current_component}_describer_method(describer)
+              raise NotImplementedError
+            end
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/active_kit/bedrock/bedrocker.rb

@@ -0,0 +1,120 @@
+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}
+              if describer = #{@current_component}er.find_describer_by(name: "#{name}".to_sym)
+                #{@current_component}_describer_method(describer)
+              end
+            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
+      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
+
+      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
+
+      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.rb

@@ -0,0 +1,7 @@
+module ActiveKit
+  module Bedrock
+    extend ActiveSupport::Autoload
+
+    autoload :Bedrocker
+  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,24 +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

data/lib/active_kit/export/exporter.rb

@@ -1,113 +1,9 @@
 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
-
+    class Exporter < Bedrock::Bedrocker
       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/index.rb

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

data/lib/active_kit/search/key.rb

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

data/lib/active_kit/search/search.rb

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

data/lib/active_kit/search/search_result.rb

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

data/lib/active_kit/search/searchable.rb

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

data/lib/active_kit/search/searcher.rb

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

data/lib/active_kit/search/searching.rb

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

data/lib/active_kit/search/suggestion.rb

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

data/lib/active_kit/search/suggestion_result.rb

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

data/lib/active_kit/search.rb

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

data/lib/active_kit/version.rb

@@ -1,3 +1,3 @@
 module ActiveKit
-  VERSION = '0.5.0.dev7'
+  VERSION = '0.5.0.dev8'
 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,84 @@
+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
+    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
+    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
+    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.dev8
 platform: ruby
 authors:
 - plainsource
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-22 00:00:00.000000000 Z
+date: 2024-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -50,8 +50,9 @@ 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/engine.rb
 - lib/active_kit/export.rb
 - lib/active_kit/export/exportable.rb
@@ -63,9 +64,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/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
+- lib/tasks/search_tasks.rake
 homepage: https://github.com/plainsource/activekit
 licenses:
 - MIT

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