arel-helpers 2.11.0 → 2.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b15a810e483ddccf300cec2e2926a44b05be707e557fa7f89d432fa6542ddc72
-  data.tar.gz: 8acaece31ba468798d127deab33ac06c8569b71d51e0a813902f398a5f3efbcc
+  metadata.gz: 667479f8a68b5bb0af49054dea8aad1071976d752ca00f1e6cd4560005b71ba7
+  data.tar.gz: 0d7d43d81c584cf98a7a2becb0cc61e9f36af9cc24296146d0e4857855a9ef4b
 SHA512:
-  metadata.gz: 265f9cd3e9cbc2d8e3b4c4aa6cb4d2b3cbab4ab8cba267a7088ec56da4cc038271da0ca51d3e2d2d3923cf04d04fc4c8ee79fda0cd571f2b59561677b8dba6d2
-  data.tar.gz: 60de9c7c46e7d1ed33f8d5ac9466613075e8ab1fd0b9a3335a1f88c6ccc19b64a388297c151578fb23d090c58847151a01c4af5a3365702941fb607c9f0512c5
+  metadata.gz: 07545d1df75177211b9e40302b3273df2eac33d29dc3ad42fa8c737b06711f2cdbf6455e1e2b90cb523a7248bfece31e8b16296501c103a8f65c513cf21dde02
+  data.tar.gz: 978312ef3268e698c8b155fad5bdbdf084a5175a1a753b8367386d8f116af2fbacb58601288987a3e8cc3a6755eb1efee9412eb459aec72a1990ecb6112e8c1a

data/Gemfile

@@ -1,2 +1,3 @@
-ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile-rails-6.0.x', __FILE__)
-Bundler.load
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -1,6 +1,6 @@
+![Unit Tests](https://github.com/camertron/arel-helpers/actions/workflows/unit_tests.yml/badge.svg?branch=master)
 
-
-## arel-helpers [![Build Status](https://secure.travis-ci.org/camertron/arel-helpers.png?branch=master)](http://travis-ci.org/camertron/arel-helpers)
+## arel-helpers
 
 Useful tools to help construct database queries with ActiveRecord and Arel.
 
@@ -215,7 +215,7 @@ This can become repetitive, and as an alternative you can choose to prepend `not
 
 ## Requirements
 
-Requires ActiveRecord >= 3.1.0, < 6, tested against Ruby 2.2.4. Depends on SQLite for testing purposes.
+Requires ActiveRecord >= 3.1.0, < 7. Depends on SQLite for testing purposes.
 
 ## Running Tests
 

data/arel-helpers.gemspec

@@ -1,23 +1,27 @@
-$:.unshift File.join(File.dirname(__FILE__), 'lib')
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), 'lib')
 require 'arel-helpers/version'
 
 Gem::Specification.new do |s|
-  s.name     = "arel-helpers"
+  s.name     = 'arel-helpers'
   s.version  = ::ArelHelpers::VERSION
-  s.authors  = ["Cameron Dutro"]
-  s.email    = ["camertron@gmail.com"]
-  s.homepage = "https://github.com/camertron/arel-helpers"
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'https://github.com/camertron/arel-helpers'
   s.license  = 'MIT'
-  s.description = s.summary = "Useful tools to help construct database queries with ActiveRecord and Arel."
+  s.description = s.summary = 'Useful tools to help construct database queries with ActiveRecord and Arel.'
 
   s.platform = Gem::Platform::RUBY
 
-  s.add_dependency 'activerecord', '>= 3.1.0', '< 7'
+  s.add_dependency 'activerecord', '>= 3.1.0', '< 8'
 
-  s.add_development_dependency 'rake', '~> 10.0'
-  s.add_development_dependency 'rspec', '~> 2.11'
-  s.add_development_dependency 'rr', '~> 1.0'
+  s.add_development_dependency 'appraisal'
+  s.add_development_dependency 'combustion', '~> 1.3'
+  s.add_development_dependency 'database_cleaner', '~> 1.8'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 3'
+  s.add_development_dependency 'sqlite3', '~> 1.4.0'
 
   s.require_path = 'lib'
-  s.files = Dir["{lib,spec}/**/*", "Gemfile", "History.txt", "README.md", "Rakefile", "arel-helpers.gemspec"]
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'History.txt', 'README.md', 'Rakefile', 'arel-helpers.gemspec']
+  s.files -= Dir['spec/internal/log', 'spec/internal/log/**/*', 'spec/internal/db', 'spec/internal/db/**/*']
 end

data/lib/arel-helpers/join_association.rb

@@ -18,7 +18,9 @@ module ArelHelpers
       # This method encapsulates that functionality and yields an intermediate object for chaining.
       # It also allows you to use an outer join instead of the default inner via the join_type arg.
       def join_association(table, association, join_type = Arel::Nodes::InnerJoin, options = {}, &block)
-        if version >= '6.0.0'
+        if version >= '6.1.0'
+          join_association_6_1_0(table, association, join_type, options, &block)
+        elsif version >= '6.0.0'
           join_association_6_0_0(table, association, join_type, options, &block)
         elsif version >= '5.2.1'
           join_association_5_2_1(table, association, join_type, options, &block)
@@ -42,7 +44,7 @@ module ArelHelpers
       end
 
       def join_association_3_1(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, {})
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
         join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
         manager = Arel::SelectManager.new(table)
@@ -53,12 +55,9 @@ module ArelHelpers
         end
 
         manager.join_sources.map do |assoc|
-          if found_alias = find_alias(assoc.left.name, aliases)
-            assoc.left.table_alias = found_alias.name
-          end
+          assoc.left.table_alias = aliases[assoc.left.name].name if aliases.key?(assoc.left.name)
 
           if block_given?
-            # yield |assoc_name, join_conditions|
             right = yield assoc.left.name.to_sym, assoc.right
             assoc.class.new(assoc.left, right)
           else
@@ -68,7 +67,7 @@ module ArelHelpers
       end
 
       def join_association_4_1(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, {})
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
         join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
 
@@ -79,9 +78,7 @@ module ArelHelpers
             constraint.right
           end
 
-          if found_alias = find_alias(constraint.left.name, aliases)
-            constraint.left.table_alias = found_alias.name
-          end
+          constraint.left.table_alias = aliases[constraint.left.name].name if aliases.key?(constraint.left.name)
 
           join_type.new(constraint.left, right)
         end
@@ -93,7 +90,7 @@ module ArelHelpers
       # dynamically. To get around the problem, this method must return
       # a string.
       def join_association_4_2(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, [])
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
         join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
 
@@ -111,9 +108,7 @@ module ArelHelpers
               join.right
             end
 
-            if found_alias = find_alias(join.left.name, aliases)
-              join.left.table_alias = found_alias.name
-            end
+            join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
 
             join_type.new(join.left, right)
           end
@@ -127,7 +122,7 @@ module ArelHelpers
       end
 
       def join_association_5_0(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, [])
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
         join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
 
@@ -146,9 +141,7 @@ module ArelHelpers
               join.right
             end
 
-            if found_alias = find_alias(join.left.name, aliases)
-              join.left.table_alias = found_alias.name
-            end
+            join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
 
             join_type.new(join.left, right)
           end
@@ -162,7 +155,7 @@ module ArelHelpers
       end
 
       def join_association_5_2(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, [])
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
 
         alias_tracker = ActiveRecord::Associations::AliasTracker.create(
@@ -182,16 +175,14 @@ module ArelHelpers
             join.right
           end
 
-          if found_alias = find_alias(join.left.name, aliases)
-            join.left.table_alias = found_alias.name
-          end
+          join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
 
           join_type.new(join.left, right)
         end
       end
 
       def join_association_5_2_1(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, [])
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
 
         alias_tracker = ActiveRecord::Associations::AliasTracker.create(
@@ -211,16 +202,14 @@ module ArelHelpers
             join.right
           end
 
-          if found_alias = find_alias(join.left.name, aliases)
-            join.left.table_alias = found_alias.name
-          end
+          join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
 
           join_type.new(join.left, right)
         end
       end
 
       def join_association_6_0_0(table, association, join_type, options = {})
-        aliases = options.fetch(:aliases, [])
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
 
         alias_tracker = ActiveRecord::Associations::AliasTracker.create(
@@ -240,14 +229,56 @@ module ArelHelpers
             join.right
           end
 
-          if found_alias = find_alias(join.left.name, aliases)
-            join.left.table_alias = found_alias.name
-          end
+          join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
 
           join_type.new(join.left, right)
         end
       end
 
+      def join_association_6_1_0(table, association, join_type, options = {})
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
+        associations = association.is_a?(Array) ? association : [association]
+
+        alias_tracker = ActiveRecord::Associations::AliasTracker.create(
+          table.connection, table.name, {}
+        )
+
+        join_dependency = ActiveRecord::Associations::JoinDependency.new(
+          table, table.arel_table, associations, join_type
+        )
+
+        constraints = join_dependency.join_constraints([], alias_tracker, [])
+
+        constraints.map do |join|
+          apply_aliases(join, aliases)
+
+          right = if block_given?
+                    yield join.left.name.to_sym, join.right
+                  else
+                    join.right
+                  end
+
+          join_type.new(join.left, right)
+        end
+      end
+
+      def apply_aliases(node, aliases)
+        case node
+        when Arel::Nodes::Join
+          node.left = aliases[node.left.name] || node.left
+          apply_aliases(node.right, aliases)
+        when Arel::Attributes::Attribute
+          node.relation = aliases[node.relation.name] || node.relation
+        when Arel::Nodes::And
+          node.children.each { |child| apply_aliases(child, aliases) }
+        when Arel::Nodes::Unary
+          apply_aliases(node.value, aliases)
+        when Arel::Nodes::Binary
+          apply_aliases(node.left, aliases)
+          apply_aliases(node.right, aliases)
+        end
+      end
+
       private
 
       def to_sql(node, table, binds)
@@ -255,10 +286,6 @@ module ArelHelpers
         collect = visitor.accept(node, Arel::Collectors::Bind.new)
         collect.substitute_binds(binds).join
       end
-
-      def find_alias(name, aliases)
-        aliases.find { |a| a.table_name == name }
-      end
     end
   end
 end

data/lib/arel-helpers/query_builder.rb

@@ -9,7 +9,7 @@ module ArelHelpers
     include Enumerable
 
     attr_reader :query
-    def_delegators :@query, :to_a, :to_sql, :each
+    def_delegators :@query, :to_a, :to_sql, :each, :empty?, :size
 
     TERMINAL_METHODS = [:count, :first, :last]
     TERMINAL_METHODS << :pluck if ActiveRecord::VERSION::MAJOR >= 4
@@ -18,8 +18,8 @@ module ArelHelpers
 
     def self.not_nil(name)
       mod = Module.new do
-        define_method(name) do |*args|
-          if (value = super(*args))
+        define_method(name) do |*args, **kwargs|
+          if (value = super(*args, **kwargs))
             value
           else
             reflect(query)

data/lib/arel-helpers/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module ArelHelpers
-  VERSION = '2.11.0'
+  VERSION = '2.14.0'
 end

data/spec/aliases_spec.rb

@@ -1,17 +1,15 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 describe ArelHelpers::Aliases do
-  describe "#aliased_as" do
-    it "yields an alias when passed a block" do
+  describe '#aliased_as' do
+    it 'yields an alias when passed a block' do
       Post.aliased_as('foo') do |foo_alias|
         expect(foo_alias).to be_a(Arel::Nodes::TableAlias)
         expect(foo_alias.name).to eq('foo')
       end
     end
 
-    it "is capable of yielding multiple aliases" do
+    it 'is capable of yielding multiple aliases' do
       Post.aliased_as('foo', 'bar') do |foo_alias, bar_alias|
         expect(foo_alias).to be_a(Arel::Nodes::TableAlias)
         expect(foo_alias.name).to eq('foo')
@@ -21,14 +19,14 @@ describe ArelHelpers::Aliases do
       end
     end
 
-    it "returns an alias when not passed a block" do
+    it 'returns an alias when not passed a block' do
       aliases = Post.aliased_as('foo')
       expect(aliases.size).to eq(1)
       expect(aliases[0]).to be_a(Arel::Nodes::TableAlias)
       expect(aliases[0].name).to eq('foo')
     end
 
-    it "is capable of returning multiple aliases" do
+    it 'is capable of returning multiple aliases' do
       aliases = Post.aliased_as('foo', 'bar')
       expect(aliases.size).to eq(2)
 

data/spec/arel_table_spec.rb

@@ -1,30 +1,28 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 describe ArelHelpers::ArelTable do
-  it "should add the [] function to the model and allow attribute access" do
+  it 'should add the [] function to the model and allow attribute access' do
     Post[:id].tap do |post_id|
-      post_id.should be_a(Arel::Attribute)
-      post_id.name.should == :id
-      post_id.relation.name.should == "posts"
+      expect(post_id).to be_a Arel::Attribute
+      expect(post_id.name.to_s).to eq 'id'
+      expect(post_id.relation.name).to eq 'posts'
     end
   end
 
-  it "should not interfere with associations" do
+  it 'should not interfere with associations' do
     post = Post.create(title: "I'm a little teapot")
-    post.comments[0].should be_nil
+    expect(post.comments[0]).to be_nil
   end
 
-  it "should allow retrieving associated records" do
+  it 'should allow retrieving associated records' do
     post = Post.create(title: "I'm a little teapot")
     comment = post.comments.create
-    post.reload.comments[0].id.should == comment.id
+    expect(post.reload.comments[0].id).to eq comment.id
   end
 
-  it "does not interfere with ActiveRecord::Relation objects" do
-    Post.all[0].should be_nil
+  it 'does not interfere with ActiveRecord::Relation objects' do
+    expect(Post.all[0]).to be_nil
     p = Post.create(title: 'foo')
-    Post.all[0].id.should == p.id
+    expect(Post.all[0].id).to eq p.id
   end
 end

data/spec/env/models.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 class Post < ActiveRecord::Base
   include ArelHelpers::ArelTable
   include ArelHelpers::Aliases
@@ -44,12 +42,10 @@ end
 
 class Location < ActiveRecord::Base
   has_many :card_locations
-  has_many :community_tickets, {
-    through: :card_locations, source: :card, source_type: 'CommunityTicket'
-  }
+  has_many :community_tickets, through: :card_locations, source: :card, source_type: 'CommunityTicket'
 end
 
 class CommunityTicket < ActiveRecord::Base
-  has_many :card_locations, as: :card, source_type: 'CommunityTicket'
+  has_many :card_locations, as: :card
   has_many :locations, through: :card_locations
 end

data/spec/internal/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter:  sqlite3
+  database: db/combustion_test.sqlite

data/spec/join_association_spec.rb

@@ -1,94 +1,137 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 describe ArelHelpers do
-  describe "#join_association" do
-    it "should work for a directly associated model" do
-      Post.joins(ArelHelpers.join_association(Post, :comments)).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"'
+  describe '#join_association' do
+    it 'should work for a directly associated model' do
+      expect(Post.joins(ArelHelpers.join_association(Post, :comments)).to_sql).to(
+        eq('SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"')
+      )
     end
 
-    it "should work with an outer join" do
-      Post.joins(ArelHelpers.join_association(Post, :comments, Arel::Nodes::OuterJoin)).to_sql.should ==
-        'SELECT "posts".* FROM "posts" LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"'
+    it 'should work with an outer join' do
+      expect(Post.joins(ArelHelpers.join_association(Post, :comments, Arel::Nodes::OuterJoin)).to_sql).to(
+        eq('SELECT "posts".* FROM "posts" LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"')
+      )
     end
 
-    it "should allow adding additional join conditions" do
-      Post.joins(ArelHelpers.join_association(Post, :comments) do |assoc_name, join_conditions|
+    it 'should allow adding additional join conditions' do
+      sql = Post.joins(ArelHelpers.join_association(Post, :comments) do |_assoc_name, join_conditions|
         join_conditions.and(Comment[:id].eq(10))
-      end).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."id" = 10'
+      end).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."id" = 10
+      SQL
     end
 
-    it "should work for two models, one directly associated and the other indirectly" do
-      Post
-        .joins(ArelHelpers.join_association(Post, :comments))
-        .joins(ArelHelpers.join_association(Comment, :author))
-        .to_sql.should ==
-          'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"'
+    it 'should work for two models, one directly associated and the other indirectly' do
+      sql = Post
+              .joins(ArelHelpers.join_association(Post, :comments))
+              .joins(ArelHelpers.join_association(Comment, :author))
+              .to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+          INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+      SQL
     end
 
-    it "should work for a nested hash of association names" do
-      Post
-        .joins(ArelHelpers.join_association(Post, { comments: :author }))
-        .to_sql.should ==
-          'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"'
+    it 'should work for a nested hash of association names' do
+      sql = Post
+              .joins(ArelHelpers.join_association(Post, { comments: :author }))
+              .to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+          INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+      SQL
     end
 
-    it "should work with outer joins when given a nested hash of association names" do
-      Post
-        .joins(ArelHelpers.join_association(Post, { comments: :author }, Arel::Nodes::OuterJoin))
-        .to_sql.should ==
-          'SELECT "posts".* FROM "posts" LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id" LEFT OUTER JOIN "authors" ON "authors"."id" = "comments"."author_id"'
+    it 'should work with outer joins when given a nested hash of association names' do
+      sql = Post.joins(ArelHelpers.join_association(Post, { comments: :author }, Arel::Nodes::OuterJoin)).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          LEFT OUTER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+          LEFT OUTER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+      SQL
     end
 
-    it "should be able to handle multiple associations" do
-      Post.joins(ArelHelpers.join_association(Post, [:comments, :favorites])).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" INNER JOIN "favorites" ON "favorites"."post_id" = "posts"."id"'
+    it 'should be able to handle multiple associations' do
+      expect(Post.joins(ArelHelpers.join_association(Post, %i[comments favorites])).to_sql).to(
+        eq <<-SQL.squish
+          SELECT "posts".* FROM "posts"
+            INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+            INNER JOIN "favorites" ON "favorites"."post_id" = "posts"."id"
+      SQL
+      )
     end
 
-    it "should yield once for each association" do
-      Post.joins(ArelHelpers.join_association(Post, [:comments, :favorites]) do |assoc_name, join_conditions|
+    it 'should yield once for each association' do
+      sql = Post.joins(ArelHelpers.join_association(Post, %i[comments favorites]) do |assoc_name, join_conditions|
         case assoc_name
-          when :favorites
-            join_conditions.or(Favorite[:amount].eq("lots"))
-          when :comments
-            join_conditions.and(Comment[:text].eq("Awesome post!"))
+        when :favorites
+          join_conditions.or(Favorite[:amount].eq('lots'))
+        when :comments
+          join_conditions.and(Comment[:text].eq('Awesome post!'))
         end
-      end).to_sql.should ==
-        'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."text" = \'Awesome post!\' INNER JOIN "favorites" (ON "favorites"."post_id" = "posts"."id" OR "favorites"."amount" = \'lots\')'
+      end).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "posts".* FROM "posts"
+          INNER JOIN "comments" ON "comments"."post_id" = "posts"."id" AND "comments"."text" = 'Awesome post!'
+          INNER JOIN "favorites" (ON "favorites"."post_id" = "posts"."id" OR "favorites"."amount" = 'lots')
+      SQL
     end
 
     it 'should be able to handle has_and_belongs_to_many associations' do
-      CollabPost.joins(ArelHelpers.join_association(CollabPost, :authors)).to_sql.should ==
-        'SELECT "collab_posts".* FROM "collab_posts" INNER JOIN "authors_collab_posts" ON "authors_collab_posts"."collab_post_id" = "collab_posts"."id" INNER JOIN "authors" ON "authors"."id" = "authors_collab_posts"."author_id"'
+      sql = CollabPost.joins(ArelHelpers.join_association(CollabPost, :authors)).to_sql
+
+      expect(sql).to eq <<-SQL.squish
+        SELECT "collab_posts".* FROM "collab_posts"
+          INNER JOIN "authors_collab_posts" ON "authors_collab_posts"."collab_post_id" = "collab_posts"."id"
+          INNER JOIN "authors" ON "authors"."id" = "authors_collab_posts"."author_id"
+      SQL
     end
 
-    it "allows adding a custom alias to the joined table" do
+    it 'allows adding a custom alias to the joined table' do
       Comment.aliased_as(:foo) do |foo|
-        Post.joins(ArelHelpers.join_association(Post, :comments, Arel::Nodes::InnerJoin, aliases: [foo])).to_sql.should ==
-          'SELECT "posts".* FROM "posts" INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id"'
+        sql = Post.joins(
+          ArelHelpers.join_association(Post, :comments, Arel::Nodes::InnerJoin, aliases: [foo])
+        ).to_sql
+
+        expect(sql).to eq 'SELECT "posts".* FROM "posts" INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id"'
       end
     end
 
-    it "allows aliasing multiple associations" do
+    it 'allows aliasing multiple associations' do
       Comment.aliased_as(:foo) do |foo|
         Favorite.aliased_as(:bar) do |bar|
-          Post.joins(ArelHelpers.join_association(Post, [:comments, :favorites], Arel::Nodes::InnerJoin, aliases: [foo, bar])).to_sql.should ==
-            'SELECT "posts".* FROM "posts" INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id" INNER JOIN "favorites" "bar" ON "bar"."post_id" = "posts"."id"'
+          sql = Post.joins(
+            ArelHelpers.join_association(Post, %i[comments favorites], Arel::Nodes::InnerJoin, aliases: [foo, bar])
+          ).to_sql
+
+          expect(sql).to eq <<-SQL.squish
+            SELECT "posts".* FROM "posts"
+              INNER JOIN "comments" "foo" ON "foo"."post_id" = "posts"."id"
+              INNER JOIN "favorites" "bar" ON "bar"."post_id" = "posts"."id"
+          SQL
         end
       end
     end
 
     it 'handles polymorphic through associations' do
-      relation = Location.joins(
-        ArelHelpers.join_association(Location, :community_tickets)
-      )
+      location = Location.create!
+      ticket = CommunityTicket.create!
+      CardLocation.create! card: ticket, location: location
+
+      relation = Location.joins(ArelHelpers.join_association(Location, :community_tickets))
 
-      relation.to_sql.should == 'SELECT "locations".* FROM "locations" ' +
-        'INNER JOIN "card_locations" ON "card_locations"."location_id" = "locations"."id" AND "card_locations"."card_type" = \'CommunityTicket\' ' +
-        'INNER JOIN "community_tickets" ON "community_tickets"."id" = "card_locations"."card_id"'
+      expect(relation.count).to eq 1
+      expect(relation.to_a).to include location
     end
   end
 end
@@ -98,8 +141,9 @@ describe ArelHelpers::JoinAssociation do
     include ArelHelpers::JoinAssociation
   end
 
-  it "should provide the join_association method and use the parent class as the model to join on" do
-    AssocPost.joins(AssocPost.join_association(:comments)).to_sql.should ==
-      'SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"'
+  it 'should provide the join_association method and use the parent class as the model to join on' do
+    expect(AssocPost.joins(AssocPost.join_association(:comments)).to_sql).to eq <<-SQL.squish
+      SELECT "posts".* FROM "posts" INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+    SQL
   end
 end

data/spec/query_builder_spec.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 require 'spec_helper'
 
 class TestQueryBuilder < ArelHelpers::QueryBuilder
@@ -8,6 +6,9 @@ class TestQueryBuilder < ArelHelpers::QueryBuilder
 
   def initialize(query = nil)
     super(query || Post.unscoped)
+
+    # only necessary for the test environment to prevent pollution between tests
+    @query.reload
   end
 
   def noop
@@ -15,60 +16,69 @@ class TestQueryBuilder < ArelHelpers::QueryBuilder
   end
 
   not_nil def optional(skip:)
-    reflect(query.where(title: "BarBar")) unless skip
+    reflect(query.where(title: 'BarBar')) unless skip
   end
 end
 
 describe ArelHelpers::QueryBuilder do
   let(:builder) { TestQueryBuilder.new }
 
-  it "returns (i.e. reflects) new instances of QueryBuilder" do
+  it 'returns (i.e. reflects) new instances of QueryBuilder' do
     builder.tap do |original_builder|
       original_builder.params = true
       new_builder = original_builder.noop
-      new_builder.object_id.should_not == original_builder.object_id
-      new_builder.params?.should == true
+      expect(new_builder.object_id).not_to eq original_builder.object_id
+      expect(new_builder.params?).to be true
     end
   end
 
-  it "forwards #to_a" do
-    Post.create(title: "Foobar")
+  it 'forwards #to_a' do
+    Post.create(title: 'Foobar')
     builder.to_a.tap do |posts|
-      posts.size.should == 1
-      posts.first.title.should == "Foobar"
+      expect(posts.size).to eq 1
+      expect(posts.first.title).to eq 'Foobar'
     end
   end
 
-  it "forwards #to_sql" do
-    builder.to_sql.strip.should == 'SELECT "posts".* FROM "posts"'
+  it 'forwards #to_sql' do
+    expect(builder.to_sql.strip).to eq 'SELECT "posts".* FROM "posts"'
   end
 
-  it "forwards #each" do
-    created_post = Post.create(title: "Foobar")
+  it 'forwards #each' do
+    created_post = Post.create(title: 'Foobar')
     builder.each do |post|
-      post.should == created_post
+      expect(post).to eq created_post
     end
   end
 
-  it "forwards other enumerable methods via #each" do
-    Post.create(title: "Foobar")
-    builder.map(&:title).should == ["Foobar"]
+  it 'forwards other enumerable methods via #each' do
+    Post.create(title: 'Foobar')
+    expect(builder.map(&:title)).to eq ['Foobar']
+  end
+
+  it 'forwards #empty?' do
+    expect(builder.empty?).to eq true
+  end
+
+  it 'forwards #size' do
+    expect(builder.size).to eq 0
   end
 
   ArelHelpers::QueryBuilder::TERMINAL_METHODS.each do |method|
     it "does not enumerate records for #{method}" do
-      mock(builder).each.never
+      allow(builder).to receive :each
       builder.public_send(method)
+      expect(builder).not_to have_received :each
     end
   end
 
-  it "returns reflect on existing query if method returns a falsy value" do
-    builder.optional(skip: true).to_sql.strip.should == 'SELECT "posts".* FROM "posts"'
+  it 'returns reflect on existing query if method returns a falsy value' do
+    expect(builder.optional(skip: true).to_sql.strip).to eq 'SELECT "posts".* FROM "posts"'
   end
 
-  it "returns reflect on new query for default chainable method if value is truthy" do
-    builder.optional(skip: false).to_sql.strip.gsub(/\s+/, " ").should == %Q{
-      SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"title\" = 'BarBar'
-    }.strip
+  it 'returns reflect on new query for default chainable method if value is truthy' do
+    expect(builder.optional(skip: false).to_sql.strip.gsub(/\s+/, ' ')).to eq <<-SQL.squish
+      SELECT "posts".* FROM "posts" WHERE "posts"."title" = 'BarBar'
+    SQL
   end
 end

data/spec/spec_helper.rb

@@ -1,29 +1,20 @@
-# encoding: UTF-8
-
-$:.push(File.dirname(__FILE__))
+$LOAD_PATH.push(File.dirname(__FILE__))
 
 require 'rspec'
 require 'arel-helpers'
 require 'fileutils'
 
-require 'env'
+require 'combustion'
+Combustion.initialize! :active_record
 
-def silence(&block)
-  original_stdout = $stdout
-  $stdout = StringIO.new
-  begin
-    yield
-  ensure
-    $stdout = original_stdout
-  end
-end
+require 'database_cleaner'
+require 'env/models'
 
 RSpec.configure do |config|
-  config.mock_with :rr
+  DatabaseCleaner.strategy = :transaction
+
+  config.before(:suite) { DatabaseCleaner.clean_with :truncation }
 
-  config.before(:each) do
-    ArelHelpers::Env.establish_connection
-    ArelHelpers::Env.reset
-    silence { ArelHelpers::Env.migrate }
-  end
+  config.before { DatabaseCleaner.start }
+  config.after  { DatabaseCleaner.clean }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arel-helpers
 version: !ruby/object:Gem::Version
-  version: 2.11.0
+  version: 2.14.0
 platform: ruby
 authors:
 - Cameron Dutro
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-12-21 00:00:00.000000000 Z
+date: 2021-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: 3.1.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,49 +29,91 @@ dependencies:
         version: 3.1.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '8'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: combustion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: rr
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.4.0
 description: Useful tools to help construct database queries with ActiveRecord and
   Arel.
 email:
@@ -93,9 +135,8 @@ files:
 - lib/arel-helpers/version.rb
 - spec/aliases_spec.rb
 - spec/arel_table_spec.rb
-- spec/env.rb
-- spec/env/migrations.rb
 - spec/env/models.rb
+- spec/internal/config/database.yml
 - spec/join_association_spec.rb
 - spec/query_builder_spec.rb
 - spec/spec_helper.rb
@@ -103,7 +144,7 @@ homepage: https://github.com/camertron/arel-helpers
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -118,8 +159,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Useful tools to help construct database queries with ActiveRecord and Arel.
 test_files: []

data/spec/env/migrations.rb

@@ -1,75 +0,0 @@
-# encoding: UTF-8
-
-SuperClass = if ActiveRecord::VERSION::MAJOR >= 5
-  ActiveRecord::Migration["#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}".to_f]
-else
-  ActiveRecord::Migration
-end
-
-class CreatePostsTable < SuperClass
-  def change
-    create_table :posts do |t|
-      t.column :title, :string
-    end
-  end
-end
-
-class CreateCommentsTable < SuperClass
-  def change
-    create_table :comments do |t|
-      t.references :post
-    end
-  end
-end
-
-class CreateAuthorsTable < SuperClass
-  def change
-    create_table :authors do |t|
-      t.references :comment
-      t.references :collab_posts
-    end
-  end
-end
-
-class CreateFavoritesTable < SuperClass
-  def change
-    create_table :favorites do |t|
-      t.references :post
-    end
-  end
-end
-
-class CreateCollabPostsTable < SuperClass
-  def change
-    create_table :collab_posts do |t|
-      t.references :authors
-    end
-  end
-end
-
-class CreateCardsTable < SuperClass
-  def change
-    create_table :cards
-  end
-end
-
-class CreateCardLocationsTable < SuperClass
-  def change
-    create_table :card_locations do |t|
-      t.references :location
-      t.references :card, polymorphic: true
-    end
-  end
-end
-
-class CreateLocationsTable < SuperClass
-  def change
-    create_table :locations
-  end
-end
-
-class CreateCommunityTicketsTable < SuperClass
-  def change
-    create_table :community_tickets
-  end
-end

data/spec/env.rb

@@ -1,44 +0,0 @@
-# encoding: UTF-8
-
-require 'env/migrations'
-require 'env/models'
-
-module ArelHelpers
-  class Env
-    class << self
-
-      def db_dir
-        @db_dir ||= File.join(File.dirname(File.dirname(__FILE__)), "tmp")
-      end
-
-      def db_file
-        @db_file ||= File.join(db_dir, "test.sqlite3")
-      end
-
-      def establish_connection
-        ActiveRecord::Base.establish_connection(
-          :adapter  => "sqlite3",
-          :database => db_file
-        )
-      end
-
-      def migrate
-        CreatePostsTable.new.change
-        CreateCommentsTable.new.change
-        CreateAuthorsTable.new.change
-        CreateFavoritesTable.new.change
-        CreateCollabPostsTable.new.change
-        CreateCardsTable.new.change
-        CreateCardLocationsTable.new.change
-        CreateLocationsTable.new.change
-        CreateCommunityTicketsTable.new.change
-      end
-
-      def reset
-        File.unlink(db_file) if File.exist?(db_file)
-        FileUtils.mkdir_p(db_dir)
-      end
-
-    end
-  end
-end