activerecord-mysql-search 0.1.0

data/lib/mysql/search/callbacks.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    # Manages callbacks for updating search indices.
+    class Callbacks
+      attr_reader :source_model_class, :callbacks_config, :assigned
+
+      def self.callback(source_model_class_name, associated, association_path, on_attributes_change)
+        return unless enqueue_update?(associated, on_attributes_change)
+
+        perform = ::MySQL::Search.update_asyncronously ? :perform_later : :perform_now
+
+        ::MySQL::Search::Jobs::UpdaterJob.set(wait: 10.seconds).public_send(
+          perform,
+          source_model_class_name,
+          associated.class.name,
+          associated.id,
+          association_path
+        )
+      end
+
+      def self.enqueue_update?(associated, on_attributes_change)
+        return false unless ::MySQL::Search.automatic_update
+
+        on_attributes_change.any? { |attribute| associated.saved_change_to_attribute?(attribute) }
+      end
+
+      def initialize(source_model_class, source_config)
+        @source_model_class = source_model_class
+        @callbacks_config = transform_source_config(source_config)
+        @assigned = false
+      end
+
+      def assign
+        return if @assigned
+
+        callbacks_config.each do |association_path, on_attributes_change|
+          source_model_class_name = source_model_class.name
+          associated_class(association_path).after_save do
+            ::MySQL::Search::Callbacks.callback(source_model_class_name, self, association_path, on_attributes_change)
+          end
+        end
+
+        @assigned = true
+      end
+
+      private
+
+      def transform_source_config(source_config)
+        extract_association_paths(config: source_config.values.reduce(&:deep_merge))
+      end
+
+      def extract_association_paths(config:, association_config: {}, association_path: [])
+        config.each do |attribute_or_relation, attribute_or_relation_config|
+          if attribute_or_relation_config.is_a?(Hash)
+            extract_association_paths(association_config: association_config,
+                                      association_path: [*association_path, attribute_or_relation],
+                                      config: attribute_or_relation_config)
+          else
+            association_config[association_path] = [*association_config[association_path], attribute_or_relation]
+          end
+        end
+
+        association_config
+      end
+
+      def associated_class(association_path)
+        association_path.inject(source_model_class) do |memo, association|
+          memo.reflect_on_association(association).klass
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/grabber.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    # Extracts and formats data for search indexing.
+    class Grabber
+      attr_reader :model, :config
+
+      def initialize(model, config)
+        @model = model
+        @config = config
+      end
+
+      def grab
+        config.flat_map do |attr_or_relation, format_or_config|
+          case format_or_config
+          when Hash then forward(attr_or_relation, format_or_config)
+          when Symbol, String, Array, Proc then format(attr_or_relation, format_or_config)
+          else
+            raise(ArgumentError, "unknown config value: '#{format_or_config.inspect}'")
+          end
+        end
+      end
+
+      private
+
+      def forward(relation_name, grab_config)
+        relation = model.public_send(relation_name)
+
+        if relation.is_a?(::ActiveRecord::Relation)
+          relation.flat_map { |model| Grabber.new(model, grab_config).grab }
+        else
+          Grabber.new(relation, grab_config).grab
+        end
+      end
+
+      def format(attr_or_relation, formatters)
+        return [] if model.nil?
+
+        unless model.respond_to?(attr_or_relation)
+          raise ArgumentError,
+                "Missing attribute or relation `#{attr_or_relation}` on the model `#{model.class}`"
+        end
+
+        value = model.public_send(attr_or_relation)
+
+        Array.wrap(formatters).map { |formatter| Utils::Formatter.new(value, formatter).format }
+      end
+    end
+  end
+end

data/lib/mysql/search/jobs/scheduled_updater_job.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'active_job'
+
+module MySQL
+  module Search
+    module Jobs
+      # Periodically updates search indices
+      class ScheduledUpdaterJob < ::ActiveJob::Base
+        PERIODS = {
+          daily: ->(searchable) { searchable.where(updated_at: 1.day.ago..) },
+          weekly: ->(searchable) { searchable.where(updated_at: 1.week.ago..) },
+          monthly: ->(searchable) { searchable.where(updated_at: 1.month.ago..) },
+          all: ->(searchable) { searchable.all }
+        }.with_indifferent_access
+
+        def perform(period)
+          searchable_classes.each do |searchable_class|
+            seachables(searchable_class, period).find_in_batches do |searchables|
+              searchable_class.transaction do
+                searchables.each { |searchable| update(searchable_class, searchable) }
+              end
+            end
+          end
+        end
+
+        private
+
+        def searchable_classes
+          ::MySQL::Search.source_classes.map(&:model)
+        end
+
+        def seachables(searchable_class, period)
+          PERIODS[period].call(searchable_class)
+        end
+
+        def update(searchable_class, searchable)
+          ::MySQL::Search::Updater.new(full_text_searchable: searchable_class, associated_model: searchable).update
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/jobs/updater_job.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_job'
+
+module MySQL
+  module Search
+    module Jobs
+      # Updates the search index for a given full-text searchable model based on an associated model's changes.
+      class UpdaterJob < ::ActiveJob::Base
+        def perform(full_text_searchable_name, associated_name, associated_id, association_path)
+          associated_model = associated_name.constantize.find_by(id: associated_id)
+
+          return if associated_model.nil?
+
+          ::MySQL::Search::Updater.new(
+            full_text_searchable: full_text_searchable_name.constantize,
+            associated_model: associated_model,
+            association_path: association_path
+          ).update
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/jobs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'jobs/scheduled_updater_job'
+require_relative 'jobs/updater_job'
+
+module MySQL
+  module Search
+    # Contains job classes for managing search updates.
+    module Jobs
+    end
+  end
+end

data/lib/mysql/search/queries/full_text_search_query.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'arel'
+
+module Arel
+  module Visitors
+    # Custom visitor for MySQL to handle the `AGAINST` clause in full-text search.
+    class MySQL
+      def visit_Arel_Nodes_Against(node, collector) # rubocop:disable Naming/MethodName
+        visit(node.left, collector) << ' AGAINST ('
+        visit(node.right, collector) << ')'
+      end
+    end
+  end
+end
+
+module Arel
+  module Nodes
+    # Represents the `AGAINST` clause used in MySQL full-text search queries.
+    class Against < Arel::Nodes::Matches
+    end
+  end
+end
+
+module Arel
+  # Adds a method to the `Arel::Nodes::Node` class to allow for full-text search queries.
+  module Predications
+    def against(other)
+      Arel::Nodes::Against.new(self, quoted_node(other))
+    end
+  end
+end
+
+module MySQL
+  module Search
+    module Queries
+      # FullTextSearchQuery is responsible for building and executing full-text search queries
+      class FullTextSearchQuery
+        attr_reader :source_relation
+
+        def initialize(source_relation)
+          @source_relation = source_relation
+        end
+
+        def call(search_term, search_column: :content)
+          relation_table = source_relation.klass.arel_table
+
+          search_expression = search_expression(search_term, search_column)
+
+          [relation_table[Arel.star], search_expression.as('search_term_relevancy')]
+
+          source_relation
+            # .select(*select_expression)
+            .joins(:search_index)
+            .where(search_expression)
+            .order(search_expression.desc)
+        end
+
+        private
+
+        def search_expression(search_term, search_column)
+          search_term = ::MySQL::Search::Utils::TextNormalizer.normalize(search_term)
+          search_indices = ::MySQL::Search.search_index_class_name.constantize.arel_table
+          search_columns = Array.wrap(search_column).map { |col| search_indices[col] }
+
+          Arel::Nodes::NamedFunction.new('MATCH', search_columns).against(search_term)
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/queries/updated_sources_query.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    module Queries
+      # Queries updated sources for search indexing.
+      class UpdatedSourcesQuery
+        attr_reader :source_relation, :source_class_name
+
+        def initialize(source_relation)
+          @source_relation = source_relation.all
+          @source_class_name = "#{source_relation.all.klass.name}Source"
+        end
+
+        def call(time_ago)
+          joins_args = source_class_name.constantize.joins_args
+          relation = source_relation.left_joins(joins_args).where(updated_at: time_ago..)
+
+          append_conditions(relation, source_relation, joins_args, time_ago)
+        end
+
+        private
+
+        def append_conditions(relation, root_class, config, time_ago)
+          case config
+          when Array then config.reduce(relation) { |rel, item| append_conditions(rel, root_class, item, time_ago) }
+          when Hash
+            relation = append_conditions(relation, root_class, config.keys, time_ago)
+
+            config.reduce(relation) do |rel, (root_association, nested_config)|
+              append_conditions(rel, association_class(root_class, root_association), nested_config, time_ago)
+            end
+          else
+            append_or(relation, association_class(root_class, config), time_ago)
+          end
+        end
+
+        def association_class(root_class, association)
+          root_class.reflect_on_association(association).klass
+        end
+
+        def append_or(relation, model, time_ago)
+          return relation unless model.column_names.include?('updated_at')
+
+          relation.or(model.where(updated_at: time_ago..))
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    # Railtie for integrating MySQL::Search with Rails applications.
+    class Railtie < Rails::Railtie
+      railtie_name :mysql_search
+
+      rake_tasks do
+        path = File.expand_path(__dir__)
+        Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+      end
+
+      generators do
+        require 'generators/mysql/search/install_generator'
+      end
+    end
+  end
+end

data/lib/mysql/search/searchable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    # Provides ActiveRecord integration for search indexing.
+    module Searchable
+      extend ActiveSupport::Concern
+
+      included do
+        has_one :search_index, class_name: ::MySQL::Search.search_index_class_name.to_s,
+                               as: :searchable,
+                               dependent: :destroy
+
+        scope :full_text_search_sources_updated, lambda { |time_ago|
+          ::MySQL::Search::Queries::UpdatedSourcesQuery.new(self).call(time_ago)
+        }
+
+        scope :full_text_search, lambda { |search_term, search_column: :content|
+          ::MySQL::Search::Queries::FullTextSearchQuery.new(self).call(search_term, search_column: search_column)
+        }
+      end
+    end
+  end
+end

data/lib/mysql/search/source.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    # Represents a source for search indexing.
+    class Source
+      class_attribute :_model
+      class_attribute :_config, default: {}
+      class_attribute :_callbacks
+
+      attr_reader :model
+
+      def self.schema(config)
+        self._model = model
+        self._config = _config.merge(config)
+        self._callbacks = ::MySQL::Search::Callbacks.new(_model, _config)
+
+        _callbacks.assign
+      end
+
+      def self.model
+        _model || name.delete_suffix('Source').constantize
+      end
+
+      def self.joins_args
+        combined_config = _config.values.reduce(&:deep_merge)
+        extract_joins_args(combined_config)
+      end
+
+      def initialize(model)
+        @model = model
+      end
+
+      def extract
+        _config.each_with_object({}) do |(search_index_attribute, grabber_config), extracted|
+          validate_search_index_attribute!(search_index_attribute)
+
+          grabbed_data = Grabber.new(model, grabber_config).grab
+          extracted[search_index_attribute] = grabbed_data.compact.join(' ').squish
+        end
+      end
+
+      def self.extract_joins_args(config)
+        config.each_with_object([]) do |(attr_or_relation, format_or_config), extracted|
+          next unless format_or_config.is_a?(Hash)
+
+          extracted << if format_or_config.values.any?(Hash)
+                         { attr_or_relation => extract_joins_args(format_or_config) }
+                       else
+                         attr_or_relation
+                       end
+        end
+      end
+
+      private_class_method :extract_joins_args
+
+      private
+
+      def validate_search_index_attribute!(search_index_attribute)
+        return if Search.search_index_class.column_names.include?(search_index_attribute.to_s)
+
+        raise(
+          ArgumentError,
+          "Unknown attribute '#{search_index_attribute}' for #{::MySQL::Search.search_index_class.name}"
+        )
+      end
+    end
+  end
+end

data/lib/mysql/search/updater.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    # Updates search indices based on associated models.
+    class Updater
+      attr_reader :full_text_searchable,
+                  :associated_model,
+                  :joins_args,
+                  :source_class
+
+      def initialize(full_text_searchable:, associated_model:, association_path: [])
+        @full_text_searchable = full_text_searchable
+        @associated_model = associated_model
+        @joins_args = translate_to_joins_args(association_path)
+        @source_class = "#{full_text_searchable.name}Source".constantize
+      end
+
+      def update
+        full_text_searchable.transaction do
+          full_text_searchables.find_each do |model|
+            search_index = model.search_index || model.build_search_index
+
+            search_index.update(source_class.new(model).extract)
+          end
+        end
+      end
+
+      private
+
+      def translate_to_joins_args(association_path)
+        return association_path if association_path.empty? || association_path.one?
+
+        target_association = association_path.pop
+
+        association_path.reverse.inject(target_association) { |memo, association| { association => memo } }
+      end
+
+      def full_text_searchables
+        associated_model_relation = associated_model.class.where(id: associated_model.id)
+
+        full_text_searchable.joins(joins_args).preload(:search_index).merge(associated_model_relation)
+      end
+    end
+  end
+end

data/lib/mysql/search/utils/duration_parser.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    module Utils
+      # Parses duration strings into ActiveSupport::Duration objects.
+      class DurationParser
+        REGEXP = /(\d+)[.\s](year|month|week|day|hour|minute|second)s?/
+
+        def self.parse(duration_string, default = nil)
+          match_data = duration_string.to_s.match(REGEXP)
+
+          return default if match_data.nil?
+
+          match_data[1].to_i.public_send(match_data[2])
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/utils/formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    module Utils
+      # Formats values for search indexing.
+      class Formatter
+        attr_reader :value, :formatter
+
+        def initialize(value, formatter)
+          if formatter.instance_of?(Proc)
+            @value = formatter.call(value)
+            @formatter = nil
+          elsif respond_to?(formatter, true)
+            @value = value
+            @formatter = formatter
+          else
+            raise(ArgumentError, "Unknown formatter name: '#{formatter.inspect}'")
+          end
+        end
+
+        def format
+          formatter ? send(formatter) : value
+        end
+
+        private
+
+        def text
+          TextNormalizer.normalize(value.to_s)
+        end
+
+        def calendar_week
+          value&.strftime(::MySQL::Search.calendar_week_format)
+        end
+
+        def date
+          value&.strftime(::MySQL::Search.date_format)
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/utils/text_normalizer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module MySQL
+  module Search
+    module Utils
+      # Normalizes text by removing non-alphanumeric characters, except for spaces and hyphens.
+      class TextNormalizer
+        REGEXP = /[[:alnum:][:blank:]+\-*~<>()"@\.]/
+
+        def self.normalize(value)
+          value.to_s.scan(REGEXP).join.squish
+        end
+      end
+    end
+  end
+end

data/lib/mysql/search/utils.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'utils/formatter'
+require_relative 'utils/text_normalizer'
+require_relative 'utils/duration_parser'
+
+module MySQL
+  module Search
+    # Contains utility classes and methods for search indexing.
+    module Utils
+    end
+  end
+end

data/lib/mysql/search.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'search/callbacks'
+require_relative 'search/grabber'
+require_relative 'search/jobs'
+require_relative 'search/searchable'
+require_relative 'search/source'
+require_relative 'search/queries/updated_sources_query'
+require_relative 'search/queries/full_text_search_query'
+require_relative 'search/updater'
+require_relative 'search/utils'
+
+module MySQL
+  # Provides a namespace for MySQL search functionality.
+  module Search
+    module_function
+
+    # Runtime configuration
+    mattr_accessor :automatic_update, default: true
+    mattr_accessor :update_asyncronously, default: false
+
+    # Search Index & Sources
+    mattr_accessor :search_index_class_name, default: 'SearchIndex'
+    mattr_accessor :sources_path, default: 'app/search_sources'
+
+    # Formatters
+    mattr_accessor :calendar_week_format, default: 'week %V'
+    mattr_accessor :date_format, default: '%d.%m.%Y'
+
+    def search_index_class
+      @search_index_class ||= search_index_class_name.constantize
+    end
+
+    def source_classes
+      @source_classes ||= Dir.glob("#{sources_path}/**/*.rb").filter_map do |file|
+        file.sub("#{sources_path}/", '').sub('.rb', '').camelize.safe_constantize
+      end
+    end
+
+    def configure
+      yield self
+    end
+  end
+end
+
+# Load Railtie if Rails is defined
+require_relative 'search/railtie' if defined?(Rails::Railtie)

data/lib/tasks/actualize.rake

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+namespace :mysql do
+  namespace :search do
+    desc 'Actualizes full text search since date. Usage: rails time_tracking:full_text_search:actualize[1.hour]'
+    task :actualize, [:time_ago] => :environment do |_task, arg|
+      time_ago = MySQL::Search::Utils::DurationParser.parse(arg[:time_ago], 1.hour).ago
+      searchable_classes = MySQL::Search.source_classes.map(&:model)
+
+      searchable_classes.each do |searchable_class|
+        count = searchable_class.count
+        print "\n#{searchable_class.name}"
+
+        searchable_class.full_text_search_sources_updated(time_ago).find_each.with_index do |record, index|
+          puts(" (#{index} / #{count})") if (index % 100).zero?
+          MySQL::Search::Updater.new(full_text_searchable: record.class, associated_model: record).update
+          putc '.'
+        end
+
+        puts '✅'
+      end
+    end
+  end
+end