squeel_rbg 0.8.2

data/spec/squeel/visitors/predicate_visitor_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+module Squeel
+  module Visitors
+    describe PredicateVisitor do
+
+      before do
+        @jd = new_join_dependency(Person, {
+               :children => {
+                 :children => {
+                   :parent => :parent
+                 }
+               }
+             }, [])
+        @c = Squeel::Adapters::ActiveRecord::Context.new(@jd)
+        @v = PredicateVisitor.new(@c)
+      end
+
+      it 'does not quote Arel::SelectManager values in Predicate nodes' do
+        predicate = Nodes::Predicate.new(Nodes::Function.new(:blah, [1, 2]), :in, Person.select(:id).arel)
+        node = @v.accept(predicate)
+        node.should be_a Arel::Nodes::In
+        node.right.should be_a Arel::Nodes::SelectStatement
+      end
+
+      it 'creates Equality nodes for simple hashes' do
+        predicate = @v.accept(:name => 'Joe')
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.left.name.should eq :name
+        predicate.right.should eq 'Joe'
+      end
+
+      it 'creates In nodes for simple hashes with an array as a value' do
+        predicate = @v.accept(:name => ['Joe', 'Bob'])
+        predicate.should be_a Arel::Nodes::In
+        predicate.left.name.should eq :name
+        predicate.right.should eq ['Joe', 'Bob']
+      end
+
+      it 'generates "1=0" when given an empty array value in a hash' do
+        predicate = @v.accept(:id => [])
+        predicate.should be_a Arel::Nodes::SqlLiteral
+        predicate.should eq '1=0'
+      end
+
+      it 'generates "1=0" for in predicates when given an empty array value' do
+        predicate = @v.accept(:id.in => [])
+        predicate.should be_a Arel::Nodes::SqlLiteral
+        predicate.should eq '1=0'
+      end
+
+      it 'generates "1=1" for not_in predicates when given an empty array value' do
+        predicate = @v.accept(:id.not_in => [])
+        predicate.should be_a Arel::Nodes::SqlLiteral
+        predicate.should eq '1=1'
+      end
+
+      it 'allows a subquery on the value side of an explicit predicate' do
+        predicate = @v.accept dsl{name.in(Person.select{name}.where{name.in(['Aric Smith', 'Gladyce Kulas'])})}
+        predicate.should be_a Arel::Nodes::In
+        predicate.left.name.should eq :name
+        predicate.right.should be_a Arel::Nodes::SelectStatement
+      end
+
+      it 'allows a subquery on the value side of an implicit predicate' do
+        predicate = @v.accept(:name => Person.select{name}.where{name.in(['Aric Smith', 'Gladyce Kulas'])})
+        predicate.should be_a Arel::Nodes::In
+        predicate.left.name.should eq :name
+        predicate.right.should be_a Arel::Nodes::SelectStatement
+      end
+
+      it 'converts ActiveRecord::Base objects to their id' do
+        predicate = @v.accept(:id => Person.first)
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.left.name.should eq :id
+        predicate.right.should eq 1
+      end
+
+      it 'converts arrays of ActiveRecord::Base objects to their ids' do
+        predicate = @v.accept(:id => [Person.first, Person.last])
+        predicate.should be_a Arel::Nodes::In
+        predicate.left.name.should eq :id
+        predicate.right.should eq [1, 332]
+      end
+
+      it 'creates the node against the proper table for nested hashes' do
+        predicate = @v.accept({
+          :children => {
+            :children => {
+              :parent => {
+                :parent => {
+                  :name => 'Joe'
+                }
+              }
+            }
+          }
+        })
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.left.relation.table_alias.should eq 'parents_people_2'
+        predicate.right.should eq 'Joe'
+      end
+
+      it 'treats keypath keys like nested hashes' do
+        standard = @v.accept({
+          :children => {
+            :children => {
+              :parent => {
+                :parent => {
+                  :name => 'Joe'
+                }
+              }
+            }
+          }
+        })
+        keypath = @v.accept(Nodes::Stub.new(:children).children.parent.parent.name => 'Joe')
+        keypath.to_sql.should eq standard.to_sql
+      end
+
+      it 'honors absolute keypaths' do
+        standard = @v.accept({
+          :children => {
+            :children => {
+              :name => 'Joe'
+            }
+          }
+        })
+        keypath = @v.accept(dsl{{children => {children => {~children.children.name => 'Joe'}}}})
+        keypath.to_sql.should eq standard.to_sql
+      end
+
+      it 'honors absolute keypaths with only an endpoint' do
+        standard = @v.accept({:name => 'Joe'})
+        keypath = @v.accept(dsl{{children => {children => {~name => 'Joe'}}}})
+        keypath.to_sql.should eq standard.to_sql
+      end
+
+      it 'allows incomplete predicates (missing value) as keys' do
+        standard = @v.accept({
+          :children => {
+            :children => {
+              :parent => {
+                :parent => {
+                  :name.matches => 'Joe%'
+                }
+              }
+            }
+          }
+        })
+        keypath = @v.accept(Nodes::Stub.new(:children).children.parent.parent.name.matches => 'Joe%')
+        keypath.to_sql.should eq standard.to_sql
+      end
+
+      it 'allows hashes as values with keypath keys' do
+        standard = @v.accept({
+          :children => {
+            :children => {
+              :parent => {
+                :parent => {
+                  :name => 'Joe'
+                }
+              }
+            }
+          }
+        })
+        keypath = @v.accept(Nodes::Stub.new(:children).children.parent.parent => {:name => 'Joe'})
+        keypath.to_sql.should eq standard.to_sql
+      end
+
+      it 'contextualizes Stub values' do
+        predicate = @v.accept(dsl{{name => name}})
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.right.should be_a Arel::Attribute
+        predicate.to_sql.should match /"people"."name" = "people"."name"/
+      end
+
+      it 'contextualizes Symbol values' do
+        predicate = @v.accept(:name => :name)
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.right.should be_a Arel::Attribute
+        predicate.to_sql.should match /"people"."name" = "people"."name"/
+      end
+
+      it 'contextualizes KeyPath values in hashes' do
+        predicate = @v.accept(dsl{{name => children.name}})
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.right.should be_a Arel::Attribute
+        predicate.to_sql.should match /"people"."name" = "children_people"."name"/
+      end
+
+      it 'contextualizes KeyPath values in predicates' do
+        predicate = @v.accept(dsl{name == children.name})
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.right.should be_a Arel::Attribute
+        predicate.to_sql.should match /"people"."name" = "children_people"."name"/
+      end
+
+      it 'honors an explicit table in string keys' do
+        predicate = @v.accept('things.attribute' => 'retro')
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.to_sql.should match /"things"."attribute" = 'retro'/
+      end
+
+      it 'visits ActiveRecord::Relation values in predicates' do
+        predicate = @v.accept(dsl{id >> Person.select{id}.limit(3).order{id.desc}})
+        predicate.should be_a Arel::Nodes::In
+        predicate.right.should be_a Arel::Nodes::SelectStatement
+        predicate.to_sql.should be_like '"people"."id" IN (SELECT  "people"."id" FROM "people"  ORDER BY "people"."id" DESC LIMIT 3)'
+      end
+
+      it 'converts ActiveRecord::Relation values in function arguments to their ARel AST' do
+        predicate = @v.accept(dsl{exists(Person.where{name == 'Aric Smith'})})
+        predicate.should be_a Arel::Nodes::NamedFunction
+        predicate.expressions.first.should be_a Arel::Nodes::SelectStatement
+        predicate.to_sql.should be_like "exists(SELECT \"people\".* FROM \"people\"  WHERE \"people\".\"name\" = 'Aric Smith')"
+      end
+
+      it "doesn't try to sanitize_sql an array of strings in the value of a Predicate" do
+        predicate = @v.accept(dsl{name >> ['Aric Smith', 'Gladyce Kulas']})
+        predicate.should be_a Arel::Nodes::In
+        predicate.right.should be_an Array
+        predicate.to_sql.should match /"people"."name" IN \('Aric Smith', 'Gladyce Kulas'\)/
+      end
+
+      it 'creates a node of the proper type when a hash has a Predicate as a key' do
+        predicate = @v.accept(:name.matches => 'Joe%')
+        predicate.should be_a Arel::Nodes::Matches
+        predicate.left.name.should eq :name
+        predicate.right.should eq 'Joe%'
+      end
+
+      it 'treats hash keys as an association when there is an Or on the value side' do
+        predicate = @v.accept(:children => (:name.matches % 'Joe%' | :name.matches % 'Bob%'))
+        predicate.should be_a Arel::Nodes::Grouping
+        predicate.expr.should be_a Arel::Nodes::Or
+        predicate.expr.left.should be_a Arel::Nodes::Matches
+        predicate.expr.left.left.relation.table_alias.should eq 'children_people'
+      end
+
+      it 'treats hash keys as an association when there is an And on the value side' do
+        predicate = @v.accept(:children => (:name.matches % 'Joe%' & :name.matches % 'Bob%'))
+        predicate.should be_a Arel::Nodes::Grouping
+        predicate.expr.should be_a Arel::Nodes::And
+        predicate.expr.children.should have(2).items
+        predicate.expr.children.first.should be_a Arel::Nodes::Matches
+        predicate.expr.children.first.left.relation.table_alias.should eq 'children_people'
+      end
+
+      it 'treats hash keys as an association when there is a Not on the value side' do
+        predicate = @v.accept(:children => -(:name.matches % 'Joe%'))
+        predicate.should be_a Arel::Nodes::Not
+        predicate.expr.should be_a Arel::Nodes::Matches
+        predicate.expr.left.relation.table_alias.should eq 'children_people'
+      end
+
+      it 'treats hash keys as an association when there is a Predicate on the value side' do
+        predicate = @v.accept(:children => (:name.matches % 'Joe%'))
+        predicate.should be_a Arel::Nodes::Matches
+        predicate.left.relation.table_alias.should eq 'children_people'
+      end
+
+      it 'treats hash keys as an association when there is a KeyPath on the value side' do
+        predicate = @v.accept(:children => Nodes::Stub.new(:children).name.eq('Joe'))
+        predicate.should be_a Arel::Nodes::Equality
+        predicate.left.relation.table_alias.should eq 'children_people_2'
+        predicate.left.name.should eq :name
+        predicate.right.should eq 'Joe'
+      end
+
+      it 'creates an ARel Grouping node containing an Or node for Or nodes' do
+        left = :name.matches % 'Joe%'
+        right = :id.gt % 1
+        predicate = @v.accept(left | right)
+        predicate.should be_a Arel::Nodes::Grouping
+        predicate.expr.should be_a Arel::Nodes::Or
+        predicate.expr.left.should be_a Arel::Nodes::Matches
+        predicate.expr.right.should be_a Arel::Nodes::GreaterThan
+      end
+
+      it 'creates an ARel Not node for a Not node' do
+        expr = -(:name.matches % 'Joe%')
+        predicate = @v.accept(expr)
+        predicate.should be_a Arel::Nodes::Not
+      end
+
+      it 'creates an ARel NamedFunction node for a Function node' do
+        function = @v.accept(:find_in_set.func())
+        function.should be_a Arel::Nodes::NamedFunction
+      end
+
+      it 'maps symbols in Function args to ARel attributes' do
+        function = @v.accept(:find_in_set.func(:id, '1,2,3'))
+        function.to_sql.should match /"people"."id"/
+      end
+
+      it 'sets the alias on the ARel NamedFunction from the Function alias' do
+        function = @v.accept(:find_in_set.func(:id, '1,2,3').as('newname'))
+        function.to_sql.should match /newname/
+      end
+
+      it 'creates an ARel Addition node for an Operation node with + as operator' do
+        operation = @v.accept(dsl{id + 1})
+        operation.should be_a Arel::Nodes::Addition
+      end
+
+      it 'creates an ARel Subtraction node for an Operation node with - as operator' do
+        operation = @v.accept(dsl{id - 1})
+        operation.should be_a Arel::Nodes::Subtraction
+      end
+
+      it 'creates an ARel Multiplication node for an Operation node with * as operator' do
+        operation = @v.accept(dsl{id * 1})
+        operation.should be_a Arel::Nodes::Multiplication
+      end
+
+      it 'creates an ARel Division node for an Operation node with / as operator' do
+        operation = @v.accept(dsl{id / 1})
+        operation.should be_a Arel::Nodes::Division
+      end
+
+      it 'sets the alias on an InfixOperation from the Operation alias' do
+        operation = @v.accept(dsl{(id + 1).as(:incremented_id)})
+        operation.to_sql.should match /incremented_id/
+      end
+
+      context 'with polymorphic joins in the JoinDependency' do
+        before do
+          @jd = new_join_dependency(Note, dsl{[notable(Article), notable(Person)]}, [])
+          @c = Squeel::Adapters::ActiveRecord::Context.new(@jd)
+          @v = PredicateVisitor.new(@c)
+        end
+
+        it 'respects the polymorphic class in conditions' do
+          article_predicate = @v.accept dsl{{notable(Article) => {:title => 'Hello world!'}}}
+          person_predicate = @v.accept dsl{{notable(Person) => {:name => 'Ernie'}}}
+          article_predicate.left.relation.name.should eq 'articles'
+          person_predicate.left.relation.name.should eq 'people'
+        end
+      end
+
+    end
+  end
+end

data/spec/squeel/visitors/symbol_visitor_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Squeel
+  module Visitors
+    describe SymbolVisitor do
+      before do
+        @v = SymbolVisitor.new
+      end
+
+      it 'returns symbols unmodified' do
+        @v.accept(:blah).should eq :blah
+      end
+
+      it 'converts stubs to symbols' do
+        @v.accept(dsl{blah}).should eq :blah
+      end
+
+      it 'converts joins to their names' do
+        @v.accept(dsl{blah(Article)}).should eq :blah
+      end
+
+      it 'converts keypaths to their hash equivalents' do
+        @v.accept(dsl{one.two.three.four}).should eq({
+          :one => {:two => {:three => :four}}
+        })
+      end
+
+      it 'visits hashes' do
+        @v.accept(dsl{{
+          blah1 => {blah2(Article) => blah3}
+        }}).should eq({:blah1 => {:blah2 => :blah3}})
+      end
+
+      it 'visits arrays' do
+        @v.accept(dsl{[{
+          blah1 => {blah2(Article) => blah3}
+        }]}).should eq([{:blah1 => {:blah2 => :blah3}}])
+      end
+
+    end
+  end
+end

data/spec/support/schema.rb

@@ -0,0 +1,104 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+class Person < ActiveRecord::Base
+  belongs_to :parent, :class_name => 'Person', :foreign_key => :parent_id
+  has_many   :children, :class_name => 'Person', :foreign_key => :parent_id
+  has_many   :articles
+  has_many   :articles_with_condition, :class_name => 'Article', :conditions => {:title => 'Condition'}
+  has_many   :comments
+  has_many   :condition_article_comments, :through => :articles_with_condition, :source => :comments
+  has_many   :authored_article_comments, :through => :articles,
+             :source => :comments
+  has_many   :notes, :as => :notable
+end
+
+class Article < ActiveRecord::Base
+  belongs_to              :person
+  has_many                :comments
+  has_and_belongs_to_many :tags
+  has_many   :notes, :as => :notable
+  has_many :commenters, :through => :comments, :source => :person
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :person
+end
+
+class Tag < ActiveRecord::Base
+  has_and_belongs_to_many :articles
+end
+
+class Note < ActiveRecord::Base
+  belongs_to :notable, :polymorphic => true
+end
+
+module Schema
+  def self.create
+    ActiveRecord::Base.silence do
+      ActiveRecord::Migration.verbose = false
+
+      ActiveRecord::Schema.define do
+        create_table :people, :force => true do |t|
+          t.integer  :parent_id
+          t.string   :name
+          t.integer  :salary
+        end
+
+        create_table :articles, :force => true do |t|
+          t.integer :person_id
+          t.string  :title
+          t.text    :body
+        end
+
+        create_table :comments, :force => true do |t|
+          t.integer :article_id
+          t.integer :person_id
+          t.text    :body
+        end
+
+        create_table :tags, :force => true do |t|
+          t.string :name
+        end
+
+        create_table :articles_tags, :force => true, :id => false do |t|
+          t.integer :article_id
+          t.integer :tag_id
+        end
+
+        create_table :notes, :force => true do |t|
+          t.integer :notable_id
+          t.string  :notable_type
+          t.string  :note
+        end
+
+      end
+    end
+
+    10.times do
+      person = Person.make
+      Note.make(:notable => person)
+      3.times do
+        article = Article.make(:person => person)
+        3.times do
+          article.tags = [Tag.make, Tag.make, Tag.make]
+        end
+        Note.make(:notable => article)
+        10.times do
+          Comment.make(:article => article)
+        end
+      end
+      2.times do
+        Comment.make(:person => person)
+      end
+    end
+
+    Comment.make(:body => 'First post!', :article => Article.make(:title => 'Hello, world!'))
+
+  end
+end

data/squeel.gemspec

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "squeel/version"
+
+Gem::Specification.new do |s|
+  s.name        = "squeel_rbg"
+  s.version     = Squeel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Russen Guggemos"]
+  s.email       = ["rguggemos@berklee.edu"]
+  s.homepage    = "http://metautonomo.us/projects/squeel"
+  s.summary     = %q{ActiveRecord 3, improved.}
+  s.description = %q{
+      Squeel unlocks the power of ARel in your Rails 3 application with
+      a handy block-based syntax. You can write subqueries, access named
+      functions provided by your RDBMS, and more, all without writing
+      SQL strings.
+
+      I'm trying to push a version of this gem, so that bundler doesn't screw up with the :git included versions.
+    }
+  s.post_install_message = %q{
+*** Thanks for installing Squeel! ***
+Be sure to check out http://metautonomo.us/projects/squeel/ for a
+walkthrough of Squeel's features, and click the donate link if
+you're feeling especially appreciative. It'd help me justify this
+"open source" stuff to my lovely wife. :)
+
+}
+
+  s.rubyforge_project = "squeel_rbg"
+
+  s.add_dependency 'activerecord', '~> 3.0'
+  s.add_dependency 'activesupport', '~> 3.0'
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+  s.add_development_dependency 'machinist', '~> 1.0.6'
+  s.add_development_dependency 'faker', '~> 0.9.5'
+  s.add_development_dependency 'sqlite3', '~> 1.3.3'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end