where_lower 0.3.0 → 0.3.1

data/lib/where_lower/version.rb

@@ -1,3 +1,11 @@
 module WhereLower
-  VERSION = '0.3.0'
+  # String form of version, to be parsed by Gem::Version
+  VERSION = "0.3.1"
+
+  # Return a version object instead of just a string for easier comparison
+  #
+  # @return [Gem::Version]
+  def self.version
+    Gem::Version.new(VERSION)
+  end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,16 @@
 if ENV["TRAVIS"]
-  require 'coveralls'
-  Coveralls.wear!('rails')
+  require "coveralls"
+  Coveralls.wear!("rails")
 end
 
-require 'active_record'
-require 'where_lower'
+require "active_record"
+require "where_lower"
 
-require 'database_cleaner'
-require 'logger'
+require "database_cleaner"
+require "logger"
+
+require "rspec"
+require "rspec/its"
 
 # ActiveRecord::Base.logger = Logger.new(STDOUT) # for easier debugging
 
@@ -27,19 +30,19 @@ end
 
 # connect
 ActiveRecord::Base.establish_connection(
-  :adapter => "sqlite3",
-  :database => ":memory:"
+  adapter:  "sqlite3",
+  database: ":memory:",
 )
 
 # create tables
-ActiveRecord::Schema.define(:version => 1) do
+ActiveRecord::Schema.define(version: 1) do
   create_table :parents do |t|
     t.string :name
     t.text :description
     t.integer :age, null: false, default: 0
     t.boolean :is_minecraft_lover, default: true
 
-    t.timestamps
+    t.timestamps(null: false)
   end
 
   create_table :children do |t|
@@ -50,7 +53,7 @@ ActiveRecord::Schema.define(:version => 1) do
 
     t.integer :parent_id
 
-    t.timestamps
+    t.timestamps(null: false)
   end
 
   create_table :grand_children do |t|
@@ -61,13 +64,15 @@ ActiveRecord::Schema.define(:version => 1) do
 
     t.integer :child_id
 
-    t.timestamps
+    t.timestamps(null: false)
   end
 end
 
-class ActiveRecord::Base
-  def self.silent_set_table_name(name)
-    self.table_name = name
+module ActiveRecord
+  class Base
+    def self.silent_set_table_name(name)
+      self.table_name = name
+    end
   end
 end
 
@@ -76,7 +81,7 @@ end
 class Parent < ActiveRecord::Base
   has_many :children, inverse_of: :parent
 
-  scope :latest_first, proc { order('created_at DESC') }
+  scope :latest_first, proc { order("created_at DESC") }
   def self.earliest_first
     order(:created_at)
   end

data/spec/where_lower_spec.rb

@@ -1,504 +1,753 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe WhereLower do
+  let(:parent_name) { "Parent" }
+  let(:parent_name2) { "Parent #10" }
+  let(:parent_name3) { "Parent #20" }
+  let(:parent_description) { "I need a Medic!" }
+  let(:parent_description2) { "I need a Job!" }
 
-  let(:parent_name) { 'Parent' }
-  let(:parent_name2) { 'Parent #10' }
-  let(:parent_name3) { 'Parent #20' }
-  let(:parent_description) { 'I need a Medic!' }
-  let(:parent_description2) { 'I need a Job!' }
+  let(:child_name) { "Child" }
+  let(:child_name2) { "Child #10" }
+  let(:child_name3) { "Child #20" }
+  let(:child_description) { "I need a Power Ranger!" }
+  let(:child_description2) { "I need a Pokemon!" }
 
-  let(:child_name) { 'Child' }
-  let(:child_name2) { 'Child #10' }
-  let(:child_name3) { 'Child #20' }
-  let(:child_description) { 'I need a Power Ranger!' }
-  let(:child_description2) { 'I need a Pokemon!' }
-
-  let(:grand_child_name) { 'Grand Child' }
-  let(:grand_child_name2) { 'Grand Child #10' }
+  let(:grand_child_name) { "Grand Child" }
+  let(:grand_child_name2) { "Grand Child #10" }
 
   let!(:parent) do
-    Parent.create!(name: parent_name, description: parent_description,
-        age: 40, is_minecraft_lover: false, created_at: 40.years.ago)
+    Parent.create!(
+      name:               parent_name,
+      description:        parent_description,
+      age:                40,
+      is_minecraft_lover: false,
+      created_at:         40.years.ago,
+    )
   end
   let!(:child) do
-    Child.create!(name: child_name, description: child_description,
-        age: 18, is_minecraft_lover: true, created_at: 18.years.ago, parent: parent)
+    Child.create!(
+      name:               child_name,
+      description:        child_description,
+      age:                18,
+      is_minecraft_lover: true,
+      created_at:         18.years.ago,
+      parent:             parent,
+    )
   end
   let!(:grand_child) do
-    GrandChild.create!(name: grand_child_name, description: child_description,
-        age: 1, is_minecraft_lover: false, created_at: 1.year.ago, child: child)
+    GrandChild.create!(
+      name:               grand_child_name,
+      description:        child_description,
+      age:                1,
+      is_minecraft_lover: false,
+      created_at:         1.year.ago,
+      child:              child,
+    )
   end
 
-  describe 'finding records with condition(s) for columns inside the model table' do
-    describe 'finding record using string column' do
-      describe 'with type string' do
+  describe "finding records with condition(s) for columns inside the model table" do
+    describe "finding record using string column" do
+      describe "with type string" do
         before do
-          Parent.where(name: parent_name).should_not be_empty
-          Parent.where(name: parent_name2).should be_empty
+          expect(Parent.
+            where(name: parent_name)).
+            to_not be_empty
+          expect(Parent.
+            where(name: parent_name2)).
+            to be_empty
         end
 
-        it 'works like where' do
-          Parent.where_lower(name: parent_name).should_not be_empty
-          Parent.where_lower(name: parent_name2).should be_empty
+        it "works like where" do
+          expect(Parent.
+            where_lower(name: parent_name)).
+            to_not be_empty
+          expect(Parent.
+            where_lower(name: parent_name2)).
+            to be_empty
         end
-        it 'works like where case insensitively' do
-          Parent.where_lower(name: parent_name.swapcase).should_not be_empty
-          Parent.where_lower(name: parent_name2.swapcase).should be_empty
+        it "works like where case insensitively" do
+          expect(Parent.
+            where_lower(name: parent_name.swapcase)).
+            to_not be_empty
+          expect(Parent.
+            where_lower(name: parent_name2.swapcase)).
+            to be_empty
         end
       end
 
-      describe 'with type text' do
+      describe "with type text" do
         before do
-          Parent.where(description: parent_description).should_not be_empty
-          Parent.where(description: parent_description2).should be_empty
+          expect(Parent.
+            where(description: parent_description)).
+            to_not be_empty
+          expect(Parent.
+            where(description: parent_description2)).
+            to be_empty
         end
 
-        it 'works like where' do
-          Parent.where_lower(description: parent_description).should_not be_empty
-          Parent.where_lower(description: parent_description2).should be_empty
+        it "works like where" do
+          expect(Parent.
+            where_lower(description: parent_description)).
+            to_not be_empty
+          expect(Parent.
+            where_lower(description: parent_description2)).
+            to be_empty
         end
-        it 'works like where case insensitively' do
-          Parent.where_lower(description: parent_description.swapcase).should_not be_empty
-          Parent.where_lower(description: parent_description2.swapcase).should be_empty
+        it "works like where case insensitively" do
+          expect(Parent.
+            where_lower(description: parent_description.swapcase)).
+            to_not be_empty
+          expect(Parent.
+            where_lower(description: parent_description2.swapcase)).
+            to be_empty
         end
       end
 
-      describe 'with different types of values in conditions' do
-        describe 'with Range' do
+      describe "with different types of values in conditions" do
+        describe "with Range" do
           before do
-            Parent.where(name: ('Parens'..'Parenu')).should_not be_empty
-            Parent.where(name: ('Parenu'..'Parenv')).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.where_lower(name: ('Parens'..'Parenu')).should_not be_empty
-            Parent.where_lower(name: ('Parenu'..'Parenv')).should be_empty
-          end
-          it 'works like where case insensitively' do
-            Parent.where_lower(name: (('Parens'.swapcase)..('Parenu'.swapcase))).should_not be_empty
-            Parent.where_lower(name: (('Parenu'.swapcase)..('Parenv'.swapcase))).should be_empty
+            expect(Parent.
+              where(name: ("Parens".."Parenu"))).
+              to_not be_empty
+            expect(Parent.
+              where(name: ("Parenu".."Parenv"))).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.
+              where_lower(name: ("Parens".."Parenu"))).
+              to_not be_empty
+            expect(Parent.
+              where_lower(name: ("Parenu".."Parenv"))).
+              to be_empty
+          end
+          it "works like where case insensitively" do
+            expect(Parent.
+              where_lower(name: (("Parens".swapcase)..("Parenu".swapcase)))).
+              to_not be_empty
+            expect(Parent.
+              where_lower(name: (("Parenu".swapcase)..("Parenv".swapcase)))).
+              to be_empty
           end
         end
 
-        describe 'with Array' do
+        describe "with Array" do
           before do
-            Parent.where(name: [parent_name, parent_name2]).should_not be_empty
-            Parent.where(name: [parent_name2, parent_name3]).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.where_lower(name: [parent_name, parent_name2]).should_not be_empty
-            Parent.where_lower(name: [parent_name2, parent_name3]).should be_empty
-            Parent.where_lower(name: []).should be_empty
-          end
-          it 'works like where case insensitively' do
-            Parent.where_lower(name: [parent_name.swapcase, parent_name2.swapcase]).should_not be_empty
-            Parent.where_lower(name: [parent_name2.swapcase, parent_name3.swapcase]).should be_empty
-            Parent.where_lower(name: []).should be_empty
+            expect(Parent.
+              where(name: [parent_name, parent_name2])).
+              to_not be_empty
+            expect(Parent.
+              where(name: [parent_name2, parent_name3])).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.
+              where_lower(name: [parent_name, parent_name2])).
+              to_not be_empty
+            expect(Parent.
+              where_lower(name: [parent_name2, parent_name3])).
+              to be_empty
+            expect(Parent.
+              where_lower(name: [])).
+              to be_empty
+          end
+          it "works like where case insensitively" do
+            expect(Parent.
+              where_lower(name: [parent_name.swapcase, parent_name2.swapcase])).
+              to_not be_empty
+            expect(Parent.
+              where_lower(name: [parent_name2.swapcase, parent_name3.swapcase])).
+              to be_empty
+            expect(Parent.
+              where_lower(name: [])).
+              to be_empty
           end
         end
 
-        describe 'with nil' do
-          context 'when record with nil value does not exist' do
+        describe "with nil" do
+          context "when record with nil value does not exist" do
             before do
-              Parent.where(name: nil).should be_empty
+              expect(Parent.where(name: nil)).to be_empty
             end
 
-            it 'works like where' do
-              Parent.where_lower(name: nil).should be_empty
+            it "works like where" do
+              expect(Parent.where_lower(name: nil)).to be_empty
             end
           end
-          context 'when record with nil value does exist' do
+          context "when record with nil value does exist" do
             before do
               Parent.create!(name: nil)
             end
 
             before do
-              Parent.where(name: nil).should_not be_empty
+              expect(Parent.where(name: nil)).to_not be_empty
             end
 
-            it 'works like where' do
-              Parent.where_lower(name: nil).should_not be_empty
+            it "works like where" do
+              expect(Parent.where_lower(name: nil)).to_not be_empty
             end
           end
         end
 
-        describe 'with query injection' do
-          it 'prevents injection' do
+        describe "with query injection" do
+          it "prevents injection" do
             expect do
-              Parent.where_lower(name: "'); truncate table parents")
+              Parent.where_lower(name: %Q|"); truncate table parents|)
             end.to_not change(Parent, :count)
           end
         end
 
-
-        describe 'with chaining' do
-          it 'can be chained with where' do
-            Parent.where_lower(name: parent_name).where(description: parent_description).should_not be_empty
+        describe "with chaining" do
+          it "can be chained with where" do
+            expect(Parent.where_lower(name: parent_name).
+              where(description: parent_description)).
+              to_not be_empty
           end
 
-          it 'can be chained with where_lower' do
-            Parent.where_lower(name: parent_name).where_lower(description: parent_description).should_not be_empty
+          it "can be chained with where_lower" do
+            expect(Parent.where_lower(name: parent_name).
+              where_lower(description: parent_description)).
+              to_not be_empty
           end
 
-          it 'can be chained with order' do
-            Parent.where_lower(name: parent_name).order(:description).should_not be_empty
+          it "can be chained with order" do
+            expect(Parent.where_lower(name: parent_name).order(:description)).
+              to_not be_empty
           end
 
-
-          it 'can be chained with name scope' do
-            Parent.where_lower(name: parent_name).latest_first.should_not be_empty
+          it "can be chained with name scope" do
+            expect(Parent.where_lower(name: parent_name).latest_first).
+              to_not be_empty
           end
-          it 'can be chained with class method scope' do
-            Parent.where_lower(name: parent_name).earliest_first.should_not be_empty
+          it "can be chained with class method scope" do
+            expect(Parent.where_lower(name: parent_name).earliest_first).
+              to_not be_empty
           end
         end
       end
     end
 
-    describe 'finding record using non string columns' do
-      describe 'with type integer' do
+    describe "finding record using non string columns" do
+      describe "with type integer" do
         before do
-          Parent.where(age: parent.age).should_not be_empty
-          Parent.where(age: parent.age + 1).should be_empty
+          expect(Parent.where(age: parent.age)).
+            to_not be_empty
+          expect(Parent.where(age: parent.age + 1)).
+            to be_empty
         end
 
-        it 'works like where' do
-          Parent.where_lower(age: parent.age).should_not be_empty
-          Parent.where_lower(age: parent.age + 1).should be_empty
+        it "works like where" do
+          expect(Parent.where_lower(age: parent.age)).
+            to_not be_empty
+          expect(Parent.where_lower(age: parent.age + 1)).
+            to be_empty
         end
       end
 
-      describe 'with type boolean' do
+      describe "with type boolean" do
         before do
-          Parent.where(is_minecraft_lover: parent.is_minecraft_lover).should_not be_empty
-          Parent.where(is_minecraft_lover: !parent.is_minecraft_lover).should be_empty
+          expect(Parent.where(is_minecraft_lover: parent.is_minecraft_lover)).
+            to_not be_empty
+          expect(Parent.where(is_minecraft_lover: !parent.is_minecraft_lover)).
+            to be_empty
         end
 
-        it 'works like where' do
-          Parent.where_lower(is_minecraft_lover: parent.is_minecraft_lover).should_not be_empty
-          Parent.where_lower(is_minecraft_lover: !parent.is_minecraft_lover).should be_empty
+        it "works like where" do
+          expect(Parent.where_lower(is_minecraft_lover: parent.is_minecraft_lover)).
+            to_not be_empty
+          expect(Parent.where_lower(is_minecraft_lover: !parent.is_minecraft_lover)).
+            to be_empty
         end
       end
     end
   end
 
-  describe 'finding records with condition(s) for columns outside the model table' do
-    describe 'using string as hash key' do
-      describe 'finding record using string column' do
-        describe 'with type string' do
+  describe "finding records with condition(s) for columns outside the model table" do
+    describe "using string as hash key" do
+      describe "finding record using string column" do
+        describe "with type string" do
           before do
-            Parent.joins(:children).where('children.name' => child_name).should_not be_empty
-            Parent.joins(:children).where('children.name' => child_name2).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower('children.name' => child_name).should_not be_empty
-            Parent.joins(:children).where_lower('children.name' => child_name2).should be_empty
-          end
-          it 'works like where case insensitively' do
-            Parent.joins(:children).where_lower('children.name' => child_name.swapcase).should_not be_empty
-            Parent.joins(:children).where_lower('children.name' => child_name2.swapcase).should be_empty
+            expect(Parent.joins(:children).
+              where("children.name" => child_name)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where("children.name" => child_name2)).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower("children.name" => child_name)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower("children.name" => child_name2)).
+              to be_empty
+          end
+          it "works like where case insensitively" do
+            expect(Parent.joins(:children).
+              where_lower("children.name" => child_name.swapcase)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower("children.name" => child_name2.swapcase)).
+              to be_empty
           end
         end
 
-        describe 'with type text' do
+        describe "with type text" do
           before do
-            Parent.joins(:children).where('children.description' => child_description).should_not be_empty
-            Parent.joins(:children).where('children.description' => child_description2).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower('children.description' => child_description).should_not be_empty
-            Parent.joins(:children).where_lower('children.description' => child_description2).should be_empty
-          end
-          it 'works like where case insensitively' do
-            Parent.joins(:children).where_lower('children.description' => child_description.swapcase).should_not be_empty
-            Parent.joins(:children).where_lower('children.description' => child_description2.swapcase).should be_empty
+            expect(Parent.joins(:children).
+              where("children.description" => child_description)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where("children.description" => child_description2)).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower("children.description" => child_description)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower("children.description" => child_description2)).
+              to be_empty
+          end
+          it "works like where case insensitively" do
+            expect(Parent.joins(:children).
+              where_lower("children.description" => child_description.swapcase)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower("children.description" => child_description2.swapcase)).
+              to be_empty
           end
         end
 
-        describe 'with different types of values in conditions' do
-          describe 'with Range' do
+        describe "with different types of values in conditions" do
+          describe "with Range" do
             before do
-              Parent.joins(:children).where('children.name' => ('Chilc'..'Chile')).should_not be_empty
-              Parent.joins(:children).where('children.name' => ('Chile'..'Chilf')).should be_empty
+              expect(Parent.joins(:children).
+                where("children.name" => ("Chilc".."Chile"))).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where("children.name" => ("Chile".."Chilf"))).
+                to be_empty
             end
 
-            it 'works like where' do
-              Parent.joins(:children).where_lower('children.name' => ('Chilc'..'Chile')).should_not be_empty
-              Parent.joins(:children).where_lower('children.name' => ('Chile'..'Chilf')).should be_empty
+            it "works like where" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => ("Chilc".."Chile"))).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower("children.name" => ("Chile".."Chilf"))).
+                to be_empty
             end
-            it 'works like where case insensitively' do
-              Parent.joins(:children).where_lower('children.name' => (('Chilc'.swapcase)..('Chile'.swapcase))).should_not be_empty
-              Parent.joins(:children).where_lower('children.name' => (('Chile'.swapcase)..('Chilf'.swapcase))).should be_empty
+            it "works like where case insensitively" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => (("Chilc".swapcase)..("Chile".swapcase)))).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower("children.name" => (("Chile".swapcase)..("Chilf".swapcase)))).
+                to be_empty
             end
           end
 
-          describe 'with Array' do
+          describe "with Array" do
             before do
-              Parent.joins(:children).where('children.name' => [child_name, child_name2]).should_not be_empty
-              Parent.joins(:children).where('children.name' => [child_name2, child_name3]).should be_empty
-            end
-
-            it 'works like where' do
-              Parent.joins(:children).where_lower('children.name' => [child_name, child_name2]).should_not be_empty
-              Parent.joins(:children).where_lower('children.name' => [child_name2, child_name3]).should be_empty
-              Parent.joins(:children).where_lower('children.name' => []).should be_empty
-            end
-            it 'works like where case insensitively' do
-              Parent.joins(:children).where_lower('children.name' => [child_name.swapcase, child_name2.swapcase]).should_not be_empty
-              Parent.joins(:children).where_lower('children.name' => [child_name2.swapcase, child_name3.swapcase]).should be_empty
-              Parent.joins(:children).where_lower('children.name' => []).should be_empty
-            end
-          end
-
-          describe 'with nil' do
-            context 'when record with nil value does not exist' do
+              expect(Parent.joins(:children).
+                where("children.name" => [child_name, child_name2])).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where("children.name" => [child_name2, child_name3])).
+                to be_empty
+            end
+
+            it "works like where" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => [child_name, child_name2])).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower("children.name" => [child_name2, child_name3])).
+                to be_empty
+              expect(Parent.joins(:children).
+                where_lower("children.name" => [])).
+                to be_empty
+            end
+            it "works like where case insensitively" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => [child_name.swapcase, child_name2.swapcase])).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower("children.name" => [child_name2.swapcase, child_name3.swapcase])).
+                to be_empty
+              expect(Parent.joins(:children).
+                where_lower("children.name" => [])).
+                to be_empty
+            end
+          end
+
+          describe "with nil" do
+            context "when record with nil value does not exist" do
               before do
-                Parent.joins(:children).where('children.name' => nil).should be_empty
+                expect(Parent.joins(:children).
+                  where("children.name" => nil)).to be_empty
               end
 
-              it 'works like where' do
-                Parent.joins(:children).where_lower('children.name' => nil).should be_empty
+              it "works like where" do
+                expect(Parent.joins(:children).
+                  where_lower("children.name" => nil)).to be_empty
               end
             end
-            context 'when record with nil value does exist' do
+            context "when record with nil value does exist" do
               before do
                 Child.create!(name: nil, parent: parent)
               end
 
               before do
-                Parent.joins(:children).where('children.name' => nil).should_not be_empty
+                expect(Parent.joins(:children).
+                  where("children.name" => nil)).to_not be_empty
               end
 
-              it 'works like where' do
-                Parent.joins(:children).where_lower('children.name' => nil).should_not be_empty
+              it "works like where" do
+                expect(Parent.joins(:children).
+                  where_lower("children.name" => nil)).to_not be_empty
               end
             end
           end
 
-          describe 'with query injection' do
-            it 'prevents injection' do
+          describe "with query injection" do
+            it "prevents injection" do
               expect do
-                Parent.joins(:children).where_lower('children.name' => "'); truncate table parents")
+                Parent.joins(:children).
+                  where_lower("children.name" => %Q|"); truncate table parents|)
               end.to_not change(Child, :count)
             end
           end
 
-
-          describe 'with chaining' do
-            it 'can be chained with where' do
-              Parent.joins(:children).where_lower('children.name' => child_name).where('children.description' => child_description).should_not be_empty
+          describe "with chaining" do
+            it "can be chained with where" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => child_name).
+                where("children.description" => child_description)).
+                to_not be_empty
             end
 
-            it 'can be chained with where_lower' do
-              Parent.joins(:children).where_lower('children.name' => child_name).where_lower('children.description' => child_description).should_not be_empty
+            it "can be chained with where_lower" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => child_name).
+                where_lower("children.description" => child_description)).
+                to_not be_empty
             end
 
-            it 'can be chained with order' do
-              Parent.joins(:children).where_lower('children.name' => child_name).order('children.description').should_not be_empty
+            it "can be chained with order" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => child_name).order("children.description")).
+                to_not be_empty
             end
 
-
-            it 'can be chained with name scope' do
-              Parent.joins(:children).where_lower('children.name' => child_name).latest_first.should_not be_empty
+            it "can be chained with name scope" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => child_name).latest_first).
+                to_not be_empty
             end
-            it 'can be chained with class method scope' do
-              Parent.joins(:children).where_lower('children.name' => child_name).earliest_first.should_not be_empty
+            it "can be chained with class method scope" do
+              expect(Parent.joins(:children).
+                where_lower("children.name" => child_name).earliest_first).
+                to_not be_empty
             end
           end
         end
       end
 
-      describe 'finding record using non string columns' do
-        describe 'with type integer' do
+      describe "finding record using non string columns" do
+        describe "with type integer" do
           before do
-            Parent.joins(:children).where('children.age' => child.age).should_not be_empty
-            Parent.joins(:children).where('children.age' => child.age + 1).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower('children.age' => child.age).should_not be_empty
-            Parent.joins(:children).where_lower('children.age' => child.age + 1).should be_empty
+            expect(Parent.joins(:children).
+              where("children.age" => child.age)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where("children.age" => child.age + 1)).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower("children.age" => child.age)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower("children.age" => child.age + 1)).
+              to be_empty
           end
         end
 
-        describe 'with type boolean' do
+        describe "with type boolean" do
           before do
-            Parent.joins(:children).where('children.is_minecraft_lover' => child.is_minecraft_lover).should_not be_empty
-            Parent.joins(:children).where('children.is_minecraft_lover' => !child.is_minecraft_lover).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower('children.is_minecraft_lover' => child.is_minecraft_lover).should_not be_empty
-            Parent.joins(:children).where_lower('children.is_minecraft_lover' => !child.is_minecraft_lover).should be_empty
+            expect(Parent.joins(:children).
+              where("children.is_minecraft_lover" => child.is_minecraft_lover)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where("children.is_minecraft_lover" => !child.is_minecraft_lover)).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower("children.is_minecraft_lover" => child.is_minecraft_lover)).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower("children.is_minecraft_lover" => !child.is_minecraft_lover)).
+              to be_empty
           end
         end
       end
     end
 
-    describe 'using nested hash' do
-      describe 'finding record using string column' do
-        describe 'with type string' do
+    describe "using nested hash" do
+      describe "finding record using string column" do
+        describe "with type string" do
           before do
-            Parent.joins(:children).where(children: {name: child_name}).should_not be_empty
-            Parent.joins(:children).where(children: {name: child_name2}).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower(children: {name: child_name}).should_not be_empty
-            Parent.joins(:children).where_lower(children: {name: child_name2}).should be_empty
-          end
-          it 'works like where case insensitively' do
-            Parent.joins(:children).where_lower(children: {name: child_name.swapcase}).should_not be_empty
-            Parent.joins(:children).where_lower(children: {name: child_name2.swapcase}).should be_empty
+            expect(Parent.joins(:children).
+              where(children: {name: child_name})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where(children: {name: child_name2})).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower(children: {name: child_name})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower(children: {name: child_name2})).
+              to be_empty
+          end
+          it "works like where case insensitively" do
+            expect(Parent.joins(:children).
+              where_lower(children: {name: child_name.swapcase})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower(children: {name: child_name2.swapcase})).
+              to be_empty
           end
         end
 
-        describe 'with type text' do
+        describe "with type text" do
           before do
-            Parent.joins(:children).where(children: {description: child_description}).should_not be_empty
-            Parent.joins(:children).where(children: {description: child_description2}).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower(children: {description: child_description}).should_not be_empty
-            Parent.joins(:children).where_lower(children: {description: child_description2}).should be_empty
-          end
-          it 'works like where case insensitively' do
-            Parent.joins(:children).where_lower(children: {description: child_description.swapcase}).should_not be_empty
-            Parent.joins(:children).where_lower(children: {description: child_description2.swapcase}).should be_empty
+            expect(Parent.joins(:children).
+              where(children: {description: child_description})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where(children: {description: child_description2})).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower(children: {description: child_description})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower(children: {description: child_description2})).
+              to be_empty
+          end
+          it "works like where case insensitively" do
+            expect(Parent.joins(:children).
+              where_lower(children: {description: child_description.swapcase})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower(children: {description: child_description2.swapcase})).
+              to be_empty
           end
         end
 
-        describe 'with different types of values in conditions' do
-          describe 'with Range' do
+        describe "with different types of values in conditions" do
+          describe "with Range" do
             before do
-              Parent.joins(:children).where(children: {name: ('Chilc'..'Chile')}).should_not be_empty
-              Parent.joins(:children).where(children: {name: ('Chile'..'Chilf')}).should be_empty
+              expect(Parent.joins(:children).
+                where(children: {name: ("Chilc".."Chile")})).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where(children: {name: ("Chile".."Chilf")})).
+                to be_empty
             end
 
-            it 'works like where' do
-              Parent.joins(:children).where_lower(children: {name: ('Chilc'..'Chile')}).should_not be_empty
-              Parent.joins(:children).where_lower(children: {name: ('Chile'..'Chilf')}).should be_empty
+            it "works like where" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: ("Chilc".."Chile")})).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower(children: {name: ("Chile".."Chilf")})).
+                to be_empty
             end
-            it 'works like where case insensitively' do
-              Parent.joins(:children).where_lower(children: {name: (('Chilc'.swapcase)..('Chile'.swapcase))}).should_not be_empty
-              Parent.joins(:children).where_lower(children: {name: (('Chile'.swapcase)..('Chilf'.swapcase))}).should be_empty
+            it "works like where case insensitively" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: (("Chilc".swapcase)..("Chile".swapcase))})).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower(children: {name: (("Chile".swapcase)..("Chilf".swapcase))})).
+                to be_empty
             end
           end
 
-          describe 'with Array' do
+          describe "with Array" do
             before do
-              Parent.joins(:children).where(children: {name: [child_name, child_name2]}).should_not be_empty
-              Parent.joins(:children).where(children: {name: [child_name2, child_name3]}).should be_empty
-            end
-
-            it 'works like where' do
-              Parent.joins(:children).where_lower(children: {name: [child_name, child_name2]}).should_not be_empty
-              Parent.joins(:children).where_lower(children: {name: [child_name2, child_name3]}).should be_empty
-              Parent.joins(:children).where_lower(children: {name: []}).should be_empty
-            end
-            it 'works like where case insensitively' do
-              Parent.joins(:children).where_lower(children: {name: [child_name.swapcase, child_name2.swapcase]}).should_not be_empty
-              Parent.joins(:children).where_lower(children: {name: [child_name2.swapcase, child_name3.swapcase]}).should be_empty
-              Parent.joins(:children).where_lower(children: {name: []}).should be_empty
-            end
-          end
-
-          describe 'with nil' do
-            context 'when record with nil value does not exist' do
+              expect(Parent.joins(:children).
+                where(children: {name: [child_name, child_name2]})).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where(children: {name: [child_name2, child_name3]})).
+                to be_empty
+            end
+
+            it "works like where" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: [child_name, child_name2]})).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower(children: {name: [child_name2, child_name3]})).
+                to be_empty
+              expect(Parent.joins(:children).
+                where_lower(children: {name: []})).
+                to be_empty
+            end
+            it "works like where case insensitively" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: [child_name.swapcase, child_name2.swapcase]})).
+                to_not be_empty
+              expect(Parent.joins(:children).
+                where_lower(children: {name: [child_name2.swapcase, child_name3.swapcase]})).
+                to be_empty
+              expect(Parent.joins(:children).
+                where_lower(children: {name: []})).
+                to be_empty
+            end
+          end
+
+          describe "with nil" do
+            context "when record with nil value does not exist" do
               before do
-                Parent.joins(:children).where(children: {name: nil}).should be_empty
+                expect(Parent.joins(:children).
+                  where(children: {name: nil})).to be_empty
               end
 
-              it 'works like where' do
-                Parent.joins(:children).where_lower(children: {name: nil}).should be_empty
+              it "works like where" do
+                expect(Parent.joins(:children).
+                  where_lower(children: {name: nil})).to be_empty
               end
             end
-            context 'when record with nil value does exist' do
+            context "when record with nil value does exist" do
               before do
                 Child.create!(name: nil, parent: parent)
               end
 
               before do
-                Parent.joins(:children).where(children: {name: nil}).should_not be_empty
+                expect(Parent.joins(:children).
+                  where(children: {name: nil})).to_not be_empty
               end
 
-              it 'works like where' do
-                Parent.joins(:children).where_lower(children: {name: nil}).should_not be_empty
+              it "works like where" do
+                expect(Parent.joins(:children).
+                  where_lower(children: {name: nil})).to_not be_empty
               end
             end
           end
 
-          describe 'with query injection' do
-            it 'prevents injection' do
+          describe "with query injection" do
+            it "prevents injection" do
               expect do
-                Parent.joins(:children).where_lower(children: {name: "'); truncate table parents"})
+                Parent.joins(:children).
+                  where_lower(children: {name: %Q|"); truncate table parents|})
               end.to_not change(Child, :count)
             end
           end
 
-
-          describe 'with chaining' do
-            it 'can be chained with where' do
-              Parent.joins(:children).where_lower(children: {name: child_name}).where(children: {description: child_description}).should_not be_empty
+          describe "with chaining" do
+            it "can be chained with where" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: child_name}).
+                where(children: {description: child_description})).
+                to_not be_empty
             end
 
-            it 'can be chained with where_lower' do
-              Parent.joins(:children).where_lower(children: {name: child_name}).where_lower(children: {description: child_description}).should_not be_empty
+            it "can be chained with where_lower" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: child_name}).
+                where_lower(children: {description: child_description})).
+                to_not be_empty
             end
 
-            it 'can be chained with order' do
-              Parent.joins(:children).where_lower(children: {name: child_name}).order('children.description').should_not be_empty
+            it "can be chained with order" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: child_name}).
+                order("children.description")).
+                to_not be_empty
             end
 
-
-            it 'can be chained with name scope' do
-              Parent.joins(:children).where_lower(children: {name: child_name}).latest_first.should_not be_empty
+            it "can be chained with name scope" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: child_name}).latest_first).
+                to_not be_empty
             end
-            it 'can be chained with class method scope' do
-              Parent.joins(:children).where_lower(children: {name: child_name}).earliest_first.should_not be_empty
+            it "can be chained with class method scope" do
+              expect(Parent.joins(:children).
+                where_lower(children: {name: child_name}).earliest_first).
+                to_not be_empty
             end
           end
         end
       end
 
-      describe 'finding record using non string columns' do
-        describe 'with type integer' do
+      describe "finding record using non string columns" do
+        describe "with type integer" do
           before do
-            Parent.joins(:children).where(children: {age: child.age}).should_not be_empty
-            Parent.joins(:children).where(children: {age: child.age + 1}).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower(children: {age: child.age}).should_not be_empty
-            Parent.joins(:children).where_lower(children: {age: child.age + 1}).should be_empty
+            expect(Parent.joins(:children).
+              where(children: {age: child.age})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where(children: {age: child.age + 1})).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower(children: {age: child.age})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower(children: {age: child.age + 1})).
+              to be_empty
           end
         end
 
-        describe 'with type boolean' do
+        describe "with type boolean" do
           before do
-            Parent.joins(:children).where(children: {is_minecraft_lover: child.is_minecraft_lover}).should_not be_empty
-            Parent.joins(:children).where(children: {is_minecraft_lover: !child.is_minecraft_lover}).should be_empty
-          end
-
-          it 'works like where' do
-            Parent.joins(:children).where_lower(children: {is_minecraft_lover: child.is_minecraft_lover}).should_not be_empty
-            Parent.joins(:children).where_lower(children: {is_minecraft_lover: !child.is_minecraft_lover}).should be_empty
+            expect(Parent.joins(:children).
+              where(children: {is_minecraft_lover: child.is_minecraft_lover})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where(children: {is_minecraft_lover: !child.is_minecraft_lover})).
+              to be_empty
+          end
+
+          it "works like where" do
+            expect(Parent.joins(:children).
+              where_lower(children: {is_minecraft_lover: child.is_minecraft_lover})).
+              to_not be_empty
+            expect(Parent.joins(:children).
+              where_lower(children: {is_minecraft_lover: !child.is_minecraft_lover})).
+              to be_empty
           end
         end
       end
 
-
-      describe 'with more than one level deep'
-        it 'raises error' do
+      describe "with more than one level deep" do
+        it "raises error" do
           expect do
-            Parent.joins(children: :grand_children).where_lower(children: {grand_children: {name: grand_child_name}})
+            Parent.joins(children: :grand_children).
+              where_lower(children: {grand_children: {name: grand_child_name}})
           end.to raise_error(WhereLower::TooDeepNestedConditions)
         end
+      end
     end
   end
 end