squeel 1.0.9 → 1.0.11

data/lib/squeel/visitors/{symbol_visitor.rb → preload_visitor.rb}

@@ -1,10 +1,10 @@
-require 'squeel/visitors/visitor'
-
 module Squeel
   module Visitors
-    class SymbolVisitor < Visitor
+    class PreloadVisitor < Visitor
 
-      def initialize
+      def initialize(_ = nil)
+        # Unused. Just here to provide consistency in method signature
+        # among subclasses of Visitor
       end
 
       def accept(object, parent = nil)

data/lib/squeel/visitors/select_visitor.rb

@@ -0,0 +1,7 @@
+module Squeel
+  module Visitors
+    class SelectVisitor < Visitor
+      include PredicateVisitation
+    end
+  end
+end

data/lib/squeel/visitors/visitor.rb

@@ -61,14 +61,53 @@ module Squeel
         @hash_context_depth > 0
       end
 
+      # @return [Boolean] Whether the given value implies a context change
+      # @param v The value to consider
+      def implies_hash_context_shift?(v)
+        can_visit?(v)
+      end
+
+      # Change context (by setting the new parent to the result of a #find or
+      # #traverse on the key), then accept the given value.
+      #
+      # @param k The hash key
+      # @param v The hash value
+      # @param parent The current parent object in the context
+      # @return The visited value
+      def visit_with_hash_context_shift(k, v, parent)
+        @hash_context_depth += 1
+
+        parent = case k
+          when Nodes::KeyPath
+            traverse(k, parent, true)
+          else
+            find(k, parent)
+          end
+
+        can_visit?(v) ? visit(v, parent || k) : v
+      ensure
+        @hash_context_depth -= 1
+      end
+
+      # If there is no context change, the default behavior is to return the
+      # value unchanged. Subclasses will alter this behavior as needed.
+      #
+      # @param k The hash key
+      # @param v The hash value
+      # @param parent The current parent object in the context
+      # @return The same value we just received.
+      def visit_without_hash_context_shift(k, v, parent)
+        v
+      end
+
       # Important to avoid accidentally allowing the default ARel visitor's
       # last_column quoting behavior (where a value is quoted as though it
       # is of the type of the last visited column). This can wreak havoc with
       # Functions and Operations.
       #
       # @param object The object to check
-      # @return [Boolean] Whether or not the ARel visitor will try to quote the object if
-      #   not passed as an SqlLiteral.
+      # @return [Boolean] Whether or not the ARel visitor will try to quote the
+      #   object if not passed as an SqlLiteral.
       def quoted?(object)
         case object
         when Arel::Nodes::SqlLiteral, Bignum, Fixnum, Arel::SelectManager
@@ -117,16 +156,6 @@ module Squeel
         retry
       end
 
-      # Visit an array, which involves accepting any values we know how to
-      # accept, and skipping the rest.
-      #
-      # @param [Array] o The Array to visit
-      # @param parent The current parent object in the context
-      # @return [Array] The visited array
-      def visit_Array(o, parent)
-        o.map { |v| can_visit?(v) ? visit(v, parent) : v }.flatten
-      end
-
       # Pass an object through the visitor unmodified. This is
       # in order to allow objects that don't require modification
       # to be handled by ARel directly.
@@ -139,6 +168,209 @@ module Squeel
       end
       alias :visit_Fixnum :visit_passthrough
       alias :visit_Bignum :visit_passthrough
+      alias :visit_String :visit_passthrough
+
+      # Visit an array, which involves accepting any values we know how to
+      # accept, and skipping the rest.
+      #
+      # @param [Array] o The Array to visit
+      # @param parent The current parent object in the context
+      # @return [Array] The visited array
+      def visit_Array(o, parent)
+        o.map { |v| can_visit?(v) ? visit(v, parent) : v }.flatten
+      end
+
+      # Visit a Hash. This entails iterating through each key and value and
+      # visiting each value in turn.
+      #
+      # @param [Hash] o The Hash to visit
+      # @param parent The current parent object in the context
+      # @return [Array] An array of values for use in an ordering, grouping, etc.
+      def visit_Hash(o, parent)
+        o.map do |k, v|
+          if implies_hash_context_shift?(v)
+            visit_with_hash_context_shift(k, v, parent)
+          else
+            visit_without_hash_context_shift(k, v, parent)
+          end
+        end.flatten
+      end
+
+      # Visit a symbol. This will return an attribute named after the symbol
+      # against the current parent's contextualized table.
+      #
+      # @param [Symbol] o The symbol to visit
+      # @param parent The symbol's parent within the context
+      # @return [Arel::Attribute] An attribute on the contextualized parent
+      #   table
+      def visit_Symbol(o, parent)
+        contextualize(parent)[o]
+      end
+
+      # Visit a stub. This will return an attribute named after the stub against
+      # the current parent's contextualized table.
+      #
+      # @param [Nodes::Stub] o The stub to visit
+      # @param parent The stub's parent within the context
+      # @return [Arel::Attribute] An attribute on the contextualized parent
+      #   table
+      def visit_Squeel_Nodes_Stub(o, parent)
+        contextualize(parent)[o.to_s]
+      end
+
+      # Visit a keypath. This will traverse the keypath's "path", setting a new
+      # parent as though the keypath's endpoint was in a deeply-nested hash,
+      # then visit the endpoint with the new parent.
+      #
+      # @param [Nodes::KeyPath] o The keypath to visit
+      # @param parent The keypath's parent within the context
+      # @return The visited endpoint, with the parent from the KeyPath's path.
+      def visit_Squeel_Nodes_KeyPath(o, parent)
+        parent = traverse(o, parent)
+
+        visit(o.endpoint, parent)
+      end
+
+      # Visit a Literal by converting it to an ARel SqlLiteral
+      #
+      # @param [Nodes::Literal] o The Literal to visit
+      # @param parent The parent object in the context (unused)
+      # @return [Arel::Nodes::SqlLiteral] An SqlLiteral
+      def visit_Squeel_Nodes_Literal(o, parent)
+        Arel.sql(o.expr)
+      end
+
+      # Visit a Squeel As node, resulting in am ARel As node.
+      #
+      # @param [Nodes::As] The As node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::As] The resulting as node.
+      def visit_Squeel_Nodes_As(o, parent)
+        left = visit(o.left, parent)
+        # Some nodes, like Arel::SelectManager, have their own #as methods,
+        # with behavior that we don't want to clobber.
+        if left.respond_to?(:as)
+          left.as(o.right)
+        else
+          Arel::Nodes::As.new(left, o.right)
+        end
+      end
+
+      # Visit a Squeel And node, returning an ARel Grouping containing an
+      # ARel And node.
+      #
+      # @param [Nodes::And] o The And node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::Grouping] A grouping node, containnig an ARel
+      #   And node as its expression. All children will be visited before
+      #   being passed to the And.
+      def visit_Squeel_Nodes_And(o, parent)
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(visit(o.children, parent)))
+      end
+
+      # Visit a Squeel Or node, returning an ARel Or node.
+      #
+      # @param [Nodes::Or] o The Or node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::Or] An ARel Or node, with left and right sides visited
+      def visit_Squeel_Nodes_Or(o, parent)
+        Arel::Nodes::Grouping.new(Arel::Nodes::Or.new(visit(o.left, parent), (visit(o.right, parent))))
+      end
+
+      # Visit a Squeel Not node, returning an ARel Not node.
+      #
+      # @param [Nodes::Not] o The Not node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::Not] An ARel Not node, with expression visited
+      def visit_Squeel_Nodes_Not(o, parent)
+        Arel::Nodes::Not.new(visit(o.expr, parent))
+      end
+
+      # Visit a Squeel Grouping node, returning an ARel Grouping node.
+      #
+      # @param [Nodes::Grouping] o The Grouping node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::Grouping] An ARel Grouping node, with expression visited
+      def visit_Squeel_Nodes_Grouping(o, parent)
+        Arel::Nodes::Grouping.new(visit(o.expr, parent))
+      end
+      #
+      # Visit a Squeel function, returning an ARel NamedFunction node.
+      #
+      # @param [Nodes::Function] o The function node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::NamedFunction] A named function node. Function
+      #   arguments are visited, if necessary, before being passed to the NamedFunction.
+      def visit_Squeel_Nodes_Function(o, parent)
+        args = o.args.map do |arg|
+          case arg
+          when Nodes::Function, Nodes::As, Nodes::Literal, Nodes::Grouping, Nodes::KeyPath, Nodes::KeyPath
+            visit(arg, parent)
+          when ActiveRecord::Relation
+            arg.arel.ast
+          when Symbol, Nodes::Stub
+            Arel.sql(arel_visitor.accept contextualize(parent)[arg.to_s])
+          else
+            quote arg
+          end
+        end
+
+        Arel::Nodes::NamedFunction.new(o.name, args)
+      end
+
+      # Visit a Squeel operation node, convering it to an ARel InfixOperation
+      # (or subclass, as appropriate)
+      #
+      # @param [Nodes::Operation] o The Operation node to visit
+      # @param parent The parent object in the context
+      # @return [Arel::Nodes::InfixOperation] The InfixOperation (or Addition,
+      #   Multiplication, etc) node, with both operands visited, if needed.
+      def visit_Squeel_Nodes_Operation(o, parent)
+        args = o.args.map do |arg|
+          case arg
+          when Nodes::Function, Nodes::As, Nodes::Literal, Nodes::Grouping, Nodes::KeyPath
+            visit(arg, parent)
+          when Symbol, Nodes::Stub
+            Arel.sql(arel_visitor.accept contextualize(parent)[arg.to_s])
+          else
+            quote arg
+          end
+        end
+
+        op = case o.operator
+        when :+
+          Arel::Nodes::Addition.new(args[0], args[1])
+        when :-
+          Arel::Nodes::Subtraction.new(args[0], args[1])
+        when :*
+          Arel::Nodes::Multiplication.new(args[0], args[1])
+        when :/
+          Arel::Nodes::Division.new(args[0], args[1])
+        else
+          Arel::Nodes::InfixOperation.new(o.operator, args[0], args[1])
+        end
+
+        op
+      end
+
+      # Visit an ActiveRecord Relation, returning an Arel::SelectManager
+      # @param [ActiveRecord::Relation] o The Relation to visit
+      # @param parent The parent object in the context
+      # @return [Arel::SelectManager] The ARel select manager that represents
+      #   the relation's query
+      def visit_ActiveRecord_Relation(o, parent)
+        o.arel
+      end
+
+      # Visit ActiveRecord::Base objects. These should be converted to their
+      # id before being used in a comparison.
+      #
+      # @param [ActiveRecord::Base] o The AR::Base object to visit
+      # @param parent The current parent object in the context
+      # @return [Fixnum] The id of the object
+      def visit_ActiveRecord_Base(o, parent)
+        o.id
+      end
 
     end
   end

data/lib/squeel/visitors/where_visitor.rb

@@ -0,0 +1,8 @@
+require 'squeel/visitors/predicate_visitor'
+
+module Squeel
+  module Visitors
+    class WhereVisitor < PredicateVisitor
+    end
+  end
+end

data/spec/helpers/squeel_helper.rb

@@ -22,4 +22,17 @@ module SqueelHelper
       ActiveRecord::Associations::ClassMethods::JoinDependency.new(*args)
     end
   end
-end
+
+  def activerecord_version_at_least(version_string)
+    required_version_parts = version_string.split('.', 3).map(&:to_i)
+    (0..2).each do |index|
+      required_version_parts[index] ||= 0
+    end
+    actual_version_parts = [
+      ActiveRecord::VERSION::MAJOR,
+      ActiveRecord::VERSION::MINOR,
+      ActiveRecord::VERSION::TINY
+    ]
+    (actual_version_parts <=> required_version_parts) >= 0
+  end
+end

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

@@ -5,46 +5,6 @@ module Squeel
     module ActiveRecord
       describe RelationExtensions do
 
-        describe '#predicate_visitor' do
-
-          it 'creates a predicate visitor with a Context for the relation' do
-            relation = Person.joins({
-              :children => {
-                :children => {
-                  :parent => :parent
-                }
-              }
-            })
-
-            visitor = relation.predicate_visitor
-
-            visitor.should be_a Visitors::PredicateVisitor
-            table = visitor.contextualize(relation.join_dependency._join_parts.last)
-            table.table_alias.should eq 'parents_people_2'
-          end
-
-        end
-
-        describe '#attribute_visitor' do
-
-          it 'creates an attribute visitor with a Context for the relation' do
-            relation = Person.joins({
-              :children => {
-                :children => {
-                  :parent => :parent
-                }
-              }
-            })
-
-            visitor = relation.attribute_visitor
-
-            visitor.should be_a Visitors::AttributeVisitor
-            table = visitor.contextualize(relation.join_dependency._join_parts.last)
-            table.table_alias.should eq 'parents_people_2'
-          end
-
-        end
-
         describe 'finding by attribute' do
 
           it 'returns nil when passed an empty string' do
@@ -452,11 +412,13 @@ module Squeel
           end
 
           it 'works with non-strings in group' do
-            pending "Requires some big hacks to execute_grouped_calculation"
-            counts = Person.group{name.op('||', '-diddly')}.count
-            counts.should eq Person.group{name.op('||', '-diddly')}.count
+            if activerecord_version_at_least '3.2.7'
+              counts = Person.group{name.op('||', '-diddly')}.count
+              counts.should eq Person.group("name || '-diddly'").count
+            else
+              pending 'Unsupported in ActiveRecord < 3.2.7'
+            end
           end
-
         end
 
         describe '#group' do
@@ -628,6 +590,16 @@ module Squeel
 
         end
 
+        describe '#from' do
+          it 'creates froms with a block' do
+            expected = /SELECT "sub"."name" AS aliased_name FROM \(SELECT "people"."name" FROM "people"\s*\) sub/
+            block = Person.from{Person.select{name}.as('sub')}.
+              select{sub.name.as('aliased_name')}
+            sql = block.to_sql
+            sql.should match expected
+          end
+        end
+
         describe '#build_where' do
 
           it 'sanitizes SQL as usual with strings' do
@@ -672,6 +644,24 @@ module Squeel
             @person.name.should eq 'bob'
           end
 
+          it 'creates new records with equality predicates from has_many associations' do
+            if activerecord_version_at_least '3.1.0'
+              person = Person.first
+              article = person.articles_with_condition.new
+              article.person.should eq person
+              article.title.should eq 'Condition'
+            else
+              pending 'Unsupported on ActiveRecord < 3.1'
+            end
+          end
+
+          it 'creates new records with equality predicates from has_many :through associations' do
+            pending "When ActiveRecord supports this, we'll want to, too"
+            person = Person.first
+            comment = person.article_comments_with_first_post.new
+            comment.body.should eq 'first post'
+          end
+
           it "maintains activerecord default scope functionality" do
             PersonNamedBill.new.name.should eq 'Bill'
           end
@@ -740,12 +730,24 @@ module Squeel
             sql.should match /Bert/
           end
 
-          it 'uses the given equality condition in the case of a conflicting where from a default scope in AR >= 3.1' do
-            relation = PersonNamedBill.where{name == 'Ernie'}
+          it 'uses the given equality condition in the case of a conflicting where from a default scope' do
+            if activerecord_version_at_least '3.1'
+              relation = PersonNamedBill.where{name == 'Ernie'}
+              sql = relation.to_sql
+              sql.should_not match /Bill/
+              sql.should match /Ernie/
+            else
+              pending 'Unsupported in ActiveRecord < 3.1'
+            end
+          end
+
+          it 'allows scopes to join/query a table through two different associations and uses the correct alias' do
+            relation = Person.with_article_title('hi').
+                              with_article_condition_title('yo')
             sql = relation.to_sql
-            sql.should_not match /Bill/
-            sql.should match /Ernie/
-          end unless ::ActiveRecord::VERSION::MINOR == 0
+            sql.should match /"articles"."title" = 'hi'/
+            sql.should match /"articles_with_conditions_people"."title" = 'yo'/
+          end
 
           it "doesn't ruin everything when a scope returns nil" do
             relation = Person.nil_scope
@@ -770,6 +772,20 @@ module Squeel
             sql.scan(/"people"."id"/).should have(1).item
           end
 
+          it 'merges scopes that contain functions' do
+            relation = PersonNamedBill.scoped.with_salary_equal_to(100)
+            sql = relation.to_sql
+            sql.should match /abs\("people"."salary"\) = 100/
+          end
+
+          it 'uses last equality when merging two scopes with identical function equalities' do
+            relation = PersonNamedBill.scoped.with_salary_equal_to(100).
+                                              with_salary_equal_to(200)
+            sql = relation.to_sql
+            sql.should_not match /abs\("people"."salary"\) = 100/
+            sql.should match /abs\("people"."salary"\) = 200/
+          end
+
         end
 
         describe '#to_a' do