thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx.rb

@@ -1,213 +1,111 @@
-Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
-  $LOAD_PATH.unshift path
+# frozen_string_literal: true
+
+if RUBY_PLATFORM == 'java'
+  require 'java'
+  require 'jdbc/mysql'
+  Jdbc::MySQL.load_driver
+else
+  require 'mysql2'
 end
 
-require 'active_record'
 require 'riddle'
-require 'after_commit'
-require 'yaml'
-require 'cgi'
-
-require 'thinking_sphinx/core/array'
-require 'thinking_sphinx/core/string'
-require 'thinking_sphinx/property'
-require 'thinking_sphinx/active_record'
-require 'thinking_sphinx/association'
-require 'thinking_sphinx/attribute'
-require 'thinking_sphinx/configuration'
-require 'thinking_sphinx/excerpter'
-require 'thinking_sphinx/facet'
-require 'thinking_sphinx/class_facet'
-require 'thinking_sphinx/facet_search'
-require 'thinking_sphinx/field'
-require 'thinking_sphinx/index'
-require 'thinking_sphinx/source'
-require 'thinking_sphinx/rails_additions'
-require 'thinking_sphinx/search'
-require 'thinking_sphinx/search_methods'
-require 'thinking_sphinx/deltas'
-
-require 'thinking_sphinx/adapters/abstract_adapter'
-require 'thinking_sphinx/adapters/mysql_adapter'
-require 'thinking_sphinx/adapters/postgresql_adapter'
-
-ActiveRecord::Base.send(:include, ThinkingSphinx::ActiveRecord)
-
-Merb::Plugins.add_rakefiles(
-  File.join(File.dirname(__FILE__), "thinking_sphinx", "tasks")
-) if defined?(Merb)
+require 'riddle/2.1.0'
+require 'middleware'
+require 'active_record'
+require 'innertube'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors'
 
 module ThinkingSphinx
-  # A ConnectionError will get thrown when a connection to Sphinx can't be
-  # made.
-  class ConnectionError < StandardError
-  end
-
-  # A StaleIdsException is thrown by Collection.instances_from_matches if there
-  # are records in Sphinx but not in the database, so the search can be retried.
-  class StaleIdsException < StandardError
-    attr_accessor :ids
-    def initialize(ids)
-      self.ids = ids
-    end
-  end
-  
-  # The current version of Thinking Sphinx.
-  # 
-  # @return [String] The version number as a string
-  # 
-  def self.version
-    hash = YAML.load_file File.join(File.dirname(__FILE__), '../VERSION.yml')
-    [hash[:major], hash[:minor], hash[:patch]].join('.')
-  end
-  
-  # The collection of indexed models. Keep in mind that Rails lazily loads
-  # its classes, so this may not actually be populated with _all_ the models
-  # that have Sphinx indexes.
-  def self.indexed_models
-    @@indexed_models ||= []
-  end
-
-  def self.unique_id_expression(offset = nil)
-    "* #{ThinkingSphinx.indexed_models.size} + #{offset || 0}"
-  end
-
-  # Check if index definition is disabled.
-  #
-  def self.define_indexes?
-    @@define_indexes =  true unless defined?(@@define_indexes)
-    @@define_indexes == true
-  end
-
-  # Enable/disable indexes - you may want to do this while migrating data.
-  #
-  #   ThinkingSphinx.define_indexes = false
-  #
-  def self.define_indexes=(value)
-    @@define_indexes = value
+  def self.count(query = '', options = {})
+    search_for_ids(query, options).total_entries
   end
 
-  @@deltas_enabled = nil
-
-  # Check if delta indexing is enabled.
-  #
-  def self.deltas_enabled?
-    @@deltas_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@deltas_enabled.nil?
-    @@deltas_enabled
-  end
-
-  # Enable/disable all delta indexing.
-  #
-  #   ThinkingSphinx.deltas_enabled = false
-  #
-  def self.deltas_enabled=(value)
-    @@deltas_enabled = value
+  def self.facets(query = '', options = {})
+    ThinkingSphinx::FacetSearch.new query, options
   end
 
-  @@updates_enabled = nil
-
-  # Check if updates are enabled. True by default, unless within the test
-  # environment.
-  #
-  def self.updates_enabled?
-    @@updates_enabled  = (ThinkingSphinx::Configuration.environment != 'test') if @@updates_enabled.nil?
-    @@updates_enabled
+  def self.search(query = '', options = {})
+    ThinkingSphinx::Search.new query, options
   end
 
-  # Enable/disable updates to Sphinx
-  #
-  #   ThinkingSphinx.updates_enabled = false
-  #
-  def self.updates_enabled=(value)
-    @@updates_enabled = value
+  def self.search_for_ids(query = '', options = {})
+    search = ThinkingSphinx::Search.new query, options
+    ThinkingSphinx::Search::Merger.new(search).merge! nil, :ids_only => true
   end
 
-  @@suppress_delta_output = false
-
-  def self.suppress_delta_output?
-    @@suppress_delta_output
+  def self.none
+    ThinkingSphinx::Search.new nil, :none => true
   end
 
-  def self.suppress_delta_output=(value)
-    @@suppress_delta_output = value
-  end
-  
-  @@use_group_by_shortcut = nil
-  # Checks to see if MySQL will allow simplistic GROUP BY statements. If not,
-  # or if not using MySQL, this will return false.
-  #
-  def self.use_group_by_shortcut?
-    @@use_group_by_shortcut ||= !!(
-      mysql? && ::ActiveRecord::Base.connection.select_all(
-        "SELECT @@global.sql_mode, @@session.sql_mode;"
-      ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
-    )
+  def self.before_index_hooks
+    @before_index_hooks
   end
 
-  @@remote_sphinx = false
+  @before_index_hooks = []
 
-  # An indication of whether Sphinx is running on a remote machine instead of
-  # the same machine.
-  #
-  def self.remote_sphinx?
-    @@remote_sphinx
+  def self.output
+    @output
   end
 
-  # Tells Thinking Sphinx that Sphinx is running on a different machine, and
-  # thus it can't reliably guess whether it is running or not (ie: the
-  # #sphinx_running? method), and so just assumes it is.
-  #
-  # Useful for multi-machine deployments. Set it in your production.rb file.
-  #
-  #   ThinkingSphinx.remote_sphinx = true
-  #
-  def self.remote_sphinx=(value)
-    @@remote_sphinx = value
-  end
-
-  # Check if Sphinx is running. If remote_sphinx is set to true (indicating
-  # Sphinx is on a different machine), this will always return true, and you
-  # will have to handle any connection errors yourself.
-  #
-  def self.sphinx_running?
-    remote_sphinx? || sphinx_running_by_pid?
-  end
+  @output = STDOUT
 
-  # Check if Sphinx is actually running, provided the pid is on the same
-  # machine as this code.
-  #
-  def self.sphinx_running_by_pid?
-    !!sphinx_pid && pid_active?(sphinx_pid)
+  def self.rake_interface
+    @rake_interface ||= ThinkingSphinx::RakeInterface
   end
 
-  def self.sphinx_pid
-    if File.exists?(ThinkingSphinx::Configuration.instance.pid_file)
-      File.read(ThinkingSphinx::Configuration.instance.pid_file)[/\d+/]
-    else
-      nil
-    end
+  def self.rake_interface=(interface)
+    @rake_interface = interface
   end
 
-  def self.pid_active?(pid)
-    !!Process.kill(0, pid.to_i)
-  rescue Exception => e
-    false
-  end
+  module Hooks; end
+  module IndexingStrategies; end
+  module Subscribers; end
+end
 
-  def self.microsoft?
-    RUBY_PLATFORM =~ /mswin/
-  end
+# Core
+require 'thinking_sphinx/attribute_types'
+require 'thinking_sphinx/batched_search'
+require 'thinking_sphinx/callbacks'
+require 'thinking_sphinx/core'
+require 'thinking_sphinx/with_output'
+require 'thinking_sphinx/commander'
+require 'thinking_sphinx/commands'
+require 'thinking_sphinx/configuration'
+require 'thinking_sphinx/connection'
+require 'thinking_sphinx/deletion'
+require 'thinking_sphinx/errors'
+require 'thinking_sphinx/excerpter'
+require 'thinking_sphinx/facet'
+require 'thinking_sphinx/facet_search'
+require 'thinking_sphinx/float_formatter'
+require 'thinking_sphinx/frameworks'
+require 'thinking_sphinx/guard'
+require 'thinking_sphinx/hooks/guard_presence'
+require 'thinking_sphinx/index'
+require 'thinking_sphinx/indexing_strategies/all_at_once'
+require 'thinking_sphinx/indexing_strategies/one_at_a_time'
+require 'thinking_sphinx/index_set'
+require 'thinking_sphinx/interfaces'
+require 'thinking_sphinx/masks'
+require 'thinking_sphinx/middlewares'
+require 'thinking_sphinx/panes'
+require 'thinking_sphinx/processor'
+require 'thinking_sphinx/query'
+require 'thinking_sphinx/rake_interface'
+require 'thinking_sphinx/scopes'
+require 'thinking_sphinx/search'
+require 'thinking_sphinx/settings'
+require 'thinking_sphinx/subscribers/populator_subscriber'
+require 'thinking_sphinx/test'
+require 'thinking_sphinx/utf8'
+require 'thinking_sphinx/wildcard'
+# Extended
+require 'thinking_sphinx/deltas'
+require 'thinking_sphinx/distributed'
+require 'thinking_sphinx/logger'
+require 'thinking_sphinx/real_time'
 
-  def self.jruby?
-    defined?(JRUBY_VERSION)
-  end
+require 'thinking_sphinx/railtie' if defined?(Rails::Railtie)
 
-  def self.mysql?
-    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlAdapter" ||
-    ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlplusAdapter" || (
-      jruby? && ::ActiveRecord::Base.connection.config[:adapter] == "jdbcmysql"
-    )
-  end
-  
-  extend ThinkingSphinx::SearchMethods::ClassMethods
-end
+ThinkingSphinx.before_index_hooks << ThinkingSphinx::Hooks::GuardPresence

data/spec/acceptance/association_scoping_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Scoping association search calls by foreign keys', :live => true do
+  describe 'for ActiveRecord indices' do
+    it "limits results to those matching the foreign key" do
+      pat       = User.create :name => 'Pat'
+      melbourne = Article.create :title => 'Guide to Melbourne', :user => pat
+      paul      = User.create :name => 'Paul'
+      dublin    = Article.create :title => 'Guide to Dublin',    :user => paul
+      index
+
+      expect(pat.articles.search('Guide').to_a).to eq([melbourne])
+    end
+
+    it "limits id-only results to those matching the foreign key" do
+      pat       = User.create :name => 'Pat'
+      melbourne = Article.create :title => 'Guide to Melbourne', :user => pat
+      paul      = User.create :name => 'Paul'
+      dublin    = Article.create :title => 'Guide to Dublin',    :user => paul
+      index
+
+      expect(pat.articles.search_for_ids('Guide').to_a).to eq([melbourne.id])
+    end
+  end
+
+  describe 'for real-time indices' do
+    it "limits results to those matching the foreign key" do
+      porsche = Manufacturer.create :name => 'Porsche'
+      spyder = Car.create :name => '918 Spyder', :manufacturer => porsche
+
+      audi = Manufacturer.create :name => 'Audi'
+      r_eight = Car.create :name => 'R8 Spyder', :manufacturer => audi
+
+      expect(porsche.cars.search('Spyder').to_a).to eq([spyder])
+    end
+
+    it "limits id-only results to those matching the foreign key" do
+      porsche = Manufacturer.create :name => 'Porsche'
+      spyder = Car.create :name => '918 Spyder', :manufacturer => porsche
+
+      audi = Manufacturer.create :name => 'Audi'
+      r_eight = Car.create :name => 'R8 Spyder', :manufacturer => audi
+
+      expect(porsche.cars.search_for_ids('Spyder').to_a).to eq([spyder.id])
+    end
+  end
+
+  describe 'with has_many :through associations' do
+    it 'limits results to those matching the foreign key' do
+      pancakes = Product.create :name => 'Low fat Pancakes'
+      waffles  = Product.create :name => 'Low fat Waffles'
+
+      food = Category.create :name => 'food'
+      flat = Category.create :name => 'flat'
+
+      pancakes.categories << food
+      pancakes.categories << flat
+      waffles.categories  << food
+
+      expect(flat.products.search('Low').to_a).to eq([pancakes])
+    end
+  end
+end

data/spec/acceptance/attribute_access_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Accessing attributes directly via search results', :live => true do
+  it "allows access to attribute values" do
+    Book.create! :title => 'American Gods', :publishing_year => 2001
+    index
+
+    search = Book.search('gods')
+    search.context[:panes] << ThinkingSphinx::Panes::AttributesPane
+
+    expect(search.first.sphinx_attributes['publishing_year']).to eq(2001)
+  end
+
+  it "provides direct access to the search weight/relevance scores" do
+    Book.create! :title => 'American Gods', :publishing_year => 2001
+    index
+
+    search = Book.search 'gods', :select => "*, weight()"
+    search.context[:panes] << ThinkingSphinx::Panes::WeightPane
+
+    if ENV["SPHINX_ENGINE"] == "sphinx" && ENV["SPHINX_VERSION"].to_f > 3.3
+      expect(search.first.weight).to eq(20_000.0)
+    else
+      expect(search.first.weight).to eq(2500)
+    end
+  end
+
+  it "provides direct access to the weight with alternative primary keys" do
+    album = Album.create! :name => 'Sing to the Moon', :artist => 'Laura Mvula'
+
+    search = Album.search 'sing', :select => "*, weight()"
+    search.context[:panes] << ThinkingSphinx::Panes::WeightPane
+
+    expect(search.first.weight).to be >= 1000
+  end
+
+  it "can enumerate with the weight" do
+    gods = Book.create! :title => 'American Gods', :publishing_year => 2001
+    index
+
+    search = Book.search 'gods', :select => "*, weight()"
+    search.masks << ThinkingSphinx::Masks::WeightEnumeratorMask
+
+    if ENV["SPHINX_ENGINE"] == "sphinx" && ENV["SPHINX_VERSION"].to_f > 3.3
+      expectations = [[gods, 20_000.0]]
+    else
+      expectations = [[gods, 2500]]
+    end
+    search.each_with_weight do |result, weight|
+      expectation = expectations.shift
+
+      expect(result).to eq(expectation.first)
+      expect(weight).to eq(expectation.last)
+    end
+  end
+end

data/spec/acceptance/attribute_updates_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Update attributes automatically where possible', :live => true do
+  it "updates boolean values" do
+    article = Article.create :title => 'Pancakes', :published => false
+    index
+
+    expect(Article.search('pancakes', :with => {:published => true})).to be_empty
+
+    article.published = true
+    article.save
+
+    expect(Article.search('pancakes', :with => {:published => true}).to_a)
+      .to eq([article])
+  end
+end

data/spec/acceptance/batch_searching_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Executing multiple searches in one Sphinx call', :live => true do
+  it "returns results matching the given queries" do
+    pancakes = Article.create! :title => 'Pancakes'
+    waffles  = Article.create! :title => 'Waffles'
+    index
+
+    batch = ThinkingSphinx::BatchedSearch.new
+    batch.searches << Article.search('pancakes')
+    batch.searches << Article.search('waffles')
+
+    batch.populate
+
+    expect(batch.searches.first).to include(pancakes)
+    expect(batch.searches.first).not_to include(waffles)
+
+    expect(batch.searches.last).to include(waffles)
+    expect(batch.searches.last).not_to include(pancakes)
+  end
+end

data/spec/acceptance/big_integers_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe '64 bit integer support' do
+  it "ensures all internal id attributes are big ints if one is" do
+    large_index = ThinkingSphinx::ActiveRecord::Index.new(:tweet)
+    large_index.definition_block = Proc.new {
+      indexes text
+    }
+
+    small_index = ThinkingSphinx::ActiveRecord::Index.new(:article)
+    small_index.definition_block = Proc.new {
+      indexes title
+    }
+
+    real_time_index = ThinkingSphinx::RealTime::Index.new(:product)
+    real_time_index.definition_block = Proc.new {
+      indexes name
+    }
+
+    ThinkingSphinx::Configuration::ConsistentIds.new(
+      [small_index, large_index, real_time_index]
+    ).reconcile
+
+    expect(large_index.sources.first.attributes.detect { |attribute|
+      attribute.name == 'sphinx_internal_id'
+    }.type).to eq(:bigint)
+
+    expect(small_index.sources.first.attributes.detect { |attribute|
+      attribute.name == 'sphinx_internal_id'
+    }.type).to eq(:bigint)
+
+    expect(real_time_index.attributes.detect { |attribute|
+      attribute.name == 'sphinx_internal_id'
+    }.type).to eq(:bigint)
+  end
+end
+
+describe '64 bit document ids', :live => true do
+  context 'with ActiveRecord' do
+    it 'handles large 32 bit integers with an offset multiplier' do
+      user = User.create! :name => 'Pat'
+      user.update_column :id, 980190962
+
+      index
+
+      expect(User.search('pat').to_a).to eq([user])
+    end
+  end
+
+  context 'with Real-Time' do
+    it 'handles large 32 bit integers with an offset multiplier' do
+      product = Product.create! :name => "Widget"
+      product.update :id => 980190962
+      expect(
+        Product.search('widget', :indices => ['product_core']).to_a
+      ).to eq([product])
+    end
+  end
+end

data/spec/acceptance/excerpts_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'acceptance/spec_helper'
+
+describe 'Accessing excerpts for methods on a search result', :live => true do
+  it "returns excerpts for a given method" do
+    Book.create! :title => 'American Gods', :publishing_year => 2001
+    index
+
+    search = Book.search('gods')
+    search.context[:panes] << ThinkingSphinx::Panes::ExcerptsPane
+
+    expect(search.first.excerpts.title).
+      to eq('American <span class="match">Gods</span>')
+  end
+
+  it "handles UTF-8 text for excerpts" do
+    Book.create! :title => 'Война и миръ', :publishing_year => 1869
+    index
+
+    search = Book.search 'миръ'
+    search.context[:panes] << ThinkingSphinx::Panes::ExcerptsPane
+
+    expect(search.first.excerpts.title).
+      to eq('Война и <span class="match">миръ</span>')
+  end if ENV['SPHINX_VERSION'].try :[], /2.2.\d/
+
+  it "does not include class names in excerpts" do
+    Book.create! :title => 'The Graveyard Book'
+    index
+
+    search = Book.search('graveyard')
+    search.context[:panes] << ThinkingSphinx::Panes::ExcerptsPane
+
+    expect(search.first.excerpts.title).
+      to eq('The <span class="match">Graveyard</span> Book')
+  end
+
+  it "respects the star option with queries" do
+    Article.create! :title => 'Something'
+    index
+
+    search = Article.search('thin', :star => true)
+    search.context[:panes] << ThinkingSphinx::Panes::ExcerptsPane
+
+    expect(search.first.excerpts.title).
+      to eq('<span class="match">Something</span>')
+  end
+end