arel 1.0.1 → 2.0.0

data/spec/attributes/string_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'bigdecimal'
-
-module Arel
-  describe "Attributes::String" do
-
-    before :all do
-      @relation = Model.build do |r|
-        r.engine Testing::Engine.new
-        r.attribute :name, Attributes::String
-      end
-    end
-
-    def type_cast(val)
-      @relation[:name].type_cast(val)
-    end
-
-    describe "#type_cast" do
-      it "returns same value if passed a String" do
-        val = "hell"
-        type_cast(val).should eql(val)
-      end
-
-      it "returns nil if passed nil" do
-        type_cast(nil).should be_nil
-      end
-
-      it "returns String representation of Symbol" do
-        type_cast(:hello).should == "hello"
-      end
-
-      it "returns string representation of Integer" do
-        type_cast(1).should == '1'
-      end
-
-      it "calls #to_s on arbitrary objects" do
-        obj = Object.new
-        obj.extend Module.new { def to_s ; 'hello' ; end }
-        type_cast(obj).should == 'hello'
-      end
-    end
-  end
-end

data/spec/attributes/time_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'bigdecimal'
-
-module Arel
-  describe "Attributes::Time" do
-
-    before :all do
-      @relation = Model.build do |r|
-        r.engine Testing::Engine.new
-        r.attribute :created_at, Attributes::Time
-      end
-    end
-
-    def type_cast(val)
-      @relation[:created_at].type_cast(val)
-    end
-
-    describe "#type_cast" do
-      it "works" do
-        pending
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Join do
-    before do
-      @users = Array.new([
-        [1, 'bryan' ],
-        [2, 'emilio' ],
-        [3, 'nick']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-      @photos = Table.new(:photos)
-      @photos.delete
-      @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
-      # 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
-      it 'joins across engines' do
-        @users                                         \
-          .join(@photos)                               \
-            .on(@users[:id].eq(@photos[:user_id]))     \
-          .project(@users[:name], @photos[:camera_id]) \
-        .tap do |relation|
-          rows = relation.call
-          rows.length.should == 2
-          [
-            ['bryan', @adapter_returns_integer ? 6 : '6'],
-            ['emilio', @adapter_returns_integer ? 42 : '42']
-          ].zip(rows).each do |tuple, row|
-            row.relation.should == relation
-            row.tuple.should == tuple
-          end
-        end
-      end
-    end
-
-    describe 'when the in memory relation is on the right' do
-      it 'joins across engines' do
-        @photos                                        \
-          .join(@users)                                \
-            .on(@users[:id].eq(@photos[:user_id]))     \
-          .project(@users[:name], @photos[:camera_id]) \
-        .tap do |relation|
-          rows = relation.call
-          rows.length.should == 2
-          [
-            ['bryan', @adapter_returns_integer ? 6 : '6'],
-            ['emilio', @adapter_returns_integer ? 42 : '42']
-          ].zip(rows).each do |tuple, row|
-            row.relation.should == relation
-            row.tuple.should == tuple
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/array_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Array do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#attributes' do
-      it 'manufactures attributes corresponding to the names given on construction' do
-        @relation.attributes.should == [
-          Attribute.new(@relation, :id),
-          Attribute.new(@relation, :name)
-        ]
-      end
-    end
-
-    describe '#call' do
-      it "manufactures an array of hashes of attributes to values" do
-        rows = @relation.call
-        rows.length.should == 3
-        @relation.array.zip(rows).each do |tuple, row|
-          row.relation.should == @relation
-          row.tuple.should == tuple
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/insert_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Insert do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#call' do
-      it "manufactures an array of hashes of attributes to values" do
-        @relation                                                         \
-          .insert(@relation[:id] => 4, @relation[:name] => 'guinea fowl') \
-         do |relation|
-           relation.should == [
-             Row.new(relation, [1, 'duck']),
-             Row.new(relation, [2, 'duck']),
-             Row.new(relation, [3, 'goose']),
-             Row.new(relation, [4, 'guinea fowl'])
-           ]
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/join_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Join do
-    before do
-      @relation1 = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-      @relation2 = @relation1.alias
-    end
-
-    describe InnerJoin do
-      describe '#call' do
-        it 'combines the two tables where the predicate obtains' do
-          @relation1                                    \
-            .join(@relation2)                           \
-              .on(@relation1[:id].eq(@relation2[:id]))  \
-          .tap do |relation|
-            rows = relation.call
-            rows.length.should == 3
-            @relation1.array.zip(rows).each do |tuple, row|
-              row.relation.should == relation
-              row.tuple.should == (tuple * 2)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/order_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Order do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#call' do
-      it 'sorts the relation with the provided ordering' do
-        @relation                     \
-          .order(@relation[:id].desc) \
-        .tap do |relation|
-          rows = relation.call
-          rows.length.should == 3
-          @relation.array.reverse.zip(rows) do |tuple, row|
-            row.relation.should == relation
-            row.tuple.should == tuple
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/project_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Project do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#call' do
-      it 'retains only the attributes that are provided' do
-        @relation                   \
-          .project(@relation[:id])  \
-        .tap do |relation|
-          rows = relation.call
-          @relation.array.zip(rows) do |tuple, row|
-            row.relation.should == relation
-            row.tuple.should == [tuple.first]
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/skip_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Skip do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#call' do
-      it 'removes the first n rows' do
-        @relation   \
-          .skip(1)  \
-        .tap do |relation|
-          rows = relation.call
-          rows.length.should == 2
-          one, two = *rows
-
-          one.relation.should == relation
-          one.tuple.should == [2, 'duck']
-
-          two.relation.should == relation
-          two.tuple.should == [3, 'goose']
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/take_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Take do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#call' do
-      it 'removes the rows after the first n' do
-        @relation   \
-          .take(2)  \
-        .tap do |relation|
-          rows = relation.call
-          rows.length.should == 2
-          rows.each_with_index do |row, i|
-            row.relation.should == relation
-            row.tuple.should == [i + 1, 'duck']
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/memory/unit/relations/where_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Where do
-    before do
-      @relation = Array.new([
-        [1, 'duck' ],
-        [2, 'duck' ],
-        [3, 'goose']
-      ], [[:id, Attributes::Integer], [:name, Attributes::String]])
-    end
-
-    describe '#call' do
-      it 'filters the relation with the provided predicate' do
-        @relation                       \
-          .where(@relation[:id].lt(3))  \
-        .tap do |relation|
-          rows = relation.call
-          rows.length.should == 2
-          rows.each_with_index do |row, i|
-            row.relation.should == relation
-            row.tuple.should == [i + 1, 'duck']
-          end
-        end
-      end
-
-      describe 'when filtering a where relation' do
-        it 'further filters the already-filtered relation with the provided predicate' do
-          @relation                       \
-            .where(@relation[:id].gt(1))  \
-            .where(@relation[:id].lt(3))  \
-          .tap do |relation|
-            rows = relation.call
-            rows.length.should == 1
-            row = rows.first
-            row.relation.should == relation
-            row.tuple.should == [2, 'duck']
-          end
-        end
-      end
-    end
-  end
-end

data/spec/engines/sql/integration/joins/with_adjacency_spec.rb

@@ -1,258 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Join do
-    before do
-      @relation1 = Table(:users)
-      @relation2 = @relation1.alias
-      @predicate = @relation1[:id].eq(@relation2[:id])
-    end
-
-    describe 'when joining a relation to itself' do
-      describe '#to_sql' do
-        it 'manufactures sql aliasing the table and attributes properly in the join predicate and the where clause' do
-          sql = @relation1.join(@relation2).on(@predicate).to_sql
-
-          adapter_is :mysql do
-            sql.should be_like(%Q{
-              SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`
-              FROM `users`
-                INNER JOIN `users` `users_2`
-                  ON `users`.`id` = `users_2`.`id`
-            })
-          end
-
-          adapter_is :oracle do
-            sql.should be_like(%Q{
-              SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME"
-              FROM "USERS"
-                INNER JOIN "USERS" "USERS_2"
-                  ON "USERS"."ID" = "USERS_2"."ID"
-            })
-          end
-
-          adapter_is_not :mysql, :oracle do
-            sql.should be_like(%Q{
-              SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name"
-              FROM "users"
-                INNER JOIN "users" "users_2"
-                  ON "users"."id" = "users_2"."id"
-            })
-          end
-        end
-
-        describe 'when joining with a where on the same relation' do
-          it 'manufactures sql aliasing the tables properly' do
-            sql = @relation1                                 \
-              .join(@relation2.where(@relation2[:id].eq(1))) \
-                .on(@predicate)                              \
-            .to_sql
-
-            adapter_is :mysql do
-              sql.should be_like(%Q{
-                SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`
-                FROM `users`
-                  INNER JOIN `users` `users_2`
-                    ON `users`.`id` = `users_2`.`id` AND `users_2`.`id` = 1
-              })
-            end
-
-            adapter_is :oracle do
-              sql.should be_like(%Q{
-                SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME"
-                FROM "USERS"
-                  INNER JOIN "USERS" "USERS_2"
-                    ON "USERS"."ID" = "USERS_2"."ID" AND "USERS_2"."ID" = 1
-              })
-            end
-
-            adapter_is_not :mysql, :oracle do
-              sql.should be_like(%Q{
-                SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name"
-                FROM "users"
-                  INNER JOIN "users" "users_2"
-                    ON "users"."id" = "users_2"."id" AND "users_2"."id" = 1
-              })
-            end
-          end
-
-          describe 'when the where occurs before the alias' do
-            it 'manufactures sql aliasing the predicates properly' do
-              relation2 = @relation1.where(@relation1[:id].eq(1)).alias
-
-              sql = @relation1                            \
-                .join(relation2)                          \
-                  .on(relation2[:id].eq(@relation1[:id])) \
-              .to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{
-                  SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`
-                  FROM `users`
-                  INNER JOIN `users` `users_2`
-                    ON `users_2`.`id` = `users`.`id` AND `users_2`.`id` = 1
-                })
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{
-                  SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME"
-                  FROM "USERS"
-                  INNER JOIN "USERS" "USERS_2"
-                    ON "USERS_2"."ID" = "USERS"."ID" AND "USERS_2"."ID" = 1
-                })
-              end
-
-              adapter_is_not :mysql, :oracle do
-                sql.should be_like(%Q{
-                  SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name"
-                  FROM "users"
-                  INNER JOIN "users" "users_2"
-                    ON "users_2"."id" = "users"."id" AND "users_2"."id" = 1
-                })
-              end
-            end
-          end
-        end
-
-        describe 'when joining the relation to itself multiple times' do
-          before do
-            @relation3 = @relation1.alias
-          end
-
-          describe 'when joining left-associatively' do
-            it 'manufactures sql aliasing the tables properly' do
-              sql = @relation1                                \
-                .join(@relation2                              \
-                  .join(@relation3)                           \
-                    .on(@relation2[:id].eq(@relation3[:id]))) \
-                  .on(@relation1[:id].eq(@relation2[:id]))                                 \
-              .to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{
-                  SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`, `users_3`.`id`, `users_3`.`name`
-                  FROM `users`
-                    INNER JOIN `users` `users_2`
-                      ON `users`.`id` = `users_2`.`id`
-                    INNER JOIN `users` `users_3`
-                      ON `users_2`.`id` = `users_3`.`id`
-                })
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{
-                  SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME", "USERS_3"."ID", "USERS_3"."NAME"
-                  FROM "USERS"
-                    INNER JOIN "USERS" "USERS_2"
-                      ON "USERS"."ID" = "USERS_2"."ID"
-                    INNER JOIN "USERS" "USERS_3"
-                      ON "USERS_2"."ID" = "USERS_3"."ID"
-                })
-              end
-
-              adapter_is_not :mysql, :oracle do
-                sql.should be_like(%Q{
-                  SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name", "users_3"."id", "users_3"."name"
-                  FROM "users"
-                    INNER JOIN "users" "users_2"
-                      ON "users"."id" = "users_2"."id"
-                    INNER JOIN "users" "users_3"
-                      ON "users_2"."id" = "users_3"."id"
-                })
-              end
-            end
-          end
-
-          describe 'when joining right-associatively' do
-            it 'manufactures sql aliasing the tables properly' do
-              sql = @relation1                                              \
-                .join(@relation2).on(@relation1[:id].eq(@relation2[:id]))   \
-                .join(@relation3).on(@relation2[:id].eq(@relation3[:id]))   \
-              .to_sql
-
-              adapter_is :mysql do
-                sql.should be_like(%Q{
-                  SELECT `users`.`id`, `users`.`name`, `users_2`.`id`, `users_2`.`name`, `users_3`.`id`, `users_3`.`name`
-                  FROM `users`
-                    INNER JOIN `users` `users_2`
-                      ON `users`.`id` = `users_2`.`id`
-                    INNER JOIN `users` `users_3`
-                      ON `users_2`.`id` = `users_3`.`id`
-                })
-              end
-
-              adapter_is :oracle do
-                sql.should be_like(%Q{
-                  SELECT "USERS"."ID", "USERS"."NAME", "USERS_2"."ID", "USERS_2"."NAME", "USERS_3"."ID", "USERS_3"."NAME"
-                  FROM "USERS"
-                    INNER JOIN "USERS" "USERS_2"
-                      ON "USERS"."ID" = "USERS_2"."ID"
-                    INNER JOIN "USERS" "USERS_3"
-                      ON "USERS_2"."ID" = "USERS_3"."ID"
-                })
-              end
-
-              adapter_is_not :mysql, :oracle do
-                sql.should be_like(%Q{
-                  SELECT "users"."id", "users"."name", "users_2"."id", "users_2"."name", "users_3"."id", "users_3"."name"
-                  FROM "users"
-                    INNER JOIN "users" "users_2"
-                      ON "users"."id" = "users_2"."id"
-                    INNER JOIN "users" "users_3"
-                      ON "users_2"."id" = "users_3"."id"
-                })
-              end
-            end
-          end
-        end
-      end
-
-      describe '[]' do
-        describe 'when given an attribute belonging to both sub-relations' do
-          it 'disambiguates the relation that serves as the ancestor to the attribute' do
-            @relation1          \
-              .join(@relation2) \
-                .on(@predicate) \
-            .should disambiguate_attributes(@relation1[:id], @relation2[:id])
-          end
-
-          describe 'when both relations are compound and only one is an alias' do
-            it 'disambiguates the relation that serves as the ancestor to the attribute' do
-              compound1 = @relation1.where(@predicate)
-              compound2 = compound1.alias
-              compound1           \
-                .join(compound2)  \
-                  .on(@predicate) \
-              .should disambiguate_attributes(compound1[:id], compound2[:id])
-            end
-          end
-
-          describe 'when the left relation is extremely compound' do
-            it 'disambiguates the relation that serves as the ancestor to the attribute' do
-              @relation1            \
-                .where(@predicate)  \
-                .where(@predicate)  \
-                .join(@relation2)   \
-                  .on(@predicate)   \
-              .should disambiguate_attributes(@relation1[:id], @relation2[:id])
-            end
-          end
-
-          describe 'when the right relation is extremely compound' do
-            it 'disambiguates the relation that serves as the ancestor to the attribute' do
-              @relation1                  \
-                .join(                    \
-                  @relation2              \
-                    .where(@predicate)    \
-                    .where(@predicate)    \
-                    .where(@predicate))   \
-                  .on(@predicate)         \
-              .should disambiguate_attributes(@relation1[:id], @relation2[:id])
-            end
-          end
-        end
-      end
-    end
-  end
-end