squeel 1.0.9 → 1.0.11

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.0.11 (2012-09-03)
+
+* Fixed issue #157, resolving problems when joining the same table twice.
+* Allow predicates in order/select values
+* Support Relation#from in Squeel DSL
+
+## 1.0.10 (2012-09-01)
+
+  * Yanked from RubyGems.org due to semantic versioning oversight
+
 ## 1.0.9 (2012-08-06)
 
 * Fix issue with duplication of order conditions in default_scope on AR 3.0.x

data/lib/squeel.rb

@@ -13,6 +13,11 @@ module Squeel
     $VERBOSE = original_verbosity
   end
 
+  def self.deprecate(message)
+    external_caller = caller.find {|s| !s.include?('/lib/squeel/')}
+    warn "DEPRECATION WARNING: #{message} (called from #{external_caller})"
+  end
+
   # Set up initial predicate aliases
   Constants::PREDICATE_ALIASES.each do |original, aliases|
     aliases.each do |aliaz|

data/lib/squeel/adapters/active_record/3.0/association_preload_extensions.rb

@@ -4,10 +4,10 @@ module Squeel
       module AssociationPreloadExtensions
 
         def preload_associations(records, associations, preload_options={})
-          super(records, Visitors::SymbolVisitor.new.accept(associations), preload_options)
+          super(records, Visitors::PreloadVisitor.new.accept(associations), preload_options)
         end
 
       end
     end
   end
-end
+end

data/lib/squeel/adapters/active_record/3.0/relation_extensions.rb

@@ -13,37 +13,37 @@ module Squeel
 
         # Returns a JoinDependency for the current relation.
         #
-        # We don't need to clear out @join_dependency by overriding #reset, because
-        # the default #reset already does this, despite never setting it anywhere that
-        # I can find. Serendipity, I say!
+        # We don't need to clear out @join_dependency by overriding #reset,
+        # because the default #reset already does this, despite never setting
+        # it anywhere that I can find. Serendipity, I say!
         def join_dependency
           @join_dependency ||= (build_join_dependency(table, @joins_values) && @join_dependency)
         end
 
-        def predicate_visitor
-          Visitors::PredicateVisitor.new(
-            Context.new(join_dependency)
-          )
-        end
-
-        def attribute_visitor
-          Visitors::AttributeVisitor.new(
-            Context.new(join_dependency)
-          )
+        %w(where having group order select from).each do |visitor|
+          define_method "#{visitor}_visit" do |values|
+            Visitors.const_get("#{visitor.capitalize}Visitor").new(
+              Context.new(join_dependency)
+            ).accept(values)
+          end
         end
 
         # We need to be able to support merging two relations without having
-        # to get our hooks too deeply into ActiveRecord. AR's relation
-        # merge functionality is very cool, but relatively complex, to
-        # handle the various edge cases. Our best shot at avoiding strange
-        # behavior with Squeel loaded is to visit the *_values arrays in
-        # the relations we're merging, and then use the default AR merge
-        # code on the result.
-        def merge(r, skip_visit = false)
-          if skip_visit or not ::ActiveRecord::Relation === r
-            super(r)
+        # to get our hooks too deeply into ActiveRecord. That proves to be
+        # easier said than done. I hate Relation#merge. If Squeel has a
+        # nemesis, Relation#merge would be it.
+        #
+        # Whatever code you see here currently is my current best attempt at
+        # coexisting peacefully with said nemesis.
+        def merge(r, equalities_resolved = false)
+          if ::ActiveRecord::Relation === r && !equalities_resolved
+            if self.table_name != r.table_name
+              super(r.visited)
+            else
+              merge_resolving_duplicate_squeel_equalities(r)
+            end
           else
-            visited.merge(r.visited, true)
+            super(r)
           end
         end
 
@@ -52,15 +52,12 @@ module Squeel
         end
 
         def visit!
-          predicate_viz = predicate_visitor
-          attribute_viz = attribute_visitor
-
-          @where_values = predicate_viz.accept((@where_values - ['']).uniq)
-          @having_values = predicate_viz.accept(@having_values.uniq.reject{|h| h.blank?})
+          @where_values = where_visit((@where_values - ['']).uniq)
+          @having_values = having_visit(@having_values.uniq.reject{|h| h.blank?})
           # FIXME: AR barfs on ARel attributes in group_values. Workaround?
-          # @group_values = attribute_viz.accept(@group_values.uniq.reject{|g| g.blank?})
-          @order_values = attribute_viz.accept(@order_values.uniq.reject{|o| o.blank?})
-          @select_values = attribute_viz.accept(@select_values.uniq)
+          # @group_values = group_visit(@group_values.uniq.reject{|g| g.blank?})
+          @order_values = order_visit(@order_values.uniq.reject{|o| o.blank?})
+          @select_values = select_visit(@select_values.uniq)
 
           self
         end
@@ -70,23 +67,20 @@ module Squeel
 
           arel = build_join_dependency(arel, @joins_values) unless @joins_values.empty?
 
-          predicate_viz = predicate_visitor
-          attribute_viz = attribute_visitor
-
-          arel = collapse_wheres(arel, predicate_viz.accept((@where_values - ['']).uniq))
+          arel = collapse_wheres(arel, where_visit((@where_values - ['']).uniq))
 
-          arel = arel.having(*predicate_viz.accept(@having_values.uniq.reject{|h| h.blank?})) unless @having_values.empty?
+          arel = arel.having(*having_visit(@having_values.uniq.reject{|h| h.blank?})) unless @having_values.empty?
 
           arel = arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
           arel = arel.skip(@offset_value) if @offset_value
 
-          arel = arel.group(*attribute_viz.accept(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
+          arel = arel.group(*group_visit(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
 
-          arel = arel.order(*attribute_viz.accept(@order_values.uniq.reject{|o| o.blank?})) unless @order_values.empty?
+          arel = arel.order(*order_visit(@order_values.uniq.reject{|o| o.blank?})) unless @order_values.empty?
 
-          arel = build_select(arel, attribute_viz.accept(@select_values.uniq))
+          arel = build_select(arel, select_visit(@select_values.uniq))
 
-          arel = arel.from(@from_value) if @from_value
+          arel = arel.from(from_visit(@from_value)) if @from_value
           arel = arel.lock(@lock_value) if @lock_value
 
           arel
@@ -104,7 +98,7 @@ module Squeel
         # Rails core, but for now, I'm going to settle for this hack
         # that tries really hard to coerce things to a string.
         def select_for_count
-          visited_values = attribute_visitor.accept(select_values.uniq)
+          visited_values = select_visit(select_values.uniq)
           if visited_values.size == 1
             select = visited_values.first
 
@@ -245,6 +239,14 @@ module Squeel
           end
         end
 
+        def from(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
         def build_where(opts, other = [])
           case opts
           when String, Array
@@ -285,7 +287,10 @@ module Squeel
           nodes.map { |node|
             case node
             when Arel::Nodes::Equality
-              node if node.left.relation.name == table_name
+              if node.left.respond_to?(:relation) &&
+                node.left.relation.name == table_name
+                node
+              end
             when Arel::Nodes::Grouping
               find_equality_predicates([node.expr])
             when Arel::Nodes::And
@@ -296,6 +301,48 @@ module Squeel
           }.compact.flatten
         end
 
+        def flatten_nodes(nodes)
+          nodes.map { |node|
+            case node
+            when Array
+              flatten_nodes(node)
+            when Nodes::And
+              flatten_nodes(node.children)
+            when Nodes::Grouping
+              flatten_nodes(node.expr)
+            else
+              node
+            end
+          }.flatten
+        end
+
+        def merge_resolving_duplicate_squeel_equalities(r)
+          left = clone
+          right = r.clone
+          left.where_values = flatten_nodes(left.where_values)
+          right.where_values = flatten_nodes(right.where_values)
+          right_equalities = right.where_values.select do |obj|
+            Nodes::Predicate === obj && obj.method_name == :eq
+          end
+          right.where_values -= right_equalities
+          left.where_values = resolve_duplicate_squeel_equalities(
+            left.where_values + right_equalities
+          )
+          left.merge(right, true)
+        end
+
+        def resolve_duplicate_squeel_equalities(wheres)
+          seen = {}
+          wheres.reverse.reject { |n|
+            nuke = false
+            if Nodes::Predicate === n && n.method_name == :eq
+              nuke       = seen[n.expr]
+              seen[n.expr] = true
+            end
+            nuke
+          }.reverse
+        end
+
         # Simulate the logic that occurs in #to_a
         #
         # This will let us get a dump of the SQL that will be run against the
@@ -316,10 +363,12 @@ module Squeel
         # ...
         # Since you're still looking, let me explain this horrible
         # transgression you see before you.
+        #
         # You see, Relation#where_values_hash is defined on the
-        # ActiveRecord::Relation class. Since it's defined there, but
-        # I would very much like to modify its behavior, I have three
-        # choices.
+        # ActiveRecord::Relation class, itself.
+        #
+        # Since it's defined there, but I would very much like to modify its
+        # behavior, I have three choices:
         #
         # 1. Inherit from ActiveRecord::Relation in a Squeel::Relation
         #    class, and make an attempt to usurp all of the various calls
@@ -335,6 +384,9 @@ module Squeel
         #
         # I opted to go with #3. Except for the hail Hansson thing.
         # Unless you're DHH, in which case, I totally said them.
+        #
+        # If you'd like to read more about alias_method_chain, see
+        # http://erniemiller.org/2011/02/03/when-to-use-alias_method_chain/
 
         def self.included(base)
           base.class_eval do
@@ -343,7 +395,7 @@ module Squeel
         end
 
         def where_values_hash_with_squeel
-          equalities = find_equality_predicates(predicate_visitor.accept(@where_values))
+          equalities = find_equality_predicates(where_visit(@where_values))
 
           Hash[equalities.map { |where| [where.left.name, where.right] }]
         end

data/lib/squeel/adapters/active_record/3.1/preloader_extensions.rb

@@ -11,11 +11,11 @@ module Squeel
 
         def run_with_squeel
           unless records.empty?
-            Visitors::SymbolVisitor.new.accept(associations).each { |association| preload(association) }
+            Visitors::PreloadVisitor.new.accept(associations).each { |association| preload(association) }
           end
         end
 
       end
     end
   end
-end
+end

data/lib/squeel/adapters/active_record/3.1/relation_extensions.rb

@@ -13,37 +13,37 @@ module Squeel
 
         # Returns a JoinDependency for the current relation.
         #
-        # We don't need to clear out @join_dependency by overriding #reset, because
-        # the default #reset already does this, despite never setting it anywhere that
-        # I can find. Serendipity, I say!
+        # We don't need to clear out @join_dependency by overriding #reset,
+        # because the default #reset already does this, despite never setting
+        # it anywhere that I can find. Serendipity, I say!
         def join_dependency
           @join_dependency ||= (build_join_dependency(table.from(table), @joins_values) && @join_dependency)
         end
 
-        def predicate_visitor
-          Visitors::PredicateVisitor.new(
-            Context.new(join_dependency)
-          )
-        end
-
-        def attribute_visitor
-          Visitors::AttributeVisitor.new(
-            Context.new(join_dependency)
-          )
+        %w(where having group order select from).each do |visitor|
+          define_method "#{visitor}_visit" do |values|
+            Visitors.const_get("#{visitor.capitalize}Visitor").new(
+              Context.new(join_dependency)
+            ).accept(values)
+          end
         end
 
         # We need to be able to support merging two relations without having
-        # to get our hooks too deeply into ActiveRecord. AR's relation
-        # merge functionality is very cool, but relatively complex, to
-        # handle the various edge cases. Our best shot at avoiding strange
-        # behavior with Squeel loaded is to visit the *_values arrays in
-        # the relations we're merging, and then use the default AR merge
-        # code on the result.
-        def merge(r, skip_visit = false)
-          if skip_visit or not ::ActiveRecord::Relation === r
-            super(r)
+        # to get our hooks too deeply into ActiveRecord. That proves to be
+        # easier said than done. I hate Relation#merge. If Squeel has a
+        # nemesis, Relation#merge would be it.
+        #
+        # Whatever code you see here currently is my current best attempt at
+        # coexisting peacefully with said nemesis.
+        def merge(r, equalities_resolved = false)
+          if ::ActiveRecord::Relation === r && !equalities_resolved
+            if self.table_name != r.table_name
+              super(r.visited)
+            else
+              merge_resolving_duplicate_squeel_equalities(r)
+            end
           else
-            visited.merge(r.visited, true)
+            super(r)
           end
         end
 
@@ -52,15 +52,12 @@ module Squeel
         end
 
         def visit!
-          predicate_viz = predicate_visitor
-          attribute_viz = attribute_visitor
-
-          @where_values = predicate_viz.accept((@where_values - ['']).uniq)
-          @having_values = predicate_viz.accept(@having_values.uniq.reject{|h| h.blank?})
+          @where_values = where_visit((@where_values - ['']).uniq)
+          @having_values = having_visit(@having_values.uniq.reject{|h| h.blank?})
           # FIXME: AR barfs on ARel attributes in group_values. Workaround?
-          # @group_values = attribute_viz.accept(@group_values.uniq.reject{|g| g.blank?})
-          @order_values = attribute_viz.accept(@order_values.uniq.reject{|o| o.blank?})
-          @select_values = attribute_viz.accept(@select_values.uniq)
+          # @group_values = group_visit(@group_values.uniq.reject{|g| g.blank?})
+          @order_values = order_visit(@order_values.uniq.reject{|o| o.blank?})
+          @select_values = select_visit(@select_values.uniq)
 
           self
         end
@@ -70,26 +67,23 @@ module Squeel
 
           build_join_dependency(arel, @joins_values) unless @joins_values.empty?
 
-          predicate_viz = predicate_visitor
-          attribute_viz = attribute_visitor
-
-          collapse_wheres(arel, predicate_viz.accept((@where_values - ['']).uniq))
+          collapse_wheres(arel, where_visit((@where_values - ['']).uniq))
 
-          arel.having(*predicate_viz.accept(@having_values.uniq.reject{|h| h.blank?})) unless @having_values.empty?
+          arel.having(*having_visit(@having_values.uniq.reject{|h| h.blank?})) unless @having_values.empty?
 
           arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
           arel.skip(@offset_value) if @offset_value
 
-          arel.group(*attribute_viz.accept(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
+          arel.group(*group_visit(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
 
           order = @reorder_value ? @reorder_value : @order_values
-          order = attribute_viz.accept(order)
+          order = order_visit(order)
           order = reverse_sql_order(attrs_to_orderings(order)) if @reverse_order_value
           arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?
 
-          build_select(arel, attribute_viz.accept(@select_values.uniq))
+          build_select(arel, select_visit(@select_values.uniq))
 
-          arel.from(@from_value) if @from_value
+          arel.from(from_visit(@from_value)) if @from_value
           arel.lock(@lock_value) if @lock_value
 
           arel
@@ -115,7 +109,7 @@ module Squeel
         # Rails core, but for now, I'm going to settle for this hack
         # that tries really hard to coerce things to a string.
         def select_for_count
-          visited_values = attribute_visitor.accept(select_values.uniq)
+          visited_values = select_visit(select_values.uniq)
           if visited_values.size == 1
             select = visited_values.first
 
@@ -263,6 +257,14 @@ module Squeel
           end
         end
 
+        def from(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
         def build_where(opts, other = [])
           case opts
           when String, Array
@@ -301,7 +303,10 @@ module Squeel
           nodes.map { |node|
             case node
             when Arel::Nodes::Equality
-              node if node.left.relation.name == table_name
+              if node.left.respond_to?(:relation) &&
+                node.left.relation.name == table_name
+                node
+              end
             when Arel::Nodes::Grouping
               find_equality_predicates([node.expr])
             when Arel::Nodes::And
@@ -327,9 +332,24 @@ module Squeel
           }.flatten
         end
 
-        def overwrite_squeel_equalities(wheres)
+        def merge_resolving_duplicate_squeel_equalities(r)
+          left = clone
+          right = r.clone
+          left.where_values = flatten_nodes(left.where_values)
+          right.where_values = flatten_nodes(right.where_values)
+          right_equalities = right.where_values.select do |obj|
+            Nodes::Predicate === obj && obj.method_name == :eq
+          end
+          right.where_values -= right_equalities
+          left.where_values = resolve_duplicate_squeel_equalities(
+            left.where_values + right_equalities
+          )
+          left.merge(right, true)
+        end
+
+        def resolve_duplicate_squeel_equalities(wheres)
           seen = {}
-          flatten_nodes(wheres).reverse.reject { |n|
+          wheres.reverse.reject { |n|
             nuke = false
             if Nodes::Predicate === n && n.method_name == :eq
               nuke       = seen[n.expr]
@@ -360,11 +380,11 @@ module Squeel
         # Since you're still looking, let me explain this horrible
         # transgression you see before you.
         #
-        # You see, Relation#where_values_hash and with_default_scope
-        # are defined on the ActiveRecord::Relation class, itself.
-        # ActiveRecord::Relation class. Since they're defined there, but
-        # I would very much like to modify their behavior, I have three
-        # choices.
+        # You see, Relation#where_values_hash is defined on the
+        # ActiveRecord::Relation class, itself.
+        #
+        # Since it's defined there, but I would very much like to modify its
+        # behavior, I have three choices:
         #
         # 1. Inherit from ActiveRecord::Relation in a Squeel::Relation
         #    class, and make an attempt to usurp all of the various calls
@@ -372,7 +392,7 @@ module Squeel
         #    evil stuff with constant reassignment, all for the sake of
         #    being able to use super().
         #
-        # 2. Submit a patch to Rails core, breaking these methods off into
+        # 2. Submit a patch to Rails core, breaking this method off into
         #    another module, all for my own selfish desire to use super()
         #    while mucking about in Rails internals.
         #
@@ -387,7 +407,6 @@ module Squeel
         def self.included(base)
           base.class_eval do
             alias_method_chain :where_values_hash, :squeel
-            alias_method_chain :with_default_scope, :squeel
           end
         end
 
@@ -397,44 +416,11 @@ module Squeel
         # And and Grouping nodes, which are equivalent to seeing top-level
         # Equality nodes in stock AR terms.
         def where_values_hash_with_squeel
-          equalities = find_equality_predicates(predicate_visitor.accept(with_default_scope.where_values))
+          equalities = find_equality_predicates(where_visit(with_default_scope.where_values))
 
           Hash[equalities.map { |where| [where.left.name, where.right] }]
         end
 
-        # with_default_scope was added to ActiveRecord ~> 3.1 in order to
-        # address https://github.com/rails/rails/issues/1233. Unfortunately,
-        # it plays havoc with Squeel's approach of visiting both sides of
-        # a relation merge. Thankfully, when merging with a relation from
-        # the same AR::Base, it's unnecessary to visit...
-        #
-        # Except, of course, this means we have to handle the edge case
-        # where equalities are duplicated on both sides of the merge, in
-        # which case, unlike all other chained relation calls, the latter
-        # equality overwrites the former.
-        #
-        # The workaround using overwrite_squeel_equalities works as long
-        # as you stick to the Squeel DSL, but breaks down if you throw hash
-        # conditions into the mix. If anyone's got any suggestions, I'm all
-        # ears. Otherwise, just stick to the Squeel DSL.
-        #
-        # Or, don't use default scopes. They're the devil, anyway. I can't
-        # remember the last time I used one and didn't find myself
-        # regretting the decision later.
-        def with_default_scope_with_squeel
-          if default_scoped? &&
-            default_scope = klass.build_default_scope_with_squeel
-            default_scope = default_scope.merge(self, true)
-            default_scope.default_scoped = false
-            default_scope.where_values = overwrite_squeel_equalities(
-              default_scope.where_values + self.where_values
-            )
-            default_scope
-          else
-            self
-          end
-        end
-
       end
     end
   end