arel 0.3.3 → 0.4.0

data/spec/attributes/boolean_spec.rb

@@ -54,4 +54,4 @@ module Arel
       end
     end
   end
-end
+end

data/spec/attributes/float_spec.rb

@@ -116,4 +116,4 @@ module Arel
       end
     end
   end
-end
+end

data/spec/attributes/header_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Arel
+  describe "Header" do
+    before :all do
+      @relation = Model.build do |r|
+        r.attribute :id,   Attributes::Integer
+        r.attribute :name, Attributes::String
+        r.attribute :age,  Attributes::Integer
+      end
+
+      @other = Model.build do |r|
+        r.attribute :foo, Attributes::String
+      end
+
+      @subset = Model.build do |r|
+        r.attribute :id, Attributes::Integer
+      end
+    end
+
+    describe "attribute lookup" do
+      it "finds attributes by name" do
+        @relation.attributes[:name].should == Attributes::String.new(@relation, :name)
+      end
+
+      it "returns nil if no attribute is found" do
+        @relation.attributes[:does_not_exist].should be_nil
+        @relation[:does_not_exist].should be_nil
+      end
+    end
+
+    describe "#union" do
+      it "keeps all attributes from disjoint headers" do
+        (@relation.attributes.union @other.attributes).to_ary.should have(4).items
+      end
+
+      it "keeps all attributes from both relations even if they seem like subsets" do
+        (@relation.attributes.union @subset.attributes).to_ary.should have(4).items
+      end
+    end
+  end
+end

data/spec/attributes/integer_spec.rb

@@ -116,4 +116,4 @@ module Arel
       end
     end
   end
-end
+end

data/spec/attributes/string_spec.rb

@@ -40,4 +40,4 @@ module Arel
       end
     end
   end
-end
+end

data/spec/attributes/time_spec.rb

@@ -16,7 +16,9 @@ module Arel
     end
 
     describe "#type_cast" do
-      it "works"
+      it "works" do
+        pending
+      end
     end
   end
-end
+end

data/spec/engines/memory/integration/joins/cross_engine_spec.rb

@@ -13,10 +13,9 @@ module Arel
       @photos.insert(@photos[:id] => 1, @photos[:user_id] => 1, @photos[:camera_id] => 6)
       @photos.insert(@photos[:id] => 2, @photos[:user_id] => 2, @photos[:camera_id] => 42)
       # Oracle adapter returns database integers as Ruby integers and not strings
-      @adapter_returns_integer = false
-      adapter_is :oracle do
-        @adapter_returns_integer = true
-      end
+      # So does the FFI sqlite library
+      db_int_return = @photos.project(@photos[:camera_id]).first.tuple.first
+      @adapter_returns_integer = db_int_return.is_a?(String) ? false : true
     end
 
     describe 'when the in memory relation is on the left' do

data/spec/engines/sql/unit/predicates/in_spec.rb

@@ -100,6 +100,28 @@ module Arel
           end
         end
 
+        describe 'when relating to a range with an excluded end' do
+          before do
+            @range = 1...3
+          end
+
+          it 'manufactures sql with a >= and <' do
+            sql = In.new(@attribute, @range).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{(`users`.`id` >= 1 AND `users`.`id` < 3)})
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{("USERS"."ID" >= 1 AND "USERS"."ID" < 3)})
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{("users"."id" >= 1 AND "users"."id" < 3)})
+            end
+          end
+        end
+
         describe 'when relating to a time range' do
           before do
             @relation = Arel::Table.new(:developers)
@@ -115,11 +137,7 @@ module Arel
             end
 
             adapter_is :sqlite3 do
-              if RUBY_VERSION < '1.9'
-                sql.should be_like(%Q{"developers"."created_at" BETWEEN '2010-01-01 00:00:00.000000' AND '2010-02-01 00:00:00.000000'})
-              else
-                sql.should be_like(%Q{"developers"."created_at" BETWEEN '2010-01-01 00:00:00' AND '2010-02-01 00:00:00'})
-              end
+              sql.should match(/"developers"."created_at" BETWEEN '2010-01-01 00:00:00(?:\.\d+)' AND '2010-02-01 00:00:00(?:\.\d+)'/)
             end
 
             adapter_is :postgresql do

data/spec/engines/sql/unit/predicates/noteq_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Arel
+  module Predicates
+    describe Equality do
+      before do
+        @relation1 = Arel::Table.new(:users)
+        @relation2 = Arel::Table.new(:photos)
+        @attribute1 = @relation1[:id]
+        @attribute2 = @relation2[:user_id]
+      end
+
+      describe '#to_sql' do
+        describe 'when relating to a non-nil value' do
+          it "manufactures a not predicate" do
+            sql = Inequality.new(@attribute1, @attribute2).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`id` != `photos`.`user_id`})
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{"USERS"."ID" != "PHOTOS"."USER_ID"})
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{"users"."id" != "photos"."user_id"})
+            end
+          end
+        end
+
+        describe 'when relation to a nil value' do
+          before do
+            @nil = nil
+          end
+
+          it "manufactures an is null predicate" do
+            sql = Inequality.new(@attribute1, @nil).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`id` IS NOT NULL})
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{"USERS"."ID" IS NOT NULL})
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{"users"."id" IS NOT NULL})
+            end
+          end
+        end
+
+        describe "when relating to a nil Value" do
+          it "manufactures an IS NULL predicate" do
+            value = nil.bind(@relation1)
+            sql = Inequality.new(@attribute1, value).to_sql
+
+            adapter_is :mysql do
+              sql.should be_like(%Q{`users`.`id` IS NOT NULL})
+            end
+
+            adapter_is :oracle do
+              sql.should be_like(%Q{"USERS"."ID" IS NOT NULL})
+            end
+
+            adapter_is_not :mysql, :oracle do
+              sql.should be_like(%Q{"users"."id" IS NOT NULL})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/engines/sql/unit/primitives/attribute_spec.rb

@@ -31,25 +31,6 @@ module Arel
           end
         end
       end
-
-      describe 'for an inexistent attribute' do
-        it "manufactures sql" do
-          sql = @relation[:does_not_exist].to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{`users`.`does_not_exist`})
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{"USERS"."DOEST_NOT_EXIST"})
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{"users"."does_not_exist"})
-          end
-        end
-      end
-
     end
   end
 end

data/spec/engines/sql/unit/relations/having_spec.rb

@@ -39,6 +39,39 @@ module Arel
           end
         end
       end
+
+      describe 'when given two predicates' do
+        it "manufactures sql with where clause conditions joined by AND" do
+          sql = @relation.group(@relation[:department]).having("MIN(salary) > 1000", "MAX(salary) < 10000").to_sql
+
+          adapter_is :mysql do
+            sql.should be_like(%Q{
+              SELECT `developers`.`id`, `developers`.`name`, `developers`.`salary`, `developers`.`department`, `developers`.`created_at`
+              FROM `developers`
+              GROUP BY `developers`.`department`
+              HAVING MIN(salary) > 1000 AND MAX(salary) < 10000
+            })
+          end
+
+          adapter_is :oracle do
+            sql.should be_like(%Q{
+              SELECT "DEVELOPERS"."ID", "DEVELOPERS"."NAME", "DEVELOPERS"."SALARY", "DEVELOPERS"."DEPARTMENT", "DEVELOPERS"."CREATED_AT"
+              FROM "DEVELOPERS"
+              GROUP BY "DEVELOPERS"."DEPARTMENT"
+              HAVING MIN(salary) > 1000 AND MAX(salary) < 10000
+            })
+          end
+
+          adapter_is_not :mysql, :oracle do
+            sql.should be_like(%Q{
+              SELECT "developers"."id", "developers"."name", "developers"."salary", "developers"."department", "developers"."created_at"
+              FROM "developers"
+              GROUP BY "developers"."department"
+              HAVING MIN(salary) > 1000 AND MAX(salary) < 10000
+            })
+          end
+        end
+      end
     end
   end
 end

data/spec/relations/join_spec.rb

@@ -13,6 +13,7 @@ describe "Arel" do
 
       r.attribute :id,       Arel::Attributes::Integer
       r.attribute :owner_id, Arel::Attributes::Integer
+      r.attribute :name,     Arel::Attributes::String
       r.attribute :age,      Arel::Attributes::Integer
     end
   end
@@ -28,13 +29,14 @@ describe "Arel" do
         8.times do |i|
           thing_id = owner_id * 8 + i
           age      = 2 * thing_id
+          name     = "Name #{thing_id % 6}"
 
-          @thing.insert([thing_id, owner_id, age])
-          @expected << Arel::Row.new(@relation, [thing_id, owner_id, age, owner_id])
+          @thing.insert([thing_id, owner_id, name, age])
+          @expected << Arel::Row.new(@relation, [thing_id, owner_id, name, age, owner_id])
         end
       end
     end
 
     it_should_behave_like 'A Relation'
   end
-end
+end

data/spec/relations/relation_spec.rb

@@ -14,7 +14,7 @@ describe "Arel" do
 
   describe "Relation" do
     before :all do
-      @expected = (1..20).map { |i| @relation.insert([i, nil, 2 * i]) }
+      @expected = (1..20).map { |i| @relation.insert([i, "Name #{i % 6}", 2 * i]) }
     end
 
     it_should_behave_like 'A Relation'
@@ -28,4 +28,4 @@ describe "Arel" do
       end
     end
   end
-end
+end

data/spec/shared/relation_spec.rb

@@ -35,9 +35,19 @@ share_examples_for 'A Relation' do
       @relation.where(@relation[:age].eq(@pivot[@relation[:age]])).should have_rows(expected)
     end
 
-    it "finds rows with a not predicate" do
+    it "finds rows with an equal to complement predicate" do
       expected = @expected.select { |r| r[@relation[:age]] != @pivot[@relation[:age]] }
-      @relation.where(@relation[:age].not(@pivot[@relation[:age]])).should have_rows(expected)
+      @relation.where(@relation[:age].eq(@pivot[@relation[:age]]).complement).should have_rows(expected)
+    end
+
+    it "finds rows with a not eq predicate" do
+      expected = @expected.select { |r| r[@relation[:age]] != @pivot[@relation[:age]] }
+      @relation.where(@relation[:age].not_eq(@pivot[@relation[:age]])).should have_rows(expected)
+    end
+
+    it "finds rows with an not eq complement predicate" do
+      expected = @expected.select { |r| r[@relation[:age]] == @pivot[@relation[:age]] }
+      @relation.where(@relation[:age].not_eq(@pivot[@relation[:age]]).complement).should have_rows(expected)
     end
 
     it "finds rows with a less than predicate" do
@@ -45,52 +55,155 @@ share_examples_for 'A Relation' do
       @relation.where(@relation[:age].lt(@pivot[@relation[:age]])).should have_rows(expected)
     end
 
+    it "finds rows with a less than complement predicate" do
+      expected = @expected.select { |r| r[@relation[:age]] >= @pivot[@relation[:age]] }
+      @relation.where(@relation[:age].lt(@pivot[@relation[:age]]).complement).should have_rows(expected)
+    end
+
     it "finds rows with a less than or equal to predicate" do
       expected = @expected.select { |r| r[@relation[:age]] <= @pivot[@relation[:age]] }
       @relation.where(@relation[:age].lteq(@pivot[@relation[:age]])).should have_rows(expected)
     end
 
+    it "finds rows with a less than or equal to complement predicate" do
+      expected = @expected.select { |r| r[@relation[:age]] > @pivot[@relation[:age]] }
+      @relation.where(@relation[:age].lteq(@pivot[@relation[:age]]).complement).should have_rows(expected)
+    end
+
     it "finds rows with a greater than predicate" do
       expected = @expected.select { |r| r[@relation[:age]] > @pivot[@relation[:age]] }
       @relation.where(@relation[:age].gt(@pivot[@relation[:age]])).should have_rows(expected)
     end
 
+    it "finds rows with a greater than complement predicate" do
+      expected = @expected.select { |r| r[@relation[:age]] <= @pivot[@relation[:age]] }
+      @relation.where(@relation[:age].gt(@pivot[@relation[:age]]).complement).should have_rows(expected)
+    end
+
     it "finds rows with a greater than or equal to predicate" do
       expected = @expected.select { |r| r[@relation[:age]] >= @pivot[@relation[:age]] }
       @relation.where(@relation[:age].gteq(@pivot[@relation[:age]])).should have_rows(expected)
     end
 
-    it "finds rows with a matches predicate"
+    it "finds rows with a greater than or equal to complement predicate" do
+      expected = @expected.select { |r| r[@relation[:age]] < @pivot[@relation[:age]] }
+      @relation.where(@relation[:age].gteq(@pivot[@relation[:age]]).complement).should have_rows(expected)
+    end
+
+    it "finds rows with a matches predicate" do
+      expected = @expected.select { |r| r[@relation[:name]] =~ /#{@pivot[@relation[:name]]}/ }
+      @relation.where(@relation[:name].matches(/#{@pivot[@relation[:name]]}/)).should have_rows(expected)
+    end
+
+    it "finds rows with a matches complement predicate" do
+      expected = @expected.select { |r| r[@relation[:name]] !~ /#{@pivot[@relation[:name]]}/ }
+      @relation.where(@relation[:name].matches(/#{@pivot[@relation[:name]]}/).complement).should have_rows(expected)
+    end
+
+    it "finds rows with a not matches predicate" do
+      expected = @expected.select { |r| r[@relation[:name]] !~ /#{@pivot[@relation[:name]]}/ }
+      @relation.where(@relation[:name].not_matches(/#{@pivot[@relation[:name]]}/)).should have_rows(expected)
+    end
+
+    it "finds rows with a not matches complement predicate" do
+      expected = @expected.select { |r| r[@relation[:name]] =~ /#{@pivot[@relation[:name]]}/ }
+      @relation.where(@relation[:name].not_matches(/#{@pivot[@relation[:name]]}/).complement).should have_rows(expected)
+    end
 
     it "finds rows with an in predicate" do
-      pending
-      set = @expected[1..(@expected.length/2+1)]
-      @relation.all(:id.in => set.map { |r| r.id }).should have_resources(set)
+      expected = @expected.select {|r| r[@relation[:age]] >=3 && r[@relation[:age]] <= 20}
+      @relation.where(@relation[:age].in(3..20)).should have_rows(expected)
+    end
+
+    it "finds rows with an in complement predicate" do
+      expected = @expected.select {|r| !(r[@relation[:age]] >=3 && r[@relation[:age]] <= 20)}
+      @relation.where(@relation[:age].in(3..20).complement).should have_rows(expected)
+    end
+
+    it "finds rows with a not in predicate" do
+      expected = @expected.select {|r| !(r[@relation[:age]] >=3 && r[@relation[:age]] <= 20)}
+      @relation.where(@relation[:age].not_in(3..20)).should have_rows(expected)
+    end
+
+    it "finds rows with a not in complement predicate" do
+      expected = @expected.select {|r| r[@relation[:age]] >=3 && r[@relation[:age]] <= 20}
+      @relation.where(@relation[:age].not_in(3..20).complement).should have_rows(expected)
+    end
+
+    it "finds rows with a polyadic predicate of class Any" do
+      expected = @expected.select {|r| [2,4,8,16].include?(r[@relation[:age]])}
+      @relation.where(@relation[:age].in_any([2,4], [8, 16])).should have_rows(expected)
+    end
+
+    it "finds rows with a polyadic predicate of class Any complement" do
+      expected = @expected.select {|r| ![2,4,8,16].include?(r[@relation[:age]])}
+      @relation.where(@relation[:age].in_any([2,4], [8, 16]).complement).should have_rows(expected)
+    end
+
+    it "finds rows with a polyadic predicate of class All" do
+      expected = @expected.select {|r| r[@relation[:name]] =~ /Name/ && r[@relation[:name]] =~ /1/}
+      @relation.where(@relation[:name].matches_all(/Name/, /1/)).should have_rows(expected)
+    end
+
+    it "finds rows with a polyadic predicate of class All complement" do
+      expected = @expected.select {|r| !(r[@relation[:name]] =~ /Name/ && r[@relation[:name]] =~ /1/)}
+      @relation.where(@relation[:name].matches_all(/Name/, /1/).complement).should have_rows(expected)
     end
   end
 
   describe "#order" do
     describe "by one attribute" do
       before :all do
-        @expected.map! { |r| r[@relation[:age]] }
-        @expected.sort!
+        @expected.sort! { |a, b| a[@relation[:age]] <=> b[@relation[:age]]}.map! {|e| e[@relation[:id]]}
       end
 
       it "can be specified as ascending order" do
         actual = []
-        @relation.order(@relation[:age].asc).each { |r| actual << r[@relation[:age]] }
+        @relation.order(@relation[:age].asc).each { |r| actual << r[@relation[:id]] }
         actual.should == @expected
       end
 
       it "can be specified as descending order" do
         actual = []
-        @relation.order(@relation[:age].desc).each { |r| actual << r[@relation[:age]] }
+        @relation.order(@relation[:age].desc).each { |r| actual << r[@relation[:id]] }
         actual.should == @expected.reverse
       end
     end
 
-    describe "by two attributes" do
-      it "works"
+    describe "by two attributes in two separate calls to #order" do
+      before :all do
+        @expected = @expected.sort_by { |e| [e[@relation[:name]], e[@relation[:age]]]}.map {|e| e[@relation[:id]]}
+      end
+
+      it "can be specified as ascending order" do
+        actual = []
+        @relation.order(@relation[:age].asc).order(@relation[:name].asc).each { |r| actual << r[@relation[:id]] }
+        actual.should == @expected
+      end
+
+      it "can be specified as descending order" do
+        actual = []
+        @relation.order(@relation[:age].desc).order(@relation[:name].desc).each { |r| actual << r[@relation[:id]] }
+        actual.should == @expected.reverse
+      end
+    end
+
+    describe "by two attributes in one call to #order" do
+      before :all do
+        @expected = @expected.sort_by { |e| [e[@relation[:name]], e[@relation[:age]]]}.map {|e| e[@relation[:id]]}
+      end
+
+      it "can be specified as ascending order in one call to #order" do
+        actual = []
+        @relation.order(@relation[:name].asc, @relation[:age].asc).each { |r| actual << r[@relation[:id]] }
+        actual.should == @expected
+      end
+
+      it "can be specified as descending order in one call to #order" do
+        actual = []
+        @relation.order(@relation[:name].desc, @relation[:age].desc).each { |r| actual << r[@relation[:id]] }
+        actual.should == @expected.reverse
+      end
     end
   end
 
@@ -139,4 +252,4 @@ share_examples_for 'A Relation' do
       actual.should == expected[3..-1]
     end
   end
-end
+end