squeel 0.5.0 → 0.5.5

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

@@ -3,7 +3,6 @@ require 'active_record'
 module Squeel
   module Adapters
     module ActiveRecord
-
       class JoinAssociation < ::ActiveRecord::Associations::JoinDependency::JoinAssociation
 
         def initialize(reflection, join_dependency, parent = nil, polymorphic_class = nil)
@@ -25,66 +24,21 @@ module Squeel
           reflection.options[:polymorphic] = original_polymorphic
         end
 
-        def join_to(relation)
-          tables        = @tables.dup
-          foreign_table = parent_table
-
-          # The chain starts with the target table, but we want to end with it here (makes
-          # more sense in this context), so we reverse
-          chain.reverse.each_with_index do |reflection, i|
-            table = tables.shift
-
-            case reflection.source_macro
-            when :belongs_to
-              key         = reflection.association_primary_key
-              foreign_key = reflection.foreign_key
-            when :has_and_belongs_to_many
-              # Join the join table first...
-              relation.from(join(
-                table,
-                table[reflection.foreign_key].
-                  eq(foreign_table[reflection.active_record_primary_key])
-              ))
-
-              foreign_table, table = table, tables.shift
-
-              key         = reflection.association_primary_key
-              foreign_key = reflection.association_foreign_key
-            else
-              key         = reflection.foreign_key
-              foreign_key = reflection.active_record_primary_key
-            end
-
-            constraint = table[key].eq(foreign_table[foreign_key])
-
-            if reflection.options[:polymorphic]
-              constraint = constraint.and(
-                foreign_table[reflection.foreign_type].eq(reflection.klass.name)
-              )
-            end
-
-            if reflection.klass.finder_needs_type_condition?
-              constraint = table.create_and([
-                constraint,
-                reflection.klass.send(:type_condition, table)
-              ])
-            end
-
-            relation.from(join(table, constraint))
-
-            unless conditions[i].empty?
-              relation.where(sanitize(conditions[i], table))
-            end
+        def ==(other)
+          super && active_record == other.active_record
+        end
 
-            # The current table in this iteration becomes the foreign table in the next
-            foreign_table = table
+        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+          if reflection.options[:polymorphic]
+            super.and(
+              foreign_table[reflection.foreign_type].eq(reflection.klass.name)
+            )
+          else
+            super
           end
-
-          relation
         end
 
       end
-
     end
   end
 end

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

@@ -12,9 +12,24 @@ module Squeel
         def self.included(base)
           base.class_eval do
             alias_method_chain :build, :squeel
+            alias_method_chain :graft, :squeel
           end
         end
 
+        def graft_with_squeel(*associations)
+          associations.each do |association|
+            unless join_associations.detect {|a| association == a}
+              if association.reflection.options[:polymorphic]
+                build(Nodes::Join.new(association.reflection.name, association.join_type, association.reflection.klass),
+                      association.find_parent_in(self) || join_base, association.join_type)
+              else
+                build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
+              end
+            end
+          end
+          self
+        end
+
         def build_with_squeel(associations, parent = nil, join_type = Arel::InnerJoin)
           associations = associations.symbol if Nodes::Stub === associations
 
@@ -24,9 +39,9 @@ module Squeel
             reflection = parent.reflections[associations.name] or
               raise ::ActiveRecord::ConfigurationError, "Association named '#{ associations.name }' was not found; perhaps you misspelled it?"
 
-            unless join_association = find_join_association_respecting_polymorphism(reflection, parent, associations)
+            unless join_association = find_join_association_respecting_polymorphism(reflection, parent, associations.klass)
               @reflections << reflection
-              join_association = build_join_association_respecting_polymorphism(reflection, parent, associations)
+              join_association = build_join_association_respecting_polymorphism(reflection, parent, associations.klass)
               join_association.join_type = associations.type
               @join_parts << join_association
               cache_joined_association(join_association)
@@ -44,19 +59,19 @@ module Squeel
           end
         end
 
-        def find_join_association_respecting_polymorphism(reflection, parent, join)
+        def find_join_association_respecting_polymorphism(reflection, parent, klass)
           if association = find_join_association(reflection, parent)
             unless reflection.options[:polymorphic]
               association
             else
-              association if association.active_record == join.klass
+              association if association.active_record == klass
             end
           end
         end
 
-        def build_join_association_respecting_polymorphism(reflection, parent, join)
-          if reflection.options[:polymorphic] && join.polymorphic?
-            JoinAssociation.new(reflection, self, parent, join.klass)
+        def build_join_association_respecting_polymorphism(reflection, parent, klass)
+          if reflection.options[:polymorphic] && klass
+            JoinAssociation.new(reflection, self, parent, klass)
           else
             JoinAssociation.new(reflection, self, parent)
           end

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

@@ -0,0 +1,21 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      module Preloader
+
+        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/relation.rb

@@ -11,28 +11,35 @@ module Squeel
         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 select_visitor
-          Visitors::SelectVisitor.new(
-            Contexts::JoinDependencyContext.new(join_dependency)
-          )
-        end
-
         def predicate_visitor
           Visitors::PredicateVisitor.new(
-            Contexts::JoinDependencyContext.new(join_dependency)
+            Context.new(join_dependency)
           )
         end
 
-        def order_visitor
-          Visitors::OrderVisitor.new(
-            Contexts::JoinDependencyContext.new(join_dependency)
+        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. Merging relations is a really nifty shortcut
+        # but another little corner of ActiveRecord where the magic quickly fades. :(
         def merge(r, association_name = nil)
           if association_name || relation_with_different_base?(r)
             r = r.clone
@@ -66,6 +73,7 @@ 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))
 
@@ -74,14 +82,12 @@ module Squeel
           arel.take(connection.sanitize_limit(@limit_value)) if @limit_value
           arel.skip(@offset_value) if @offset_value
 
-          arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
+          arel.group(*attribute_viz.accept(@group_values.uniq.reject{|g| g.blank?})) unless @group_values.empty?
 
-          unless @order_values.empty?
-            order_viz = order_visitor
-            arel.order(*order_viz.accept(@order_values.uniq.reject{|o| o.blank?}))
-          end
+          order = @reorder_value ? @reorder_value : @order_values
+          arel.order(*attribute_viz.accept(order.uniq.reject{|o| o.blank?})) unless order.empty?
 
-          build_select(arel, select_visitor.accept(@select_values.uniq))
+          build_select(arel, attribute_viz.accept(@select_values.uniq))
 
           arel.from(@from_value) if @from_value
           arel.lock(@lock_value) if @lock_value
@@ -139,13 +145,37 @@ module Squeel
           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.evaluate &value)
+              relation.select_values += Array.wrap(DSL.eval &value)
               relation
             end
           else
@@ -153,35 +183,25 @@ module Squeel
           end
         end
 
-        def where(opts = Proc.new, *rest)
-          if block_given? && Proc === opts
-            super(DSL.evaluate &opts)
+        def group(*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
+        def order(*args)
+          if block_given? && args.empty?
+            super(DSL.eval &Proc.new)
+          else
             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 order(*args)
+        def reorder(*args)
           if block_given? && args.empty?
-            super(DSL.evaluate &Proc.new)
+            super(DSL.eval &Proc.new)
           else
             super
           end
@@ -189,7 +209,15 @@ module Squeel
 
         def joins(*args)
           if block_given? && args.empty?
-            super(DSL.evaluate &Proc.new)
+            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
@@ -197,12 +225,30 @@ module Squeel
 
         def having(*args)
           if block_given? && args.empty?
-            super(DSL.evaluate &Proc.new)
+            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 = [wheres] unless Array === wheres
           binaries = wheres.grep(Arel::Nodes::Binary)

data/lib/squeel/context.rb

@@ -0,0 +1,38 @@
+require 'arel'
+
+module Squeel
+  class Context
+    attr_reader :base, :engine, :arel_visitor
+
+    def initialize(object)
+      @object = object
+      @engine = @base.arel_engine
+      @arel_visitor = Arel::Visitors.visitor_for @engine
+      @default_table = Arel::Table.new(@base.table_name, :as => @base.aliased_table_name, :engine => @engine)
+      @tables = Hash.new {|hash, key| hash[key] = get_table(key)}
+    end
+
+    def find(object, parent = @base)
+      raise NotImplementedError, "Subclasses must implement public method find"
+    end
+
+    def traverse(keypath, parent = @base, include_endpoint = false)
+      raise NotImplementedError, "Subclasses must implement public method traverse"
+    end
+
+    def contextualize(object)
+      @tables[object]
+    end
+
+    def sanitize_sql(conditions, parent)
+      raise NotImplementedError, "Subclasses must implement public method sanitize_sql"
+    end
+
+    private
+
+    def get_table(object)
+      raise NotImplementedError, "Subclasses must implement private method get_table"
+    end
+
+  end
+end

data/lib/squeel/dsl.rb

@@ -9,7 +9,7 @@ module Squeel
       end
     end
 
-    def self.evaluate(&block)
+    def self.eval(&block)
       if block.arity > 0
         yield self.new
       else

data/lib/squeel/nodes/join.rb

@@ -26,6 +26,24 @@ module Squeel
         @klass
       end
 
+      def eql?(other)
+        self.class == other.class &&
+        self.name  == other.name &&
+        self.type == other.type &&
+        self.klass == other.klass
+      end
+
+      alias :== :eql?
+
+      def method_missing(method_id, *args)
+        super if method_id == :to_ary
+        if (args.size == 1) && (Class === args[0])
+          KeyPath.new(self, Join.new(method_id, Arel::InnerJoin, args[0]))
+        else
+          KeyPath.new(self, method_id)
+        end
+      end
+
       # expand_hash_conditions_for_aggregates assumes our hash keys can be
       # converted to symbols, so this has to be implemented, but it doesn't
       # really have to do anything useful.

data/lib/squeel/nodes/key_path.rb

@@ -101,8 +101,8 @@ module Squeel
         if endpoint.respond_to? method_id
           @endpoint = @endpoint.send(method_id, *args)
           self
-        elsif Stub === endpoint
-          @path << endpoint.symbol
+        elsif Stub === endpoint || Join === endpoint
+          @path << endpoint
           if args.empty?
             @endpoint = Stub.new(method_id)
           elsif (args.size == 1) && (Class === args[0])