squeel 0.5.0 → 0.5.5

data/lib/squeel/nodes/stub.rb

@@ -33,7 +33,11 @@ module Squeel
 
       def method_missing(method_id, *args)
         super if method_id == :to_ary
-        KeyPath.new(self.symbol, method_id)
+        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
 
       def ==(value)

data/lib/squeel/version.rb

@@ -1,3 +1,3 @@
 module Squeel
-  VERSION = "0.5.0"
+  VERSION = "0.5.5"
 end

data/lib/squeel/visitors.rb

@@ -1,3 +1,3 @@
 require 'squeel/visitors/predicate_visitor'
-require 'squeel/visitors/order_visitor'
-require 'squeel/visitors/select_visitor'
+require 'squeel/visitors/attribute_visitor'
+require 'squeel/visitors/symbol_visitor'

data/lib/squeel/visitors/{order_visitor.rb → attribute_visitor.rb}

@@ -1,9 +1,8 @@
 require 'squeel/visitors/base'
-require 'squeel/contexts/join_dependency_context'
 
 module Squeel
   module Visitors
-    class OrderVisitor < Base
+    class AttributeVisitor < Base
 
       def visit_Hash(o, parent)
         o.map do |k, v|

data/lib/squeel/visitors/predicate_visitor.rb

@@ -1,5 +1,4 @@
 require 'squeel/visitors/base'
-require 'squeel/contexts/join_dependency_context'
 
 module Squeel
   module Visitors
@@ -24,11 +23,7 @@ module Squeel
       end
 
       def visit_Array(o, parent)
-        if o.first.is_a? String
-          sanitize_sql(o, parent)
-        else
-          o.map { |v| can_accept?(v) ? accept(v, parent) : v }.flatten
-        end
+        o.map { |v| can_accept?(v) ? accept(v, parent) : v }.flatten
       end
 
       def visit_Squeel_Nodes_KeyPath(o, parent)
@@ -37,13 +32,16 @@ module Squeel
         accept(o.endpoint, parent)
       end
 
+      def visit_Squeel_Nodes_Stub(o, parent)
+        contextualize(parent)[o.symbol]
+      end
+
       def visit_Squeel_Nodes_Predicate(o, parent)
         value = o.value
-        case value
-        when Nodes::Function
-          value = accept(value, parent)
-        when Nodes::KeyPath
+        if Nodes::KeyPath === value
           value = can_accept?(value.endpoint) ? accept(value, parent) : contextualize(traverse(value, parent))[value.endpoint.to_sym]
+        else
+          value = accept(value, parent) if can_accept?(value)
         end
         if Nodes::Function === o.expr
           accept(o.expr, parent).send(o.method_name, value)
@@ -68,6 +66,10 @@ module Squeel
         Arel::Nodes::NamedFunction.new(o.name, args, o.alias)
       end
 
+      def visit_ActiveRecord_Relation(o, parent)
+        o.arel
+      end
+
       def visit_Squeel_Nodes_Operation(o, parent)
         args = o.args.map do |arg|
           case arg
@@ -114,7 +116,7 @@ module Squeel
         when Hash, Nodes::Predicate, Nodes::Unary, Nodes::Binary, Nodes::Nary
           true
         when Nodes::KeyPath
-          can_accept?(v.endpoint)
+          can_accept?(v.endpoint) && !(Nodes::Stub === v.endpoint)
         when Array
           (!v.empty? && v.all? {|val| can_accept?(val)})
         else

data/lib/squeel/visitors/symbol_visitor.rb

@@ -0,0 +1,48 @@
+require 'squeel/visitors/base'
+
+module Squeel
+  module Visitors
+    class SymbolVisitor < Base
+
+      def initialize
+      end
+
+      def accept(object, parent = nil)
+        visit(object, parent)
+      end
+
+      private
+
+      def visit_Array(o, parent)
+        o.map {|e| accept(e, parent)}.flatten
+      end
+
+      def visit_Hash(o, parent)
+        {}.tap do |hash|
+          o.each do |key, value|
+            hash[accept(key, parent)] = accept(value, parent)
+          end
+        end
+      end
+
+      def visit_Symbol(o, parent)
+        o
+      end
+
+      def visit_Squeel_Nodes_Stub(o, parent)
+        o.symbol
+      end
+
+      def visit_Squeel_Nodes_KeyPath(o, parent)
+        o.path_with_endpoint.reverse.map(&:to_sym).inject do |hash, key|
+          {key => hash}
+        end
+      end
+
+      def visit_Squeel_Nodes_Join(o, parent)
+        o.name
+      end
+
+    end
+  end
+end

data/spec/helpers/squeel_helper.rb

@@ -1,5 +1,21 @@
 module SqueelHelper
   def dsl(&block)
-    Squeel::DSL.evaluate(&block)
+    Squeel::DSL.eval(&block)
+  end
+
+  def queries_for
+    $queries_executed = []
+    yield
+    $queries_executed
+  ensure
+    %w{ BEGIN COMMIT }.each { |x| $queries_executed.delete(x) }
+  end
+
+  def new_join_dependency(*args)
+    if defined?(ActiveRecord::Associations::JoinDependency)
+      ActiveRecord::Associations::JoinDependency.new(*args)
+    else
+      ActiveRecord::Associations::ClassMethods::JoinDependency.new(*args)
+    end
   end
 end

data/spec/spec_helper.rb

@@ -2,6 +2,30 @@ require 'machinist/active_record'
 require 'sham'
 require 'faker'
 
+module ActiveRecord
+  class SQLCounter
+    IGNORED_SQL = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/,
+      /SELECT name\s+FROM sqlite_master\s+WHERE type = 'table' AND NOT name = 'sqlite_sequence'/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+
+    def initialize
+      $queries_executed = []
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      unless 'CACHE' == values[:name]
+        $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+      end
+    end
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end
+
 Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
   require f
 end
@@ -23,6 +47,13 @@ RSpec.configure do |config|
   config.include SqueelHelper
 end
 
+RSpec::Matchers.define :be_like do |expected|
+  match do |actual|
+    actual.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip ==
+      expected.gsub(/^\s+|\s+$/, '').gsub(/\s+/, ' ').strip
+  end
+end
+
 require 'squeel'
 
 Squeel.configure do |config|

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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module Squeel
+  module Adapters
+    module ActiveRecord
+      describe Context do
+        before do
+          @jd = new_join_dependency(Person, {
+                 :children => {
+                   :children => {
+                     :parent => :parent
+                   }
+                 }
+               }, [])
+          @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'
+        end
+
+        it 'contextualizes symbols as a generic table' do
+          table = @c.contextualize :table
+          table.name.should eq 'table'
+          table.table_alias.should be_nil
+        end
+
+        it 'contextualizes polymorphic Join nodes to the arel_table of their klass' do
+          table = @c.contextualize Nodes::Join.new(:notable, Arel::InnerJoin, Article)
+          table.name.should eq 'articles'
+          table.table_alias.should be_nil
+        end
+
+        it 'contextualizes non-polymorphic Join nodes to the table for their name' do
+          table = @c.contextualize Nodes::Join.new(:notes, Arel::InnerJoin)
+          table.name.should eq 'notes'
+          table.table_alias.should be_nil
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@ module Squeel
     module ActiveRecord
       describe JoinAssociation do
         before do
-          @jd = ::ActiveRecord::Associations::JoinDependency.new(Note, {}, [])
+          @jd = new_join_dependency(Note, {}, [])
           @notable = Note.reflect_on_association(:notable)
         end
 

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

@@ -3,7 +3,7 @@ module Squeel
     module ActiveRecord
       describe JoinDependency do
         before do
-          @jd = ::ActiveRecord::Associations::JoinDependency.new(Person, {}, [])
+          @jd = new_join_dependency(Person, {}, [])
         end
 
         it 'joins with symbols' do

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

@@ -5,7 +5,7 @@ module Squeel
 
         describe '#predicate_visitor' do
 
-          it 'creates a predicate visitor with a JoinDependencyContext for the relation' do
+          it 'creates a predicate visitor with a Context for the relation' do
             relation = Person.joins({
               :children => {
                 :children => {
@@ -23,9 +23,9 @@ module Squeel
 
         end
 
-        describe '#order_visitor' do
+        describe '#attribute_visitor' do
 
-          it 'creates an order visitor with a JoinDependencyContext for the relation' do
+          it 'creates an attribute visitor with a Context for the relation' do
             relation = Person.joins({
               :children => {
                 :children => {
@@ -34,29 +34,9 @@ module Squeel
               }
             })
 
-            visitor = relation.order_visitor
+            visitor = relation.attribute_visitor
 
-            visitor.should be_a Visitors::OrderVisitor
-            table = visitor.contextualize(relation.join_dependency.join_parts.last)
-            table.table_alias.should eq 'parents_people_2'
-          end
-
-        end
-
-        describe '#select_visitor' do
-
-          it 'creates a select visitor with a JoinDependencyContext for the relation' do
-            relation = Person.joins({
-              :children => {
-                :children => {
-                  :parent => :parent
-                }
-              }
-            })
-
-            visitor = relation.select_visitor
-
-            visitor.should be_a Visitors::SelectVisitor
+            visitor.should be_a Visitors::AttributeVisitor
             table = visitor.contextualize(relation.join_dependency.join_parts.last)
             table.table_alias.should eq 'parents_people_2'
           end
@@ -209,6 +189,116 @@ module Squeel
 
         end
 
+        describe '#includes' do
+
+          it 'builds options with a block' do
+            standard = Person.includes(:children => :children).where(:children => {:children => {:name => 'bob'}})
+            block = Person.includes{{children => children}}.where(:children => {:children => {:name => 'bob'}})
+            block.debug_sql.should eq standard.debug_sql
+          end
+
+          it 'eager loads multiple top-level associations with a block' do
+            standard = Person.includes(:children, :articles, :comments).where(:children => {:name => 'bob'})
+            block = Person.includes{[children, articles, comments]}.where(:children => {:name => 'bob'})
+            block.debug_sql.should eq standard.debug_sql
+          end
+
+          it 'eager loads polymorphic belongs_to associations' do
+            relation = Note.includes{notable(Article)}.where{{notable(Article) => {title => 'hey'}}}
+            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
+          end
+
+          it 'eager loads multiple polymorphic belongs_to associations' do
+            relation = Note.includes{[notable(Article), notable(Person)]}.
+                            where{{notable(Article) => {title => 'hey'}}}.
+                            where{{notable(Person) => {name => 'joe'}}}
+            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
+            relation.debug_sql.should match /"notes"."notable_type" = 'Person'/
+          end
+
+          it "only includes once, even if two join types are used" do
+            relation = Person.includes(:articles.inner, :articles.outer).where(:articles => {:title => 'hey'})
+            relation.debug_sql.scan("JOIN").size.should eq 1
+          end
+
+          it 'includes a keypath' do
+            relation = Note.includes{notable(Article).person.children}.where{notable(Article).person.children.name == 'Ernie'}
+            relation.debug_sql.should match /SELECT "notes".* FROM "notes" LEFT OUTER JOIN "articles" ON "articles"."id" = "notes"."notable_id" AND "notes"."notable_type" = 'Article' LEFT OUTER JOIN "people" ON "people"."id" = "articles"."person_id" LEFT OUTER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"/
+          end
+
+        end
+
+        describe '#preload' do
+
+          it 'builds options with a block' do
+            relation = Person.preload{children}
+            queries_for {relation.all}.should have(2).items
+            queries_for {relation.first.children}.should have(0).items
+          end
+
+          it 'builds options with a keypath' do
+            relation = Person.preload{articles.comments}
+            queries_for {relation.all}.should have(3).items
+            queries_for {relation.first.articles.first.comments}.should have(0).items
+          end
+
+          it 'builds options with a hash' do
+            relation = Person.preload{{
+              articles => {
+                comments => person
+              }
+            }}
+
+            queries_for {relation.all}.should have(4).items
+
+            queries_for {
+              relation.first.articles
+              relation.first.articles.first.comments
+              relation.first.articles.first.comments.first.person
+            }.should have(0).items
+          end
+
+        end
+
+        describe '#eager_load' do
+
+          it 'builds options with a block' do
+            standard = Person.eager_load(:children => :children)
+            block = Person.eager_load{{children => children}}
+            block.debug_sql.should eq standard.debug_sql
+            queries_for {block.all}.should have(1).item
+            queries_for {block.first.children}.should have(0).items
+          end
+
+          it 'eager loads multiple top-level associations with a block' do
+            standard = Person.eager_load(:children, :articles, :comments)
+            block = Person.eager_load{[children, articles, comments]}
+            block.debug_sql.should eq standard.debug_sql
+          end
+
+          it 'eager loads polymorphic belongs_to associations' do
+            relation = Note.eager_load{notable(Article)}
+            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
+          end
+
+          it 'eager loads multiple polymorphic belongs_to associations' do
+            relation = Note.eager_load{[notable(Article), notable(Person)]}
+            relation.debug_sql.should match /"notes"."notable_type" = 'Article'/
+            relation.debug_sql.should match /"notes"."notable_type" = 'Person'/
+          end
+
+          it "only eager_load once, even if two join types are used" do
+            relation = Person.eager_load(:articles.inner, :articles.outer)
+            relation.debug_sql.scan("JOIN").size.should eq 1
+          end
+
+          it 'eager_load a keypath' do
+            relation = Note.eager_load{notable(Article).person.children}
+            relation.debug_sql.should match /SELECT "notes".* FROM "notes" LEFT OUTER JOIN "articles" ON "articles"."id" = "notes"."notable_id" AND "notes"."notable_type" = 'Article' LEFT OUTER JOIN "people" ON "people"."id" = "articles"."person_id" LEFT OUTER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"/
+          end
+
+        end
+
         describe '#select' do
 
           it 'accepts options from a block' do
@@ -251,6 +341,16 @@ module Squeel
 
         end
 
+        describe '#group' do
+
+          it 'builds options with a block' do
+            standard = Person.group(:name)
+            block = Person.group{name}
+            block.to_sql.should eq standard.to_sql
+          end
+
+        end
+
         describe '#where' do
 
           it 'builds options with a block' do
@@ -284,6 +384,23 @@ module Squeel
             relation.first.id.should eq 1
           end
 
+          it 'maps conditions onto their proper table with multiple polymorphic joins' do
+            relation = Note.joins{[notable(Article).outer, notable(Person).outer]}
+            people_notes = relation.where{notable(Person).salary > 30000}
+            article_notes = relation.where{notable(Article).title =~ '%'}
+            people_and_article_notes = relation.where{(notable(Person).salary > 30000) | (notable(Article).title =~ '%')}
+            people_notes.should have(10).items
+            article_notes.should have(30).items
+            people_and_article_notes.should have(40).items
+          end
+
+          it 'allows a subquery on the value side of a predicate' do
+            old_and_busted = Person.where(:name => ['Aric Smith', 'Gladyce Kulas'])
+            new_hotness = Person.where{name.in(Person.select{name}.where{name.in(['Aric Smith', 'Gladyce Kulas'])})}
+            new_hotness.should have(2).items
+            old_and_busted.to_a.should eq new_hotness.to_a
+          end
+
         end
 
         describe '#joins' do
@@ -305,11 +422,22 @@ module Squeel
             relation.to_sql.should match /"notes"."notable_type" = 'Article'/
           end
 
+          it 'joins multiple polymorphic belongs_to associations' do
+            relation = Note.joins{[notable(Article), notable(Person)]}
+            relation.to_sql.should match /"notes"."notable_type" = 'Article'/
+            relation.to_sql.should match /"notes"."notable_type" = 'Person'/
+          end
+
           it "only joins once, even if two join types are used" do
             relation = Person.joins(:articles.inner, :articles.outer)
             relation.to_sql.scan("JOIN").size.should eq 1
           end
 
+          it 'joins a keypath' do
+            relation = Note.joins{notable(Article).person.children}
+            relation.to_sql.should match /SELECT "notes".* FROM "notes" INNER JOIN "articles" ON "articles"."id" = "notes"."notable_id" AND "notes"."notable_type" = 'Article' INNER JOIN "people" ON "people"."id" = "articles"."person_id" INNER JOIN "people" "children_people" ON "children_people"."parent_id" = "people"."id"/
+          end
+
         end
 
         describe '#having' do
@@ -347,6 +475,19 @@ module Squeel
 
         end
 
+        describe '#reorder' do
+          before do
+            @standard = Person.order(:name)
+          end
+
+          it 'builds options with a block' do
+            block = Person.reorder{id}
+            block.to_sql.should_not eq @standard.to_sql
+            block.to_sql.should match /ORDER BY "people"."id"/
+          end
+
+        end
+
         describe '#build_where' do
 
           it 'sanitizes SQL as usual with strings' do