squeel 1.0.11 → 1.0.12

data/lib/squeel/adapters/active_record/3.2/compat.rb

@@ -0,0 +1 @@
+require 'squeel/adapters/active_record/compat'

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

@@ -0,0 +1 @@
+require 'squeel/adapters/active_record/context'

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

@@ -0,0 +1 @@
+require 'squeel/adapters/active_record/preloader_extensions'

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

@@ -0,0 +1,40 @@
+require 'squeel/adapters/active_record/relation_extensions'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module RelationExtensions
+
+        def build_arel
+          arel = table.from table
+
+          build_join_dependency(arel, @joins_values) unless @joins_values.empty?
+
+          collapse_wheres(arel, where_visit((@where_values - ['']).uniq))
+
+          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(*group_visit(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
+
+          order = order_visit(@order_values.uniq)
+          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, select_visit(@select_values.uniq))
+
+          arel.distinct(@uniq_value)
+          arel.from(from_visit(@from_value)) if @from_value
+          arel.lock(@lock_value) if @lock_value
+
+          arel
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.send :include, Squeel::Adapters::ActiveRecord::RelationExtensions

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

@@ -20,3 +20,5 @@ module Squeel
     end
   end
 end
+
+ActiveRecord::Base.extend Squeel::Adapters::ActiveRecord::BaseExtensions

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

@@ -1 +1,22 @@
-require 'squeel/adapters/active_record/3.1/compat'
+module Arel
+
+  module Nodes
+
+    class Grouping < Unary
+      include Arel::Predications
+    end unless Grouping.include?(Arel::Predications)
+
+  end
+
+  module Visitors
+
+    class DepthFirst < Visitor
+
+      unless method_defined?(:visit_Arel_Nodes_InfixOperation)
+        alias :visit_Arel_Nodes_InfixOperation :binary
+      end
+
+    end
+
+  end
+end

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

@@ -1 +1,84 @@
-require 'squeel/adapters/active_record/3.1/context'
+require 'squeel/context'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      class Context < ::Squeel::Context
+
+        def initialize(object)
+          super
+          @base = object.join_base
+          @engine = @base.arel_engine
+          @arel_visitor = get_arel_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
+            case object
+            when String, Symbol, Nodes::Stub
+              assoc_name = object.to_s
+              @object.join_associations.detect { |j|
+                j.reflection.name.to_s == assoc_name && 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_without_endpoint.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_s, :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
+
+        def get_arel_visitor
+          @engine.connection.visitor
+        end
+
+      end
+
+      if defined?(::ActiveRecord::Associations::JoinDependency::JoinPart)
+        JoinPart = ::ActiveRecord::Associations::JoinDependency::JoinPart
+      elsif defined?(::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase)
+        JoinPart = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
+      end
+    end
+  end
+end

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

@@ -31,6 +31,17 @@ module Squeel
         end
 
       end
+
+      if defined?(::ActiveRecord::Associations::JoinDependency)
+        JoinAssociation = ::ActiveRecord::Associations::JoinDependency::JoinAssociation
+        JoinDependency = ::ActiveRecord::Associations::JoinDependency
+      elsif defined?(::ActiveRecord::Associations::ClassMethods::JoinDependency)
+        JoinAssociation = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation
+        JoinDependency = ::ActiveRecord::Associations::ClassMethods::JoinDependency
+      end
+
+      JoinDependency.send :include, Adapters::ActiveRecord::JoinDependencyExtensions
+
     end
   end
 end

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

@@ -1 +1,23 @@
-require 'squeel/adapters/active_record/3.1/preloader_extensions'
+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::PreloadVisitor.new.accept(associations).each { |association| preload(association) }
+          end
+        end
+
+      end
+    end
+  end
+end
+
+ActiveRecord::Associations::Preloader.send :include, Squeel::Adapters::ActiveRecord::PreloaderExtensions

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

@@ -1,35 +1,394 @@
-require 'squeel/adapters/active_record/3.1/relation_extensions'
+require 'active_record'
 
 module Squeel
   module Adapters
     module ActiveRecord
       module RelationExtensions
 
-        def build_arel
-          arel = table.from table
+        attr_writer :join_dependency
+        private :join_dependency=
 
-          build_join_dependency(arel, @joins_values) unless @joins_values.empty?
+        # 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
+
+        %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. 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
+            super(r)
+          end
+        end
+
+        def visited
+          clone.visit!
+        end
+
+        def visit!
+          @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 = 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
+
+        # 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
+
+        # So, building a select for a count query in ActiveRecord is
+        # pretty heavily dependent on select_values containing strings.
+        # I'd initially expected that I could just hack together a fix
+        # to select_for_count and everything would fall in line, but
+        # unfortunately, pretty much everything from that point on
+        # in ActiveRecord::Calculations#perform_calculation expects
+        # the column to be a string, or at worst, a symbol.
+        #
+        # In the long term, I would like to refactor the code in
+        # 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 = select_visit(select_values.uniq)
+          if visited_values.size == 1
+            select = visited_values.first
+
+            str_select = case select
+            when String
+              select
+            when Symbol
+              select.to_s
+            else
+              select.to_sql if select.respond_to?(:to_sql)
+            end
+
+            str_select if str_select && str_select !~ /[,*]/
+          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'] || []).uniq
+          string_joins              = (buckets['string_join'] || []).map { |x|
+            x.strip
+          }.uniq
+
+          join_list = join_nodes + custom_join_ast(manager, string_joins)
+
+          # All of that duplication just to do this...
+          self.join_dependency = JoinDependency.new(
+            @klass,
+            association_joins,
+            join_list
+          )
+
+          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_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
 
-          collapse_wheres(arel, where_visit((@where_values - ['']).uniq))
+        def having(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
 
-          arel.having(*having_visit(@having_values.uniq.reject{|h| h.blank?})) unless @having_values.empty?
+        def from(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
+            super
+          end
+        end
 
-          arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
-          arel.skip(@offset_value) if @offset_value
+        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
 
-          arel.group(*group_visit(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
+        def collapse_wheres(arel, wheres)
+          wheres = Array(wheres)
+          binaries = wheres.grep(Arel::Nodes::Binary)
 
-          order = order_visit(@order_values)
-          order = reverse_sql_order(attrs_to_orderings(order)) if @reverse_order_value
-          arel.order(*order.uniq.reject{|o| o.blank?}) unless order.empty?
+          groups = binaries.group_by {|b| [b.class, b.left]}
 
-          build_select(arel, select_visit(@select_values.uniq))
+          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
+              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
+              find_equality_predicates(node.children)
+            else
+              nil
+            end
+          }.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
+        # 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, 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
+        #    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.
+        #
+        # 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
+            alias_method_chain :where_values_hash, :squeel
+          end
+        end
 
-          arel.distinct(@uniq_value)
-          arel.from(from_visit(@from_value)) if @from_value
-          arel.lock(@lock_value) if @lock_value
+        # where_values_hash is used in scope_for_create. It's what allows
+        # new records to be created with any equality values that exist in
+        # your model's default scope. We hijack it in order to dig down into
+        # 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(where_visit(with_default_scope.where_values))
 
-          arel
+          Hash[equalities.map { |where| [where.left.name, where.right] }]
         end
 
       end