squeel 0.5.5 → 0.6.0

data/lib/squeel/visitors/base.rb

@@ -3,32 +3,61 @@ require 'squeel/nodes'
 
 module Squeel
   module Visitors
+    # The Base visitor class, containing the default behavior common to subclasses.
     class Base
       attr_accessor :context
-      delegate :contextualize, :find, :traverse, :sanitize_sql, :engine, :arel_visitor, :to => :context
+      delegate :contextualize, :find, :traverse, :engine, :arel_visitor, :to => :context
 
+      # Create a new Visitor that uses the supplied context object to contextualize
+      # visited nodes.
+      #
+      # @param [Context] context The context to use for node visitation.
       def initialize(context = nil)
         @context = context
       end
 
+      # Accept an object.
+      #
+      # @param object The object to visit
+      # @param parent The parent of this object, to track the object's place in
+      #   any association hierarchy.
+      # @return The results of the node visitation, typically an ARel object of some kind.
       def accept(object, parent = context.base)
         visit(object, parent)
       end
 
+      # @param object The object to check
+      # @return [Boolean] Whether or not the visitor can accept the given object
       def can_accept?(object)
-        respond_to? DISPATCH[object.class]
+        self.class.can_accept? object
       end
 
+      # @param object The object to check
+      # @return [Boolean] Whether or not visitors of this class can accept the given object
       def self.can_accept?(object)
-        method_defined? DISPATCH[object.class]
+        @can_accept ||= Hash.new do |hash, klass|
+          hash[klass] = klass.ancestors.detect { |ancestor|
+            private_method_defined? DISPATCH[ancestor]
+          } ? true : false
+        end
+        @can_accept[object.class]
       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('::', '_')}"
+        hash[klass] = "visit_#{(klass.name || '').gsub('::', '_')}"
       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.
       def quoted?(object)
         case object
         when Arel::Nodes::SqlLiteral, Bignum, Fixnum
@@ -38,9 +67,46 @@ module Squeel
         end
       end
 
+      # Quote a value based on its type, not on the last column used by the
+      # ARel visitor. This is occasionally necessary to avoid having ARel
+      # quote a value according to an integer column, converting 'My String' to 0.
+      #
+      # @param value The value to quote
+      # @return [Arel::Nodes::SqlLiteral] if the value needs to be pre-quoted
+      # @return the unquoted value, if default quoting won't hurt.
+      def quote(value)
+        if quoted? value
+          case value
+          when Array
+            value.map {|v| quote(v)}
+          when Range
+            Range.new(quote(value.begin), quote(value.end), value.exclude_end?)
+          else
+            Arel.sql(arel_visitor.accept value)
+          end
+        else
+          value
+        end
+      end
+
+      # Visit the object. This is not called directly, but instead via the public
+      # #accept method.
+      #
+      # @param object The object to visit
+      # @param parent The object's parent within the context
       def visit(object, parent)
         send(DISPATCH[object.class], object, parent)
+      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
+
     end
   end
 end

data/lib/squeel/visitors/predicate_visitor.rb

@@ -4,6 +4,8 @@ module Squeel
   module Visitors
     class PredicateVisitor < Base
 
+      private
+
       def visit_Hash(o, parent)
         predicates = o.map do |k, v|
           if implies_context_change?(v)
@@ -26,6 +28,10 @@ module Squeel
         o.map { |v| can_accept?(v) ? accept(v, parent) : v }.flatten
       end
 
+      def visit_ActiveRecord_Base(o, parent)
+        o.id
+      end
+
       def visit_Squeel_Nodes_KeyPath(o, parent)
         parent = traverse(o, parent)
 
@@ -43,8 +49,12 @@ module Squeel
         else
           value = accept(value, parent) if can_accept?(value)
         end
-        if Nodes::Function === o.expr
+
+        case o.expr
+        when Nodes::Stub
           accept(o.expr, parent).send(o.method_name, value)
+        when Nodes::Function
+          accept(o.expr, parent).send(o.method_name, quote(value))
         else
           contextualize(parent)[o.expr].send(o.method_name, value)
         end
@@ -60,7 +70,7 @@ module Squeel
           when Symbol, Nodes::Stub
             Arel.sql(arel_visitor.accept contextualize(parent)[arg.to_sym])
           else
-            quoted?(arg) ? Arel.sql(arel_visitor.accept arg) : arg
+            quote arg
           end
         end
         Arel::Nodes::NamedFunction.new(o.name, args, o.alias)
@@ -80,7 +90,7 @@ module Squeel
           when Symbol, Nodes::Stub
             Arel.sql(arel_visitor.accept contextualize(parent)[arg.to_sym])
           else
-            quoted?(arg) ? Arel.sql(arel_visitor.accept arg) : arg
+            quote arg
           end
         end
 
@@ -117,8 +127,6 @@ module Squeel
           true
         when Nodes::KeyPath
           can_accept?(v.endpoint) && !(Nodes::Stub === v.endpoint)
-        when Array
-          (!v.empty? && v.all? {|val| can_accept?(val)})
         else
           false
         end
@@ -156,11 +164,11 @@ module Squeel
 
         case k
         when Nodes::Predicate
-          accept(k % v, parent)
+          accept(k % quote_for_node(k.expr, v), parent)
         when Nodes::Function
-          arel_predicate_for(accept(k, parent), v, parent)
+          arel_predicate_for(accept(k, parent), quote(v), parent)
         when Nodes::KeyPath
-          accept(k % v, parent)
+          accept(k % quote_for_node(k.endpoint, v), parent)
         else
           attribute = contextualize(parent)[k.to_sym]
           arel_predicate_for(attribute, v, parent)
@@ -168,14 +176,25 @@ module Squeel
       end
 
       def arel_predicate_for(attribute, value, parent)
+        value = can_accept?(value) ? accept(value, parent) : value
         if [Array, Range, Arel::SelectManager].include?(value.class)
           attribute.in(value)
         else
-          value = can_accept?(value) ? accept(value, parent) : value
           attribute.eq(value)
         end
       end
 
+      def quote_for_node(node, v)
+        case node
+        when Nodes::Function
+          quote(v)
+        when Nodes::Predicate
+          Nodes::Function === node.expr ? quote(v) : v
+        else
+          v
+        end
+      end
+
     end
   end
 end

data/lib/squeel/visitors/symbol_visitor.rb

@@ -40,7 +40,7 @@ module Squeel
       end
 
       def visit_Squeel_Nodes_Join(o, parent)
-        o.name
+        o._name
       end
 
     end

data/spec/core_ext/symbol_spec.rb

@@ -56,13 +56,13 @@ describe Symbol do
   it 'creates inner joins' do
     join = :join.inner
     join.should be_a Squeel::Nodes::Join
-    join.type.should eq Arel::InnerJoin
+    join._type.should eq Arel::InnerJoin
   end
 
   it 'creates outer joins' do
     join = :join.outer
     join.should be_a Squeel::Nodes::Join
-    join.type.should eq Arel::OuterJoin
+    join._type.should eq Arel::OuterJoin
   end
 
 end

data/spec/spec_helper.rb

@@ -40,7 +40,12 @@ Sham.define do
 end
 
 RSpec.configure do |config|
-  config.before(:suite) { Schema.create }
+  config.before(:suite) do
+    puts '=' * 80
+    puts "Running specs against ActiveRecord #{ActiveRecord::VERSION::STRING} and ARel #{Arel::VERSION}..."
+    puts '=' * 80
+    Schema.create
+  end
   config.before(:all)   { Sham.reset(:before_all) }
   config.before(:each)  { Sham.reset(:before_each) }
 

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

@@ -15,13 +15,6 @@ module Squeel
           @c = Context.new(@jd)
         end
 
-        it 'finds associations' do
-          last_association = @jd.join_parts.last
-          next_to_last_association = @jd.join_parts[-2]
-
-          @c.find(:parent, next_to_last_association).should eq last_association
-        end
-
         it 'contextualizes join parts with the proper alias' do
           table = @c.contextualize @jd.join_parts.last
           table.table_alias.should eq 'parents_people_2'

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

@@ -189,6 +189,33 @@ module Squeel
 
         end
 
+        describe '#to_sql' do
+          it 'casts a non-acceptable value for a Function key properly in a hash' do
+            relation = Person.joins(:children).where(:children => {:coalesce.func(:name, 'Mr. No-name') => 'Ernie'})
+            relation.to_sql.should match /'Ernie'/
+          end
+
+          it 'casts a non-acceptable value for a Predicate containing a Function expr properly' do
+            relation = Person.joins(:children).where(:children => {:coalesce.func(:name, 'Mr. No-name').eq => 'Ernie'})
+            relation.to_sql.should match /'Ernie'/
+          end
+
+          it 'casts a non-acceptable value for a KeyPath with a Function endpoint properly' do
+            relation = Person.joins(:children).where{{children.coalesce(:name, 'Mr. No-name') => 'Ernie'}}
+            relation.to_sql.should match /'Ernie'/
+          end
+
+          it 'casts a non-acceptable value for a KeyPath with a Predicate endpoint containing a Function expr properly' do
+            relation = Person.joins(:children).where{{children.coalesce(:name, 'Mr. No-name').eq => 'Ernie'}}
+            relation.to_sql.should match /'Ernie'/
+          end
+
+          it 'casts a non-acceptable value for a Function with a Predicate endpoint containing a Function expr properly' do
+            relation = Person.joins(:children).where{children.coalesce(:name, 'Mr. No-name') == 'Ernie'}
+            relation.to_sql.should match /'Ernie'/
+          end
+        end
+
         describe '#includes' do
 
           it 'builds options with a block' do

data/spec/squeel/dsl_spec.rb

@@ -18,7 +18,7 @@ module Squeel
     it 'creates polymorphic join nodes when a method has a single class argument' do
       result = DSL.eval { association(Person) }
       result.should be_a Nodes::Join
-      result.klass.should eq Person
+      result._klass.should eq Person
     end
 
     it 'handles OR between predicates' do
@@ -69,5 +69,24 @@ module Squeel
       result.value.should eq 'test'
     end
 
+    describe '#my' do
+      it 'allows access to caller instance variables' do
+        @test_var = "test"
+        result = DSL.eval{my{@test_var}}
+        result.should be_a String
+        result.should eq @test_var
+      end
+
+      it 'allows access to caller methods' do
+        def test_scoped_method
+          :name
+        end
+
+        result = DSL.eval{my{test_scoped_method}}
+        result.should be_a Symbol
+        result.should eq :name
+      end
+    end
+
   end
 end

data/spec/squeel/nodes/join_spec.rb

@@ -9,18 +9,18 @@ module Squeel
       end
 
       it 'defaults to Arel::InnerJoin' do
-        @j.type.should eq Arel::InnerJoin
+        @j._type.should eq Arel::InnerJoin
       end
 
       it 'allows setting join type' do
         @j.outer
-        @j.type.should eq Arel::OuterJoin
+        @j._type.should eq Arel::OuterJoin
       end
 
       it 'allows setting polymorphic class' do
-        @j.klass = Person
+        @j._klass = Person
         @j.should be_polymorphic
-        @j.klass.should eq Person
+        @j._klass.should eq Person
       end
 
       it 'creates a KeyPath when sent an unknown method' do
@@ -35,6 +35,13 @@ module Squeel
         keypath.path_with_endpoint.should eq [@j, Join.new(:another, Arel::InnerJoin, Person)]
       end
 
+      it 'creates an absolute keypath with just an endpoint with ~' do
+        node = ~@j
+        node.should be_a KeyPath
+        node.path.should eq []
+        node.endpoint.should eq @j
+      end
+
     end
   end
 end

data/spec/squeel/nodes/key_path_spec.rb

@@ -20,7 +20,7 @@ module Squeel
 
       it 'stops appending once its endpoint is not a Stub' do
         @k.third.fourth.fifth == 'cinco'
-        @k.endpoint.should eq Predicate.new(:fifth, :eq, 'cinco')
+        @k.endpoint.should eq Predicate.new(Stub.new(:fifth), :eq, 'cinco')
         expect { @k.another }.to raise_error NoMethodError
       end
 

data/spec/squeel/nodes/predicate_spec.rb

@@ -4,48 +4,6 @@ module Squeel
   module Nodes
     describe Predicate do
 
-      context 'ARel predicate methods' do
-        before do
-          @p = Predicate.new(:attribute)
-        end
-
-        Squeel::Constants::PREDICATES.each do |method_name|
-          it "creates #{method_name} predicates with no value" do
-            predicate = @p.send(method_name)
-            predicate.expr.should eq :attribute
-            predicate.method_name.should eq method_name
-            predicate.value?.should be_false
-          end
-
-          it "creates #{method_name} predicates with a value" do
-            predicate = @p.send(method_name, 'value')
-            predicate.expr.should eq :attribute
-            predicate.method_name.should eq method_name
-            predicate.value.should eq 'value'
-          end
-        end
-
-        Squeel::Constants::PREDICATE_ALIASES.each do |method_name, aliases|
-          aliases.each do |aliaz|
-            ['', '_any', '_all'].each do |suffix|
-              it "creates #{method_name.to_s + suffix} predicates with no value using the alias #{aliaz.to_s + suffix}" do
-                predicate = @p.send(aliaz.to_s + suffix)
-                predicate.expr.should eq :attribute
-                predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
-                predicate.value?.should be_false
-              end
-
-              it "creates #{method_name.to_s + suffix} predicates with a value using the alias #{aliaz.to_s + suffix}" do
-                predicate = @p.send((aliaz.to_s + suffix), 'value')
-                predicate.expr.should eq :attribute
-                predicate.method_name.should eq "#{method_name}#{suffix}".to_sym
-                predicate.value.should eq 'value'
-              end
-            end
-          end
-        end
-      end
-
       it 'accepts a value on instantiation' do
         @p = Predicate.new :name, :eq, 'value'
         @p.value.should eq 'value'

data/spec/squeel/nodes/stub_spec.rb

@@ -39,6 +39,13 @@ module Squeel
         keypath.path_with_endpoint.should eq [@s, Join.new(:another, Arel::InnerJoin, Person)]
       end
 
+      it 'creates an absolute keypath with just an endpoint with ~' do
+        node = ~@s
+        node.should be_a KeyPath
+        node.path.should eq []
+        node.endpoint.should eq @s
+      end
+
       Squeel::Constants::PREDICATES.each do |method_name|
         it "creates #{method_name} predicates with no value" do
           predicate = @s.send(method_name)
@@ -165,13 +172,13 @@ module Squeel
       it 'creates inner joins' do
         join = @s.inner
         join.should be_a Join
-        join.type.should eq Arel::InnerJoin
+        join._type.should eq Arel::InnerJoin
       end
 
       it 'creates outer joins' do
         join = @s.outer
         join.should be_a Join
-        join.type.should eq Arel::OuterJoin
+        join._type.should eq Arel::OuterJoin
       end
 
       it 'creates functions with #func' do
@@ -179,12 +186,6 @@ module Squeel
         function.should be_a Function
       end
 
-      it 'creates functions with #[]' do
-        function = @s[1, 2, 3]
-        function.should be_a Function
-        function.args.should eq [1, 2, 3]
-      end
-
     end
   end
 end