squeel 0.5.0

data/spec/helpers/squeel_helper.rb

@@ -0,0 +1,5 @@
+module SqueelHelper
+  def dsl(&block)
+    Squeel::DSL.evaluate(&block)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+
+Dir[File.expand_path('../{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+Sham.define do
+  name     { Faker::Name.name }
+  title    { Faker::Lorem.sentence }
+  body     { Faker::Lorem.paragraph }
+  salary   {|index| 30000 + (index * 1000)}
+  tag_name { Faker::Lorem.words(3).join(' ') }
+  note     { Faker::Lorem.words(7).join(' ') }
+end
+
+RSpec.configure do |config|
+  config.before(:suite) { Schema.create }
+  config.before(:all)   { Sham.reset(:before_all) }
+  config.before(:each)  { Sham.reset(:before_each) }
+
+  config.include SqueelHelper
+end
+
+require 'squeel'
+
+Squeel.configure do |config|
+  config.load_core_extensions :hash, :symbol
+end

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

@@ -0,0 +1,18 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      describe JoinAssociation do
+        before do
+          @jd = ::ActiveRecord::Associations::JoinDependency.new(Note, {}, [])
+          @notable = Note.reflect_on_association(:notable)
+        end
+
+        it 'accepts a 4th parameter to set a polymorphic class' do
+          join_association = JoinAssociation.new(@notable, @jd, @jd.join_base, Article)
+          join_association.reflection.klass.should eq Article
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      describe JoinDependency do
+        before do
+          @jd = ::ActiveRecord::Associations::JoinDependency.new(Person, {}, [])
+        end
+
+        it 'joins with symbols' do
+          @jd.send(:build, :articles => :comments)
+          @jd.join_associations.should have(2).associations
+          @jd.join_associations.each do |association|
+            association.join_type.should eq Arel::InnerJoin
+          end
+        end
+
+        it 'joins with stubs' do
+          @jd.send(:build, Nodes::Stub.new(:articles) => Nodes::Stub.new(:comments))
+          @jd.join_associations.should have(2).associations
+          @jd.join_associations.each do |association|
+            association.join_type.should eq Arel::InnerJoin
+          end
+          @jd.join_associations[0].table_name.should eq 'articles'
+          @jd.join_associations[1].table_name.should eq 'comments'
+        end
+
+        it 'joins with key paths' do
+          @jd.send(:build, dsl{children.children.parent})
+          @jd.join_associations.should have(3).associations
+          @jd.join_associations.each do |association|
+            association.join_type.should eq Arel::InnerJoin
+          end
+          @jd.join_associations[0].aliased_table_name.should eq 'children_people'
+          @jd.join_associations[1].aliased_table_name.should eq 'children_people_2'
+          @jd.join_associations[2].aliased_table_name.should eq 'parents_people'
+        end
+
+        it 'joins with key paths as keys' do
+          @jd.send(:build, dsl{{children.parent => parent}})
+          @jd.join_associations.should have(3).associations
+          @jd.join_associations.each do |association|
+            association.join_type.should eq Arel::InnerJoin
+          end
+          @jd.join_associations[0].aliased_table_name.should eq 'children_people'
+          @jd.join_associations[1].aliased_table_name.should eq 'parents_people'
+          @jd.join_associations[2].aliased_table_name.should eq 'parents_people_2'
+        end
+
+        it 'joins using outer joins' do
+          @jd.send(:build, :articles.outer => :comments.outer)
+          @jd.join_associations.should have(2).associations
+          @jd.join_associations.each do |association|
+            association.join_type.should eq Arel::OuterJoin
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,437 @@
+module Squeel
+  module Adapters
+    module ActiveRecord
+      describe Relation do
+
+        describe '#predicate_visitor' do
+
+          it 'creates a predicate visitor with a JoinDependencyContext 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 '#order_visitor' do
+
+          it 'creates an order visitor with a JoinDependencyContext for the relation' do
+            relation = Person.joins({
+              :children => {
+                :children => {
+                  :parent => :parent
+                }
+              }
+            })
+
+            visitor = relation.order_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
+            table = visitor.contextualize(relation.join_dependency.join_parts.last)
+            table.table_alias.should eq 'parents_people_2'
+          end
+
+        end
+
+        describe '#build_arel' do
+
+          it 'joins associations' do
+            relation = Person.joins({
+              :children => {
+                :children => {
+                  :parent => :parent
+                }
+              }
+            })
+
+            arel = relation.build_arel
+
+            relation.join_dependency.join_associations.should have(4).items
+            arel.to_sql.should match /INNER JOIN "people" "parents_people_2" ON "parents_people_2"."id" = "parents_people"."parent_id"/
+          end
+
+          it 'joins associations with custom join types' do
+            relation = Person.joins({
+              :children.outer => {
+                :children => {
+                  :parent => :parent.outer
+                }
+              }
+            })
+
+            arel = relation.build_arel
+
+            relation.join_dependency.join_associations.should have(4).items
+            arel.to_sql.should match /LEFT OUTER JOIN "people" "children_people"/
+            arel.to_sql.should match /LEFT OUTER JOIN "people" "parents_people_2" ON "parents_people_2"."id" = "parents_people"."parent_id"/
+          end
+
+          it 'only joins an association once, even if two overlapping joins_values hashes are given' do
+            relation = Person.joins({
+              :children => {
+                :children => {
+                  :parent => :parent
+                }
+              }
+            }).joins({
+              :children => {
+                :children => {
+                  :children => :parent
+                }
+              }
+            })
+
+            arel = relation.build_arel
+            relation.join_dependency.join_associations.should have(6).items
+            arel.to_sql.should match /INNER JOIN "people" "parents_people_3" ON "parents_people_3"."id" = "children_people_3"."parent_id"/
+          end
+
+          it 'visits wheres with a PredicateVisitor, converting them to ARel nodes' do
+            relation = Person.where(:name.matches => '%bob%')
+            arel = relation.build_arel
+            arel.to_sql.should match /"people"."name" LIKE '%bob%'/
+          end
+
+          it 'maps wheres inside a hash to their appropriate association table' do
+            relation = Person.joins({
+              :children => {
+                :children => {
+                  :parent => :parent
+                }
+              }
+            }).where({
+              :children => {
+                :children => {
+                  :parent => {
+                    :parent => { :name => 'bob' }
+                  }
+                }
+              }
+            })
+
+            arel = relation.build_arel
+
+            arel.to_sql.should match /"parents_people_2"."name" = 'bob'/
+          end
+
+          it 'combines multiple conditions of the same type against the same column with AND' do
+            relation = Person.where(:name.matches => '%bob%')
+            relation = relation.where(:name.matches => '%joe%')
+            arel = relation.build_arel
+            arel.to_sql.should match /"people"."name" LIKE '%bob%' AND "people"."name" LIKE '%joe%'/
+          end
+
+          it 'handles ORs between predicates' do
+            relation = Person.joins{articles}.where{(name =~ 'Joe%') | (articles.title =~ 'Hello%')}
+            arel = relation.build_arel
+            arel.to_sql.should match /OR/
+          end
+
+          it 'maintains groupings as given' do
+            relation = Person.where(dsl{(name == 'Ernie') | ((name =~ 'Bob%') & (name =~ '%by'))})
+            arel = relation.build_arel
+            arel.to_sql.should match /"people"."name" = 'Ernie' OR \("people"."name" LIKE 'Bob%' AND "people"."name" LIKE '%by'\)/
+          end
+
+          it 'maps havings inside a hash to their appropriate association table' do
+            relation = Person.joins({
+              :children => {
+                :children => {
+                  :parent => :parent
+                }
+              }
+            }).having({
+              :children => {
+                :children => {
+                  :parent => {
+                    :parent => {:name => 'joe'}
+                  }
+                }
+              }
+            })
+
+            arel = relation.build_arel
+
+            arel.to_sql.should match /HAVING "parents_people_2"."name" = 'joe'/
+          end
+
+          it 'maps orders inside a hash to their appropriate association table' do
+            relation = Person.joins({
+              :children => {
+                :children => {
+                  :parent => :parent
+                }
+              }
+            }).order({
+              :children => {
+                :children => {
+                  :parent => {
+                    :parent => :id.asc
+                  }
+                }
+              }
+            })
+
+            arel = relation.build_arel
+
+            arel.to_sql.should match /ORDER BY "parents_people_2"."id" ASC/
+          end
+
+        end
+
+        describe '#select' do
+
+          it 'accepts options from a block' do
+            standard = Person.select(:id)
+            block = Person.select {id}
+            block.to_sql.should eq standard.to_sql
+          end
+
+          it 'falls back to Array#select behavior with a block that has an arity' do
+            people = Person.select{|p| p.name =~ /John/}
+            people.should have(1).person
+            people.first.name.should eq 'Miss Cameron Johnson'
+          end
+
+          it 'behaves as normal with standard parameters' do
+            people = Person.select(:id)
+            people.should have(332).people
+            expect { people.first.name }.to raise_error ActiveModel::MissingAttributeError
+          end
+
+          it 'allows a function in the select values via Symbol#func' do
+            relation = Person.select(:max.func(:id).as('max_id'))
+            relation.first.max_id.should eq 332
+          end
+
+          it 'allows a function in the select values via block' do
+            relation = Person.select{max(id).as(max_id)}
+            relation.first.max_id.should eq 332
+          end
+
+          it 'allows an operation in the select values via block' do
+            relation = Person.select{[id, (id + 1).as('id_plus_one')]}.where('id_plus_one = 2')
+            relation.first.id.should eq 1
+          end
+
+          it 'allows custom operators in the select values via block' do
+            relation = Person.select{name.op('||', '-diddly').as(flanderized_name)}
+            relation.first.flanderized_name.should eq 'Aric Smith-diddly'
+          end
+
+        end
+
+        describe '#where' do
+
+          it 'builds options with a block' do
+            standard = Person.where(:name => 'bob')
+            block = Person.where{{name => 'bob'}}
+            block.to_sql.should eq standard.to_sql
+          end
+
+          it 'builds compound conditions with a block' do
+            block = Person.where{(name == 'bob') & (salary == 100000)}
+            block.to_sql.should match /"people"."name" = 'bob'/
+            block.to_sql.should match /AND/
+            block.to_sql.should match /"people"."salary" = 100000/
+          end
+
+          it 'allows mixing hash and operator syntax inside a block' do
+            block = Person.joins(:comments).
+                           where{(name == 'bob') & {comments => (body == 'First post!')}}
+            block.to_sql.should match /"people"."name" = 'bob'/
+            block.to_sql.should match /AND/
+            block.to_sql.should match /"comments"."body" = 'First post!'/
+          end
+
+          it 'allows a condition on a function via block' do
+            relation = Person.where{coalesce(nil,id) == 5}
+            relation.first.id.should eq 5
+          end
+
+          it 'allows a condition on an operation via block' do
+            relation = Person.where{(id + 1) == 2}
+            relation.first.id.should eq 1
+          end
+
+        end
+
+        describe '#joins' do
+
+          it 'builds options with a block' do
+            standard = Person.joins(:children => :children)
+            block = Person.joins{{children => children}}
+            block.to_sql.should eq standard.to_sql
+          end
+
+          it 'accepts multiple top-level associations with a block' do
+            standard = Person.joins(:children, :articles, :comments)
+            block = Person.joins{[children, articles, comments]}
+            block.to_sql.should eq standard.to_sql
+          end
+
+          it 'joins polymorphic belongs_to associations' do
+            relation = Note.joins{notable(Article)}
+            relation.to_sql.should match /"notes"."notable_type" = 'Article'/
+          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
+
+        end
+
+        describe '#having' do
+
+          it 'builds options with a block' do
+            standard = Person.having(:name => 'bob')
+            block = Person.having{{name => 'bob'}}
+            block.to_sql.should eq standard.to_sql
+          end
+
+          it 'allows complex conditions on aggregate columns' do
+            relation = Person.group(:parent_id).having{salary == max(salary)}
+            relation.first.name.should eq 'Gladyce Kulas'
+          end
+
+          it 'allows a condition on a function via block' do
+            relation = Person.group(:id).having{coalesce(nil,id) == 5}
+            relation.first.id.should eq 5
+          end
+
+          it 'allows a condition on an operation via block' do
+            relation = Person.group(:id).having{(id + 1) == 2}
+            relation.first.id.should eq 1
+          end
+
+        end
+
+        describe '#order' do
+
+          it 'builds options with a block' do
+            standard = Person.order(:name)
+            block = Person.order{name}
+            block.to_sql.should eq standard.to_sql
+          end
+
+        end
+
+        describe '#build_where' do
+
+          it 'sanitizes SQL as usual with strings' do
+            wheres = Person.where('name like ?', '%bob%').where_values
+            wheres.should eq ["name like '%bob%'"]
+          end
+
+          it 'sanitizes SQL as usual with strings and hash substitution' do
+            wheres = Person.where('name like :name', :name => '%bob%').where_values
+            wheres.should eq ["name like '%bob%'"]
+          end
+
+          it 'sanitizes SQL as usual with arrays' do
+            wheres = Person.where(['name like ?', '%bob%']).where_values
+            wheres.should eq ["name like '%bob%'"]
+          end
+
+          it 'adds hash where values without converting to ARel predicates' do
+            wheres = Person.where({:name => 'bob'}).where_values
+            wheres.should eq [{:name => 'bob'}]
+          end
+
+        end
+
+        describe '#debug_sql' do
+
+          it 'returns the query that would be run against the database, even if eager loading' do
+            relation = Person.includes(:comments, :articles).
+              where(:comments => {:body => 'First post!'}).
+              where(:articles => {:title => 'Hello, world!'})
+            relation.debug_sql.should_not eq relation.to_sql
+            relation.debug_sql.should match /SELECT "people"."id" AS t0_r0/
+          end
+
+        end
+
+        describe '#where_values_hash' do
+
+          it 'creates new records with equality predicates from wheres' do
+            @person = Person.where(:name => 'bob', :parent_id => 3).new
+            @person.parent_id.should eq 3
+            @person.name.should eq 'bob'
+          end
+
+          it 'uses the last supplied equality predicate in where_values when creating new records' do
+            @person = Person.where(:name => 'bob', :parent_id => 3).where(:name => 'joe').new
+            @person.parent_id.should eq 3
+            @person.name.should eq 'joe'
+          end
+
+        end
+
+        describe '#merge' do
+
+          it 'merges relations with the same base' do
+            relation = Person.where{name == 'bob'}.merge(Person.where{salary == 100000})
+            sql = relation.to_sql
+            sql.should match /"people"."name" = 'bob'/
+            sql.should match /"people"."salary" = 100000/
+          end
+
+          it 'merges relations with a different base' do
+            relation = Person.where{name == 'bob'}.merge(Article.where{title == 'Hello world!'})
+            sql = relation.to_sql
+            sql.should match /INNER JOIN "articles" ON "articles"."person_id" = "people"."id"/
+            sql.should match /"people"."name" = 'bob'/
+            sql.should match /"articles"."title" = 'Hello world!'/
+          end
+
+        end
+
+        describe '#to_a' do
+
+          it 'eager-loads associations with dependent conditions' do
+            relation = Person.includes(:comments, :articles).
+              where{{comments => {body => 'First post!'}}}
+            relation.size.should be 1
+            person = relation.first
+            person.name.should eq 'Gladyce Kulas'
+            person.comments.loaded?.should be true
+          end
+
+        end
+
+      end
+    end
+  end
+end