thinking-sphinx 4.3.0 → 5.0.0

data/lib/thinking_sphinx/callbacks.rb

@@ -3,6 +3,13 @@
 class ThinkingSphinx::Callbacks
   attr_reader :instance
 
+  def self.append(model, reference = nil, options, &block)
+    reference ||= ThinkingSphinx::Configuration.instance.index_set_class.
+      reference_name(model)
+
+    ThinkingSphinx::Callbacks::Appender.call(model, reference, options, &block)
+  end
+
   def self.callbacks(*methods)
     mod = Module.new
     methods.each do |method|
@@ -33,3 +40,5 @@ class ThinkingSphinx::Callbacks
     @instance = instance
   end
 end
+
+require "thinking_sphinx/callbacks/appender"

data/lib/thinking_sphinx/callbacks/appender.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Callbacks::Appender
+  def self.call(model, reference, options, &block)
+    new(model, reference, options, &block).call
+  end
+
+  def initialize(model, reference, options, &block)
+    @model = model
+    @reference = reference
+    @options = options
+    @block = block
+  end
+
+  def call
+    model.after_destroy ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks
+
+    if behaviours.include?(:deltas)
+      model.before_save  ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+      model.after_commit ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks
+    end
+
+    if behaviours.include?(:real_time)
+      model.after_save ThinkingSphinx::RealTime.callback_for(
+        reference, path, &block
+      )
+    end
+
+    if behaviours.include?(:updates)
+      model.after_update(
+        ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks
+      )
+    end
+  end
+
+  private
+
+  attr_reader :model, :reference, :options, :block
+
+  def behaviours
+    options[:behaviours] || []
+  end
+
+  def path
+    options[:path] || []
+  end
+end

data/lib/thinking_sphinx/commands/index_real_time.rb

@@ -2,9 +2,7 @@
 
 class ThinkingSphinx::Commands::IndexRealTime < ThinkingSphinx::Commands::Base
   def call
-    options[:indices].each do |index|
-      ThinkingSphinx::RealTime::Populator.populate index
-
+    ThinkingSphinx::RealTime.processor.call options[:indices] do
       command :rotate
     end
   end

data/lib/thinking_sphinx/configuration.rb

@@ -87,9 +87,7 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
       return if @preloaded_indices
 
       index_paths.each do |path|
-        Dir["#{path}/**/*.rb"].sort.each do |file|
-          ActiveSupport::Dependencies.require_or_load file
-        end
+        Dir["#{path}/**/*.rb"].sort.each { |file| preload_index file }
       end
 
       normalise
@@ -99,6 +97,14 @@ class ThinkingSphinx::Configuration < Riddle::Configuration
     end
   end
 
+  def preload_index(file)
+    if ActiveRecord::VERSION::MAJOR <= 5
+      ActiveSupport::Dependencies.require_or_load file
+    else
+      load file
+    end
+  end
+
   def render
     preload_indices
 

data/lib/thinking_sphinx/core/index.rb

@@ -11,7 +11,6 @@ module ThinkingSphinx::Core::Index
 
   def initialize(reference, options = {})
     @reference    = reference.to_sym
-    @docinfo      = :extern unless config.settings["skip_docinfo"]
     @options      = options
     @offset       = config.next_offset(options[:offset_as] || reference)
     @type         = 'plain'
@@ -38,7 +37,11 @@ module ThinkingSphinx::Core::Index
   end
 
   def interpret_definition!
-    return unless model.table_exists?
+    table_exists = model.table_exists?
+    unless table_exists
+      Rails.logger.info "No table exists for #{model}. Index can not be created"
+      return
+    end
     return if @interpreted_definition
 
     apply_defaults!

data/lib/thinking_sphinx/deletion.rb

@@ -22,10 +22,6 @@ class ThinkingSphinx::Deletion
 
   attr_reader :index, :ids
 
-  def document_ids_for_keys
-    ids.collect { |id| index.document_id_for_key id }
-  end
-
   def execute(statement)
     statement = statement.gsub(/\s*\n\s*/, ' ').strip
 
@@ -36,11 +32,28 @@ class ThinkingSphinx::Deletion
     end
   end
 
+  class PlainDeletion < ThinkingSphinx::Deletion
+    def perform
+      ids.each_slice(1000) do |some_ids|
+        execute <<-SQL
+UPDATE #{name}
+SET sphinx_deleted = 1
+WHERE sphinx_internal_id IN (#{some_ids.join(', ')})
+        SQL
+      end
+    end
+  end
+
   class RealtimeDeletion < ThinkingSphinx::Deletion
     def perform
       return unless callbacks_enabled?
 
-      execute Riddle::Query::Delete.new(name, document_ids_for_keys).to_sql
+      ids.each_slice(1000) do |some_ids|
+        execute <<-SQL
+DELETE FROM #{name}
+WHERE sphinx_internal_id IN (#{some_ids.join(', ')})
+        SQL
+      end
     end
 
     private
@@ -54,16 +67,4 @@ class ThinkingSphinx::Deletion
       ThinkingSphinx::Configuration.instance
     end
   end
-
-  class PlainDeletion < ThinkingSphinx::Deletion
-    def perform
-      document_ids_for_keys.each_slice(1000) do |document_ids|
-        execute <<-SQL
-UPDATE #{name}
-SET sphinx_deleted = 1
-WHERE id IN (#{document_ids.join(', ')})
-        SQL
-      end
-    end
-  end
 end

data/lib/thinking_sphinx/index_set.rb

@@ -34,11 +34,11 @@ class ThinkingSphinx::IndexSet
   end
 
   def classes
-    options[:classes] || []
+    options[:classes] || instances.collect(&:class)
   end
 
   def classes_specified?
-    classes.any? || references_specified?
+    instances.any? || classes.any? || references_specified?
   end
 
   def classes_and_ancestors
@@ -68,6 +68,10 @@ class ThinkingSphinx::IndexSet
     all_indices.select { |index| references.include? index.reference }
   end
 
+  def instances
+    options[:instances] || []
+  end
+
   def mti_classes
     classes.reject { |klass|
       klass.column_names.include?(klass.inheritance_column)
@@ -76,7 +80,7 @@ class ThinkingSphinx::IndexSet
 
   def references
     options[:references] || classes_and_ancestors.collect { |klass|
-      ThinkingSphinx::IndexSet.reference_name(klass)
+      self.class.reference_name(klass)
     }
   end
 

data/lib/thinking_sphinx/middlewares/sphinxql.rb

@@ -133,7 +133,7 @@ class ThinkingSphinx::Middlewares::SphinxQL <
 
     def indices_match_classes?
       indices.collect(&:reference).uniq.sort == classes.collect { |klass|
-        ThinkingSphinx::IndexSet.reference_name(klass)
+        configuration.index_set_class.reference_name(klass)
       }.sort
     end
 

data/lib/thinking_sphinx/railtie.rb

@@ -7,7 +7,15 @@ class ThinkingSphinx::Railtie < Rails::Railtie
 
   initializer 'thinking_sphinx.initialisation' do
     ActiveSupport.on_load(:active_record) do
-      ActiveRecord::Base.send :include, ThinkingSphinx::ActiveRecord::Base
+      ActiveRecord::Base.include ThinkingSphinx::ActiveRecord::Base
+    end
+
+    if ActiveSupport::VERSION::MAJOR > 5
+      if Rails.application.config.autoloader == :zeitwerk
+        ActiveSupport::Dependencies.autoload_paths.delete(
+          Rails.root.join("app", "indices").to_s
+        )
+      end
     end
   end
 

data/lib/thinking_sphinx/real_time.rb

@@ -8,6 +8,22 @@ module ThinkingSphinx::RealTime
   def self.callback_for(reference, path = [], &block)
     Callbacks::RealTimeCallbacks.new reference.to_sym, path, &block
   end
+
+  def self.populator
+    @populator ||= ThinkingSphinx::RealTime::Populator
+  end
+
+  def self.populator=(value)
+    @populator = value
+  end
+
+  def self.processor
+    @processor ||= ThinkingSphinx::RealTime::Processor
+  end
+
+  def self.processor=(value)
+    @processor = value
+  end
 end
 
 require 'thinking_sphinx/real_time/property'
@@ -16,6 +32,7 @@ require 'thinking_sphinx/real_time/field'
 require 'thinking_sphinx/real_time/index'
 require 'thinking_sphinx/real_time/interpreter'
 require 'thinking_sphinx/real_time/populator'
+require 'thinking_sphinx/real_time/processor'
 require 'thinking_sphinx/real_time/transcribe_instance'
 require 'thinking_sphinx/real_time/transcriber'
 require 'thinking_sphinx/real_time/translator'

data/lib/thinking_sphinx/real_time/index.rb

@@ -16,10 +16,14 @@ class ThinkingSphinx::RealTime::Index < Riddle::Configuration::RealtimeIndex
   end
 
   def add_attribute(attribute)
+    @attributes.delete_if { |existing| existing.name == attribute.name }
+
     @attributes << attribute
   end
 
   def add_field(field)
+    @fields.delete_if { |existing| existing.name == field.name }
+
     @fields << field
   end
 

data/lib/thinking_sphinx/real_time/interpreter.rb

@@ -5,16 +5,18 @@ class ThinkingSphinx::RealTime::Interpreter <
 
   def has(*columns)
     options = columns.extract_options!
-    @index.attributes += columns.collect { |column|
+
+    columns.collect { |column|
       ::ThinkingSphinx::RealTime::Attribute.new column, options
-    }
+    }.each { |attribute| @index.add_attribute attribute }
   end
 
   def indexes(*columns)
     options = columns.extract_options!
-    @index.fields += columns.collect { |column|
+
+    columns.collect { |column|
       ::ThinkingSphinx::RealTime::Field.new column, options
-    }
+    }.each { |field| @index.add_field field }
 
     append_sortable_attributes columns, options if options[:sortable]
   end
@@ -39,7 +41,7 @@ class ThinkingSphinx::RealTime::Interpreter <
   def append_sortable_attributes(columns, options)
     options = options.except(:sortable).merge(:type => :string)
 
-    @index.attributes += columns.collect { |column|
+    columns.collect { |column|
       aliased_name   = options[:as]
       aliased_name ||= column.__name.to_sym if column.respond_to?(:__name)
       aliased_name ||= column
@@ -47,6 +49,6 @@ class ThinkingSphinx::RealTime::Interpreter <
       options[:as] = "#{aliased_name}_sort".to_sym
 
       ::ThinkingSphinx::RealTime::Attribute.new column, options
-    }
+    }.each { |attribute| @index.add_attribute attribute }
   end
 end

data/lib/thinking_sphinx/real_time/populator.rb

@@ -9,7 +9,7 @@ class ThinkingSphinx::RealTime::Populator
     @index = index
   end
 
-  def populate(&block)
+  def populate
     instrument 'start_populating'
 
     scope.find_in_batches(:batch_size => batch_size) do |instances|

data/lib/thinking_sphinx/real_time/processor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::RealTime::Processor
+  def self.call(indices, &block)
+    new(indices).call(&block)
+  end
+
+  def initialize(indices)
+    @indices = indices
+  end
+
+  def call(&block)
+    subscribe_to_progress
+
+    indices.each do |index|
+      ThinkingSphinx::RealTime.populator.populate index
+
+      block.call
+    end
+  end
+
+  private
+
+  attr_reader :indices
+
+  def command
+    ThinkingSphinx::Commander.call(
+      command, configuration, options, stream
+    )
+  end
+
+  def subscribe_to_progress
+    ThinkingSphinx::Subscribers::PopulatorSubscriber.
+      attach_to 'thinking_sphinx.real_time'
+  end
+end

data/lib/thinking_sphinx/real_time/transcriber.rb

@@ -11,25 +11,8 @@ class ThinkingSphinx::RealTime::Transcriber
     }
     return unless items.present?
 
-    values = []
-    items.each do |instance|
-      begin
-        values << ThinkingSphinx::RealTime::TranscribeInstance.call(
-          instance, index, properties
-        )
-      rescue ThinkingSphinx::TranscriptionError => error
-        instrument 'error', :error => error
-      end
-    end
-
-    insert = Riddle::Query::Insert.new index.name, columns, values
-    sphinxql = insert.replace!.to_sql
-
-    ThinkingSphinx::Logger.log :query, sphinxql do
-      ThinkingSphinx::Connection.take do |connection|
-        connection.execute sphinxql
-      end
-    end
+    delete_existing items
+    insert_replacements items
   end
 
   private
@@ -55,6 +38,27 @@ class ThinkingSphinx::RealTime::Transcriber
     }
   end
 
+  def delete_existing(instances)
+    ids = instances.collect(&index.primary_key.to_sym)
+
+    execute <<~SQL.strip
+      DELETE FROM #{@index.name} WHERE sphinx_internal_id IN (#{ids.join(', ')})
+    SQL
+  end
+
+  def execute(sphinxql)
+    ThinkingSphinx::Logger.log :query, sphinxql do
+      ThinkingSphinx::Connection.take do |connection|
+        connection.execute sphinxql
+      end
+    end
+  end
+
+  def insert_replacements(instances)
+    insert = Riddle::Query::Insert.new index.name, columns, values(instances)
+    execute insert.replace!.to_sql
+  end
+
   def instrument(message, options = {})
     ActiveSupport::Notifications.instrument(
       "#{message}.thinking_sphinx.real_time", options.merge(:index => index)
@@ -64,4 +68,16 @@ class ThinkingSphinx::RealTime::Transcriber
   def properties
     @properties ||= index.fields + index.attributes
   end
+
+  def values(instances)
+    instances.each_with_object([]) do |instance, array|
+      begin
+        array << ThinkingSphinx::RealTime::TranscribeInstance.call(
+          instance, index, properties
+        )
+      rescue ThinkingSphinx::TranscriptionError => error
+        instrument 'error', :error => error
+      end
+    end
+  end
 end