thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/search_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Search do
@@ -34,26 +36,26 @@ describe ThinkingSphinx::Search do
   end
 
   before :each do
-    ThinkingSphinx::Search::Context.stub :new => context
+    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
-      search.current_page.should == 1
+      expect(search.current_page).to eq(1)
     end
 
     it "should handle string page values" do
-      ThinkingSphinx::Search.new(:page => '2').current_page.should == 2
+      expect(ThinkingSphinx::Search.new(:page => '2').current_page).to eq(2)
     end
 
     it "should handle empty string page values" do
-      ThinkingSphinx::Search.new(:page => '').current_page.should == 1
+      expect(ThinkingSphinx::Search.new(:page => '').current_page).to eq(1)
     end
 
     it "should return the requested page" do
-      ThinkingSphinx::Search.new(:page => 10).current_page.should == 10
+      expect(ThinkingSphinx::Search.new(:page => 10).current_page).to eq(10)
     end
   end
 
@@ -61,25 +63,25 @@ describe ThinkingSphinx::Search do
     it "returns false if there is anything in the data set" do
       context[:results] << double
 
-      search.should_not be_empty
+      expect(search).not_to be_empty
     end
 
     it "returns true if the data set is empty" do
       context[:results].clear
 
-      search.should be_empty
+      expect(search).to be_empty
     end
   end
 
   describe '#initialize' do
     it "lazily loads by default" do
-      stack.should_not_receive(:call)
+      expect(stack).not_to receive(:call)
 
       ThinkingSphinx::Search.new
     end
 
     it "should automatically populate when :populate is set to true" do
-      stack.should_receive(:call).and_return(true)
+      expect(stack).to receive(:call).and_return(true)
 
       ThinkingSphinx::Search.new(:populate => true)
     end
@@ -87,74 +89,74 @@ describe ThinkingSphinx::Search do
 
   describe '#offset' do
     it "should default to 0" do
-      search.offset.should == 0
+      expect(search.offset).to eq(0)
     end
 
     it "should increase by the per_page value for each page in" do
-      ThinkingSphinx::Search.new(:per_page => 25, :page => 2).offset.
-        should == 25
+      expect(ThinkingSphinx::Search.new(:per_page => 25, :page => 2).offset).
+        to eq(25)
     end
 
     it "should prioritise explicit :offset over calculated if given" do
-      ThinkingSphinx::Search.new(:offset => 5).offset.should == 5
+      expect(ThinkingSphinx::Search.new(:offset => 5).offset).to eq(5)
     end
   end
 
   describe '#page' do
     it "sets the current page" do
       search.page(3)
-      search.current_page.should == 3
+      expect(search.current_page).to eq(3)
     end
 
     it "returns the search object" do
-      search.page(2).should == search
+      expect(search.page(2)).to eq(search)
     end
   end
 
   describe '#per' do
     it "sets the current per_page value" do
       search.per(29)
-      search.per_page.should == 29
+      expect(search.per_page).to eq(29)
     end
 
     it "returns the search object" do
-      search.per(29).should == search
+      expect(search.per(29)).to eq(search)
     end
   end
 
   describe '#per_page' do
     it "defaults to 20" do
-      search.per_page.should == 20
+      expect(search.per_page).to eq(20)
     end
 
     it "is set as part of the search options" do
-      ThinkingSphinx::Search.new(:per_page => 10).per_page.should == 10
+      expect(ThinkingSphinx::Search.new(:per_page => 10).per_page).to eq(10)
     end
 
     it "should prioritise :limit over :per_page if given" do
-      ThinkingSphinx::Search.new(:per_page => 30, :limit => 40).per_page.
-        should == 40
+      expect(ThinkingSphinx::Search.new(:per_page => 30, :limit => 40).per_page).
+        to eq(40)
     end
 
     it "should allow for string arguments" do
-      ThinkingSphinx::Search.new(:per_page => '10').per_page.should == 10
+      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)
-      search.per_page.should == 24
+      expect(search.per_page).to eq(24)
     end
   end
 
   describe '#populate' do
     it "runs the middleware" do
-      stack.should_receive(:call).with([context]).and_return(true)
+      expect(stack).to receive(:call).with([context]).and_return(true)
 
       search.populate
     end
 
     it "does not retrieve results twice" do
-      stack.should_receive(:call).with([context]).once.and_return(true)
+      expect(stack).to receive(:call).with([context]).once.and_return(true)
 
       search.populate
       search.populate
@@ -163,11 +165,11 @@ describe ThinkingSphinx::Search do
 
   describe '#respond_to?' do
     it "should respond to Array methods" do
-      search.respond_to?(:each).should be_true
+      expect(search.respond_to?(:each)).to be_truthy
     end
 
     it "should respond to Search methods" do
-      search.respond_to?(:per_page).should be_true
+      expect(search.respond_to?(:per_page)).to be_truthy
     end
 
     it "should return true for methods delegated to pagination mask by method_missing" do
@@ -196,7 +198,7 @@ describe ThinkingSphinx::Search do
 
       context[:results] << glazed
 
-      search.to_a.first.__id__.should == unglazed.__id__
+      expect(search.to_a.first.__id__).to eq(unglazed.__id__)
     end
   end
 

data/spec/thinking_sphinx/wildcard_spec.rb

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

data/spec/thinking_sphinx_spec.rb

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

data/thinking-sphinx.gemspec

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = 'thinking-sphinx'
-  s.version     = '3.1.4'
+  s.version     = '6.0.0'
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Pat Allan"]
   s.email       = ["pat@freelancing-gods.com"]
@@ -12,7 +14,10 @@ Gem::Specification.new do |s|
   s.description = %Q{An intelligent layer for ActiveRecord (via Rails and Sinatra) for the Sphinx full-text search tool.}
   s.license     = 'MIT'
 
-  s.rubyforge_project = 'thinking-sphinx'
+  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")
@@ -21,15 +26,17 @@ Gem::Specification.new do |s|
   }
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency 'activerecord', '>= 3.1.0'
-  s.add_runtime_dependency 'builder',      '>= 2.1.2'
-  s.add_runtime_dependency 'joiner',       '>= 0.2.0'
+  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.0.2'
-  s.add_runtime_dependency 'riddle',       '>= 1.5.11'
+  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',       '~> 0.4.0'
-  s.add_development_dependency 'database_cleaner', '~> 1.2.0'
-  s.add_development_dependency 'rspec',            '~> 2.13.0'
+  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