thinking-sphinx 3.2.0 → 3.3.0

data/spec/acceptance/sorting_search_results_spec.rb

@@ -7,7 +7,7 @@ describe 'Sorting search results', :live => true do
     boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
     index
 
-    Book.search(:order => 'year ASC').to_a.should == [gods, boys, grave]
+    expect(Book.search(:order => 'year ASC').to_a).to eq([gods, boys, grave])
   end
 
   it "sorts by a given attribute in ascending order" do
@@ -16,7 +16,7 @@ describe 'Sorting search results', :live => true do
     boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
     index
 
-    Book.search(:order => :year).to_a.should == [gods, boys, grave]
+    expect(Book.search(:order => :year).to_a).to eq([gods, boys, grave])
   end
 
   it "sorts by a given sortable field" do
@@ -25,14 +25,14 @@ describe 'Sorting search results', :live => true do
     boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
     index
 
-    Book.search(:order => :title).to_a.should == [gods, boys, grave]
+    expect(Book.search(:order => :title).to_a).to eq([gods, boys, grave])
   end
 
   it "sorts by a given sortable field with real-time indices" do
     widgets = Product.create! :name => 'Widgets'
     gadgets = Product.create! :name => 'Gadgets'
 
-    Product.search(:order => "name_sort ASC").to_a.should == [gadgets, widgets]
+    expect(Product.search(:order => "name_sort ASC").to_a).to eq([gadgets, widgets])
   end
 
   it "can sort with a provided expression" do
@@ -41,8 +41,8 @@ describe 'Sorting search results', :live => true do
     boys  = Book.create! :title => 'Anansi Boys',        :year => 2005
     index
 
-    Book.search(
+    expect(Book.search(
       :select => '*, year MOD 2004 as mod_year', :order => 'mod_year ASC'
-    ).to_a.should == [boys, grave, gods]
+    ).to_a).to eq([boys, grave, gods])
   end
 end

data/spec/acceptance/specifying_sql_spec.rb

@@ -8,7 +8,7 @@ describe 'specifying SQL for index definitions' do
       join user
     }
     index.render
-    index.sources.first.sql_query.should match(/LEFT OUTER JOIN .users./)
+    expect(index.sources.first.sql_query).to match(/LEFT OUTER JOIN .users./)
   end
 
   it "handles deep joins" do
@@ -20,8 +20,8 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .users./)
-    query.should match(/LEFT OUTER JOIN .articles./)
+    expect(query).to match(/LEFT OUTER JOIN .users./)
+    expect(query).to match(/LEFT OUTER JOIN .articles./)
   end
 
   it "handles has-many :through joins" do
@@ -32,8 +32,8 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .taggings./)
-    query.should match(/LEFT OUTER JOIN .tags./)
+    expect(query).to match(/LEFT OUTER JOIN .taggings./)
+    expect(query).to match(/LEFT OUTER JOIN .tags./)
   end
 
   it "handles custom join SQL statements" do
@@ -45,7 +45,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/INNER JOIN foo ON foo.x = bar.y/)
+    expect(query).to match(/INNER JOIN foo ON foo.x = bar.y/)
   end
 
   it "handles GROUP BY clauses" do
@@ -57,7 +57,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/GROUP BY .articles.\..id., .?articles.?\..title., .?articles.?\..id., lat/)
+    expect(query).to match(/GROUP BY .articles.\..id., .?articles.?\..title., .?articles.?\..id., lat/)
   end
 
   it "handles WHERE clauses" do
@@ -69,7 +69,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/WHERE .+title != 'secret'.+ GROUP BY/)
+    expect(query).to match(/WHERE .+title != 'secret'.+ GROUP BY/)
   end
 
   it "handles manual MVA declarations" do
@@ -81,7 +81,7 @@ describe 'specifying SQL for index definitions' do
     }
     index.render
 
-    index.sources.first.sql_attr_multi.should == ['uint tag_ids from field']
+    expect(index.sources.first.sql_attr_multi).to eq(['uint tag_ids from field'])
   end
 
   it "provides the sanitize_sql helper within the index definition block" do
@@ -93,7 +93,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/WHERE .+title != 'secret'.+ GROUP BY/)
+    expect(query).to match(/WHERE .+title != 'secret'.+ GROUP BY/)
   end
 
   it "escapes new lines in SQL snippets" do
@@ -111,7 +111,7 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/\\\n/)
+    expect(query).to match(/\\\n/)
   end
 
   it "joins each polymorphic relation" do
@@ -123,9 +123,9 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
-    query.should match(/LEFT OUTER JOIN .books. ON .books.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Book'/)
-    query.should match(/.articles.\..title., .books.\..title./)
+    expect(query).to match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
+    expect(query).to match(/LEFT OUTER JOIN .books. ON .books.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Book'/)
+    expect(query).to match(/.articles.\..title., .books.\..title./)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "concatenates references that have column" do
@@ -137,9 +137,9 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
-    query.should_not match(/articles\..title., users\..title./)
-    query.should match(/.articles.\..title./)
+    expect(query).to match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
+    expect(query).not_to match(/articles\..title., users\..title./)
+    expect(query).to match(/.articles.\..title./)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "respects deeper associations through polymorphic joins" do
@@ -151,9 +151,9 @@ describe 'specifying SQL for index definitions' do
     index.render
 
     query = index.sources.first.sql_query
-    query.should match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
-    query.should match(/LEFT OUTER JOIN .users. ON .users.\..id. = .articles.\..user_id./)
-    query.should match(/.users.\..name./)
+    expect(query).to match(/LEFT OUTER JOIN .articles. ON .articles.\..id. = .events.\..eventable_id. AND .events.\..eventable_type. = 'Article'/)
+    expect(query).to match(/LEFT OUTER JOIN .users. ON .users.\..id. = .articles.\..user_id./)
+    expect(query).to match(/.users.\..name./)
   end
 end if ActiveRecord::VERSION::MAJOR > 3
 
@@ -174,8 +174,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)$/)
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVAs" do
@@ -190,8 +190,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
   end
 
   it "respects has_many :through joins for MVA queries" do
@@ -206,8 +206,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.taggings.\..article_id. IS NOT NULL\)\s?$/)
   end
 
   it "can handle multiple joins for MVA queries" do
@@ -224,8 +224,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.articles.\..user_id. IS NOT NULL\)\s?$/)
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. WHERE \(.articles.\..user_id. IS NOT NULL\)\s?$/)
   end
 
   it "can handle simple HABTM joins for MVA queries" do
@@ -242,8 +242,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint genre_ids from query'
-    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres.\s?$/)
+    expect(declaration).to eq('uint genre_ids from query')
+    expect(query).to match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres.\s?$/)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "generates an appropriate range SQL queries for an MVA" do
@@ -258,9 +258,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
-    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+    expect(declaration).to eq('uint tag_ids from ranged-query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .taggings.\..tag_id. AS .tag_ids. FROM .taggings. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
+    expect(range).to match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVAs" do
@@ -275,9 +275,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
-    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+    expect(declaration).to eq('uint tag_ids from ranged-query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..id. AS .tag_ids. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)$/)
+    expect(range).to match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
   it "can handle ranged queries for simple HABTM joins for MVA queries" do
@@ -294,9 +294,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint genre_ids from ranged-query'
-    query.should match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres. WHERE \(.books_genres.\..book_id. BETWEEN \$start AND \$end\)$/)
-    range.should match(/^SELECT MIN\(.books_genres.\..book_id.\), MAX\(.books_genres.\..book_id.\) FROM .books_genres.$/)
+    expect(declaration).to eq('uint genre_ids from ranged-query')
+    expect(query).to match(/^SELECT .books_genres.\..book_id. \* #{count} \+ #{source.offset} AS .id., .books_genres.\..genre_id. AS .genre_ids. FROM .books_genres. WHERE \(.books_genres.\..book_id. BETWEEN \$start AND \$end\)$/)
+    expect(range).to match(/^SELECT MIN\(.books_genres.\..book_id.\), MAX\(.books_genres.\..book_id.\) FROM .books_genres.$/)
   end if ActiveRecord::VERSION::MAJOR > 3
 
   it "respects custom SQL snippets as the query value" do
@@ -312,8 +312,8 @@ describe 'separate queries for MVAs' do
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should == 'My Custom SQL Query'
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to eq('My Custom SQL Query')
   end
 
   it "respects custom SQL snippets as the ranged query value" do
@@ -329,9 +329,9 @@ describe 'separate queries for MVAs' do
     }
     declaration, query, range = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from ranged-query'
-    query.should == 'My Custom SQL Query'
-    range.should == 'And a Range'
+    expect(declaration).to eq('uint tag_ids from ranged-query')
+    expect(query).to eq('My Custom SQL Query')
+    expect(range).to eq('And a Range')
   end
 
   it "escapes new lines in custom SQL snippets" do
@@ -349,8 +349,8 @@ SQL Query
     }
     declaration, query = attribute.split(/;\s+/)
 
-    declaration.should == 'uint tag_ids from query'
-    query.should == "My Custom\\\nSQL Query"
+    expect(declaration).to eq('uint tag_ids from query')
+    expect(query).to eq("My Custom\\\nSQL Query")
   end
 end
 
@@ -368,8 +368,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
+    expect(declaration).to eq('tags from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
   end
 
   it "respects has_many :through joins for MVF queries" do
@@ -381,8 +381,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
+    expect(declaration).to eq('tags from query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC\s?$/)
   end
 
   it "can handle multiple joins for MVF queries" do
@@ -396,8 +396,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.articles.\..user_id. IS NOT NULL\)\s? ORDER BY .articles.\..user_id. ASC\s?$/)
+    expect(declaration).to eq('tags from query')
+    expect(query).to match(/^SELECT .articles.\..user_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .articles. INNER JOIN .taggings. ON .taggings.\..article_id. = .articles.\..id. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id.\s? WHERE \(.articles.\..user_id. IS NOT NULL\)\s? ORDER BY .articles.\..user_id. ASC\s?$/)
   end
 
   it "generates a SQL query with joins when appropriate for MVFs" do
@@ -409,9 +409,9 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query, range = field.split(/;\s+/)
 
-    declaration.should == 'tags from ranged-query'
-    query.should match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC$/)
-    range.should match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
+    expect(declaration).to eq('tags from ranged-query')
+    expect(query).to match(/^SELECT .taggings.\..article_id. \* #{count} \+ #{source.offset} AS .id., .tags.\..name. AS .tags. FROM .taggings. INNER JOIN .tags. ON .tags.\..id. = .taggings.\..tag_id. \s?WHERE \(.taggings.\..article_id. BETWEEN \$start AND \$end\) AND \(.taggings.\..article_id. IS NOT NULL\)\s? ORDER BY .taggings.\..article_id. ASC$/)
+    expect(range).to match(/^SELECT MIN\(.taggings.\..article_id.\), MAX\(.taggings.\..article_id.\) FROM .taggings.\s?$/)
   end
 
   it "respects custom SQL snippets as the query value" do
@@ -423,8 +423,8 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should == 'My Custom SQL Query'
+    expect(declaration).to eq('tags from query')
+    expect(query).to eq('My Custom SQL Query')
   end
 
   it "respects custom SQL snippets as the ranged query value" do
@@ -437,9 +437,9 @@ describe 'separate queries for field' do
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query, range = field.split(/;\s+/)
 
-    declaration.should == 'tags from ranged-query'
-    query.should == 'My Custom SQL Query'
-    range.should == 'And a Range'
+    expect(declaration).to eq('tags from ranged-query')
+    expect(query).to eq('My Custom SQL Query')
+    expect(range).to eq('And a Range')
   end
 
   it "escapes new lines in custom SQL snippets" do
@@ -454,7 +454,7 @@ SQL Query
     field = source.sql_joined_field.detect { |field| field[/tags/] }
     declaration, query = field.split(/;\s+/)
 
-    declaration.should == 'tags from query'
-    query.should == "My Custom\\\nSQL Query"
+    expect(declaration).to eq('tags from query')
+    expect(query).to eq("My Custom\\\nSQL Query")
   end
 end

data/spec/acceptance/sphinx_scopes_spec.rb

@@ -7,7 +7,7 @@ describe 'Sphinx scopes', :live => true do
     grave = Book.create! :title => 'The Graveyard Book', :year => 2009
     index
 
-    Book.by_year(2009).to_a.should == [grave]
+    expect(Book.by_year(2009).to_a).to eq([grave])
   end
 
   it "allows scopes to return both query and options" do
@@ -16,7 +16,7 @@ describe 'Sphinx scopes', :live => true do
     grave = Book.create! :title => 'The Graveyard Book', :year => 2009
     index
 
-    Book.by_query_and_year('Graveyard', 2009).to_a.should == [grave]
+    expect(Book.by_query_and_year('Graveyard', 2009).to_a).to eq([grave])
   end
 
   it "allows chaining of scopes" do
@@ -25,7 +25,7 @@ describe 'Sphinx scopes', :live => true do
     grave = Book.create! :title => 'The Graveyard Book', :year => 2009
     index
 
-    Book.by_year(2001..2005).ordered.to_a.should == [boys, gods]
+    expect(Book.by_year(2001..2005).ordered.to_a).to eq([boys, gods])
   end
 
   it "allows chaining of scopes that include queries" do
@@ -34,8 +34,8 @@ describe 'Sphinx scopes', :live => true do
     grave = Book.create! :title => 'The Graveyard Book', :year => 2009
     index
 
-    Book.by_year(2001).by_query_and_year('Graveyard', 2009).to_a.
-      should == [grave]
+    expect(Book.by_year(2001).by_query_and_year('Graveyard', 2009).to_a).
+      to eq([grave])
   end
 
   it "allows further search calls on scopes" do
@@ -43,7 +43,7 @@ describe 'Sphinx scopes', :live => true do
     pratchett = Book.create! :title => 'Small Gods'
     index
 
-    Book.by_query('Gods').search('Small').to_a.should == [pratchett]
+    expect(Book.by_query('Gods').search('Small').to_a).to eq([pratchett])
   end
 
   it "allows facet calls on scopes" do
@@ -52,9 +52,9 @@ describe 'Sphinx scopes', :live => true do
     Book.create! :title => 'Small Gods',    :author => 'Terry Pratchett'
     index
 
-    Book.by_query('Gods').facets.to_hash[:author].should == {
+    expect(Book.by_query('Gods').facets.to_hash[:author]).to eq({
       'Neil Gaiman' => 1, 'Terry Pratchett' => 1
-    }
+    })
   end
 
   it "allows accessing counts on scopes" do
@@ -64,7 +64,7 @@ describe 'Sphinx scopes', :live => true do
     Book.create! :title => 'Night Watch'
     index
 
-    Book.by_query('gods').count.should == 2
+    expect(Book.by_query('gods').count).to eq(2)
   end
 
   it 'raises an exception when trying to modify a populated request' do

data/spec/acceptance/sql_deltas_spec.rb

@@ -7,38 +7,38 @@ describe 'SQL delta indexing', :live => true do
     )
     index
 
-    Book.search('Terry Pratchett').to_a.should == [guards]
+    expect(Book.search('Terry Pratchett').to_a).to eq([guards])
 
     men = Book.create(
       :title => 'Men At Arms', :author => 'Terry Pratchett'
     )
     sleep 0.25
 
-    Book.search('Terry Pratchett').to_a.should == [guards, men]
+    expect(Book.search('Terry Pratchett').to_a).to eq([guards, men])
   end
 
   it "automatically indexes updated records" do
     book = Book.create :title => 'Night Watch', :author => 'Harry Pritchett'
     index
 
-    Book.search('Harry').to_a.should == [book]
+    expect(Book.search('Harry').to_a).to eq([book])
 
     book.reload.update_attributes(:author => 'Terry Pratchett')
     sleep 0.25
 
-    Book.search('Terry').to_a.should == [book]
+    expect(Book.search('Terry').to_a).to eq([book])
   end
 
   it "does not match on old values" do
     book = Book.create :title => 'Night Watch', :author => 'Harry Pritchett'
     index
 
-    Book.search('Harry').to_a.should == [book]
+    expect(Book.search('Harry').to_a).to eq([book])
 
     book.reload.update_attributes(:author => 'Terry Pratchett')
     sleep 0.25
 
-    Book.search('Harry').should be_empty
+    expect(Book.search('Harry')).to be_empty
   end
 
   it "automatically indexes new records of subclasses" do
@@ -47,6 +47,6 @@ describe 'SQL delta indexing', :live => true do
     )
     sleep 0.25
 
-    Book.search('Gaiman').to_a.should == [book]
+    expect(Book.search('Gaiman').to_a).to eq([book])
   end
 end