arel-helpers 2.2.0 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 875e70afa83c9d6c1c5b74713162b2eef19c94b1
-  data.tar.gz: 562a0e972c495904a876f5cfcbf08dbadf71b058
+SHA256:
+  metadata.gz: d792fc6a4945a79243f3e4b9720c9f10ce21f5a044328f56f2b381045183589a
+  data.tar.gz: becca530d9ecfd5a25594ce0363cbde8d792d564358d2394a36d7040e6341384
 SHA512:
-  metadata.gz: 2a364dbb1ccbe4937fa23892678261cdfabc4846111499748f244701f210d7a8996465f80f8d14d7c9add1ab4706f3b4a71d48736caa12ffed20f6b6c5f223f1
-  data.tar.gz: 746357d316c5eb82e29952f2a5fd54ffebae6e550acb7e8eebdf7fcc9bc6562e37975217afde0f8f4e441495b5789c907d0f2a0e22f398ef06d7913e842de0fe
+  metadata.gz: 2d825413e0dc2f3caff9ddcbc93a4eadbb1d8814196bc515fd13b3a759969db970a9fe2df911da86def2125d724d5c651e5a39eba2d9cf873d573c913b6a51f5
+  data.tar.gz: 70bea7795e9bcd75058dad5aaee877f6fb1d00e40f9e62b0db8b908d1a1f0656654fe67170a1024e1776b2a458ea11622fad399cda001ffd127c5f35f8197824

data/Gemfile

@@ -1,14 +1,3 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec
-
-group :development, :test do
-  gem 'pry-nav'
-  gem 'rake'
-end
-
-group :test do
-  gem 'rspec', '~> 2.11.0'
-  gem 'rr',    '~> 1.0.4'
-  gem 'sqlite3'
-end

data/README.md

@@ -96,6 +96,23 @@ Post.joins(
 
 Easy peasy.
 
+Note that pretty much anything you can pass to ActiveRecord's `#join` method you can also pass to `#join_association`'s second argument. For example, you can pass a hash to indicate a set of nested associations:
+
+```ruby
+Post.joins(
+  ArelHelpers.join_association(Post, { comments: :author })
+)
+```
+
+This might execute the following query:
+
+```sql
+SELECT "posts".*
+FROM "posts"
+INNER JOIN "comments" ON "comments"."post_id" = "posts"."id"
+INNER JOIN "authors" ON "authors"."id" = "comments"."author_id"
+```
+
 `#join_association` also allows you to customize the join conditions via a block:
 
 ```ruby
@@ -138,7 +155,7 @@ class PostQueryBuilder < ArelHelpers::QueryBuilder
   def with_comments_by(usernames)
     reflect(
       query
-        .joins(:comments => :author)
+        .joins(comments: :author)
         .where(author[:username].in(usernames))
     )
   end
@@ -170,9 +187,35 @@ PostQueryBuilder.new
   .since_yesterday
 ```
 
+#### Conditional reflections
+
+If you have parts of a query that should only be added under certain conditions you can return `reflect(query)` from your method. E.g:
+
+```ruby
+  def with_comments_by(usernames)
+    if usernames
+      reflect(
+        query.where(post[:title].matches("%#{title}%"))
+      )
+    else
+      reflect(query)
+    end
+  end
+```
+
+This can become repetitive, and as an alternative you can choose to prepend `not_nil` to your method definition:
+
+```ruby
+  class PostQueryBuilder < ArelHelpers::QueryBuilder
+    not_nil def with_comments_by(usernames)
+      reflect(query.where(post[:title].matches("%#{title}%"))) if usernames
+    end
+  end
+```
+
 ## Requirements
 
-Requires ActiveRecord >= 3.1.0, <= 4.2.0, tested with Ruby 1.9.3, 2.0.0, and 2.1.0. Depends on SQLite for testing purposes.
+Requires ActiveRecord >= 3.1.0, < 6, tested against Ruby 2.2.4. Depends on SQLite for testing purposes.
 
 ## Running Tests
 

data/Rakefile

@@ -10,7 +10,7 @@ require './lib/arel-helpers'
 
 Bundler::GemHelper.install_tasks
 
-task :default => :spec
+task default: :spec
 
 desc 'Run specs'
 RSpec::Core::RakeTask.new do |t|
@@ -21,7 +21,7 @@ task :console do
   $:.push(File.dirname(__FILE__))
 
   require 'spec/env'
-  require 'pry-nav'
+  require 'pry-byebug'
 
   ArelHelpers::Env.establish_connection
   ArelHelpers::Env.reset

data/arel-helpers.gemspec

@@ -1,24 +1,26 @@
-$:.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 = "http://github.com/camertron"
-
-  s.description = s.summary = "Useful tools to help construct database queries with ActiveRecord and Arel."
+  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.platform = Gem::Platform::RUBY
-  s.has_rdoc = true
 
-  if ENV["AR"]
-    s.add_dependency 'activerecord', ENV["AR"]
-  else
-    s.add_dependency 'activerecord', '>= 3.1.0', '< 5'
-  end
+  s.add_dependency 'activerecord', '>= 3.1.0', '< 7'
+
+  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', '~> 10.0'
+  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']
 end

data/lib/arel-helpers.rb

@@ -17,8 +17,9 @@ rescue
 end
 
 module ArelHelpers
-  autoload :JoinAssociation, "arel-helpers/join_association"
+  autoload :Aliases,         "arel-helpers/aliases"
   autoload :ArelTable,       "arel-helpers/arel_table"
+  autoload :JoinAssociation, "arel-helpers/join_association"
   autoload :QueryBuilder,    "arel-helpers/query_builder"
 
   def self.join_association(*args, &block)

data/lib/arel-helpers/aliases.rb

@@ -0,0 +1,21 @@
+# encoding: UTF-8
+
+module ArelHelpers
+
+  module Aliases
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def aliased_as(*args)
+        aliases = args.map { |name| arel_table.alias(name) }
+
+        if block_given?
+          yield *aliases
+        else
+          aliases
+        end
+      end
+    end
+  end
+
+end

data/lib/arel-helpers/join_association.rb

@@ -17,19 +17,34 @@ module ArelHelpers
       # For example, for HABTM associations, two join statements are required.
       # 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, &block)
-        if ActiveRecord::VERSION::STRING >= '4.2.0'
-          join_association_4_2(table, association, join_type, &block)
-        elsif ActiveRecord::VERSION::STRING >= '4.1.0'
-          join_association_4_1(table, association, join_type, &block)
+      def join_association(table, association, join_type = Arel::Nodes::InnerJoin, options = {}, &block)
+        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)
+        elsif version >= '5.2.0'
+          join_association_5_2(table, association, join_type, options, &block)
+        elsif version >= '5.0.0'
+          join_association_5_0(table, association, join_type, options, &block)
+        elsif version >= '4.2.0'
+          join_association_4_2(table, association, join_type, options, &block)
+        elsif version >= '4.1.0'
+          join_association_4_1(table, association, join_type, options, &block)
         else
-          join_association_3_1(table, association, join_type, &block)
+          join_association_3_1(table, association, join_type, options, &block)
         end
       end
 
       private
 
-      def join_association_3_1(table, association, join_type)
+      def version
+        ActiveRecord::VERSION::STRING
+      end
+
+      def join_association_3_1(table, association, join_type, options = {})
+        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)
@@ -40,8 +55,9 @@ module ArelHelpers
         end
 
         manager.join_sources.map do |assoc|
+          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
@@ -50,7 +66,8 @@ module ArelHelpers
         end
       end
 
-      def join_association_4_1(table, association, join_type)
+      def join_association_4_1(table, association, join_type, options = {})
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
         join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
 
@@ -61,6 +78,8 @@ module ArelHelpers
             constraint.right
           end
 
+          constraint.left.table_alias = aliases[constraint.left.name].name if aliases.key?(constraint.left.name)
+
           join_type.new(constraint.left, right)
         end
       end
@@ -70,7 +89,8 @@ module ArelHelpers
       # join_association isn't able to add to the list of bind variables
       # dynamically. To get around the problem, this method must return
       # a string.
-      def join_association_4_2(table, association, join_type)
+      def join_association_4_2(table, association, join_type, options = {})
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
         associations = association.is_a?(Array) ? association : [association]
         join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
 
@@ -88,6 +108,8 @@ module ArelHelpers
               join.right
             end
 
+            join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
+
             join_type.new(join.left, right)
           end
         end
@@ -99,6 +121,164 @@ module ArelHelpers
         join_strings.join(' ')
       end
 
+      def join_association_5_0(table, association, join_type, options = {})
+        aliases = options.fetch(:aliases, []).index_by(&:table_name)
+        associations = association.is_a?(Array) ? association : [association]
+        join_dependency = ActiveRecord::Associations::JoinDependency.new(table, associations, [])
+
+        constraints = join_dependency.join_constraints([], join_type)
+
+        binds = constraints.flat_map do |info|
+          prepared_binds = info.binds.map(&:value_for_database)
+          prepared_binds.map { |value| table.connection.quote(value) }
+        end
+
+        joins = constraints.flat_map do |constraint|
+          constraint.joins.map do |join|
+            right = if block_given?
+              yield join.left.name.to_sym, join.right
+            else
+              join.right
+            end
+
+            join.left.table_alias = aliases[join.left.name].name if aliases.key?(join.left.name)
+
+            join_type.new(join.left, right)
+          end
+        end
+
+        join_strings = joins.map do |join|
+          to_sql(join, table, binds)
+        end
+
+        join_strings.join(' ')
+      end
+
+      def join_association_5_2(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, alias_tracker
+        )
+
+        constraints = join_dependency.join_constraints([], join_type)
+
+        constraints.map do |join|
+          right = if block_given?
+            yield join.left.name.to_sym, join.right
+          else
+            join.right
+          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, []).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
+        )
+
+        constraints = join_dependency.join_constraints([], join_type, alias_tracker)
+
+        constraints.map do |join|
+          right = if block_given?
+            yield join.left.name.to_sym, join.right
+          else
+            join.right
+          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, []).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|
+          right = if block_given?
+            yield join.left.name.to_sym, join.right
+          else
+            join.right
+          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)