thinking-sphinx 1.2.13 → 6.0.0

data/spec/internal/app/models/manufacturer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Manufacturer < ActiveRecord::Base
+  has_many :cars
+end

data/spec/internal/app/models/product.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Product < ActiveRecord::Base
+  has_many :categorisations
+  has_many :categories, :through => :categorisations
+
+  ThinkingSphinx::Callbacks.append(self, :behaviours => [:real_time])
+end

data/spec/internal/app/models/tag.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Tag < ActiveRecord::Base
+  has_many :taggings
+  has_many :articles, :through => :taggings
+end

data/{features/support → spec/internal/app}/models/tagging.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 class Tagging < ActiveRecord::Base
   belongs_to :tag
-  belongs_to :taggable, :polymorphic => true
+  belongs_to :article
 end

data/spec/internal/app/models/tee.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Tee < ActiveRecord::Base
+  belongs_to :colour
+
+  ThinkingSphinx::Callbacks.append(self, :behaviours => [:sql])
+  ThinkingSphinx::Callbacks.append(
+    self, behaviours: [:sql, :deltas], :path => [:colour]
+  )
+end

data/spec/internal/app/models/tweet.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Tweet < ActiveRecord::Base
+  self.primary_key = :id
+end

data/spec/internal/app/models/user.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class User < ActiveRecord::Base
+  has_many :articles
+
+  ThinkingSphinx::Callbacks.append(self, :behaviours => [:sql])
+
+  default_scope { order(:id) }
+  scope :recent, lambda { where('created_at > ?', 1.week.ago) }
+end

data/spec/internal/config/database.yml

@@ -0,0 +1,17 @@
+test:
+  adapter:      <%= ENV['DATABASE'] || 'mysql2' %>
+  database:     thinking_sphinx
+  username:     <%= ENV['DATABASE'] == 'postgresql' ? 'postgres' : 'root' %>
+<% if ENV["DATABASE_PASSWORD"] %>
+  password:     <%= ENV["DATABASE_PASSWORD"] %>
+<% end %>
+<% if ENV["DATABASE_PORT"] %>
+  host:         127.0.0.1
+  port:         <%= ENV["DATABASE_PORT"] %>
+<% elsif ENV["CI"] %>
+  password:     thinking_sphinx
+  host:         127.0.0.1
+  port:         <%= ENV['DATABASE'] == 'postgresql' ? 5432 : 3306 %>
+<% end %>
+  min_messages: warning
+  encoding:     utf8

data/spec/internal/db/schema.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table(:admin_people, :force => true) do |t|
+    t.string :name
+    t.timestamps null: false
+  end
+
+  create_table(:albums, :force => true, :id => false) do |t|
+    t.string :id
+    t.integer :integer_id
+    t.string :name
+    t.string :artist
+    t.boolean :delta, :default => true, :null => false
+  end
+
+  create_table(:animals, :force => true) do |t|
+    t.string :name
+    t.string :type
+  end
+
+  create_table(:articles, :force => true) do |t|
+    t.string  :title
+    t.text    :content
+    t.boolean :published
+    t.integer :user_id
+    t.timestamps null: false
+  end
+
+  create_table(:manufacturers, :force => true) do |t|
+    t.string  :name
+  end
+
+  create_table(:cars, :force => true) do |t|
+    t.integer :manufacturer_id
+    t.string  :name
+  end
+
+  create_table(:books, :force => true) do |t|
+    t.string  :title
+    t.string  :author
+    t.integer :publishing_year
+    t.string  :blurb_file
+    t.boolean :delta, :default => true,   :null => false
+    t.string  :type,  :default => 'Book', :null => false
+    t.timestamps null: false
+  end
+
+  create_table(:books_genres, :force => true, :id => false) do |t|
+    t.integer :book_id
+    t.integer :genre_id
+  end
+
+  create_table(:categories, :force => true) do |t|
+    t.string :name
+  end
+
+  create_table(:categorisations, :force => true) do |t|
+    t.integer :category_id
+    t.integer :product_id
+  end
+
+  create_table(:cities, :force => true) do |t|
+    t.string :name
+    t.float  :lat
+    t.float  :lng
+  end
+
+  create_table(:colours, :force => true) do |t|
+    t.string :name
+    t.boolean :delta, :null => false, :default => true
+    t.timestamps null: false
+  end
+
+  create_table(:events, :force => true) do |t|
+    t.string  :eventable_type
+    t.integer :eventable_id
+  end
+
+  create_table(:genres, :force => true) do |t|
+    t.string :name
+  end
+
+  create_table(:products, :force => true) do |t|
+    t.string :name
+    t.json :options if ::JSONColumn.call
+  end
+
+  create_table(:taggings, :force => true) do |t|
+    t.integer :tag_id
+    t.integer :article_id
+    t.timestamps null: false
+  end
+
+  create_table(:tags, :force => true) do |t|
+    t.string :name
+    t.timestamps null: false
+  end
+
+  create_table(:tees, :force => true) do |t|
+    t.integer :colour_id
+    t.timestamps null: false
+  end
+
+  create_table(:tweets, :force => true, :id => false) do |t|
+    t.column :id, :bigint, :null => false
+    t.string :text
+    t.timestamps null: false
+  end
+
+  create_table(:users, :force => true) do |t|
+    t.string :name
+    t.timestamps null: false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+require 'logger'
+
+Bundler.require :default, :development
+
+root = File.expand_path File.dirname(__FILE__)
+require "#{root}/support/multi_schema"
+require "#{root}/support/json_column"
+require "#{root}/support/mysql"
+require 'thinking_sphinx/railtie'
+
+Combustion.initialize! :active_record
+
+MultiSchema.new.create 'thinking_sphinx'
+
+require "#{root}/support/sphinx_yaml_helpers"
+
+RSpec.configure do |config|
+  # enable filtering for examples
+  config.filter_run :wip => nil
+  config.run_all_when_everything_filtered = true
+
+  config.around :each, :live do |example|
+    example.run_with_retry :retry => 3
+  end
+end

data/spec/support/json_column.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class JSONColumn
+  include ActiveRecord::ConnectionAdapters
+
+  def self.call
+    new.call
+  end
+
+  def call
+    ruby? && postgresql? && column?
+  end
+
+  private
+
+  def column?
+    (
+      ActiveRecord::ConnectionAdapters.constants.include?(:PostgreSQLAdapter) &&
+      PostgreSQLAdapter.constants.include?(:TableDefinition) &&
+      PostgreSQLAdapter::TableDefinition.instance_methods.include?(:json)
+    ) || (
+      ActiveRecord::ConnectionAdapters.constants.include?(:PostgreSQL) &&
+      PostgreSQL.constants.include?(:ColumnMethods) &&
+      PostgreSQL::ColumnMethods.instance_methods.include?(:json)
+    )
+  end
+
+  def postgresql?
+    ENV['DATABASE'] == 'postgresql'
+  end
+
+  def ruby?
+    RUBY_PLATFORM != 'java'
+  end
+end

data/spec/support/multi_schema.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class MultiSchema
+  def active?
+    ENV['DATABASE'] == 'postgresql'
+  end
+
+  def create(schema_name)
+    return unless active?
+
+    unless connection.schema_exists? schema_name
+      connection.execute %Q{CREATE SCHEMA "#{schema_name}"}
+    end
+
+    switch schema_name
+    load Rails.root.join('db', 'schema.rb')
+  end
+
+  def current
+    connection.schema_search_path
+  end
+
+  def switch(schema_name)
+    connection.schema_search_path = %Q{"#{schema_name}"}
+    connection.clear_query_cache
+  end
+
+  private
+
+  def connection
+    ActiveRecord::Base.connection
+  end
+
+  class IndexSet < ThinkingSphinx::IndexSet
+    private
+
+    def indices
+      return super if index_names.any?
+
+      prefixed = !multi_schema.current.include?('public')
+      super.select { |index|
+        prefixed ? index.name[/_two_core$/] : index.name[/_two_core$/].nil?
+      }
+    end
+
+    def multi_schema
+      @multi_schema ||= MultiSchema.new
+    end
+  end
+end

data/spec/support/mysql.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# New versions of MySQL don't allow NULL values for primary keys, but old
+# versions of Rails do. To use both at the same time, we need to update Rails'
+# default primary key type to no longer have a default NULL value.
+#
+class PatchAdapter
+  def call
+    return unless using_mysql? && using_rails_pre_4_1?
+
+    require 'active_record/connection_adapters/abstract_mysql_adapter'
+    ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::
+      NATIVE_DATABASE_TYPES[:primary_key] = "int(11) auto_increment PRIMARY KEY"
+  end
+
+  def using_mysql?
+    ENV.fetch('DATABASE', 'mysql2') == 'mysql2'
+  end
+
+  def using_rails_pre_4_1?
+    ActiveRecord::VERSION::STRING.to_f < 4.1
+  end
+end
+
+PatchAdapter.new.call

data/spec/support/sphinx_yaml_helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SphinxYamlHelpers
+  def write_configuration(hash)
+    allow(File).to receive(:read).and_return({'test' => hash}.to_yaml)
+    allow(File).to receive(:exist?).and_wrap_original do |original, path|
+      next true if path.to_s == File.absolute_path("config/thinking_sphinx.yml", Rails.root.to_s)
+
+      original.call(path)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include SphinxYamlHelpers
+end

data/spec/thinking_sphinx/active_record/association_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Association do
+  let(:association) { ThinkingSphinx::ActiveRecord::Association.new column }
+  let(:column)      { double('column', :__stack => [:users], :__name => :post) }
+
+  describe '#stack' do
+    it "returns the column's stack and name" do
+      expect(association.stack).to eq([:users, :post])
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/attribute/type_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module ActiveRecord
+    class Attribute; end
+  end
+end
+
+require 'thinking_sphinx/errors'
+require 'thinking_sphinx/active_record/attribute/type'
+
+describe ThinkingSphinx::ActiveRecord::Attribute::Type do
+  let(:type) {
+    ThinkingSphinx::ActiveRecord::Attribute::Type.new attribute, model }
+  let(:attribute) { double('attribute', :columns => [column], :options => {}) }
+  let(:model)     { double('model', :columns => [db_column]) }
+  let(:column)    { double('column', :__name => :created_at, :string? => false,
+    :__stack => []) }
+  let(:db_column) { double('column', :name => 'created_at',
+    :type => :integer) }
+
+  describe '#multi?' do
+    let(:association) { double('association', :klass => double) }
+
+    before :each do
+      column.__stack << :foo
+
+      allow(model).to receive(:reflect_on_association).and_return(association)
+    end
+
+    it "returns true if there are has_many associations" do
+      allow(association).to receive(:macro).and_return(:has_many)
+
+      expect(type).to be_multi
+    end
+
+    it "returns true if there are has_and_belongs_to_many associations" do
+      allow(association).to receive(:macro).and_return(:has_and_belongs_to_many)
+
+      expect(type).to be_multi
+    end
+
+    it "returns false if there are no associations" do
+      column.__stack.clear
+
+      expect(type).not_to be_multi
+    end
+
+    it "returns false if there are only belongs_to associations" do
+      allow(association).to receive(:macro).and_return(:belongs_to)
+
+      expect(type).not_to be_multi
+    end
+
+    it "returns false if there are only has_one associations" do
+      allow(association).to receive(:macro).and_return(:has_one)
+
+      expect(type).not_to be_multi
+    end
+
+    it "returns true if deeper associations have many" do
+      column.__stack << :bar
+      deep_association = double(:klass => double, :macro => :has_many)
+
+      allow(association).to receive(:macro).and_return(:belongs_to)
+      allow(association).to receive(:klass).and_return(
+        double(:reflect_on_association => deep_association)
+      )
+
+      expect(type).to be_multi
+    end
+
+    it "respects the provided setting" do
+      attribute.options[:multi] = true
+
+      expect(type).to be_multi
+    end
+  end
+
+  describe '#type' do
+    it "returns the type option provided" do
+      attribute.options[:type] = :datetime
+
+      expect(type.type).to eq(:datetime)
+    end
+
+    it "detects integer types from the database" do
+      allow(db_column).to receive_messages(:type => :integer, :sql_type => 'integer(11)')
+
+      expect(type.type).to eq(:integer)
+    end
+
+    it "detects boolean types from the database" do
+      allow(db_column).to receive_messages(:type => :boolean)
+
+      expect(type.type).to eq(:boolean)
+    end
+
+    it "detects datetime types from the database as timestamps" do
+      allow(db_column).to receive_messages(:type => :datetime)
+
+      expect(type.type).to eq(:timestamp)
+    end
+
+    it "detects date types from the database as timestamps" do
+      allow(db_column).to receive_messages(:type => :date)
+
+      expect(type.type).to eq(:timestamp)
+    end
+
+    it "detects string types from the database" do
+      allow(db_column).to receive_messages(:type => :string)
+
+      expect(type.type).to eq(:string)
+    end
+
+    it "detects text types from the database as strings" do
+      allow(db_column).to receive_messages(:type => :text)
+
+      expect(type.type).to eq(:string)
+    end
+
+    it "detects float types from the database" do
+      allow(db_column).to receive_messages(:type => :float)
+
+      expect(type.type).to eq(:float)
+    end
+
+    it "detects decimal types from the database as floats" do
+      allow(db_column).to receive_messages(:type => :decimal)
+
+      expect(type.type).to eq(:float)
+    end
+
+    it "detects big ints as big ints" do
+      allow(db_column).to receive_messages :type => :bigint
+
+      expect(type.type).to eq(:bigint)
+    end
+
+    it "detects large integers as big ints" do
+      allow(db_column).to receive_messages :type => :integer, :sql_type => 'bigint(20)'
+
+      expect(type.type).to eq(:bigint)
+    end
+
+    it "detects JSON" do
+      allow(db_column).to receive_messages :type => :json
+
+      expect(type.type).to eq(:json)
+    end
+
+    it "respects provided type setting" do
+      attribute.options[:type] = :timestamp
+
+      expect(type.type).to eq(:timestamp)
+    end
+
+    it 'raises an error if the database column does not exist' do
+      model.columns.clear
+
+      expect { type.type }.to raise_error(ThinkingSphinx::MissingColumnError)
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/base_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Base do
+  let(:model) {
+    Class.new(ActiveRecord::Base) do
+      include ThinkingSphinx::ActiveRecord::Base
+
+      def self.name; 'Model'; end
+    end
+  }
+  let(:sub_model) {
+    Class.new(model) do
+      def self.name; 'SubModel'; end
+    end
+  }
+
+  describe '.facets' do
+    it "returns a new search object" do
+      expect(model.facets).to be_a(ThinkingSphinx::FacetSearch)
+    end
+
+    it "passes through arguments to the search object" do
+      expect(model.facets('pancakes').query).to eq('pancakes')
+    end
+
+    it "scopes the search to a given model" do
+      expect(model.facets('pancakes').options[:classes]).to eq([model])
+    end
+
+    it "merges the :classes option with the model" do
+      expect(model.facets('pancakes', :classes => [sub_model]).
+        options[:classes]).to eq([sub_model, model])
+    end
+
+    it "applies the default scope if there is one" do
+      allow(model).to receive_messages :default_sphinx_scope => :default,
+        :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}
+
+      expect(model.facets.options[:order]).to eq(:created_at)
+    end
+
+    it "does not apply a default scope if one is not set" do
+      allow(model).to receive_messages :default_sphinx_scope => nil,
+        :default => {:order => :created_at}
+
+      expect(model.facets.options[:order]).to be_nil
+    end
+  end
+
+  describe '.search' do
+    let(:stack) { double('stack', :call => true) }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Middlewares::DEFAULT', stack
+    end
+
+    it "returns a new search object" do
+      expect(model.search).to be_a(ThinkingSphinx::Search)
+    end
+
+    it "passes through arguments to the search object" do
+      expect(model.search('pancakes').query).to eq('pancakes')
+    end
+
+    it "scopes the search to a given model" do
+      expect(model.search('pancakes').options[:classes]).to eq([model])
+    end
+
+    it "passes through options to the search object" do
+      expect(model.search('pancakes', populate: true).
+        options[:populate]).to be_truthy
+    end
+
+    it "should automatically populate when :populate is set to true" do
+      expect(stack).to receive(:call).and_return(true)
+
+      model.search('pancakes', populate: true)
+    end
+
+    it "merges the :classes option with the model" do
+      expect(model.search('pancakes', :classes => [sub_model]).
+        options[:classes]).to eq([sub_model, model])
+    end
+
+    it "respects provided middleware" do
+      expect(model.search(:middleware => ThinkingSphinx::Middlewares::RAW_ONLY).
+        options[:middleware]).to eq(ThinkingSphinx::Middlewares::RAW_ONLY)
+    end
+
+    it "respects provided masks" do
+      expect(model.search(:masks => [ThinkingSphinx::Masks::PaginationMask]).
+        masks).to eq([ThinkingSphinx::Masks::PaginationMask])
+    end
+
+    it "applies the default scope if there is one" do
+      allow(model).to receive_messages :default_sphinx_scope => :default,
+        :sphinx_scopes => {:default => Proc.new { {:order => :created_at} }}
+
+      expect(model.search.options[:order]).to eq(:created_at)
+    end
+
+    it "does not apply a default scope if one is not set" do
+      allow(model).to receive_messages :default_sphinx_scope => nil,
+        :default => {:order => :created_at}
+
+      expect(model.search.options[:order]).to be_nil
+    end
+  end
+
+  describe '.search_count' do
+    let(:search) { double('search', :options => {}, :total_entries => 12,
+      :populated? => false) }
+
+    before :each do
+      allow(ThinkingSphinx).to receive_messages :search => search
+      allow(FileUtils).to receive_messages :mkdir_p => true
+    end
+
+    it "returns the search object's total entries count" do
+      expect(model.search_count).to eq(search.total_entries)
+    end
+
+    it "scopes the search to a given model" do
+      model.search_count
+
+      expect(search.options[:classes]).to eq([model])
+    end
+  end
+end