arel 1.0.1 → 2.0.0

data/spec/relations/join_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe "Arel" do
-  before :all do
-    @owner = Arel::Model.build do |r|
-      r.engine Arel::Testing::Engine.new
-
-      r.attribute :id, Arel::Attributes::Integer
-    end
-
-    @thing = Arel::Model.build do |r|
-      r.engine Arel::Testing::Engine.new
-
-      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
-
-  describe "Join" do
-    before :all do
-      @relation = @thing.join(@owner).on(@thing[:owner_id].eq(@owner[:id]))
-      @expected = []
-
-      3.times do |owner_id|
-        @owner.insert([owner_id])
-
-        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, 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

data/spec/relations/relation_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe "Arel" do
-  before :all do
-    @engine = Arel::Testing::Engine.new
-    @relation = Arel::Model.build do |r|
-      r.engine @engine
-
-      r.attribute :id,   Arel::Attributes::Integer
-      r.attribute :name, Arel::Attributes::String
-      r.attribute :age,  Arel::Attributes::Integer
-    end
-  end
-
-  describe "Relation" do
-    before :all do
-      @expected = (1..20).map { |i| @relation.insert([i, "Name #{i % 6}", 2 * i]) }
-    end
-
-    it_should_behave_like 'A Relation'
-  end
-
-  describe "Relation" do
-    describe "#insert" do
-      it "inserts the row into the engine" do
-        @relation.insert([1, 'Foo', 10])
-        @engine.rows.should == [[1, 'Foo', 10]]
-      end
-    end
-  end
-end

data/spec/shared/relation_spec.rb

@@ -1,255 +0,0 @@
-share_examples_for 'A Relation' do
-
-  before :all do
-    # The two needed instance variables need to be set in a
-    # before :all callback.
-    #   @relation is the relation being tested here.
-    #   @expected is an array of the elements that are expected to be in
-    #     the relation.
-    %w[ @relation @expected ].each do |ivar|
-      raise "#{ivar} needs to be defined" unless instance_variable_get(ivar)
-    end
-
-    # There needs to be enough items to be able to run all the tests
-    raise "@expected needs to have at least 6 items" unless @expected.length >= 6
-  end
-
-  before :each do
-    @expected = @expected.dup
-  end
-
-  describe "#each" do
-    it "iterates over the rows in any order" do
-      @relation.should have_rows(@expected)
-    end
-  end
-
-  describe "#where" do
-    before :all do
-      @expected = @expected.sort_by { |r| r[@relation[:age]] }
-      @pivot = @expected[@expected.length / 2]
-    end
-
-    it "finds rows with an equal to predicate" do
-      expected = @expected.select { |r| r[@relation[:age]] == @pivot[@relation[:age]] }
-      @relation.where(@relation[:age].eq(@pivot[@relation[:age]])).should have_rows(expected)
-    end
-
-    it "finds rows with an equal to complement predicate" do
-      expected = @expected.select { |r| r[@relation[:age]] != @pivot[@relation[:age]] }
-      @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
-      expected = @expected.select { |r| r[@relation[:age]] < @pivot[@relation[:age]] }
-      @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 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
-      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.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[:id]] }
-        actual.should == @expected
-      end
-
-      it "can be specified as descending order" do
-        actual = []
-        @relation.order(@relation[:age].desc).each { |r| actual << r[@relation[:id]] }
-        actual.should == @expected.reverse
-      end
-    end
-
-    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
-
-  describe "#take" do
-    it "returns a relation" do
-      @relation.take(3).should be_a(Arel::Relation)
-    end
-
-    it "returns X items from the collection" do
-      length = @expected.length
-
-      @relation.take(3).each do |resource|
-        @expected.delete_if { |r| r.tuple == resource.tuple }
-      end
-
-      @expected.length.should == length - 3
-    end
-
-    it "works with ordering" do
-      expected = @expected.sort_by { |r| [r[@relation[:age]], r[@relation[:id]]] }.map { |r| r[@relation[:id]] }
-      actual   = @relation.order(@relation[:age].asc, @relation[:id].asc).take(3).map { |r| r[@relation[:id]] }
-
-      actual.should == expected[0,3]
-    end
-  end
-
-  describe "#skip" do
-    it "returns a relation" do
-      @relation.skip(3).should be_a(Arel::Relation)
-    end
-
-    it "skips X items from the collection" do
-      length = @expected.length
-
-      @relation.skip(3).each do |resource|
-        @expected.delete_if { |r| r.tuple == resource.tuple }
-      end
-
-      @expected.length.should == 3
-    end
-
-    it "works with ordering" do
-      expected = @expected.sort_by { |r| [r[@relation[:age]], r[@relation[:id]]] }.map { |r| r[@relation[:id]] }
-      actual   = @relation.order(@relation[:age].asc, @relation[:id].asc).skip(3).map { |r| r[@relation[:id]] }
-
-      actual.should == expected[3..-1]
-    end
-  end
-end

data/spec/sql/christener_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  module Sql
-    describe "Christener" do
-      it "returns the first name" do
-        christener = Christener.new
-        table = Table.new 'users'
-        table2 = Table.new 'pictures'
-        christener.name_for(table).should == 'users'
-        christener.name_for(table2).should == 'pictures'
-        christener.name_for(table).should == 'users'
-      end
-
-      it "returns a unique name for an alias" do
-        christener = Christener.new
-        table = Table.new 'users'
-        table2 = Table.new 'users', :as => 'friends'
-        christener.name_for(table).should == 'users'
-        christener.name_for(table2).should == 'friends'
-      end
-
-      it "returns a unique name for an alias with same name" do
-        christener = Christener.new
-        table = Table.new 'users'
-        table2 = Table.new 'friends', :as => 'users'
-        christener.name_for(table).should == 'users'
-        christener.name_for(table2).should == 'users_2'
-      end
-
-      it "returns alias name" do
-        christener = Christener.new
-        table = Table.new 'users'
-        aliaz = Alias.new table
-
-        christener.name_for(table).should == 'users'
-        christener.name_for(aliaz).should == 'users_2'
-      end
-
-      it "returns alias first" do
-        christener = Christener.new
-        table = Table.new 'users'
-        aliaz = Alias.new table
-
-        christener.name_for(aliaz).should == 'users'
-        christener.name_for(table).should == 'users_2'
-      end
-
-      it "returns externalization name" do
-        christener = Christener.new
-        table = Table.new 'users'
-        ext = Externalization.new table
-
-        christener.name_for(table).should == 'users'
-        christener.name_for(ext).should == 'users_external'
-      end
-
-      it "returns aliases externalizations and tables" do
-        christener = Christener.new
-        table = Table.new 'users'
-        aliaz = Alias.new table
-        ext = Externalization.new table
-
-        christener.name_for(table).should == 'users'
-        christener.name_for(aliaz).should == 'users_2'
-        christener.name_for(ext).should == 'users_external'
-      end
-    end
-  end
-end

data/spec/support/connections/mysql_connection.rb

@@ -1,14 +0,0 @@
-puts "Using native MySQL"
-require "active_record"
-require 'logger'
-
-ENV['ADAPTER'] = 'mysql'
-
-ActiveRecord::Base.configurations = {
-  'unit' => {
-    :adapter  => 'mysql',
-    :username => 'root',
-    :encoding => 'utf8',
-    :database => 'arel_unit',
-  }
-}

data/spec/support/connections/oracle_connection.rb

@@ -1,17 +0,0 @@
-puts "Using native Oracle"
-require "active_record"
-require 'logger'
-
-ENV['ADAPTER'] = 'oracle'
-
-# Prepend oracle_enhanced local development directory in front of load path
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../../oracle-enhanced/lib"
-
-ActiveRecord::Base.configurations = {
-  'unit' => {
-    :adapter  => 'oracle_enhanced',
-    :username => 'arel_unit',
-    :password => 'arel_unit',
-    :database => 'orcl',
-  }
-}

data/spec/support/connections/postgresql_connection.rb

@@ -1,13 +0,0 @@
-puts "Using native PostgreSQL"
-require "active_record"
-require 'logger'
-
-ENV['ADAPTER'] = 'postgresql'
-
-ActiveRecord::Base.configurations = {
-  'unit' => {
-    :adapter  => 'postgresql',
-    :encoding => 'utf8',
-    :database => 'arel_unit',
-  }
-}