arel 1.0.1 → 2.0.0

data/lib/arel/engines/sql/relations/table.rb

@@ -1,100 +0,0 @@
-module Arel
-  class Table
-    include Relation, Recursion::BaseCase
-
-    @@engine = nil
-    @@tables = nil
-    class << self # FIXME: Do we really need these?
-      def engine; @@engine; end
-      def engine= e; @@engine = e; end
-
-      def tables; @@tables; end
-      def tables= e; @@tables = e; end
-    end
-
-    attr_reader :name, :engine, :table_alias, :options, :christener
-
-    def initialize(name, options = {})
-      @name = name.to_s
-      @table_exists = nil
-      @table_alias = nil
-      @christener = Sql::Christener.new
-      @attributes = nil
-      @matching_attributes = nil
-
-      if options.is_a?(Hash)
-        @options = options
-        @engine = options[:engine] || Table.engine
-
-        if options[:as]
-          as = options[:as].to_s
-          @table_alias = as unless as == @name
-        end
-      else
-        @engine = options # Table.new('foo', engine)
-      end
-
-      if @engine.connection
-        begin
-          require "arel/engines/sql/compilers/#{@engine.adapter_name.downcase}_compiler"
-        rescue LoadError
-          begin
-            # try to load an externally defined compiler, in case this adapter has defined the compiler on its own.
-            require "#{@engine.adapter_name.downcase}/arel_compiler"
-          rescue LoadError
-            raise "#{@engine.adapter_name} is not supported by Arel."
-          end
-        end
-
-        @@tables ||= engine.connection.tables
-      end
-    end
-
-    def as(table_alias)
-      Table.new(name, options.merge(:as => table_alias))
-    end
-
-    def table_exists?
-      @table_exists ||= @@tables.include?(name) || engine.connection.table_exists?(name)
-    end
-
-    def attributes
-      return @attributes if @attributes
-      if table_exists?
-        attrs = columns.collect do |column|
-          Sql::Attributes.for(column).new(column, self, column.name.to_sym)
-        end
-        @attributes = Header.new(attrs)
-      else
-        Header.new
-      end
-    end
-
-    def column_for(attribute)
-      has_attribute?(attribute) and columns.detect { |c| c.name == attribute.name.to_s }
-    end
-
-    def columns
-      @columns ||= engine.connection.columns(name, "#{name} Columns")
-    end
-
-    def reset
-      @columns = nil
-      @attributes = Header.new([])
-    end
-
-    private
-    def matching_attributes
-      @matching_attributes ||= Hash[attributes.map { |a| [a.root, true] }]
-    end
-
-    def has_attribute?(attribute)
-      matching_attributes.key? attribute.root
-    end
-  end
-end
-
-def Table(name, engine = Arel::Table.engine)
-  Arel::Table.new(name, engine)
-end
-

data/lib/arel/engines/sql/relations/utilities/nil.rb

@@ -1,6 +0,0 @@
-module Arel
-  class Nil
-    def table_sql(formatter = nil); '' end
-    def name; '' end
-  end
-end

data/lib/arel/recursion/base_case.rb

@@ -1,13 +0,0 @@
-module Arel
-  module Recursion
-    module BaseCase
-      def table
-        self
-      end
-
-      def table_sql(formatter = Sql::TableReference.new(self))
-        formatter.table self
-      end
-    end
-  end
-end

data/lib/arel/session.rb

@@ -1,35 +0,0 @@
-module Arel
-  class Session
-    @instance = nil
-
-    def self.instance
-      @instance || new
-    end
-
-    def self.start
-      @instance ||= new
-      yield @instance
-    ensure
-      @instance = nil
-    end
-
-    def create(insert)
-      insert.call
-    end
-
-    def read(select)
-      @read ||= {}
-      key = select.object_id
-      return @read[key] if @read.key? key
-      @read[key] = select.call
-    end
-
-    def update(update)
-      update.call
-    end
-
-    def delete(delete)
-      delete.call
-    end
-  end
-end

data/lib/arel/version.rb

@@ -1,3 +0,0 @@
-module Arel
-  VERSION = "1.0.1" unless defined?(Arel::VERSION)
-end

data/spec/algebra/unit/predicates/binary_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  module Predicates
-    describe Binary do
-      before do
-        @relation = Arel::Table.new(:users)
-        @attribute1 = @relation[:id]
-        @attribute2 = @relation[:name]
-        class ConcreteBinary < Binary
-        end
-      end
-
-      describe '#bind' do
-        before do
-          @another_relation = @relation.alias
-        end
-
-        describe 'when both operands are attributes' do
-          it "manufactures an expression with the attributes bound to the relation" do
-            ConcreteBinary.new(@attribute1, @attribute2).bind(@another_relation). \
-              should == ConcreteBinary.new(@another_relation[@attribute1], @another_relation[@attribute2])
-          end
-        end
-
-        describe 'when an operand is a value' do
-          it "manufactures an expression with unmodified values" do
-            ConcreteBinary.new(@attribute1, "asdf").bind(@another_relation). \
-              should == ConcreteBinary.new(@attribute1.find_correlate_in(@another_relation), "asdf".find_correlate_in(@another_relation))
-          end
-        end
-      end
-    end
-  end
-end

data/spec/algebra/unit/predicates/equality_spec.rb

@@ -1,29 +0,0 @@
-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 '==' do
-        it "obtains if attribute1 and attribute2 are identical" do
-          check Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute1, @attribute2)
-          Equality.new(@attribute1, @attribute2).should_not == Equality.new(@attribute1, @attribute1)
-        end
-
-        it "obtains if the concrete type of the predicates are identical" do
-          Equality.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute2)
-        end
-
-        it "is commutative on the attributes" do
-          Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute2, @attribute1)
-        end
-      end
-    end
-  end
-end

data/spec/algebra/unit/predicates/in_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  module Predicates
-    describe In do
-      before do
-        @relation = Table.new(:users)
-        @attribute = @relation[:id]
-      end
-    end
-  end
-end

data/spec/algebra/unit/predicates/inequality_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  module Predicates
-    describe Inequality do
-      before do
-        relation1 = Arel::Table.new(:users)
-        relation2 = Arel::Table.new(:photos)
-        left      = relation1[:id]
-        right     = relation2[:user_id]
-        @a        = Inequality.new(left, right)
-        @b        = Inequality.new(right, left)
-      end
-
-      describe 'operator' do
-        it "should have one" do
-          @a.operator.should == :"!="
-        end
-      end
-
-      describe '==' do
-        it "is equal to itself" do
-          @a.should == @a
-        end
-
-        it "should not care abount children order" do
-          @a.should == @b
-        end
-      end
-    end
-  end
-end

data/spec/algebra/unit/predicates/predicate_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  module Predicates
-    describe Polyadic do
-      before do
-        @relation1 = Arel::Table.new(:users)
-        @relation2 = Arel::Table.new(:photos)
-        @a = @relation1[:id]
-        @b = @relation2[:user_id]
-      end
-
-      describe '==' do
-        left = Polyadic.new @a, @b
-        right = Polyadic.new @b, @a
-
-        left.should != right
-        left.should == right
-      end
-    end
-  end
-end

data/spec/algebra/unit/primitives/attribute_spec.rb

@@ -1,175 +0,0 @@
-require 'spec_helper'
-
-module Arel
-  describe Attribute do
-    before do
-      @relation = Table.new(:users)
-      @attribute = @relation[:id]
-    end
-
-    describe 'Attribute::Transformations' do
-      describe '#as' do
-        it "manufactures an aliased attributed" do
-          @attribute.as(:alias).should == Attribute.new(@relation, @attribute.name, :alias => :alias, :ancestor => @attribute)
-        end
-      end
-
-      describe '#bind' do
-        it "manufactures an attribute with the relation bound and self as an ancestor" do
-          derived_relation = @relation.where(@relation[:id].eq(1))
-          @attribute.bind(derived_relation).should == Attribute.new(derived_relation, @attribute.name, :ancestor => @attribute)
-        end
-
-        it "returns self if the substituting to the same relation" do
-          @attribute.bind(@relation).should == @attribute
-        end
-      end
-
-      describe '#to_attribute' do
-        describe 'when the given relation is the same as the attributes relation' do
-          it "returns self" do
-            @attribute.to_attribute(@relation).should == @attribute
-          end
-        end
-
-        describe 'when the given relation differs from the attributes relation' do
-          it 'binds to the new relation' do
-            @attribute.to_attribute(new_relation = @relation.alias).should == @attribute.bind(new_relation)
-          end
-        end
-      end
-    end
-
-    describe '#column' do
-      it "returns the corresponding column in the relation" do
-        @attribute.column.should == @relation.column_for(@attribute)
-      end
-    end
-
-    describe '#engine' do
-      it "delegates to its relation" do
-        Attribute.new(@relation, :id).engine.should == @relation.engine
-      end
-    end
-
-    describe 'Attribute::Congruence' do
-      describe '/' do
-        before do
-          @aliased_relation = @relation.alias
-          @doubly_aliased_relation = @aliased_relation.alias
-        end
-
-        describe 'when dividing two unrelated attributes' do
-          it "returns 0.0" do
-            (@relation[:id] / @relation[:name]).should == 0.0
-          end
-        end
-
-        describe 'when dividing two matching attributes' do
-          it 'returns a the highest score for the most similar attributes' do
-            check((@aliased_relation[:id] / @relation[:id]).should == (@aliased_relation[:id] / @relation[:id]))
-            (@aliased_relation[:id] / @relation[:id]).should < (@aliased_relation[:id] / @aliased_relation[:id])
-          end
-        end
-      end
-    end
-
-    describe 'Attribute::Predications' do
-      before do
-        @attribute = Attribute.new(@relation, :name)
-      end
-
-      describe '#eq' do
-        it "manufactures an equality predicate" do
-          @attribute.eq('name').should == Predicates::Equality.new(@attribute, 'name')
-        end
-      end
-
-      describe '#lt' do
-        it "manufactures a less-than predicate" do
-          @attribute.lt(10).should == Predicates::LessThan.new(@attribute, 10)
-        end
-      end
-
-      describe '#lteq' do
-        it "manufactures a less-than or equal-to predicate" do
-          @attribute.lteq(10).should == Predicates::LessThanOrEqualTo.new(@attribute, 10)
-        end
-      end
-
-      describe '#gt' do
-        it "manufactures a greater-than predicate" do
-          @attribute.gt(10).should == Predicates::GreaterThan.new(@attribute, 10)
-        end
-      end
-
-      describe '#gteq' do
-        it "manufactures a greater-than or equal-to predicate" do
-          @attribute.gteq(10).should == Predicates::GreaterThanOrEqualTo.new(@attribute, 10)
-        end
-      end
-
-      describe '#matches' do
-        it "manufactures a match predicate" do
-          @attribute.matches(/.*/).should == Predicates::Match.new(@attribute, /.*/)
-        end
-      end
-
-      describe '#in' do
-        it "manufactures an in predicate" do
-          @attribute.in(1..30).should == Predicates::In.new(@attribute, (1..30))
-        end
-      end
-    end
-
-    describe Attribute::Expressions do
-      before do
-        @attribute = Attribute.new(@relation, :name)
-      end
-
-      describe '#count' do
-        it "manufactures a count Expression" do
-          @attribute.count.should == Count.new(@attribute)
-        end
-      end
-
-      describe '#sum' do
-        it "manufactures a sum Expression" do
-          @attribute.sum.should == Sum.new(@attribute)
-        end
-      end
-
-      describe '#maximum' do
-        it "manufactures a maximum Expression" do
-          @attribute.maximum.should == Maximum.new(@attribute)
-        end
-      end
-
-      describe '#minimum' do
-        it "manufactures a minimum Expression" do
-          @attribute.minimum.should == Minimum.new(@attribute)
-        end
-      end
-
-      describe '#average' do
-        it "manufactures an average Expression" do
-          @attribute.average.should == Average.new(@attribute)
-        end
-      end
-    end
-
-    describe Attribute::Orderings do
-      describe '#asc' do
-        it 'manufactures an ascending ordering' do
-          @attribute.asc.should == Ascending.new(@attribute)
-        end
-      end
-
-      describe '#desc' do
-        it 'manufactures a descending ordering' do
-          @attribute.desc.should == Descending.new(@attribute)
-        end
-      end
-    end
-  end
-end