squeel 0.9.3 → 0.9.4

data/.travis.yml

@@ -1,7 +1,10 @@
 rvm:
   - 1.8.7
   - 1.9.2
+  - 1.9.3
   - ree
   - rbx
-  - rbx-2.0
-  - ruby-head
+  - ruby-head
+
+env:
+  - RAILS=3-2-stable

data/lib/squeel/adapters/active_record.rb

@@ -15,6 +15,14 @@ when 3
     ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions
     ActiveRecord::Associations::ClassMethods::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependencyExtensions
     ActiveRecord::Base.extend Squeel::Adapters::ActiveRecord::AssociationPreloadExtensions
+  when 1
+    require 'squeel/adapters/active_record/3.1/relation_extensions'
+    require 'squeel/adapters/active_record/3.1/preloader_extensions'
+    require 'squeel/adapters/active_record/3.1/context'
+    
+    ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions
+    ActiveRecord::Associations::JoinDependency.send :include, Squeel::Adapters::ActiveRecord::JoinDependencyExtensions
+    ActiveRecord::Associations::Preloader.send :include, Squeel::Adapters::ActiveRecord::PreloaderExtensions
   else
     require 'squeel/adapters/active_record/relation_extensions'
     require 'squeel/adapters/active_record/preloader_extensions'

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

@@ -0,0 +1,76 @@
+require 'squeel/context'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      class Context < ::Squeel::Context
+        # Because the AR::Associations namespace is insane
+        JoinPart = ::ActiveRecord::Associations::JoinDependency::JoinPart
+
+        def initialize(object)
+          super
+          @base = object.join_base
+          @engine = @base.arel_engine
+          @arel_visitor = @engine.connection.visitor
+          @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
+        end
+
+        def find(object, parent = @base)
+          if JoinPart === parent
+            object = object.to_sym if String === object
+            case object
+            when Symbol, Nodes::Stub
+              @object.join_associations.detect { |j|
+                j.reflection.name == object.to_sym && j.parent == parent
+              }
+            when Nodes::Join
+              @object.join_associations.detect { |j|
+                j.reflection.name == object.name && j.parent == parent &&
+                (object.polymorphic? ? j.reflection.klass == object._klass : true)
+              }
+            else
+              @object.join_associations.detect { |j|
+                j.reflection == object && j.parent == parent
+              }
+            end
+          end
+        end
+
+        def traverse(keypath, parent = @base, include_endpoint = false)
+          parent = @base if keypath.absolute?
+          keypath.path.each do |key|
+            parent = find(key, parent) || key
+          end
+          parent = find(keypath.endpoint, parent) if include_endpoint
+
+          parent
+        end
+
+        private
+
+        def get_table(object)
+          if [Symbol, String, Nodes::Stub].include?(object.class)
+            Arel::Table.new(object.to_sym, :engine => @engine)
+          elsif Nodes::Join === object
+            object._klass ? object._klass.arel_table : Arel::Table.new(object._name, :engine => @engine)
+          elsif object.respond_to?(:aliased_table_name)
+            Arel::Table.new(object.table_name, :as => object.aliased_table_name, :engine => @engine)
+          else
+            raise ArgumentError, "Unable to get table for #{object}"
+          end
+        end
+
+        def classify(object)
+          if Class === object
+            object
+          elsif object.respond_to? :active_record
+            object.active_record
+          else
+            raise ArgumentError, "#{object} can't be converted to a class"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module PreloaderExtensions
+
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :run, :squeel
+          end
+        end
+
+        def run_with_squeel
+          unless records.empty?
+            Visitors::SymbolVisitor.new.accept(associations).each { |association| preload(association) }
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,360 @@
+require 'active_record'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module RelationExtensions
+
+        JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+        JoinDependency = ::ActiveRecord::Associations::JoinDependency
+
+        attr_writer :join_dependency
+        private :join_dependency=
+
+        # 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!
+        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)
+          )
+        end
+
+        # We need to be able to support merging two relations that have a different
+        # base class. Stock ActiveRecord doesn't have to do anything too special, because
+        # it's already created predicates out of the where_values by now, and they're
+        # already bound to the proper table.
+        #
+        # Squeel, on the other hand, needs to do its best to ensure the predicates are still
+        # winding up against the proper table. The most "correct" way I can think of to do
+        # this is to try to emulate the default AR behavior -- that is, de-squeelifying
+        # the *_values, erm... values by visiting them and converting them to ARel nodes
+        # before merging. Merging relations is a nifty little trick, but it's another
+        # little corner of ActiveRecord where the magic quickly fades. :(
+        def merge(r)
+          if relation_with_different_base?(r)
+            r = r.clone.visit!
+          end
+
+          super(r)
+        end
+
+        def relation_with_different_base?(r)
+          ::ActiveRecord::Relation === r &&
+          base_class.name != r.klass.base_class.name
+        end
+
+        def prepare_relation_for_association_merge!(r, association_name)
+          r.where_values.map! {|w| Squeel::Visitors::PredicateVisitor.can_visit?(w) ? {association_name => w} : w}
+          r.having_values.map! {|h| Squeel::Visitors::PredicateVisitor.can_visit?(h) ? {association_name => h} : h}
+          r.group_values.map! {|g| Squeel::Visitors::AttributeVisitor.can_visit?(g) ? {association_name => g} : g}
+          r.order_values.map! {|o| Squeel::Visitors::AttributeVisitor.can_visit?(o) ? {association_name => o} : o}
+          r.select_values.map! {|s| Squeel::Visitors::AttributeVisitor.can_visit?(s) ? {association_name => s} : s}
+          r.joins_values.map! {|j| [Symbol, Hash, Nodes::Stub, Nodes::Join, Nodes::KeyPath].include?(j.class) ? {association_name => j} : j}
+          r.includes_values.map! {|i| [Symbol, Hash, Nodes::Stub, Nodes::Join, Nodes::KeyPath].include?(i.class) ? {association_name => i} : i}
+        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?})
+          @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)
+
+          self
+        end
+
+        def build_arel
+          arel = table.from table
+
+          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))
+
+          arel.having(*predicate_viz.accept(@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?
+
+          order = @reorder_value ? @reorder_value : @order_values
+          order = attribute_viz.accept(order.uniq.reject{|o| o.blank?})
+          order = reverse_sql_order(attrs_to_orderings(order)) if @reverse_order_value
+          arel.order(*order) unless order.empty?
+
+          build_select(arel, attribute_viz.accept(@select_values.uniq))
+
+          arel.from(@from_value) if @from_value
+          arel.lock(@lock_value) if @lock_value
+
+          arel
+        end
+
+        # reverse_sql_order will reverse the order of strings or Orderings,
+        # but not attributes
+        def attrs_to_orderings(order)
+          order.map do |o|
+            Arel::Attribute === o ? o.asc : o
+          end
+        end
+
+        def build_join_dependency(manager, joins)
+          buckets = joins.group_by do |join|
+            case join
+            when String
+              'string_join'
+            when Hash, Symbol, Array, Nodes::Stub, Nodes::Join, Nodes::KeyPath
+              'association_join'
+            when JoinAssociation
+              'stashed_join'
+            when Arel::Nodes::Join
+              'join_node'
+            else
+              raise 'unknown class: %s' % join.class.name
+            end
+          end
+
+          association_joins         = buckets['association_join'] || []
+          stashed_association_joins = buckets['stashed_join'] || []
+          join_nodes                = buckets['join_node'] || []
+          string_joins              = (buckets['string_join'] || []).map { |x|
+            x.strip
+          }.uniq
+
+          join_list = custom_join_ast(manager, string_joins)
+
+          # All of this duplication just to add
+          self.join_dependency = JoinDependency.new(
+            @klass,
+            association_joins,
+            join_list
+          )
+
+          join_nodes.each do |join|
+            join_dependency.alias_tracker.aliased_name_for(join.left.name.downcase)
+          end
+
+          join_dependency.graft(*stashed_association_joins)
+
+          @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
+
+          join_dependency.join_associations.each do |association|
+            association.join_to(manager)
+          end
+
+          manager.join_sources.concat join_nodes.uniq
+          manager.join_sources.concat join_list
+
+          manager
+        end
+
+        def includes(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def preload(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def eager_load(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def select(value = Proc.new)
+          if block_given? && Proc === value
+            if value.arity > 0
+              to_a.select {|*block_args| value.call(*block_args)}
+            else
+              relation = clone
+              relation.select_values += Array.wrap(DSL.eval &value)
+              relation
+            end
+          else
+            super
+          end
+        end
+
+        def group(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def order(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def reorder(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def joins(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
+
+        def where(opts = Proc.new, *rest)
+          if block_given? && Proc === opts
+            super(DSL.eval &opts)
+          else
+            super
+          end
+        end
+
+        def having(*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
+            super
+          else  # Let's prevent PredicateBuilder from doing its thing
+            [opts, *other].map do |arg|
+              case arg
+              when Array  # Just in case there's an array in there somewhere
+                @klass.send(:sanitize_sql, arg)
+              when Hash
+                @klass.send(:expand_hash_conditions_for_aggregates, arg)
+              else
+                arg
+              end
+            end
+          end
+        end
+
+        def collapse_wheres(arel, wheres)
+          wheres = Array(wheres)
+          binaries = wheres.grep(Arel::Nodes::Binary)
+
+          groups = binaries.group_by {|b| [b.class, b.left]}
+
+          groups.each do |_, bins|
+            arel.where(Arel::Nodes::And.new(bins))
+          end
+
+          (wheres - binaries).each do |where|
+            where = Arel.sql(where) if String === where
+            arel.where(Arel::Nodes::Grouping.new(where))
+          end
+        end
+
+        def find_equality_predicates(nodes)
+          nodes.map { |node|
+            case node
+            when Arel::Nodes::Equality
+              node if node.left.relation.name == table_name
+            when Arel::Nodes::Grouping
+              find_equality_predicates([node.expr])
+            when Arel::Nodes::And
+              find_equality_predicates(node.children)
+            else
+              nil
+            end
+          }.compact.flatten
+        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
+        # DB for debug purposes without actually running the query.
+        def debug_sql
+          if eager_loading?
+            including = (@eager_load_values + @includes_values).uniq
+            join_dependency = JoinDependency.new(@klass, including, [])
+            construct_relation_for_association_find(join_dependency).to_sql
+          else
+            arel.to_sql
+          end
+        end
+
+        ### ZOMG ALIAS_METHOD_CHAIN IS BELOW. HIDE YOUR EYES!
+        # ...
+        # ...
+        # ...
+        # 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.
+        #
+        # 1. Inherit from ActiveRecord::Relation in a Squeel::Relation
+        #    class, and make an attempt to usurp all of the various calls
+        #    to methods on ActiveRecord::Relation by doing some really
+        #    evil stuff with constant reassignment, all for the sake of
+        #    being able to use super().
+        #
+        # 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.
+        #
+        # 3. Use alias_method_chain, and say 10 hail Hanssons as penance.
+        #
+        # I opted to go with #3. Except for the hail Hansson thing.
+        # Unless you're DHH, in which case, I totally said them.
+
+        def self.included(base)
+          base.class_eval do
+            alias_method_chain :where_values_hash, :squeel
+          end
+        end
+
+        def where_values_hash_with_squeel
+          equalities = find_equality_predicates(predicate_visitor.accept(@where_values))
+
+          Hash[equalities.map { |where| [where.left.name, where.right] }]
+        end
+
+      end
+    end
+  end
+end

data/lib/squeel/adapters/active_record/context.rb

@@ -1,76 +1 @@
-require 'squeel/context'
-
-module Squeel
-  module Adapters
-    module ActiveRecord
-      class Context < ::Squeel::Context
-        # Because the AR::Associations namespace is insane
-        JoinPart = ::ActiveRecord::Associations::JoinDependency::JoinPart
-
-        def initialize(object)
-          super
-          @base = object.join_base
-          @engine = @base.arel_engine
-          @arel_visitor = @engine.connection.visitor
-          @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
-        end
-
-        def find(object, parent = @base)
-          if JoinPart === parent
-            object = object.to_sym if String === object
-            case object
-            when Symbol, Nodes::Stub
-              @object.join_associations.detect { |j|
-                j.reflection.name == object.to_sym && j.parent == parent
-              }
-            when Nodes::Join
-              @object.join_associations.detect { |j|
-                j.reflection.name == object.name && j.parent == parent &&
-                (object.polymorphic? ? j.reflection.klass == object._klass : true)
-              }
-            else
-              @object.join_associations.detect { |j|
-                j.reflection == object && j.parent == parent
-              }
-            end
-          end
-        end
-
-        def traverse(keypath, parent = @base, include_endpoint = false)
-          parent = @base if keypath.absolute?
-          keypath.path.each do |key|
-            parent = find(key, parent) || key
-          end
-          parent = find(keypath.endpoint, parent) if include_endpoint
-
-          parent
-        end
-
-        private
-
-        def get_table(object)
-          if [Symbol, String, Nodes::Stub].include?(object.class)
-            Arel::Table.new(object.to_sym, :engine => @engine)
-          elsif Nodes::Join === object
-            object._klass ? object._klass.arel_table : Arel::Table.new(object._name, :engine => @engine)
-          elsif object.respond_to?(:aliased_table_name)
-            Arel::Table.new(object.table_name, :as => object.aliased_table_name, :engine => @engine)
-          else
-            raise ArgumentError, "Unable to get table for #{object}"
-          end
-        end
-
-        def classify(object)
-          if Class === object
-            object
-          elsif object.respond_to? :active_record
-            object.active_record
-          else
-            raise ArgumentError, "#{object} can't be converted to a class"
-          end
-        end
-
-      end
-    end
-  end
-end
+require 'squeel/adapters/active_record/3.1/context'

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

@@ -1,21 +1 @@
-module Squeel
-  module Adapters
-    module ActiveRecord
-      module PreloaderExtensions
-
-        def self.included(base)
-          base.class_eval do
-            alias_method_chain :run, :squeel
-          end
-        end
-
-        def run_with_squeel
-          unless records.empty?
-            Visitors::SymbolVisitor.new.accept(associations).each { |association| preload(association) }
-          end
-        end
-
-      end
-    end
-  end
-end
+require 'squeel/adapters/active_record/3.1/preloader_extensions'

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

@@ -1,84 +1,10 @@
-require 'active_record'
+require 'squeel/adapters/active_record/3.1/relation_extensions'
 
 module Squeel
   module Adapters
     module ActiveRecord
       module RelationExtensions
-
-        JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
-        JoinDependency = ::ActiveRecord::Associations::JoinDependency
-
-        attr_writer :join_dependency
-        private :join_dependency=
-
-        # 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!
-        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)
-          )
-        end
-
-        # We need to be able to support merging two relations that have a different
-        # base class. Stock ActiveRecord doesn't have to do anything too special, because
-        # it's already created predicates out of the where_values by now, and they're
-        # already bound to the proper table.
-        #
-        # Squeel, on the other hand, needs to do its best to ensure the predicates are still
-        # winding up against the proper table. The most "correct" way I can think of to do
-        # this is to try to emulate the default AR behavior -- that is, de-squeelifying
-        # the *_values, erm... values by visiting them and converting them to ARel nodes
-        # before merging. Merging relations is a nifty little trick, but it's another
-        # little corner of ActiveRecord where the magic quickly fades. :(
-        def merge(r)
-          if relation_with_different_base?(r)
-            r = r.clone.visit!
-          end
-
-          super(r)
-        end
-
-        def relation_with_different_base?(r)
-          ::ActiveRecord::Relation === r &&
-          base_class.name != r.klass.base_class.name
-        end
-
-        def prepare_relation_for_association_merge!(r, association_name)
-          r.where_values.map! {|w| Squeel::Visitors::PredicateVisitor.can_visit?(w) ? {association_name => w} : w}
-          r.having_values.map! {|h| Squeel::Visitors::PredicateVisitor.can_visit?(h) ? {association_name => h} : h}
-          r.group_values.map! {|g| Squeel::Visitors::AttributeVisitor.can_visit?(g) ? {association_name => g} : g}
-          r.order_values.map! {|o| Squeel::Visitors::AttributeVisitor.can_visit?(o) ? {association_name => o} : o}
-          r.select_values.map! {|s| Squeel::Visitors::AttributeVisitor.can_visit?(s) ? {association_name => s} : s}
-          r.joins_values.map! {|j| [Symbol, Hash, Nodes::Stub, Nodes::Join, Nodes::KeyPath].include?(j.class) ? {association_name => j} : j}
-          r.includes_values.map! {|i| [Symbol, Hash, Nodes::Stub, Nodes::Join, Nodes::KeyPath].include?(i.class) ? {association_name => i} : i}
-        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?})
-          @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)
-
-          self
-        end
-
+        
         def build_arel
           arel = table.from table
 
@@ -102,258 +28,14 @@ module Squeel
           arel.order(*order) unless order.empty?
 
           build_select(arel, attribute_viz.accept(@select_values.uniq))
-
+          
+          arel.distinct(@uniq_value)
           arel.from(@from_value) if @from_value
           arel.lock(@lock_value) if @lock_value
 
           arel
         end
-
-        # reverse_sql_order will reverse the order of strings or Orderings,
-        # but not attributes
-        def attrs_to_orderings(order)
-          order.map do |o|
-            Arel::Attribute === o ? o.asc : o
-          end
-        end
-
-        def build_join_dependency(manager, joins)
-          buckets = joins.group_by do |join|
-            case join
-            when String
-              'string_join'
-            when Hash, Symbol, Array, Nodes::Stub, Nodes::Join, Nodes::KeyPath
-              'association_join'
-            when JoinAssociation
-              'stashed_join'
-            when Arel::Nodes::Join
-              'join_node'
-            else
-              raise 'unknown class: %s' % join.class.name
-            end
-          end
-
-          association_joins         = buckets['association_join'] || []
-          stashed_association_joins = buckets['stashed_join'] || []
-          join_nodes                = buckets['join_node'] || []
-          string_joins              = (buckets['string_join'] || []).map { |x|
-            x.strip
-          }.uniq
-
-          join_list = custom_join_ast(manager, string_joins)
-
-          # All of this duplication just to add
-          self.join_dependency = JoinDependency.new(
-            @klass,
-            association_joins,
-            join_list
-          )
-
-          join_nodes.each do |join|
-            join_dependency.alias_tracker.aliased_name_for(join.left.name.downcase)
-          end
-
-          join_dependency.graft(*stashed_association_joins)
-
-          @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
-
-          join_dependency.join_associations.each do |association|
-            association.join_to(manager)
-          end
-
-          manager.join_sources.concat join_nodes.uniq
-          manager.join_sources.concat join_list
-
-          manager
-        end
-
-        def includes(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def preload(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def eager_load(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def select(value = Proc.new)
-          if block_given? && Proc === value
-            if value.arity > 0
-              to_a.select {|*block_args| value.call(*block_args)}
-            else
-              relation = clone
-              relation.select_values += Array.wrap(DSL.eval &value)
-              relation
-            end
-          else
-            super
-          end
-        end
-
-        def group(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def order(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def reorder(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def joins(*args)
-          if block_given? && args.empty?
-            super(DSL.eval &Proc.new)
-          else
-            super
-          end
-        end
-
-        def where(opts = Proc.new, *rest)
-          if block_given? && Proc === opts
-            super(DSL.eval &opts)
-          else
-            super
-          end
-        end
-
-        def having(*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
-            super
-          else  # Let's prevent PredicateBuilder from doing its thing
-            [opts, *other].map do |arg|
-              case arg
-              when Array  # Just in case there's an array in there somewhere
-                @klass.send(:sanitize_sql, arg)
-              when Hash
-                @klass.send(:expand_hash_conditions_for_aggregates, arg)
-              else
-                arg
-              end
-            end
-          end
-        end
-
-        def collapse_wheres(arel, wheres)
-          wheres = Array(wheres)
-          binaries = wheres.grep(Arel::Nodes::Binary)
-
-          groups = binaries.group_by {|b| [b.class, b.left]}
-
-          groups.each do |_, bins|
-            arel.where(Arel::Nodes::And.new(bins))
-          end
-
-          (wheres - binaries).each do |where|
-            where = Arel.sql(where) if String === where
-            arel.where(Arel::Nodes::Grouping.new(where))
-          end
-        end
-
-        def find_equality_predicates(nodes)
-          nodes.map { |node|
-            case node
-            when Arel::Nodes::Equality
-              node if node.left.relation.name == table_name
-            when Arel::Nodes::Grouping
-              find_equality_predicates([node.expr])
-            when Arel::Nodes::And
-              find_equality_predicates(node.children)
-            else
-              nil
-            end
-          }.compact.flatten
-        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
-        # DB for debug purposes without actually running the query.
-        def debug_sql
-          if eager_loading?
-            including = (@eager_load_values + @includes_values).uniq
-            join_dependency = JoinDependency.new(@klass, including, [])
-            construct_relation_for_association_find(join_dependency).to_sql
-          else
-            arel.to_sql
-          end
-        end
-
-        ### ZOMG ALIAS_METHOD_CHAIN IS BELOW. HIDE YOUR EYES!
-        # ...
-        # ...
-        # ...
-        # 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.
-        #
-        # 1. Inherit from ActiveRecord::Relation in a Squeel::Relation
-        #    class, and make an attempt to usurp all of the various calls
-        #    to methods on ActiveRecord::Relation by doing some really
-        #    evil stuff with constant reassignment, all for the sake of
-        #    being able to use super().
-        #
-        # 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.
-        #
-        # 3. Use alias_method_chain, and say 10 hail Hanssons as penance.
-        #
-        # I opted to go with #3. Except for the hail Hansson thing.
-        # Unless you're DHH, in which case, I totally said them.
-
-        def self.included(base)
-          base.class_eval do
-            alias_method_chain :where_values_hash, :squeel
-          end
-        end
-
-        def where_values_hash_with_squeel
-          equalities = find_equality_predicates(predicate_visitor.accept(@where_values))
-
-          Hash[equalities.map { |where| [where.left.name, where.right] }]
-        end
-
+        
       end
     end
   end

data/lib/squeel/configuration.rb

@@ -34,7 +34,7 @@ module Squeel
     #   @param [Symbol] sym2 :hash or :symbol
     def load_core_extensions(*exts)
       exts.each do |ext|
-        require "core_ext/#{ext}"
+        require "squeel/core_ext/#{ext}"
       end
     end
 
@@ -51,4 +51,4 @@ module Squeel
     end
 
   end
-end
+end

data/lib/squeel/version.rb

@@ -1,3 +1,3 @@
 module Squeel
-  VERSION = "0.9.3"
+  VERSION = "0.9.4"
 end

data/spec/squeel/adapters/active_record/relation_extensions_spec.rb

@@ -97,6 +97,10 @@ module Squeel
             relation.join_dependency.join_associations.should have(6).items
             arel.to_sql.should match /INNER JOIN "people" "parents_people_3" ON "parents_people_3"."id" = "children_people_3"."parent_id"/
           end
+          
+          it 'respects :uniq option on associations' do
+            Article.first.uniq_commenters.length.should eq Article.first.uniq_commenters.count
+          end
 
           it 'visits wheres with a PredicateVisitor, converting them to ARel nodes' do
             relation = Person.where(:name.matches => '%bob%')

data/spec/support/schema.rb

@@ -48,6 +48,7 @@ class Article < ActiveRecord::Base
   has_and_belongs_to_many :tags
   has_many   :notes, :as => :notable
   has_many :commenters, :through => :comments, :source => :person
+  has_many :uniq_commenters, :through => :comments, :source => :person, :uniq => true
 end
 
 class Comment < ActiveRecord::Base
@@ -137,6 +138,7 @@ module Schema
     end
 
     Comment.make(:body => 'First post!', :article => Article.make(:title => 'Hello, world!'))
+    Comment.make(:body => 'Last post!', :article => Article.first, :person => Article.first.commenters.first)
 
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: squeel
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-30 00:00:00.000000000Z
+date: 2012-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70248155556820 !ruby/object:Gem::Requirement
+  requirement: &70129585123660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70248155556820
+  version_requirements: *70129585123660
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &70248155556320 !ruby/object:Gem::Requirement
+  requirement: &70129585122480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70248155556320
+  version_requirements: *70129585122480
 - !ruby/object:Gem::Dependency
   name: polyamorous
-  requirement: &70248155551000 !ruby/object:Gem::Requirement
+  requirement: &70129585121660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 0.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *70248155551000
+  version_requirements: *70129585121660
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70248155547740 !ruby/object:Gem::Requirement
+  requirement: &70129585121080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.6.0
   type: :development
   prerelease: false
-  version_requirements: *70248155547740
+  version_requirements: *70129585121080
 - !ruby/object:Gem::Dependency
   name: machinist
-  requirement: &70248155546940 !ruby/object:Gem::Requirement
+  requirement: &70129585120560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 1.0.6
   type: :development
   prerelease: false
-  version_requirements: *70248155546940
+  version_requirements: *70129585120560
 - !ruby/object:Gem::Dependency
   name: faker
-  requirement: &70248155545680 !ruby/object:Gem::Requirement
+  requirement: &70129585135820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +76,10 @@ dependencies:
         version: 0.9.5
   type: :development
   prerelease: false
-  version_requirements: *70248155545680
+  version_requirements: *70129585135820
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70248155527020 !ruby/object:Gem::Requirement
+  requirement: &70129585134740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,7 +87,7 @@ dependencies:
         version: 1.3.3
   type: :development
   prerelease: false
-  version_requirements: *70248155527020
+  version_requirements: *70129585134740
 description: ! "\n      Squeel unlocks the power of ARel in your Rails 3 application
   with\n      a handy block-based syntax. You can write subqueries, access named\n
   \     functions provided by your RDBMS, and more, all without writing\n      SQL
@@ -105,14 +105,15 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/core_ext/hash.rb
-- lib/core_ext/symbol.rb
 - lib/squeel.rb
 - lib/squeel/adapters/active_record.rb
 - lib/squeel/adapters/active_record/3.0/association_preload_extensions.rb
 - lib/squeel/adapters/active_record/3.0/compat.rb
 - lib/squeel/adapters/active_record/3.0/context.rb
 - lib/squeel/adapters/active_record/3.0/relation_extensions.rb
+- lib/squeel/adapters/active_record/3.1/context.rb
+- lib/squeel/adapters/active_record/3.1/preloader_extensions.rb
+- lib/squeel/adapters/active_record/3.1/relation_extensions.rb
 - lib/squeel/adapters/active_record/base_extensions.rb
 - lib/squeel/adapters/active_record/context.rb
 - lib/squeel/adapters/active_record/join_dependency_extensions.rb
@@ -121,6 +122,8 @@ files:
 - lib/squeel/configuration.rb
 - lib/squeel/constants.rb
 - lib/squeel/context.rb
+- lib/squeel/core_ext/hash.rb
+- lib/squeel/core_ext/symbol.rb
 - lib/squeel/dsl.rb
 - lib/squeel/nodes.rb
 - lib/squeel/nodes/aliasing.rb