squeel 1.1.1 → 1.2.1

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

@@ -3,6 +3,12 @@ require 'squeel/context'
 module Squeel
   module Adapters
     module ActiveRecord
+      JoinPart = if defined?(::ActiveRecord::Associations::JoinDependency::JoinPart)
+          ::ActiveRecord::Associations::JoinDependency::JoinPart
+        elsif defined?(::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase)
+          ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase
+        end
+
       class Context < ::Squeel::Context
 
         def initialize(object)
@@ -23,7 +29,7 @@ module Squeel
               }
             when Nodes::Join
               @object.join_associations.detect { |j|
-                j.reflection.name == object.name && j.parent == parent &&
+                j.reflection.name == object._name && j.parent == parent &&
                 (object.polymorphic? ? j.reflection.klass == object._klass : true)
               }
             else
@@ -73,12 +79,6 @@ module Squeel
         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

@@ -1,17 +1,22 @@
-require 'polyamorous'
-
 module Squeel
   module Adapters
     module ActiveRecord
-      module JoinDependencyExtensions
+      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
 
+      module JoinDependencyExtensions
         def self.included(base)
           base.class_eval do
             alias_method_chain :build, :squeel
           end
         end
 
-        def build_with_squeel(associations, parent = nil, join_type = Arel::InnerJoin)
+        def build_with_squeel(associations, parent = nil, join_type = InnerJoin)
           case associations
           when Nodes::Stub
             associations = associations.symbol
@@ -29,15 +34,6 @@ module Squeel
             build_without_squeel(associations, parent, join_type)
           end
         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

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

@@ -45,7 +45,6 @@ module Squeel
               merge_resolving_duplicate_squeel_equalities(r)
             end
           else
-            puts r.inspect if r.is_a?(Proc)
             super(r)
           end
         end
@@ -115,6 +114,8 @@ module Squeel
               :stashed_join
             when Arel::Nodes::Join
               :join_node
+            when Nodes::SubqueryJoin
+              :subquery_join
             else
               raise 'unknown class: %s' % join.class.name
             end
@@ -123,6 +124,7 @@ module Squeel
           association_joins         = buckets[:association_join] || []
           stashed_association_joins = buckets[:stashed_join] || []
           join_nodes                = (buckets[:join_node] || []).uniq
+          subquery_joins            = (buckets[:subquery_join] || []).uniq
           string_joins              = (buckets[:string_join] || []).map { |x|
             x.strip
           }.uniq
@@ -144,11 +146,12 @@ module Squeel
             association.join_to(manager)
           end
 
-          manager.join_sources.concat join_list
+          manager.join_sources.concat(join_list)
+          manager.join_sources.concat(build_join_from_subquery(subquery_joins))
 
           manager
         end
-        # For 4.x adapters
+        # For 4.0 adapters
         alias :build_joins :build_join_dependency
 
         def includes(*args)
@@ -279,12 +282,12 @@ module Squeel
           end
         end
 
-        def find_equality_predicates(nodes)
+        def find_equality_predicates(nodes, relation_table_name = table_name)
           nodes.map { |node|
             case node
             when Arel::Nodes::Equality
               if node.left.respond_to?(:relation) &&
-                node.left.relation.name == table_name
+                node.left.relation.name == relation_table_name
                 node
               end
             when Arel::Nodes::Grouping
@@ -395,9 +398,8 @@ module Squeel
         # 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))
-
+        def where_values_hash_with_squeel(relation_table_name = table_name)
+          equalities = find_equality_predicates(where_visit(with_default_scope.where_values), relation_table_name)
           binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
 
           Hash[equalities.map { |where|
@@ -406,6 +408,34 @@ module Squeel
           }]
         end
 
+        def build_join_from_subquery(subquery_joins)
+          subquery_joins.map do |join|
+            join.type.new(
+              Arel::Nodes::TableAlias.new(
+                Arel::Nodes::Grouping.new(join.subquery.left.arel.ast),
+                join.subquery.right),
+              Arel::Nodes::On.new(where_visit(join.constraints))
+            )
+          end
+        end
+
+        def preprocess_attrs_with_ar(attributes)
+          attributes.map do |key, value|
+            case key
+              when Squeel::Nodes::Node
+                {key => value}
+              when Symbol
+                if value.is_a?(Hash)
+                  {key => value}
+                else
+                  ::ActiveRecord::PredicateBuilder.build_from_hash(klass, {key => value}, table)
+                end
+              else
+                ::ActiveRecord::PredicateBuilder.build_from_hash(klass, {key => value}, table)
+              end
+          end
+        end
+
       end
     end
   end

data/lib/squeel/core_ext/symbol.rb

@@ -15,15 +15,15 @@ class Symbol
   end
 
   def inner
-    Squeel::Nodes::Join.new(self, Arel::InnerJoin)
+    Squeel::Nodes::Join.new(self, Squeel::InnerJoin)
   end
 
   def outer
-    Squeel::Nodes::Join.new(self, Arel::OuterJoin)
+    Squeel::Nodes::Join.new(self, Squeel::OuterJoin)
   end
 
   def of_class(klass)
-    Squeel::Nodes::Join.new(self, Arel::InnerJoin, klass)
+    Squeel::Nodes::Join.new(self, Squeel::InnerJoin, klass)
   end
 
 end

data/lib/squeel/dsl.rb

@@ -110,7 +110,7 @@ module Squeel
       if args.empty?
         Nodes::Stub.new method_id
       elsif (args.size == 1) && (Class === args[0])
-        Nodes::Join.new(method_id, Arel::InnerJoin, args[0])
+        Nodes::Join.new(method_id, InnerJoin, args[0])
       else
         Nodes::Function.new method_id, args
       end

data/lib/squeel/nodes.rb

@@ -27,3 +27,4 @@ require 'squeel/nodes/as'
 require 'squeel/nodes/not'
 require 'squeel/nodes/join'
 require 'squeel/nodes/grouping'
+require 'squeel/nodes/subquery_join'

data/lib/squeel/nodes/as.rb

@@ -12,6 +12,18 @@ module Squeel
       def initialize(left, right)
         @left, @right = left, right
       end
+
+      def on(*args)
+        raise "only can convert ActiveRecord::Relation to a join node" unless left.is_a?(ActiveRecord::Relation)
+        proc =
+          if block_given?
+            DSL.eval(&Proc.new)
+          else
+            args
+          end
+
+        SubqueryJoin.new(self, proc)
+      end
     end
   end
 end

data/lib/squeel/nodes/join.rb

@@ -14,21 +14,21 @@ module Squeel
       # @param [Symbol] name The association name
       # @param [Arel::InnerJoin, Arel::OuterJoin] type The Arel join class
       # @param [Class, String, Symbol] klass The polymorphic belongs_to class or class name
-      def initialize(name, type = Arel::InnerJoin, klass = nil)
+      def initialize(name, type = InnerJoin, klass = nil)
         @_join = Polyamorous::Join.new(name, type, klass)
       end
 
       # Set the join type to an inner join
       # @return [Join] The join, with an updated join type.
       def inner
-        self._type = Arel::InnerJoin
+        self._type = InnerJoin
         self
       end
 
       # Set the join type to an outer join
       # @return [Join] The join, with an updated join type.
       def outer
-        self._type = Arel::OuterJoin
+        self._type = OuterJoin
         self
       end
 
@@ -61,7 +61,7 @@ module Squeel
       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])])
+          KeyPath.new([self, Join.new(method_id, InnerJoin, args[0])])
         else
           KeyPath.new([self, method_id])
         end
@@ -83,6 +83,10 @@ module Squeel
         nil
       end
 
+      def add_to_tree(hash)
+        hash[_join] ||= {}
+      end
+
     end
   end
 end

data/lib/squeel/nodes/key_path.rb

@@ -177,6 +177,10 @@ module Squeel
       end
       alias :to_str :to_s
 
+      def add_to_tree(hash)
+        walk_through_path(path.dup, hash)
+      end
+
       # Appends to the KeyPath or delegates to the endpoint, as appropriate
       # @return [KeyPath] The updated KeyPath
       def method_missing(method_id, *args, &block)
@@ -194,7 +198,7 @@ module Squeel
           if args.empty?
             @path << Stub.new(method_id)
           elsif (args.size == 1) && (Class === args[0])
-            @path << Join.new(method_id, Arel::InnerJoin, args[0])
+            @path << Join.new(method_id, InnerJoin, args[0])
           else
             @path << Nodes::Function.new(method_id, args)
           end
@@ -213,6 +217,11 @@ module Squeel
         @path = @path.dup
       end
 
+      def walk_through_path(path, hash)
+        cache = path.shift.add_to_tree(hash)
+        path.empty? ? cache : walk_through_path(path, cache)
+      end
+
       # Raises a NoMethodError manually, bypassing #method_missing.
       # Used by special-case operator overrides.
       def no_method_error(method_id)

data/lib/squeel/nodes/node.rb

@@ -1,6 +1,27 @@
+require 'polyamorous/tree_node'
+
 module Squeel
   module Nodes
     class Node
+      include ::Polyamorous::TreeNode
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        Visitors::EnumerationVisitor.new(block).accept(self)
+      end
+
+      # We don't want the full Enumerable method list, because it will mess
+      # with stuff like KeyPath
+      def grep(object, &block)
+        if block_given?
+          each { |value| yield value if object === value }
+        else
+          [].tap do |results|
+            each { |value| results << value if object === value }
+          end
+        end
+      end
     end
   end
 end

data/lib/squeel/nodes/stub.rb

@@ -79,7 +79,7 @@ module Squeel
         if args.empty?
           KeyPath.new([self, method_id])
         elsif (args.size == 1) && (Class === args[0])
-          KeyPath.new([self, Join.new(method_id, Arel::InnerJoin, args[0])])
+          KeyPath.new([self, Join.new(method_id, InnerJoin, args[0])])
         else
           KeyPath.new([self, Nodes::Function.new(method_id, args)])
         end
@@ -102,7 +102,7 @@ module Squeel
       # Create an inner Join node for the association named by this Stub
       # @return [Join] The new inner Join node
       def inner
-        Join.new(self.symbol, Arel::InnerJoin)
+        Join.new(self.symbol, InnerJoin)
       end
 
       # Create a keypath with a sifter as its endpoint
@@ -114,14 +114,18 @@ module Squeel
       # Create an outer Join node for the association named by this Stub
       # @return [Join] The new outer Join node
       def outer
-        Join.new(self.symbol, Arel::OuterJoin)
+        Join.new(self.symbol, OuterJoin)
       end
 
       # Create a polymorphic Join node for the association named by this Stub,
       # @param [Class] klass The polymorphic belongs_to class for this Join
       # @return [Join] The new polymorphic Join node
       def of_class(klass)
-        Join.new(self.symbol, Arel::InnerJoin, klass)
+        Join.new(self.symbol, InnerJoin, klass)
+      end
+
+      def add_to_tree(hash)
+        hash[symbol] ||= {}
       end
 
     end

data/lib/squeel/nodes/subquery_join.rb

@@ -0,0 +1,44 @@
+module Squeel
+  module Nodes
+    class SubqueryJoin < Node
+      attr_accessor :subquery, :type, :constraints
+
+      def initialize(subquery, constraints, type = Squeel::InnerJoin)
+        raise ArgumentError,
+          "subquery(#{subquery}) isn't an Squeel::Nodes::As" unless subquery.is_a?(As)
+
+        raise ArgumentError,
+          "constraints(#{constraints}) isn't a Squeel::Nodes::Node" unless constraints.is_a?(Node)
+
+        self.subquery = subquery
+        self.constraints = constraints
+        self.type = type
+      end
+
+      # Implemented for equality testing
+      def hash
+        [subquery, type, constraints].hash
+      end
+
+      def inner
+        self.type = Squeel::InnerJoin
+        self
+      end
+
+      def outer
+        self.type = Squeel::OuterJoin
+        self
+      end
+
+      # Compare with other objects
+      def eql?(other)
+        self.class.eql?(other.class) &&
+        self.subquery.eql?(other.subquery) &&
+        self.type.eql?(other.type) &&
+        self.constraints.eql?(other.constraints)
+      end
+      alias :== :eql?
+
+    end
+  end
+end

data/lib/squeel/version.rb

@@ -1,3 +1,3 @@
 module Squeel
-  VERSION = '1.1.1'
+  VERSION = '1.2.1'
 end

data/lib/squeel/visitors.rb

@@ -8,3 +8,5 @@ require 'squeel/visitors/order_visitor'
 require 'squeel/visitors/select_visitor'
 require 'squeel/visitors/from_visitor'
 require 'squeel/visitors/preload_visitor'
+
+require 'squeel/visitors/enumeration_visitor'

data/lib/squeel/visitors/enumeration_visitor.rb

@@ -0,0 +1,101 @@
+require 'active_support/core_ext/module'
+require 'squeel/nodes'
+
+module Squeel
+  module Visitors
+    # The Enumeration visitor class, used to implement Node#each
+    class EnumerationVisitor
+
+      # Create a new EnumerationVisitor.
+      #
+      # @param [Proc] block The block to execute against each node.
+      def initialize(block = Proc.new)
+        @block = block
+      end
+
+      # Accept an object.
+      #
+      # @param object The object to visit
+      # @return The results of the node visitation, which will be the last
+      #   call to the @block
+      def accept(object)
+        visit(object)
+      end
+
+      private
+      # A hash that caches the method name to use for a visitor for a given
+      # class
+      DISPATCH = Hash.new do |hash, klass|
+        hash[klass] = "visit_#{(klass.name || '').gsub('::', '_')}"
+      end
+
+      # Visit the object.
+      #
+      # @param object The object to visit
+      def visit(object)
+        send(DISPATCH[object.class], object)
+        @block.call(object)
+      rescue NoMethodError => e
+        raise e if respond_to?(DISPATCH[object.class], true)
+
+        superklass = object.class.ancestors.find { |klass|
+          respond_to?(DISPATCH[klass], true)
+        }
+        raise(TypeError, "Cannot visit #{object.class}") unless superklass
+        DISPATCH[object.class] = DISPATCH[superklass]
+        retry
+      end
+
+      def visit_terminal(o)
+      end
+      alias :visit_Object :visit_terminal
+
+      def visit_Array(o)
+        o.map { |v| visit(v) }
+      end
+
+      def visit_Hash(o)
+        o.each { |k, v| visit(k); visit(v) }
+      end
+
+      def visit_Squeel_Nodes_Nary(o)
+        visit(o.children)
+      end
+
+      def visit_Squeel_Nodes_Binary(o)
+        visit(o.left)
+        visit(o.right)
+      end
+
+      def visit_Squeel_Nodes_Unary(o)
+        visit(o.expr)
+      end
+
+      def visit_Squeel_Nodes_Order(o)
+        visit(o.expr)
+      end
+
+      def visit_Squeel_Nodes_Function(o)
+        visit(o.args)
+      end
+
+      def visit_Squeel_Nodes_Predicate(o)
+        visit(o.expr)
+        visit(o.value)
+      end
+
+      def visit_Squeel_Nodes_KeyPath(o)
+        visit(o.path)
+      end
+
+      def visit_Squeel_Nodes_Join(o)
+        visit(o._join)
+      end
+
+      def visit_Squeel_Nodes_Literal(o)
+        visit(o.expr)
+      end
+
+    end
+  end
+end