thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/search/glaze_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  class Search; end
+end
+
+require 'thinking_sphinx/search/glaze'
+
+describe ThinkingSphinx::Search::Glaze do
+  let(:glaze)   { ThinkingSphinx::Search::Glaze.new context, object, raw, [] }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+  let(:context) { {} }
+
+  describe '#!=' do
+    it "is true for objects that don't match" do
+      expect(glaze != double('foo')).to be_truthy
+    end
+
+    it "is false when the underlying object is a match" do
+      expect(glaze != object).to be_falsey
+    end
+  end
+
+  describe '#method_missing' do
+    let(:glaze)    {
+      ThinkingSphinx::Search::Glaze.new context, object, raw, [klass, klass] }
+    let(:klass)    { double('pane class') }
+    let(:pane_one) { double('pane one', :foo => 'one') }
+    let(:pane_two) { double('pane two', :foo => 'two', :bar => 'two') }
+
+    before :each do
+      allow(klass).to receive(:new).and_return(pane_one, pane_two)
+    end
+
+    it "respects objects existing methods" do
+      allow(object).to receive_messages :foo => 'original'
+
+      expect(glaze.foo).to eq('original')
+    end
+
+    it "uses the first pane that responds to the method" do
+      expect(glaze.foo).to eq('one')
+      expect(glaze.bar).to eq('two')
+    end
+
+    it "raises the method missing error otherwise" do
+      allow(object).to receive_messages :respond_to? => false
+      allow(object).to receive(:baz).and_raise(NoMethodError)
+
+      expect { glaze.baz }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe '#respond_to?' do
+    it "responds to underlying object methods" do
+      allow(object).to receive_messages :foo => true
+
+      expect(glaze.respond_to?(:foo)).to be_truthy
+    end
+
+    it "responds to underlying pane methods" do
+      pane  = double('Pane Class', :new => double('pane', :bar => true))
+      glaze = ThinkingSphinx::Search::Glaze.new context, object, raw, [pane]
+
+      expect(glaze.respond_to?(:bar)).to be_truthy
+    end
+
+    it "does not to respond to methods that don't exist" do
+      expect(glaze.respond_to?(:something)).to be_falsey
+    end
+  end
+
+  describe '#unglazed' do
+    it "returns the original object" do
+      expect(glaze.unglazed).to eq(object)
+    end
+  end
+end

data/spec/thinking_sphinx/search/query_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  class Search; end
+end
+
+require 'active_support/core_ext/object/blank'
+require './lib/thinking_sphinx/search/query'
+
+describe ThinkingSphinx::Search::Query do
+  before :each do
+    stub_const 'ThinkingSphinx::Query', double(wildcard: '')
+  end
+
+  describe '#to_s' do
+    it "passes through the keyword as provided" do
+      query = ThinkingSphinx::Search::Query.new 'pancakes'
+
+      expect(query.to_s).to eq('pancakes')
+    end
+
+    it "pairs fields and keywords for given conditions" do
+      query = ThinkingSphinx::Search::Query.new '', :title => 'pancakes'
+
+      expect(query.to_s).to eq('@title pancakes')
+    end
+
+    it "combines both keywords and conditions" do
+      query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes'
+
+      expect(query.to_s).to eq('tasty @title pancakes')
+    end
+
+    it "automatically stars keywords if requested" do
+      expect(ThinkingSphinx::Query).to receive(:wildcard).with('cake', true).
+        and_return('*cake*')
+
+      ThinkingSphinx::Search::Query.new('cake', {}, true).to_s
+    end
+
+    it "automatically stars condition keywords if requested" do
+      expect(ThinkingSphinx::Query).to receive(:wildcard).with('pan', true).
+        and_return('*pan*')
+
+      ThinkingSphinx::Search::Query.new('', {:title => 'pan'}, true).to_s
+    end
+
+    it "does not star the sphinx_internal_class field keyword" do
+      query = ThinkingSphinx::Search::Query.new '',
+        {:sphinx_internal_class_name => 'article'}, true
+
+      expect(query.to_s).to eq('@sphinx_internal_class_name article')
+    end
+
+    it "handles null values by removing them from the conditions hash" do
+      query = ThinkingSphinx::Search::Query.new '', :title => nil
+
+      expect(query.to_s).to eq('')
+    end
+
+    it "handles empty string values by removing them from the conditions hash" do
+      query = ThinkingSphinx::Search::Query.new '', :title => ''
+
+      expect(query.to_s).to eq('')
+    end
+
+    it "handles nil queries" do
+      query = ThinkingSphinx::Search::Query.new nil, {}
+
+      expect(query.to_s).to eq('')
+    end
+
+    it "allows mixing of blank and non-blank conditions" do
+      query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes',
+        :ingredients => nil
+
+      expect(query.to_s).to eq('tasty @title pancakes')
+    end
+
+    it "handles multiple fields for a single condition" do
+      query = ThinkingSphinx::Search::Query.new '',
+        [:title, :content] => 'pancakes'
+
+      expect(query.to_s).to eq('@(title,content) pancakes')
+    end
+  end
+end

data/spec/thinking_sphinx/search_spec.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Search do
+  let(:search)        { ThinkingSphinx::Search.new }
+  let(:context)       { {:results => []} }
+  let(:stack)         { double('stack', :call => true) }
+
+  let(:pagination_mask_methods) do
+    [:first_page?,
+     :last_page?,
+     :next_page,
+     :next_page?,
+     :page,
+     :per,
+     :previous_page,
+     :total_entries,
+     :total_count,
+     :count,
+     :total_pages,
+     :page_count,
+     :num_pages]
+  end
+
+  let(:scopes_mask_methods) do
+    [:facets,
+     :search,
+     :search_for_ids]
+  end
+
+  let(:group_enumerator_mask_methods) do
+    [:each_with_count,
+     :each_with_group,
+     :each_with_group_and_count]
+  end
+
+  before :each do
+    allow(ThinkingSphinx::Search::Context).to receive_messages :new => context
+
+    stub_const 'ThinkingSphinx::Middlewares::DEFAULT', stack
+  end
+
+  describe '#current_page' do
+    it "should return 1 by default" do
+      expect(search.current_page).to eq(1)
+    end
+
+    it "should handle string page values" do
+      expect(ThinkingSphinx::Search.new(:page => '2').current_page).to eq(2)
+    end
+
+    it "should handle empty string page values" do
+      expect(ThinkingSphinx::Search.new(:page => '').current_page).to eq(1)
+    end
+
+    it "should return the requested page" do
+      expect(ThinkingSphinx::Search.new(:page => 10).current_page).to eq(10)
+    end
+  end
+
+  describe '#empty?' do
+    it "returns false if there is anything in the data set" do
+      context[:results] << double
+
+      expect(search).not_to be_empty
+    end
+
+    it "returns true if the data set is empty" do
+      context[:results].clear
+
+      expect(search).to be_empty
+    end
+  end
+
+  describe '#initialize' do
+    it "lazily loads by default" do
+      expect(stack).not_to receive(:call)
+
+      ThinkingSphinx::Search.new
+    end
+
+    it "should automatically populate when :populate is set to true" do
+      expect(stack).to receive(:call).and_return(true)
+
+      ThinkingSphinx::Search.new(:populate => true)
+    end
+  end
+
+  describe '#offset' do
+    it "should default to 0" do
+      expect(search.offset).to eq(0)
+    end
+
+    it "should increase by the per_page value for each page in" do
+      expect(ThinkingSphinx::Search.new(:per_page => 25, :page => 2).offset).
+        to eq(25)
+    end
+
+    it "should prioritise explicit :offset over calculated if given" do
+      expect(ThinkingSphinx::Search.new(:offset => 5).offset).to eq(5)
+    end
+  end
+
+  describe '#page' do
+    it "sets the current page" do
+      search.page(3)
+      expect(search.current_page).to eq(3)
+    end
+
+    it "returns the search object" do
+      expect(search.page(2)).to eq(search)
+    end
+  end
+
+  describe '#per' do
+    it "sets the current per_page value" do
+      search.per(29)
+      expect(search.per_page).to eq(29)
+    end
+
+    it "returns the search object" do
+      expect(search.per(29)).to eq(search)
+    end
+  end
+
+  describe '#per_page' do
+    it "defaults to 20" do
+      expect(search.per_page).to eq(20)
+    end
+
+    it "is set as part of the search options" do
+      expect(ThinkingSphinx::Search.new(:per_page => 10).per_page).to eq(10)
+    end
+
+    it "should prioritise :limit over :per_page if given" do
+      expect(ThinkingSphinx::Search.new(:per_page => 30, :limit => 40).per_page).
+        to eq(40)
+    end
+
+    it "should allow for string arguments" do
+      expect(ThinkingSphinx::Search.new(:per_page => '10').per_page).to eq(10)
+    end
+
+    it "allows setting of the per_page value" do
+      search.per_page(24)
+      expect(search.per_page).to eq(24)
+    end
+  end
+
+  describe '#populate' do
+    it "runs the middleware" do
+      expect(stack).to receive(:call).with([context]).and_return(true)
+
+      search.populate
+    end
+
+    it "does not retrieve results twice" do
+      expect(stack).to receive(:call).with([context]).once.and_return(true)
+
+      search.populate
+      search.populate
+    end
+  end
+
+  describe '#respond_to?' do
+    it "should respond to Array methods" do
+      expect(search.respond_to?(:each)).to be_truthy
+    end
+
+    it "should respond to Search methods" do
+      expect(search.respond_to?(:per_page)).to be_truthy
+    end
+
+    it "should return true for methods delegated to pagination mask by method_missing" do
+      pagination_mask_methods.each do |method|
+        expect(search).to respond_to method
+      end
+    end
+
+    it "should return true for methods delegated to scopes mask by method_missing" do
+      scopes_mask_methods.each do |method|
+        expect(search).to respond_to method
+      end
+    end
+
+    it "should return true for methods delegated to group enumerators mask by method_missing" do
+      group_enumerator_mask_methods.each do |method|
+        expect(search).to respond_to method
+      end
+    end
+  end
+
+  describe '#to_a' do
+    it "returns each of the standard ActiveRecord objects" do
+      unglazed = double('unglazed instance')
+      glazed   = double('glazed instance', :unglazed => unglazed)
+
+      context[:results] << glazed
+
+      expect(search.to_a.first.__id__).to eq(unglazed.__id__)
+    end
+  end
+
+  it "correctly handles access to methods delegated to masks through 'method' call" do
+    [
+      pagination_mask_methods,
+      scopes_mask_methods,
+      group_enumerator_mask_methods
+    ].flatten.each do |method|
+      expect { search.method method }.to_not raise_exception
+    end
+  end
+end

data/spec/thinking_sphinx/wildcard_spec.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module ThinkingSphinx; end
+
+require './lib/thinking_sphinx/wildcard'
+
+describe ThinkingSphinx::Wildcard do
+  describe '.call' do
+    it "does not star quorum operators" do
+      expect(ThinkingSphinx::Wildcard.call("foo/3")).to eq("*foo*/3")
+    end
+
+    it "does not star proximity operators or quoted strings" do
+      expect(ThinkingSphinx::Wildcard.call(%q{"hello world"~3})).
+        to eq(%q{"hello world"~3})
+    end
+
+    it "treats slashes as a separator when starring" do
+      expect(ThinkingSphinx::Wildcard.call("a\\/c")).to eq("*a*\\/*c*")
+    end
+
+    it "separates escaping from the end of words" do
+      expect(ThinkingSphinx::Wildcard.call("\\(913\\)")).to eq("\\(*913*\\)")
+    end
+
+    it "ignores escaped slashes" do
+      expect(ThinkingSphinx::Wildcard.call("\\/\\/pan")).to eq("\\/\\/*pan*")
+    end
+
+    it "does not star manually provided field tags" do
+      expect(ThinkingSphinx::Wildcard.call("@title pan")).to eq("@title *pan*")
+    end
+
+    it 'does not star multiple field tags' do
+      expect(ThinkingSphinx::Wildcard.call("@title pan @tags food")).
+        to eq("@title *pan* @tags *food*")
+    end
+
+    it "does not star manually provided arrays of field tags" do
+      expect(ThinkingSphinx::Wildcard.call("@(title, body) pan")).
+        to eq("@(title, body) *pan*")
+    end
+
+    it "handles nil queries" do
+      expect(ThinkingSphinx::Wildcard.call(nil)).to eq('')
+    end
+
+    it "handles unicode values" do
+      expect(ThinkingSphinx::Wildcard.call('älytön')).to eq('*älytön*')
+    end
+  end
+end

data/spec/thinking_sphinx_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx do
+  describe '.count' do
+    let(:search) { double('search', :total_entries => 23, :populated? => false,
+      :options => {}) }
+
+    before :each do
+      allow(ThinkingSphinx::Search).to receive_messages :new => search
+    end
+
+    it "returns the total entries of the search object" do
+      expect(ThinkingSphinx.count).to eq(search.total_entries)
+    end
+
+    it "passes through the given query and options" do
+      expect(ThinkingSphinx::Search).to receive(:new).with('foo', { :bar => :baz }).
+        and_return(search)
+
+      ThinkingSphinx.count('foo', :bar => :baz)
+    end
+  end
+
+  describe '.search' do
+    let(:search) { double('search') }
+
+    before :each do
+      allow(ThinkingSphinx::Search).to receive_messages :new => search
+    end
+
+    it "returns a new search object" do
+      expect(ThinkingSphinx.search).to eq(search)
+    end
+
+    it "passes through the given query and options" do
+      expect(ThinkingSphinx::Search).to receive(:new).with('foo', { :bar => :baz }).
+        and_return(search)
+
+      ThinkingSphinx.search('foo', :bar => :baz)
+    end
+  end
+end

data/thinking-sphinx.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'thinking-sphinx'
+  s.version     = '6.0.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Pat Allan"]
+  s.email       = ["pat@freelancing-gods.com"]
+  s.homepage    = 'https://pat.github.io/thinking-sphinx/'
+  s.summary     = 'A smart wrapper over Sphinx for ActiveRecord'
+  s.description = %Q{An intelligent layer for ActiveRecord (via Rails and Sinatra) for the Sphinx full-text search tool.}
+  s.license     = 'MIT'
+
+  s.metadata['homepage_uri'] = s.homepage
+  s.metadata['source_code_uri'] = 'https://github.com/pat/thinking-sphinx'
+  s.metadata['changelog_uri'] = 'https://github.com/pat/thinking-sphinx/blob/develop/CHANGELOG.markdown'
+  s.metadata['rubygems_mfa_required'] = 'true'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f|
+    File.basename(f)
+  }
+  s.require_paths = ['lib']
+
+  s.required_ruby_version = '>= 3.0'
+
+  s.add_runtime_dependency 'activerecord', '>= 6.1.0'
+  s.add_runtime_dependency 'joiner',       '>= 0.6.0'
+  s.add_runtime_dependency 'middleware',   '>= 0.1.0'
+  s.add_runtime_dependency 'innertube',    '>= 1.1.0'
+  s.add_runtime_dependency 'riddle',       '~> 2.4'
+
+  s.add_development_dependency 'appraisal',        '~> 1.0.2'
+  s.add_development_dependency 'combustion',       '~> 1.1'
+  s.add_development_dependency 'database_cleaner', '~> 2.0.2'
+  s.add_development_dependency 'rspec',            '~> 3.12.0'
+  s.add_development_dependency 'rspec-retry',      '~> 0.5.6'
+end