arel-helpers 2.4.0 → 2.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6356cdb2e00758c2e17276118d916f727a1be308
-  data.tar.gz: 26faaf1834fd66939b376ef0caa88f7e85d6bc41
+SHA256:
+  metadata.gz: d792fc6a4945a79243f3e4b9720c9f10ce21f5a044328f56f2b381045183589a
+  data.tar.gz: becca530d9ecfd5a25594ce0363cbde8d792d564358d2394a36d7040e6341384
 SHA512:
-  metadata.gz: e07f4c676161cd241f861b48aef16411f262f09fc53d9773432e185804e062c41d117d196f553b2fb3fff834c42ec7fbd3e081ad42ed741a6ced87f66d7c1a73
-  data.tar.gz: 9a72da308ac57e7df7dab0fce3c2909d6478f8c96170ede5c98fcf940f51f415c529838150dca14fd83ced259846c84601d312fb406b59a1545d120c43fa46c1
+  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

@@ -155,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
@@ -187,6 +187,32 @@ 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, < 6, tested against Ruby 2.2.4. Depends on SQLite for testing purposes.

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', '< 6'
-  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,21 +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 >= '5.0.0'
-          join_association_5_0(table, association, join_type, &block)
-        elsif 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)
@@ -42,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
@@ -52,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, [])
 
@@ -63,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
@@ -72,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, [])
 
@@ -90,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
@@ -101,7 +121,8 @@ module ArelHelpers
         join_strings.join(' ')
       end
 
-      def join_association_5_0(table, association, join_type)
+      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, [])
 
@@ -120,6 +141,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
@@ -131,6 +154,131 @@ module ArelHelpers
         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)

data/lib/arel-helpers/query_builder.rb

@@ -16,6 +16,21 @@ module ArelHelpers
 
     def_delegators :@query, *TERMINAL_METHODS
 
+    def self.not_nil(name)
+      mod = Module.new do
+        define_method(name) do |*args|
+          if (value = super(*args))
+            value
+          else
+            reflect(query)
+          end
+        end
+      end
+
+      prepend mod
+      name
+    end
+
     def initialize(query)
       @query = query
     end
@@ -23,7 +38,7 @@ module ArelHelpers
     protected
 
     def reflect(query)
-      self.class.new(query)
+      dup.tap { |obj| obj.instance_variable_set('@query'.freeze, query) }
     end
   end
 end

data/lib/arel-helpers/version.rb

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