thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/deltas.rb

@@ -1,30 +1,55 @@
-require 'thinking_sphinx/deltas/default_delta'
-require 'thinking_sphinx/deltas/delayed_delta'
-require 'thinking_sphinx/deltas/datetime_delta'
-
-module ThinkingSphinx
-  module Deltas
-    def self.parse(index)
-      delta_option = index.local_options.delete(:delta)
-      case delta_option
-      when TrueClass, :default
-        DefaultDelta.new index, index.local_options
-      when :delayed
-        DelayedDelta.new index, index.local_options
-      when :datetime
-        DatetimeDelta.new index, index.local_options
-      when FalseClass, nil
-        nil
-      else
-        if delta_option.is_a?(String)
-          delta_option = Kernel.const_get(delta_option)
-        end
-        if delta_option.ancestors.include?(ThinkingSphinx::Deltas::DefaultDelta)
-          delta_option.new index, index.local_options
-        else
-          raise "Unknown delta type"
-        end
-      end
+# frozen_string_literal: true
+
+module ThinkingSphinx::Deltas
+  def self.config
+    ThinkingSphinx::Configuration.instance
+  end
+
+  def self.processor_for(delta)
+    case delta
+    when TrueClass
+      ThinkingSphinx::Deltas::DefaultDelta
+    when Class
+      delta
+    when String
+      delta.constantize
+    else
+      nil
+    end
+  end
+
+  def self.resume!
+    @suspended = false
+  end
+
+  def self.suspend(reference, &block)
+    suspend!
+    yield
+    resume!
+
+    config.indices_for_references(reference).each do |index|
+      index.delta_processor.index index if index.delta?
     end
   end
+
+  def self.suspend_and_update(reference, &block)
+    suspend reference, &block
+
+    ids = reference.to_s.camelize.constantize.where(delta: true).pluck(:id)
+    config.indices_for_references(reference).each do |index|
+      ThinkingSphinx::Deletion.perform index, ids unless index.delta?
+    end
+  end
+
+  def self.suspend!
+    @suspended = true
+  end
+
+  def self.suspended?
+    @suspended
+  end
 end
+
+require 'thinking_sphinx/deltas/default_delta'
+require 'thinking_sphinx/deltas/delete_job'
+require 'thinking_sphinx/deltas/index_job'

data/lib/thinking_sphinx/distributed/index.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Distributed::Index <
+  Riddle::Configuration::DistributedIndex
+
+  attr_reader :reference, :options, :local_index_objects
+
+  def initialize(reference)
+    @reference           = reference
+    @options             = {}
+    @local_index_objects = []
+
+    super reference.to_s.gsub('/', '_')
+  end
+
+  def delta?
+    false
+  end
+
+  def distributed?
+    true
+  end
+
+  def facets
+    local_index_objects.collect(&:facets).flatten
+  end
+
+  def local_index_objects=(indices)
+    self.local_indices = indices.collect(&:name)
+    @local_index_objects = indices
+  end
+
+  def model
+    @model ||= reference.to_s.camelize.constantize
+  end
+
+  def primary_key
+    @primary_key ||= configuration.settings['primary_key'] || :id
+  end
+
+  private
+
+  def configuration
+    ThinkingSphinx::Configuration.instance
+  end
+end

data/lib/thinking_sphinx/distributed.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Distributed
+  #
+end
+
+require 'thinking_sphinx/distributed/index'

data/lib/thinking_sphinx/errors.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::SphinxError < StandardError
+  attr_accessor :statement
+
+  def self.new_from_mysql(error)
+    case error.message
+    when /parse error/, /query is non-computable/
+      replacement = ThinkingSphinx::ParseError.new(error.message)
+    when /syntax error/
+      replacement = ThinkingSphinx::SyntaxError.new(error.message)
+    when /query error/, /unknown column/
+      replacement = ThinkingSphinx::QueryError.new(error.message)
+    when /Can't connect to( MySQL)? server/,
+      /Communications link failure/,
+      /Lost connection to( MySQL)? server/
+      replacement = ThinkingSphinx::ConnectionError.new(
+        "Error connecting to Sphinx via the MySQL protocol. #{error.message}"
+      )
+    when /offset out of bounds/
+      replacement = ThinkingSphinx::OutOfBoundsError.new(error.message)
+    else
+      replacement = new(error.message)
+    end
+
+    replacement.set_backtrace error.backtrace
+    replacement.statement = error.statement if error.respond_to?(:statement)
+    replacement
+  end
+end
+
+class ThinkingSphinx::ConnectionError < ThinkingSphinx::SphinxError
+end
+
+class ThinkingSphinx::QueryError < ThinkingSphinx::SphinxError
+end
+
+class ThinkingSphinx::QueryLengthError < ThinkingSphinx::SphinxError
+  def message
+    <<-MESSAGE
+The supplied SphinxQL statement is #{statement.length} characters long. The maximum allowed length is #{ThinkingSphinx::Configuration.instance.settings['maximum_statement_length']}.
+
+If this error has been raised during real-time index population, it's probably due to overly large batches of records being processed at once. The default is 1000, but you can lower it on a per-environment basis in config/thinking_sphinx.yml:
+
+  development:
+    batch_size: 500
+    MESSAGE
+  end
+end
+
+class ThinkingSphinx::SyntaxError < ThinkingSphinx::QueryError
+end
+
+class ThinkingSphinx::ParseError < ThinkingSphinx::QueryError
+end
+
+class ThinkingSphinx::OutOfBoundsError < ThinkingSphinx::QueryError
+end
+
+class ThinkingSphinx::QueryExecutionError < StandardError
+  attr_accessor :statement
+end
+
+class ThinkingSphinx::MixedScopesError < StandardError
+end
+
+class ThinkingSphinx::NoIndicesError < StandardError
+end
+
+class ThinkingSphinx::MissingColumnError < StandardError
+end
+
+class ThinkingSphinx::PopulatedResultsError < StandardError
+end
+
+class ThinkingSphinx::DuplicateNameError < StandardError
+end
+
+class ThinkingSphinx::InvalidDatabaseAdapter < StandardError
+end
+
+class ThinkingSphinx::SphinxAlreadyRunning < StandardError
+end
+
+class ThinkingSphinx::UnknownDatabaseAdapter < StandardError
+end
+
+class ThinkingSphinx::UnknownAttributeType < StandardError
+end
+
+class ThinkingSphinx::TranscriptionError < StandardError
+  attr_accessor :inner_exception, :instance, :property
+end
+
+class ThinkingSphinx::UnknownCommand < StandardError
+end

data/lib/thinking_sphinx/excerpter.rb

@@ -1,22 +1,39 @@
-module ThinkingSphinx
-  class Excerpter
-    CoreMethods = %w( kind_of? object_id respond_to? should should_not stub! )
-    # Hide most methods, to allow them to be passed through to the instance.
-    instance_methods.select { |method|
-      method.to_s[/^__/].nil? && !CoreMethods.include?(method.to_s)
-    }.each { |method|
-      undef_method method
-    }
-    
-    def initialize(search, instance)
-      @search   = search
-      @instance = instance
-    end
-    
-    def method_missing(method, *args, &block)
-      string = CGI::escapeHTML @instance.send(method, *args, &block).to_s
-      
-      @search.excerpt_for(string, @instance.class)
+# frozen_string_literal: true
+
+class ThinkingSphinx::Excerpter
+  DefaultOptions = {
+    :before_match    => '<span class="match">',
+    :after_match     => '</span>',
+    :chunk_separator => ' &#8230; ' # ellipsis
+  }
+
+  attr_accessor :index, :words, :options
+
+  def initialize(index, words, options = {})
+    @index, @words = index, words
+    @options = DefaultOptions.merge(options)
+    @words = @options.delete(:words) if @options[:words]
+  end
+
+  def excerpt!(text)
+    result = ThinkingSphinx::Connection.take do |connection|
+      query = statement_for text
+      ThinkingSphinx::Logger.log :query, query do
+        connection.execute(query).first['snippet']
+      end
     end
+
+    encoded? ? result : ThinkingSphinx::UTF8.encode(result)
+  end
+
+  private
+
+  def statement_for(text)
+    Riddle::Query.snippets(text, index, words, options)
+  end
+
+  def encoded?
+    ThinkingSphinx::Configuration.instance.settings['utf8'].nil? ||
+    ThinkingSphinx::Configuration.instance.settings['utf8']
   end
 end

data/lib/thinking_sphinx/facet.rb

@@ -1,125 +1,32 @@
-module ThinkingSphinx
-  class Facet
-    attr_reader :property
-    
-    def initialize(property)
-      @property = property
-      
-      if property.columns.length != 1
-        raise "Can't translate Facets on multiple-column field or attribute"
-      end
-    end
+# frozen_string_literal: true
 
-    def self.name_for(facet)
-      case facet
-      when Facet
-        facet.name
-      when String, Symbol
-        facet.to_s.gsub(/(_facet|_crc)$/,'').to_sym
-      end
-    end
-    
-    def self.attribute_name_for(name)
-      name.to_s == 'class' ? 'class_crc' : "#{name}_facet"
-    end
-    
-    def self.attribute_name_from_value(name, value)
-      case value
-      when String
-        attribute_name_for(name)
-      when Array
-        if value.all? { |val| val.is_a?(Integer) }
-          name
-        else
-          attribute_name_for(name)
-        end
-      else
-        name
-      end
-    end
-    
-    def self.translate?(property)
-      return true if property.is_a?(Field)
-      
-      case property.type
-      when :string
-        true
-      when :integer, :boolean, :datetime, :float
-        false
-      when :multi
-        !property.all_ints?
-      end
-    end
-    
-    def name
-      property.unique_name
-    end
-    
-    def attribute_name
-      if translate?
-        Facet.attribute_name_for(@property.unique_name)
-      else
-        @property.unique_name.to_s
-      end
-    end
-    
-    def translate?
-      Facet.translate?(@property)
-    end
-    
-    def type
-      @property.is_a?(Field) ? :string : @property.type
-    end
-    
-    def value(object, attribute_value)
-      return translate(object, attribute_value) if translate? || float?
-      
-      case @property.type
-      when :datetime
-        Time.at(attribute_value)
-      when :boolean
-        attribute_value > 0
-      else
-        attribute_value
-      end
-    end
-    
-    def to_s
-      name
-    end
-    
-    private
-    
-    def translate(object, attribute_value)
-      objects = source_objects(object)
-      return nil if objects.nil? || objects.empty?
-      
-      if objects.length > 1
-        objects.collect { |item| item.send(column.__name) }.detect { |item|
-          item.to_crc32 == attribute_value
-        }
-      else
-        objects.first.send(column.__name)
-      end
-    end
-    
-    def source_objects(object)
-      column.__stack.each { |method|
-        object = Array(object).collect { |item|
-          item.send(method)
-        }.flatten.compact
-        
-        return nil if object.empty?
-      }
-      Array(object)
-    end
-    
-    def column
-      @property.columns.first
-    end
-    
-    def float?
-      @property.type == :float
-    end
+class ThinkingSphinx::Facet
+  attr_reader :name
+
+  def initialize(name, properties)
+    @name, @properties = name, properties
+  end
+
+  def filter_type
+    use_field? ? :conditions : :with
+  end
+
+  def results_from(raw)
+    raw.inject({}) { |hash, row|
+      hash[row[group_column]] = row["sphinx_internal_count"]
+      hash
+    }
+  end
+
+  private
+
+  def group_column
+    @properties.any?(&:multi?) ? "sphinx_internal_group" : name
+  end
+
+  def use_field?
+    @properties.any? { |property|
+      property.type.nil? || property.type == :string
+    }
   end
 end