Arel: rubocop -a

12 files changed, 242 insertions, 234 deletions

diff --git a/activerecord/test/cases/arel/visitors/depth_first_test.rb b/activerecord/test/cases/arel/visitors/depth_first_test.rb
index b841d119d2..3baccc7316 100644
--- a/activerecord/test/cases/arel/visitors/depth_first_test.rb
+++ b/activerecord/test/cases/arel/visitors/depth_first_test.rb
@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
     class TestDepthFirst < Arel::Test
       Collector = Struct.new(:calls) do
-        def call object
+        def call(object)
           calls << object
         end
       end
@@ -164,7 +165,7 @@ module Arel
       def test_table
         relation = Arel::Table.new(:users)
         @visitor.accept relation
-        assert_equal ['users', relation], @collector.calls
+        assert_equal ["users", relation], @collector.calls
       end
 
       def test_array
diff --git a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
index eb278cde4c..a07a1a050a 100644
--- a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
+++ b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb
@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require_relative '../helper'
-require 'concurrent'
+
+require_relative "../helper"
+require "concurrent"
 
 module Arel
   module Visitors
@@ -10,14 +11,14 @@ module Arel
         @barrier = Concurrent::CyclicBarrier.new(2)
       end
 
-      def visit_Arel_Visitors_DummySuperNode node
+      def visit_Arel_Visitors_DummySuperNode(node)
         42
       end
 
       # This is terrible, but it's the only way to reliably reproduce
       # the possible race where two threads attempt to correct the
       # dispatch hash at the same time.
-      def send *args
+      def send(*args)
         super
       rescue
         # Both threads try (and fail) to dispatch to the subclass's name
@@ -43,7 +44,7 @@ module Arel
         @table = Table.new(:users)
       end
 
-      it 'dispatches properly after failing upwards' do
+      it "dispatches properly after failing upwards" do
         node = Nodes::Union.new(Nodes::True.new, Nodes::False.new)
         assert_equal "( TRUE UNION FALSE )", node.to_sql
 
@@ -52,7 +53,7 @@ module Arel
         assert_equal "( TRUE UNION FALSE )", node.to_sql
       end
 
-      it 'is threadsafe when implementing superclass fallback' do
+      it "is threadsafe when implementing superclass fallback" do
         visitor = DummyVisitor.new
         main_thread_finished = Concurrent::Event.new
 
@@ -69,4 +70,3 @@ module Arel
     end
   end
 end
-
diff --git a/activerecord/test/cases/arel/visitors/dot_test.rb b/activerecord/test/cases/arel/visitors/dot_test.rb
index 048482c3ca..98f3bab620 100644
--- a/activerecord/test/cases/arel/visitors/dot_test.rb
+++ b/activerecord/test/cases/arel/visitors/dot_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -23,7 +24,7 @@ module Arel
       end
 
       def test_named_function
-        func = Nodes::NamedFunction.new 'omg', 'omg'
+        func = Nodes::NamedFunction.new "omg", "omg"
         @visitor.accept func, Collectors::PlainString.new
       end
 
diff --git a/activerecord/test/cases/arel/visitors/ibm_db_test.rb b/activerecord/test/cases/arel/visitors/ibm_db_test.rb
index d7569eedc3..7163cb34d3 100644
--- a/activerecord/test/cases/arel/visitors/ibm_db_test.rb
+++ b/activerecord/test/cases/arel/visitors/ibm_db_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -8,18 +9,18 @@ module Arel
         @visitor = IBM_DB.new Table.engine.connection
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'uses FETCH FIRST n ROWS to limit results' do
+      it "uses FETCH FIRST n ROWS to limit results" do
         stmt = Nodes::SelectStatement.new
         stmt.limit = Nodes::Limit.new(1)
         sql = compile(stmt)
         sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY"
       end
 
-      it 'uses FETCH FIRST n ROWS in updates with a limit' do
+      it "uses FETCH FIRST n ROWS in updates with a limit" do
         table = Table.new(:users)
         stmt = Nodes::UpdateStatement.new
         stmt.relation = table
@@ -28,7 +29,6 @@ module Arel
         sql = compile(stmt)
         sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT \"users\".\"id\" FROM \"users\" FETCH FIRST 1 ROWS ONLY)"
       end
-
     end
   end
 end
diff --git a/activerecord/test/cases/arel/visitors/informix_test.rb b/activerecord/test/cases/arel/visitors/informix_test.rb
index bb6ff42f05..b0b031cca3 100644
--- a/activerecord/test/cases/arel/visitors/informix_test.rb
+++ b/activerecord/test/cases/arel/visitors/informix_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -8,18 +9,18 @@ module Arel
         @visitor = Informix.new Table.engine.connection
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'uses FIRST n to limit results' do
+      it "uses FIRST n to limit results" do
         stmt = Nodes::SelectStatement.new
         stmt.limit = Nodes::Limit.new(1)
         sql = compile(stmt)
         sql.must_be_like "SELECT FIRST 1"
       end
 
-      it 'uses FIRST n in updates with a limit' do
+      it "uses FIRST n in updates with a limit" do
         table = Table.new(:users)
         stmt = Nodes::UpdateStatement.new
         stmt.relation = table
@@ -29,14 +30,14 @@ module Arel
         sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT FIRST 1 \"users\".\"id\" FROM \"users\")"
       end
 
-      it 'uses SKIP n to jump results' do
+      it "uses SKIP n to jump results" do
         stmt = Nodes::SelectStatement.new
         stmt.offset = Nodes::Offset.new(10)
         sql = compile(stmt)
         sql.must_be_like "SELECT SKIP 10"
       end
 
-      it 'uses SKIP before FIRST' do
+      it "uses SKIP before FIRST" do
         stmt = Nodes::SelectStatement.new
         stmt.limit = Nodes::Limit.new(1)
         stmt.offset = Nodes::Offset.new(1)
@@ -44,7 +45,7 @@ module Arel
         sql.must_be_like "SELECT SKIP 1 FIRST 1"
       end
 
-      it 'uses INNER JOIN to perform joins' do
+      it "uses INNER JOIN to perform joins" do
         core = Nodes::SelectCore.new
         table = Table.new(:posts)
         core.source = Nodes::JoinSource.new(table, [table.create_join(Table.new(:comments))])
@@ -53,7 +54,6 @@ module Arel
         sql = compile(stmt)
         sql.must_be_like 'SELECT FROM "posts" INNER JOIN "comments"'
       end
-
     end
   end
 end
diff --git a/activerecord/test/cases/arel/visitors/mssql_test.rb b/activerecord/test/cases/arel/visitors/mssql_test.rb
index 4e81678813..340376c3d6 100644
--- a/activerecord/test/cases/arel/visitors/mssql_test.rb
+++ b/activerecord/test/cases/arel/visitors/mssql_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -9,17 +10,17 @@ module Arel
         @table = Arel::Table.new "users"
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'should not modify query if no offset or limit' do
+      it "should not modify query if no offset or limit" do
         stmt = Nodes::SelectStatement.new
         sql = compile(stmt)
         sql.must_be_like "SELECT"
       end
 
-      it 'should go over table PK if no .order() or .group()' do
+      it "should go over table PK if no .order() or .group()" do
         stmt = Nodes::SelectStatement.new
         stmt.cores.first.from = @table
         stmt.limit = Nodes::Limit.new(10)
@@ -27,7 +28,7 @@ module Arel
         sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY \"users\".\"id\") as _row_num FROM \"users\") as _t WHERE _row_num BETWEEN 1 AND 10"
       end
 
-      it 'caches the PK lookup for order' do
+      it "caches the PK lookup for order" do
         connection = Minitest::Mock.new
         connection.expect(:primary_key, ["id"], ["users"])
 
@@ -46,7 +47,7 @@ module Arel
         connection.verify
       end
 
-      it 'should use TOP for limited deletes' do
+      it "should use TOP for limited deletes" do
         stmt = Nodes::DeleteStatement.new
         stmt.relation = @table
         stmt.limit = Nodes::Limit.new(10)
@@ -55,23 +56,23 @@ module Arel
         sql.must_be_like "DELETE TOP (10) FROM \"users\""
       end
 
-      it 'should go over query ORDER BY if .order()' do
+      it "should go over query ORDER BY if .order()" do
         stmt = Nodes::SelectStatement.new
         stmt.limit = Nodes::Limit.new(10)
-        stmt.orders << Nodes::SqlLiteral.new('order_by')
+        stmt.orders << Nodes::SqlLiteral.new("order_by")
         sql = compile(stmt)
         sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY order_by) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10"
       end
 
-      it 'should go over query GROUP BY if no .order() and there is .group()' do
+      it "should go over query GROUP BY if no .order() and there is .group()" do
         stmt = Nodes::SelectStatement.new
-        stmt.cores.first.groups << Nodes::SqlLiteral.new('group_by')
+        stmt.cores.first.groups << Nodes::SqlLiteral.new("group_by")
         stmt.limit = Nodes::Limit.new(10)
         sql = compile(stmt)
         sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY group_by) as _row_num GROUP BY group_by) as _t WHERE _row_num BETWEEN 1 AND 10"
       end
 
-      it 'should use BETWEEN if both .limit() and .offset' do
+      it "should use BETWEEN if both .limit() and .offset" do
         stmt = Nodes::SelectStatement.new
         stmt.limit = Nodes::Limit.new(10)
         stmt.offset = Nodes::Offset.new(20)
@@ -79,21 +80,20 @@ module Arel
         sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 21 AND 30"
       end
 
-      it 'should use >= if only .offset' do
+      it "should use >= if only .offset" do
         stmt = Nodes::SelectStatement.new
         stmt.offset = Nodes::Offset.new(20)
         sql = compile(stmt)
         sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num >= 21"
       end
 
-      it 'should generate subquery for .count' do
+      it "should generate subquery for .count" do
         stmt = Nodes::SelectStatement.new
         stmt.limit = Nodes::Limit.new(10)
-        stmt.cores.first.projections << Nodes::Count.new('*')
+        stmt.cores.first.projections << Nodes::Count.new("*")
         sql = compile(stmt)
         sql.must_be_like "SELECT COUNT(1) as count_id FROM (SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10) AS subquery"
       end
-
     end
   end
 end
diff --git a/activerecord/test/cases/arel/visitors/mysql_test.rb b/activerecord/test/cases/arel/visitors/mysql_test.rb
index f9b468b1d2..9d3bad8516 100644
--- a/activerecord/test/cases/arel/visitors/mysql_test.rb
+++ b/activerecord/test/cases/arel/visitors/mysql_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -8,24 +9,24 @@ module Arel
         @visitor = MySQL.new Table.engine.connection
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'squashes parenthesis on multiple unions' do
-        subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right')
-        node    = Nodes::Union.new subnode, Arel.sql('topright')
-        assert_equal 1, compile(node).scan('(').length
+      it "squashes parenthesis on multiple unions" do
+        subnode = Nodes::Union.new Arel.sql("left"), Arel.sql("right")
+        node    = Nodes::Union.new subnode, Arel.sql("topright")
+        assert_equal 1, compile(node).scan("(").length
 
-        subnode = Nodes::Union.new Arel.sql('left'), Arel.sql('right')
-        node    = Nodes::Union.new Arel.sql('topleft'), subnode
-        assert_equal 1, compile(node).scan('(').length
+        subnode = Nodes::Union.new Arel.sql("left"), Arel.sql("right")
+        node    = Nodes::Union.new Arel.sql("topleft"), subnode
+        assert_equal 1, compile(node).scan("(").length
       end
 
       ###
       # :'(
       # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
-      it 'defaults limit to 18446744073709551615' do
+      it "defaults limit to 18446744073709551615" do
         stmt = Nodes::SelectStatement.new
         stmt.offset = Nodes::Offset.new(1)
         sql = compile(stmt)
@@ -39,20 +40,20 @@ module Arel
         assert_equal("UPDATE \"users\" LIMIT 'omg'", compile(sc))
       end
 
-      it 'uses DUAL for empty from' do
+      it "uses DUAL for empty from" do
         stmt = Nodes::SelectStatement.new
         sql = compile(stmt)
         sql.must_be_like "SELECT FROM DUAL"
       end
 
-      describe 'locking' do
-        it 'defaults to FOR UPDATE when locking' do
-          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+      describe "locking" do
+        it "defaults to FOR UPDATE when locking" do
+          node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
           compile(node).must_be_like "FOR UPDATE"
         end
 
-        it 'allows a custom string to be used as a lock' do
-          node = Nodes::Lock.new(Arel.sql('LOCK IN SHARE MODE'))
+        it "allows a custom string to be used as a lock" do
+          node = Nodes::Lock.new(Arel.sql("LOCK IN SHARE MODE"))
           compile(node).must_be_like "LOCK IN SHARE MODE"
         end
       end
@@ -68,7 +69,7 @@ module Arel
 
         it "concats a string" do
           @table = Table.new(:users)
-          query = @table[:name].concat(Nodes.build_quoted('abc'))
+          query = @table[:name].concat(Nodes.build_quoted("abc"))
           compile(query).must_be_like %{
             CONCAT("users"."name", 'abc')
           }
diff --git a/activerecord/test/cases/arel/visitors/oracle12_test.rb b/activerecord/test/cases/arel/visitors/oracle12_test.rb
index ef2050b7c9..83a2ee36ca 100644
--- a/activerecord/test/cases/arel/visitors/oracle12_test.rb
+++ b/activerecord/test/cases/arel/visitors/oracle12_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -9,11 +10,11 @@ module Arel
         @table = Table.new(:users)
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'modified except to be minus' do
+      it "modified except to be minus" do
         left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
         right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
         sql = compile Nodes::Except.new(left, right)
@@ -22,7 +23,7 @@ module Arel
         }
       end
 
-      it 'generates select options offset then limit' do
+      it "generates select options offset then limit" do
         stmt = Nodes::SelectStatement.new
         stmt.offset = Nodes::Offset.new(1)
         stmt.limit = Nodes::Limit.new(10)
@@ -30,18 +31,18 @@ module Arel
         sql.must_be_like "SELECT OFFSET 1 ROWS FETCH FIRST 10 ROWS ONLY"
       end
 
-      describe 'locking' do
-        it 'generates ArgumentError if limit and lock are used' do
+      describe "locking" do
+        it "generates ArgumentError if limit and lock are used" do
           stmt = Nodes::SelectStatement.new
           stmt.limit = Nodes::Limit.new(10)
-          stmt.lock = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+          stmt.lock = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
           assert_raises ArgumentError do
             compile(stmt)
           end
         end
 
-        it 'defaults to FOR UPDATE when locking' do
-          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+        it "defaults to FOR UPDATE when locking" do
+          node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
           compile(node).must_be_like "FOR UPDATE"
         end
       end
diff --git a/activerecord/test/cases/arel/visitors/oracle_test.rb b/activerecord/test/cases/arel/visitors/oracle_test.rb
index 0737774fbf..e1dfe40cf9 100644
--- a/activerecord/test/cases/arel/visitors/oracle_test.rb
+++ b/activerecord/test/cases/arel/visitors/oracle_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -9,79 +10,79 @@ module Arel
         @table = Table.new(:users)
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'modifies order when there is distinct and first value' do
+      it "modifies order when there is distinct and first value" do
         # *sigh*
         select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
         stmt = Nodes::SelectStatement.new
         stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('foo')
+        stmt.orders << Nodes::SqlLiteral.new("foo")
         sql = compile(stmt)
         sql.must_be_like %{
           SELECT #{select} ORDER BY alias_0__
         }
       end
 
-      it 'is idempotent with crazy query' do
+      it "is idempotent with crazy query" do
         # *sigh*
         select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
         stmt = Nodes::SelectStatement.new
         stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('foo')
+        stmt.orders << Nodes::SqlLiteral.new("foo")
 
         sql = compile(stmt)
         sql2 = compile(stmt)
         sql.must_equal sql2
       end
 
-      it 'splits orders with commas' do
+      it "splits orders with commas" do
         # *sigh*
         select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
         stmt = Nodes::SelectStatement.new
         stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('foo, bar')
+        stmt.orders << Nodes::SqlLiteral.new("foo, bar")
         sql = compile(stmt)
         sql.must_be_like %{
           SELECT #{select} ORDER BY alias_0__, alias_1__
         }
       end
 
-      it 'splits orders with commas and function calls' do
+      it "splits orders with commas and function calls" do
         # *sigh*
         select = "DISTINCT foo.id, FIRST_VALUE(projects.name) OVER (foo) AS alias_0__"
         stmt = Nodes::SelectStatement.new
         stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
-        stmt.orders << Nodes::SqlLiteral.new('NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)')
+        stmt.orders << Nodes::SqlLiteral.new("NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)")
         sql = compile(stmt)
         sql.must_be_like %{
           SELECT #{select} ORDER BY alias_0__ DESC, alias_1__
         }
       end
 
-      describe 'Nodes::SelectStatement' do
-        describe 'limit' do
-          it 'adds a rownum clause' do
+      describe "Nodes::SelectStatement" do
+        describe "limit" do
+          it "adds a rownum clause" do
             stmt = Nodes::SelectStatement.new
             stmt.limit = Nodes::Limit.new(10)
             sql = compile stmt
             sql.must_be_like %{ SELECT WHERE ROWNUM <= 10 }
           end
 
-          it 'is idempotent' do
+          it "is idempotent" do
             stmt = Nodes::SelectStatement.new
-            stmt.orders << Nodes::SqlLiteral.new('foo')
+            stmt.orders << Nodes::SqlLiteral.new("foo")
             stmt.limit = Nodes::Limit.new(10)
             sql = compile stmt
             sql2 = compile stmt
             sql.must_equal sql2
           end
 
-          it 'creates a subquery when there is order_by' do
+          it "creates a subquery when there is order_by" do
             stmt = Nodes::SelectStatement.new
-            stmt.orders << Nodes::SqlLiteral.new('foo')
+            stmt.orders << Nodes::SqlLiteral.new("foo")
             stmt.limit = Nodes::Limit.new(10)
             sql = compile stmt
             sql.must_be_like %{
@@ -89,9 +90,9 @@ module Arel
             }
           end
 
-          it 'creates a subquery when there is group by' do
+          it "creates a subquery when there is group by" do
             stmt = Nodes::SelectStatement.new
-            stmt.cores.first.groups << Nodes::SqlLiteral.new('foo')
+            stmt.cores.first.groups << Nodes::SqlLiteral.new("foo")
             stmt.limit = Nodes::Limit.new(10)
             sql = compile stmt
             sql.must_be_like %{
@@ -99,10 +100,10 @@ module Arel
             }
           end
 
-          it 'creates a subquery when there is DISTINCT' do
+          it "creates a subquery when there is DISTINCT" do
             stmt = Nodes::SelectStatement.new
             stmt.cores.first.set_quantifier = Arel::Nodes::Distinct.new
-            stmt.cores.first.projections << Nodes::SqlLiteral.new('id')
+            stmt.cores.first.projections << Nodes::SqlLiteral.new("id")
             stmt.limit = Arel::Nodes::Limit.new(10)
             sql = compile stmt
             sql.must_be_like %{
@@ -110,7 +111,7 @@ module Arel
             }
           end
 
-          it 'creates a different subquery when there is an offset' do
+          it "creates a different subquery when there is an offset" do
             stmt = Nodes::SelectStatement.new
             stmt.limit = Nodes::Limit.new(10)
             stmt.offset = Nodes::Offset.new(10)
@@ -125,7 +126,7 @@ module Arel
             }
           end
 
-          it 'creates a subquery when there is limit and offset with BindParams' do
+          it "creates a subquery when there is limit and offset with BindParams" do
             stmt = Nodes::SelectStatement.new
             stmt.limit = Nodes::Limit.new(Nodes::BindParam.new(1))
             stmt.offset = Nodes::Offset.new(Nodes::BindParam.new(1))
@@ -140,7 +141,7 @@ module Arel
             }
           end
 
-          it 'is idempotent with different subquery' do
+          it "is idempotent with different subquery" do
             stmt = Nodes::SelectStatement.new
             stmt.limit = Nodes::Limit.new(10)
             stmt.offset = Nodes::Offset.new(10)
@@ -150,8 +151,8 @@ module Arel
           end
         end
 
-        describe 'only offset' do
-          it 'creates a select from subquery with rownum condition' do
+        describe "only offset" do
+          it "creates a select from subquery with rownum condition" do
             stmt = Nodes::SelectStatement.new
             stmt.offset = Nodes::Offset.new(10)
             sql = compile stmt
@@ -166,7 +167,7 @@ module Arel
         end
       end
 
-      it 'modified except to be minus' do
+      it "modified except to be minus" do
         left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
         right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
         sql = compile Nodes::Except.new(left, right)
@@ -175,9 +176,9 @@ module Arel
         }
       end
 
-      describe 'locking' do
-        it 'defaults to FOR UPDATE when locking' do
-          node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
+      describe "locking" do
+        it "defaults to FOR UPDATE when locking" do
+          node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
           compile(node).must_be_like "FOR UPDATE"
         end
       end
diff --git a/activerecord/test/cases/arel/visitors/postgres_test.rb b/activerecord/test/cases/arel/visitors/postgres_test.rb
index 6aa786b14f..ba37afecfb 100644
--- a/activerecord/test/cases/arel/visitors/postgres_test.rb
+++ b/activerecord/test/cases/arel/visitors/postgres_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -10,19 +11,19 @@ module Arel
         @attr = @table[:id]
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      describe 'locking' do
-        it 'defaults to FOR UPDATE' do
-          compile(Nodes::Lock.new(Arel.sql('FOR UPDATE'))).must_be_like %{
+      describe "locking" do
+        it "defaults to FOR UPDATE" do
+          compile(Nodes::Lock.new(Arel.sql("FOR UPDATE"))).must_be_like %{
             FOR UPDATE
           }
         end
 
-        it 'allows a custom string to be used as a lock' do
-          node = Nodes::Lock.new(Arel.sql('FOR SHARE'))
+        it "allows a custom string to be used as a lock" do
+          node = Nodes::Lock.new(Arel.sql("FOR SHARE"))
           compile(node).must_be_like %{
             FOR SHARE
           }
@@ -32,42 +33,42 @@ module Arel
       it "should escape LIMIT" do
         sc = Arel::Nodes::SelectStatement.new
         sc.limit = Nodes::Limit.new(Nodes.build_quoted("omg"))
-        sc.cores.first.projections << Arel.sql('DISTINCT ON')
+        sc.cores.first.projections << Arel.sql("DISTINCT ON")
         sc.orders << Arel.sql("xyz")
-        sql =  compile(sc)
+        sql = compile(sc)
         assert_match(/LIMIT 'omg'/, sql)
-        assert_equal 1, sql.scan(/LIMIT/).length, 'should have one limit'
+        assert_equal 1, sql.scan(/LIMIT/).length, "should have one limit"
       end
 
-      it 'should support DISTINCT ON' do
+      it "should support DISTINCT ON" do
         core = Arel::Nodes::SelectCore.new
-        core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
-        assert_match 'DISTINCT ON ( aaron )', compile(core)
+        core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql("aaron"))
+        assert_match "DISTINCT ON ( aaron )", compile(core)
       end
 
-      it 'should support DISTINCT' do
+      it "should support DISTINCT" do
         core = Arel::Nodes::SelectCore.new
         core.set_quantifier = Arel::Nodes::Distinct.new
-        assert_equal 'SELECT DISTINCT', compile(core)
+        assert_equal "SELECT DISTINCT", compile(core)
       end
 
-      it 'encloses LATERAL queries in parens' do
-        subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+      it "encloses LATERAL queries in parens" do
+        subquery = @table.project(:id).where(@table[:name].matches("foo%"))
         compile(subquery.lateral).must_be_like %{
           LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
         }
       end
 
-      it 'produces LATERAL queries with alias' do
-        subquery = @table.project(:id).where(@table[:name].matches('foo%'))
-        compile(subquery.lateral('bar')).must_be_like %{
+      it "produces LATERAL queries with alias" do
+        subquery = @table.project(:id).where(@table[:name].matches("foo%"))
+        compile(subquery.lateral("bar")).must_be_like %{
           LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') bar
         }
       end
 
       describe "Nodes::Matches" do
         it "should know how to visit" do
-          node = @table[:name].matches('foo%')
+          node = @table[:name].matches("foo%")
           node.must_be_kind_of Nodes::Matches
           node.case_sensitive.must_equal(false)
           compile(node).must_be_like %{
@@ -76,7 +77,7 @@ module Arel
         end
 
         it "should know how to visit case sensitive" do
-          node = @table[:name].matches('foo%', nil, true)
+          node = @table[:name].matches("foo%", nil, true)
           node.case_sensitive.must_equal(true)
           compile(node).must_be_like %{
             "users"."name" LIKE 'foo%'
@@ -84,14 +85,14 @@ module Arel
         end
 
         it "can handle ESCAPE" do
-          node = @table[:name].matches('foo!%', '!')
+          node = @table[:name].matches("foo!%", "!")
           compile(node).must_be_like %{
             "users"."name" ILIKE 'foo!%' ESCAPE '!'
           }
         end
 
-        it 'can handle subqueries' do
-          subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].matches("foo%"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
@@ -101,7 +102,7 @@ module Arel
 
       describe "Nodes::DoesNotMatch" do
         it "should know how to visit" do
-          node = @table[:name].does_not_match('foo%')
+          node = @table[:name].does_not_match("foo%")
           node.must_be_kind_of Nodes::DoesNotMatch
           node.case_sensitive.must_equal(false)
           compile(node).must_be_like %{
@@ -110,7 +111,7 @@ module Arel
         end
 
         it "should know how to visit case sensitive" do
-          node = @table[:name].does_not_match('foo%', nil, true)
+          node = @table[:name].does_not_match("foo%", nil, true)
           node.case_sensitive.must_equal(true)
           compile(node).must_be_like %{
             "users"."name" NOT LIKE 'foo%'
@@ -118,14 +119,14 @@ module Arel
         end
 
         it "can handle ESCAPE" do
-          node = @table[:name].does_not_match('foo!%', '!')
+          node = @table[:name].does_not_match("foo!%", "!")
           compile(node).must_be_like %{
             "users"."name" NOT ILIKE 'foo!%' ESCAPE '!'
           }
         end
 
-        it 'can handle subqueries' do
-          subquery = @table.project(:id).where(@table[:name].does_not_match('foo%'))
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].does_not_match("foo%"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT ILIKE 'foo%')
@@ -135,7 +136,7 @@ module Arel
 
       describe "Nodes::Regexp" do
         it "should know how to visit" do
-          node = @table[:name].matches_regexp('foo.*')
+          node = @table[:name].matches_regexp("foo.*")
           node.must_be_kind_of Nodes::Regexp
           node.case_sensitive.must_equal(true)
           compile(node).must_be_like %{
@@ -144,7 +145,7 @@ module Arel
         end
 
         it "can handle case insensitive" do
-          node = @table[:name].matches_regexp('foo.*', false)
+          node = @table[:name].matches_regexp("foo.*", false)
           node.must_be_kind_of Nodes::Regexp
           node.case_sensitive.must_equal(false)
           compile(node).must_be_like %{
@@ -152,8 +153,8 @@ module Arel
           }
         end
 
-        it 'can handle subqueries' do
-          subquery = @table.project(:id).where(@table[:name].matches_regexp('foo.*'))
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ~ 'foo.*')
@@ -163,7 +164,7 @@ module Arel
 
       describe "Nodes::NotRegexp" do
         it "should know how to visit" do
-          node = @table[:name].does_not_match_regexp('foo.*')
+          node = @table[:name].does_not_match_regexp("foo.*")
           node.must_be_kind_of Nodes::NotRegexp
           node.case_sensitive.must_equal(true)
           compile(node).must_be_like %{
@@ -172,15 +173,15 @@ module Arel
         end
 
         it "can handle case insensitive" do
-          node = @table[:name].does_not_match_regexp('foo.*', false)
+          node = @table[:name].does_not_match_regexp("foo.*", false)
           node.case_sensitive.must_equal(false)
           compile(node).must_be_like %{
             "users"."name" !~* 'foo.*'
           }
         end
 
-        it 'can handle subqueries' do
-          subquery = @table.project(:id).where(@table[:name].does_not_match_regexp('foo.*'))
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" !~ 'foo.*')
diff --git a/activerecord/test/cases/arel/visitors/sqlite_test.rb b/activerecord/test/cases/arel/visitors/sqlite_test.rb
index 23f66ee096..6650b6ff3a 100644
--- a/activerecord/test/cases/arel/visitors/sqlite_test.rb
+++ b/activerecord/test/cases/arel/visitors/sqlite_test.rb
@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative '../helper'
+
+require_relative "../helper"
 
 module Arel
   module Visitors
@@ -8,23 +9,23 @@ module Arel
         @visitor = SQLite.new Table.engine.connection_pool
       end
 
-      it 'defaults limit to -1' do
+      it "defaults limit to -1" do
         stmt = Nodes::SelectStatement.new
         stmt.offset = Nodes::Offset.new(1)
         sql = @visitor.accept(stmt, Collectors::SQLString.new).value
         sql.must_be_like "SELECT LIMIT -1 OFFSET 1"
       end
 
-      it 'does not support locking' do
-        node = Nodes::Lock.new(Arel.sql('FOR UPDATE'))
-        assert_equal '', @visitor.accept(node, Collectors::SQLString.new).value
+      it "does not support locking" do
+        node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
+        assert_equal "", @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'does not support boolean' do
+      it "does not support boolean" do
         node = Nodes::True.new()
-        assert_equal '1', @visitor.accept(node, Collectors::SQLString.new).value
+        assert_equal "1", @visitor.accept(node, Collectors::SQLString.new).value
         node = Nodes::False.new()
-        assert_equal '0', @visitor.accept(node, Collectors::SQLString.new).value
+        assert_equal "0", @visitor.accept(node, Collectors::SQLString.new).value
       end
     end
   end
diff --git a/activerecord/test/cases/arel/visitors/to_sql_test.rb b/activerecord/test/cases/arel/visitors/to_sql_test.rb
index 1503bcd578..ce836eded7 100644
--- a/activerecord/test/cases/arel/visitors/to_sql_test.rb
+++ b/activerecord/test/cases/arel/visitors/to_sql_test.rb
@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-require_relative '../helper'
-require 'bigdecimal'
+
+require_relative "../helper"
+require "bigdecimal"
 
 module Arel
   module Visitors
-    describe 'the to_sql visitor' do
+    describe "the to_sql visitor" do
       before do
         @conn = FakeRecord::Base.new
         @visitor = ToSql.new @conn.connection
@@ -12,24 +13,24 @@ module Arel
         @attr = @table[:id]
       end
 
-      def compile node
+      def compile(node)
         @visitor.accept(node, Collectors::SQLString.new).value
       end
 
-      it 'works with BindParams' do
+      it "works with BindParams" do
         node = Nodes::BindParam.new(1)
         sql = compile node
-        sql.must_be_like '?'
+        sql.must_be_like "?"
       end
 
-      it 'does not quote BindParams used as part of a Values' do
+      it "does not quote BindParams used as part of a Values" do
         bp = Nodes::BindParam.new(1)
         values = Nodes::Values.new([bp])
         sql = compile values
-        sql.must_be_like 'VALUES (?)'
+        sql.must_be_like "VALUES (?)"
       end
 
-      it 'can define a dispatch method' do
+      it "can define a dispatch method" do
         visited = false
         viz = Class.new(Arel::Visitors::Visitor) {
           define_method(:hello) do |node, c|
@@ -37,117 +38,117 @@ module Arel
           end
 
           def dispatch
-            { Arel::Table => 'hello' }
+            { Arel::Table => "hello" }
           end
         }.new
 
         viz.accept(@table, Collectors::SQLString.new)
-        assert visited, 'hello method was called'
+        assert visited, "hello method was called"
       end
 
-      it 'should not quote sql literals' do
+      it "should not quote sql literals" do
         node = @table[Arel.star]
         sql = compile node
         sql.must_be_like '"users".*'
       end
 
-      it 'should visit named functions' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star])
-        assert_equal 'omg(*)', compile(function)
+      it "should visit named functions" do
+        function = Nodes::NamedFunction.new("omg", [Arel.star])
+        assert_equal "omg(*)", compile(function)
       end
 
-      it 'should chain predications on named functions' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star])
+      it "should chain predications on named functions" do
+        function = Nodes::NamedFunction.new("omg", [Arel.star])
         sql = compile(function.eq(2))
         sql.must_be_like %{ omg(*) = 2 }
       end
 
-      it 'should handle nil with named functions' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star])
+      it "should handle nil with named functions" do
+        function = Nodes::NamedFunction.new("omg", [Arel.star])
         sql = compile(function.eq(nil))
         sql.must_be_like %{ omg(*) IS NULL }
       end
 
-      it 'should visit built-in functions' do
+      it "should visit built-in functions" do
         function = Nodes::Count.new([Arel.star])
-        assert_equal 'COUNT(*)', compile(function)
+        assert_equal "COUNT(*)", compile(function)
 
         function = Nodes::Sum.new([Arel.star])
-        assert_equal 'SUM(*)', compile(function)
+        assert_equal "SUM(*)", compile(function)
 
         function = Nodes::Max.new([Arel.star])
-        assert_equal 'MAX(*)', compile(function)
+        assert_equal "MAX(*)", compile(function)
 
         function = Nodes::Min.new([Arel.star])
-        assert_equal 'MIN(*)', compile(function)
+        assert_equal "MIN(*)", compile(function)
 
         function = Nodes::Avg.new([Arel.star])
-        assert_equal 'AVG(*)', compile(function)
+        assert_equal "AVG(*)", compile(function)
       end
 
-      it 'should visit built-in functions operating on distinct values' do
+      it "should visit built-in functions operating on distinct values" do
         function = Nodes::Count.new([Arel.star])
         function.distinct = true
-        assert_equal 'COUNT(DISTINCT *)', compile(function)
+        assert_equal "COUNT(DISTINCT *)", compile(function)
 
         function = Nodes::Sum.new([Arel.star])
         function.distinct = true
-        assert_equal 'SUM(DISTINCT *)', compile(function)
+        assert_equal "SUM(DISTINCT *)", compile(function)
 
         function = Nodes::Max.new([Arel.star])
         function.distinct = true
-        assert_equal 'MAX(DISTINCT *)', compile(function)
+        assert_equal "MAX(DISTINCT *)", compile(function)
 
         function = Nodes::Min.new([Arel.star])
         function.distinct = true
-        assert_equal 'MIN(DISTINCT *)', compile(function)
+        assert_equal "MIN(DISTINCT *)", compile(function)
 
         function = Nodes::Avg.new([Arel.star])
         function.distinct = true
-        assert_equal 'AVG(DISTINCT *)', compile(function)
+        assert_equal "AVG(DISTINCT *)", compile(function)
       end
 
-      it 'works with lists' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star, Arel.star])
-        assert_equal 'omg(*, *)', compile(function)
+      it "works with lists" do
+        function = Nodes::NamedFunction.new("omg", [Arel.star, Arel.star])
+        assert_equal "omg(*, *)", compile(function)
       end
 
-      describe 'Nodes::Equality' do
+      describe "Nodes::Equality" do
         it "should escape strings" do
-          test = Table.new(:users)[:name].eq 'Aaron Patterson'
+          test = Table.new(:users)[:name].eq "Aaron Patterson"
           compile(test).must_be_like %{
             "users"."name" = 'Aaron Patterson'
           }
         end
 
-        it 'should handle false' do
+        it "should handle false" do
           table = Table.new(:users)
           val = Nodes.build_quoted(false, table[:active])
           sql = compile Nodes::Equality.new(val, val)
           sql.must_be_like %{ 'f' = 'f' }
         end
 
-        it 'should handle nil' do
+        it "should handle nil" do
           sql = compile Nodes::Equality.new(@table[:name], nil)
           sql.must_be_like %{ "users"."name" IS NULL }
         end
       end
 
-      describe 'Nodes::Grouping' do
-        it 'wraps nested groupings in brackets only once' do
-          sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted('foo')))
+      describe "Nodes::Grouping" do
+        it "wraps nested groupings in brackets only once" do
+          sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted("foo")))
           sql.must_equal "('foo')"
         end
       end
 
-      describe 'Nodes::NotEqual' do
-        it 'should handle false' do
+      describe "Nodes::NotEqual" do
+        it "should handle false" do
           val = Nodes.build_quoted(false, @table[:active])
           sql = compile Nodes::NotEqual.new(@table[:active], val)
           sql.must_be_like %{ "users"."active" != 'f' }
         end
 
-        it 'should handle nil' do
+        it "should handle nil" do
           val = Nodes.build_quoted(nil, @table[:active])
           sql = compile Nodes::NotEqual.new(@table[:name], val)
           sql.must_be_like %{ "users"."name" IS NOT NULL }
@@ -225,7 +226,7 @@ module Arel
       end
 
       it "should visit_Hash" do
-        compile(Nodes.build_quoted({:a => 1}))
+        compile(Nodes.build_quoted(a: 1))
       end
 
       it "should visit_Set" do
@@ -233,7 +234,7 @@ module Arel
       end
 
       it "should visit_BigDecimal" do
-        compile Nodes.build_quoted(BigDecimal('2.14'))
+        compile Nodes.build_quoted(BigDecimal("2.14"))
       end
 
       it "should visit_Date" do
@@ -296,21 +297,21 @@ module Arel
 
       describe "Nodes::Matches" do
         it "should know how to visit" do
-          node = @table[:name].matches('foo%')
+          node = @table[:name].matches("foo%")
           compile(node).must_be_like %{
             "users"."name" LIKE 'foo%'
           }
         end
 
         it "can handle ESCAPE" do
-          node = @table[:name].matches('foo!%', '!')
+          node = @table[:name].matches("foo!%", "!")
           compile(node).must_be_like %{
             "users"."name" LIKE 'foo!%' ESCAPE '!'
           }
         end
 
-        it 'can handle subqueries' do
-          subquery = @table.project(:id).where(@table[:name].matches('foo%'))
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].matches("foo%"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" LIKE 'foo%')
@@ -320,21 +321,21 @@ module Arel
 
       describe "Nodes::DoesNotMatch" do
         it "should know how to visit" do
-          node = @table[:name].does_not_match('foo%')
+          node = @table[:name].does_not_match("foo%")
           compile(node).must_be_like %{
             "users"."name" NOT LIKE 'foo%'
           }
         end
 
         it "can handle ESCAPE" do
-          node = @table[:name].does_not_match('foo!%', '!')
+          node = @table[:name].does_not_match("foo!%", "!")
           compile(node).must_be_like %{
             "users"."name" NOT LIKE 'foo!%' ESCAPE '!'
           }
         end
 
-        it 'can handle subqueries' do
-          subquery = @table.project(:id).where(@table[:name].does_not_match('foo%'))
+        it "can handle subqueries" do
+          subquery = @table.project(:id).where(@table[:name].does_not_match("foo%"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT LIKE 'foo%')
@@ -361,24 +362,24 @@ module Arel
 
         it "should return 1=0 when empty right which is always false" do
           node = @attr.in []
-          compile(node).must_equal '1=0'
+          compile(node).must_equal "1=0"
         end
 
-        it 'can handle two dot ranges' do
+        it "can handle two dot ranges" do
           node = @attr.between 1..3
           compile(node).must_be_like %{
             "users"."id" BETWEEN 1 AND 3
           }
         end
 
-        it 'can handle three dot ranges' do
+        it "can handle three dot ranges" do
           node = @attr.between 1...3
           compile(node).must_be_like %{
             "users"."id" >= 1 AND "users"."id" < 3
           }
         end
 
-        it 'can handle ranges bounded by infinity' do
+        it "can handle ranges bounded by infinity" do
           node = @attr.between 1..Float::INFINITY
           compile(node).must_be_like %{
             "users"."id" >= 1
@@ -395,9 +396,9 @@ module Arel
           compile(node).must_be_like %{1=1}
         end
 
-        it 'can handle subqueries' do
+        it "can handle subqueries" do
           table = Table.new(:users)
-          subquery = table.project(:id).where(table[:name].eq('Aaron'))
+          subquery = table.project(:id).where(table[:name].eq("Aaron"))
           node = @attr.in subquery
           compile(node).must_be_like %{
             "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
@@ -459,7 +460,7 @@ module Arel
 
         it "should handle arbitrary operators" do
           node = Arel::Nodes::InfixOperation.new(
-            '&&',
+            "&&",
             Arel::Attributes::String.new(Table.new(:products), :name),
             Arel::Attributes::String.new(Table.new(:products), :name)
           )
@@ -474,7 +475,7 @@ module Arel
         end
 
         it "should handle arbitrary operators" do
-          node = Arel::Nodes::UnaryOperation.new('!', Arel::Attributes::String.new(Table.new(:products), :active))
+          node = Arel::Nodes::UnaryOperation.new("!", Arel::Attributes::String.new(Table.new(:products), :active))
           compile(node).must_equal %( ! "products"."active")
         end
       end
@@ -489,24 +490,24 @@ module Arel
 
         it "should return 1=1 when empty right which is always true" do
           node = @attr.not_in []
-          compile(node).must_equal '1=1'
+          compile(node).must_equal "1=1"
         end
 
-        it 'can handle two dot ranges' do
+        it "can handle two dot ranges" do
           node = @attr.not_between 1..3
           compile(node).must_equal(
             %{("users"."id" < 1 OR "users"."id" > 3)}
           )
         end
 
-        it 'can handle three dot ranges' do
+        it "can handle three dot ranges" do
           node = @attr.not_between 1...3
           compile(node).must_equal(
             %{("users"."id" < 1 OR "users"."id" >= 3)}
           )
         end
 
-        it 'can handle ranges bounded by infinity' do
+        it "can handle ranges bounded by infinity" do
           node = @attr.not_between 1..Float::INFINITY
           compile(node).must_be_like %{
             "users"."id" < 1
@@ -523,9 +524,9 @@ module Arel
           compile(node).must_be_like %{1=0}
         end
 
-        it 'can handle subqueries' do
+        it "can handle subqueries" do
           table = Table.new(:users)
-          subquery = table.project(:id).where(table[:name].eq('Aaron'))
+          subquery = table.project(:id).where(table[:name].eq("Aaron"))
           node = @attr.not_in subquery
           compile(node).must_be_like %{
             "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
@@ -533,7 +534,7 @@ module Arel
         end
       end
 
-      describe 'Constants' do
+      describe "Constants" do
         it "should handle true" do
           test = Table.new(:users).create_true
           compile(test).must_be_like %{
@@ -549,19 +550,19 @@ module Arel
         end
       end
 
-      describe 'TableAlias' do
+      describe "TableAlias" do
         it "should use the underlying table for checking columns" do
-          test = Table.new(:users).alias('zomgusers')[:id].eq '3'
+          test = Table.new(:users).alias("zomgusers")[:id].eq "3"
           compile(test).must_be_like %{
             "zomgusers"."id" = '3'
           }
         end
       end
 
-      describe 'distinct on' do
-        it 'raises not implemented error' do
+      describe "distinct on" do
+        it "raises not implemented error" do
           core = Arel::Nodes::SelectCore.new
-          core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
+          core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql("aaron"))
 
           assert_raises(NotImplementedError) do
             compile(core)
@@ -569,9 +570,9 @@ module Arel
         end
       end
 
-      describe 'Nodes::Regexp' do
-        it 'raises not implemented error' do
-          node = Arel::Nodes::Regexp.new(@table[:name], Nodes.build_quoted('foo%'))
+      describe "Nodes::Regexp" do
+        it "raises not implemented error" do
+          node = Arel::Nodes::Regexp.new(@table[:name], Nodes.build_quoted("foo%"))
 
           assert_raises(NotImplementedError) do
             compile(node)
@@ -579,9 +580,9 @@ module Arel
         end
       end
 
-      describe 'Nodes::NotRegexp' do
-        it 'raises not implemented error' do
-          node = Arel::Nodes::NotRegexp.new(@table[:name], Nodes.build_quoted('foo%'))
+      describe "Nodes::NotRegexp" do
+        it "raises not implemented error" do
+          node = Arel::Nodes::NotRegexp.new(@table[:name], Nodes.build_quoted("foo%"))
 
           assert_raises(NotImplementedError) do
             compile(node)
@@ -589,10 +590,10 @@ module Arel
         end
       end
 
-      describe 'Nodes::Case' do
-        it 'supports simple case expressions' do
+      describe "Nodes::Case" do
+        it "supports simple case expressions" do
           node = Arel::Nodes::Case.new(@table[:name])
-            .when('foo').then(1)
+            .when("foo").then(1)
             .else(0)
 
           compile(node).must_be_like %{
@@ -600,7 +601,7 @@ module Arel
           }
         end
 
-        it 'supports extended case expressions' do
+        it "supports extended case expressions" do
           node = Arel::Nodes::Case.new
             .when(@table[:name].in(%w(foo bar))).then(1)
             .else(0)
@@ -610,19 +611,19 @@ module Arel
           }
         end
 
-        it 'works without default branch' do
+        it "works without default branch" do
           node = Arel::Nodes::Case.new(@table[:name])
-            .when('foo').then(1)
+            .when("foo").then(1)
 
           compile(node).must_be_like %{
             CASE "users"."name" WHEN 'foo' THEN 1 END
           }
         end
 
-        it 'allows chaining multiple conditions' do
+        it "allows chaining multiple conditions" do
           node = Arel::Nodes::Case.new(@table[:name])
-            .when('foo').then(1)
-            .when('bar').then(2)
+            .when("foo").then(1)
+            .when("bar").then(2)
             .else(0)
 
           compile(node).must_be_like %{
@@ -630,7 +631,7 @@ module Arel
           }
         end
 
-        it 'supports #when with two arguments and no #then' do
+        it "supports #when with two arguments and no #then" do
           node = Arel::Nodes::Case.new @table[:name]
 
           { foo: 1, bar: 0 }.reduce(node) { |_node, pair| _node.when(*pair) }
@@ -640,8 +641,8 @@ module Arel
           }
         end
 
-        it 'can be chained as a predicate' do
-          node = @table[:name].when('foo').then('bar').else('baz')
+        it "can be chained as a predicate" do
+          node = @table[:name].when("foo").then("bar").else("baz")
 
           compile(node).must_be_like %{
             CASE "users"."name" WHEN 'foo' THEN 'bar' ELSE 'baz' END