arel 0.4.0 → 1.0.0.rc1

data/lib/arel/session.rb

@@ -1,51 +1,35 @@
 module Arel
   class Session
-    class << self
-      attr_accessor :instance
-      alias_method :manufacture, :new
+    @instance = nil
 
-      def start
-        if defined?(@started) && @started
-          yield
-        else
-          begin
-            @started = true
-            @instance = manufacture
-            singleton_class.class_eval do
-              undef :new
-              alias_method :new, :instance
-            end
-            yield
-          ensure
-            singleton_class.class_eval do
-              undef :new
-              alias_method :new, :manufacture
-            end
-            @started = false
-          end
-        end
-      end
+    def self.instance
+      @instance || new
     end
 
-    module CRUD
-      def create(insert)
-        insert.call
-      end
+    def self.start
+      @instance ||= new
+      yield @instance
+    ensure
+      @instance = nil
+    end
 
-      def read(select)
-        (@read ||= Hash.new do |hash, select|
-          hash[select] = select.call
-        end)[select]
-      end
+    def create(insert)
+      insert.call
+    end
 
-      def update(update)
-        update.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
+    def delete(delete)
+      delete.call
     end
-    include CRUD
   end
 end

data/lib/arel/sql_literal.rb

@@ -0,0 +1,13 @@
+module Arel
+  class SqlLiteral < String
+    def relation
+      nil
+    end
+
+    def to_sql(formatter = nil)
+      self
+    end
+
+    include Attribute::Expressions
+  end
+end

data/lib/arel/version.rb

@@ -1,3 +1,3 @@
 module Arel
-  VERSION = "0.4.0" unless defined?(Arel::VERSION)
+  VERSION = "1.0.0.rc1" unless defined?(Arel::VERSION)
 end

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -7,13 +7,7 @@ module Arel
       @attribute = @relation[:id]
     end
 
-    describe "#inspect" do
-      it "returns a simple, short inspect string" do
-        @attribute.inspect.should == "<Attribute id>"
-      end
-    end
-
-    describe Attribute::Transformations do
+    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)
@@ -58,7 +52,7 @@ module Arel
       end
     end
 
-    describe Attribute::Congruence do
+    describe 'Attribute::Congruence' do
       describe '/' do
         before do
           @aliased_relation = @relation.alias
@@ -80,7 +74,7 @@ module Arel
       end
     end
 
-    describe Attribute::Predications do
+    describe 'Attribute::Predications' do
       before do
         @attribute = Attribute.new(@relation, :name)
       end

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

@@ -7,13 +7,7 @@ module Arel
       @attribute = @relation[:id]
     end
 
-    describe "#inspect" do
-      it "returns a simple, short inspect string" do
-        @attribute.count.inspect.should == "<Arel::Count <Attribute id>>"
-      end
-    end
-
-    describe Expression::Transformations do
+    describe 'Expression::Transformations' do
       before do
         @expression = Count.new(@attribute)
       end

data/spec/algebra/unit/relations/join_spec.rb

@@ -8,13 +8,6 @@ module Arel
       @predicate = @relation1[:id].eq(@relation2[:user_id])
     end
 
-    describe 'hashing' do
-      it 'implements hash equality' do
-        InnerJoin.new(@relation1, @relation2, @predicate) \
-          .should hash_the_same_as(InnerJoin.new(@relation1, @relation2, @predicate))
-      end
-    end
-
     describe '#attributes' do
       it 'combines the attributes of the two relations' do
         join = InnerJoin.new(@relation1, @relation2, @predicate)

data/spec/algebra/unit/relations/project_spec.rb

@@ -9,7 +9,7 @@ module Arel
 
     describe '#attributes' do
       before do
-        @projection = Project.new(@relation, @attribute)
+        @projection = Project.new(@relation, [@attribute])
       end
 
       it "manufactures attributes associated with the projection relation" do
@@ -20,13 +20,13 @@ module Arel
     describe '#externalizable?' do
       describe 'when the projections are attributes' do
         it 'returns false' do
-          Project.new(@relation, @attribute).should_not be_externalizable
+          Project.new(@relation, [@attribute]).should_not be_externalizable
         end
       end
 
       describe 'when the projections include an aggregation' do
         it "obtains" do
-          Project.new(@relation, @attribute.sum).should be_externalizable
+          Project.new(@relation, [@attribute.sum]).should be_externalizable
         end
       end
     end

data/spec/algebra/unit/relations/relation_spec.rb

@@ -23,7 +23,7 @@ module Arel
       end
     end
 
-    describe Relation::Operable do
+    describe 'Relation::Operable' do
       describe 'joins' do
         before do
           @predicate = @relation[:id].eq(@relation[:id])
@@ -32,14 +32,23 @@ module Arel
         describe '#join' do
           describe 'when given a relation' do
             it "manufactures an inner join operation between those two relations" do
-              @relation.join(@relation).on(@predicate). \
-                should == InnerJoin.new(@relation, @relation, @predicate)
+              join = @relation.join(@relation).on(@predicate)
+              join.relation1.should == @relation
+              join.relation2.should == @relation
+              join.predicates.should == [@predicate]
+              join.should be_kind_of(InnerJoin)
             end
           end
 
           describe "when given a string" do
             it "manufactures a join operation with the string passed through" do
-              @relation.join(arbitrary_string = "ASDF").should == StringJoin.new(@relation, arbitrary_string)
+              arbitrary_string = "ASDF"
+
+              join = @relation.join(arbitrary_string)
+              join.relation1.should == @relation
+              join.relation2.should == arbitrary_string
+              join.predicates.should == []
+              join.should be_kind_of StringJoin
             end
           end
 
@@ -52,16 +61,21 @@ module Arel
 
         describe '#outer_join' do
           it "manufactures a left outer join operation between those two relations" do
-            @relation.outer_join(@relation).on(@predicate). \
-              should == OuterJoin.new(@relation, @relation, @predicate)
+            join = @relation.outer_join(@relation).on(@predicate)
+            join.relation1.should == @relation
+            join.relation2.should == @relation
+            join.predicates.should == [@predicate]
+            join.should be_kind_of OuterJoin
           end
         end
       end
 
       describe '#project' do
         it "manufactures a projection relation" do
-          @relation.project(@attribute1, @attribute2). \
-            should == Project.new(@relation, @attribute1, @attribute2)
+          project = @relation.project(@attribute1, @attribute2)
+          project.relation.should == @relation
+          project.projections.should == [@attribute1, @attribute2]
+          project.should be_kind_of Project
         end
 
         describe "when given blank attributes" do
@@ -83,11 +97,20 @@ module Arel
         end
 
         it "manufactures a where relation" do
-          @relation.where(@predicate).should == Where.new(@relation, @predicate)
+          where = @relation.where(@predicate)
+          where.relation.should == @relation
+          where.predicates.should == [@predicate]
+          where.should be_kind_of Where
         end
 
         it "accepts arbitrary strings" do
-          @relation.where("arbitrary").should == Where.new(@relation, "arbitrary")
+          where = @relation.where("arbitrary")
+          where.relation.should == @relation
+
+          where.predicates.length.should == 1
+          where.predicates.first.value.should == "arbitrary"
+
+          where.should be_kind_of Where
         end
 
         describe 'when given a blank predicate' do
@@ -99,7 +122,10 @@ module Arel
 
       describe '#order' do
         it "manufactures an order relation" do
-          @relation.order(@attribute1, @attribute2).should == Order.new(@relation, @attribute1, @attribute2)
+          order = @relation.order(@attribute1, @attribute2)
+          order.relation.should == @relation
+          order.orderings.should == [@attribute1, @attribute2]
+          order.should be_kind_of Order
         end
 
         describe 'when given a blank ordering' do
@@ -111,19 +137,24 @@ module Arel
 
       describe '#take' do
         it "manufactures a take relation" do
-          @relation.take(5).should == Take.new(@relation, 5)
+          take = @relation.take(5)
+          take.relation.should == @relation
+          take.taken.should == 5
         end
 
         describe 'when given a blank number of items' do
-          it 'returns self' do
-            @relation.take.should == @relation
+          it 'raises error' do
+            lambda { @relation.take }.should raise_exception
           end
         end
       end
 
       describe '#skip' do
         it "manufactures a skip relation" do
-          @relation.skip(4).should == Skip.new(@relation, 4)
+          skip = @relation.skip(4)
+          skip.relation.should == @relation
+          skip.skipped.should == 4
+          skip.should be_kind_of Skip
         end
 
         describe 'when given a blank number of items' do
@@ -135,7 +166,12 @@ module Arel
 
       describe '#group' do
         it 'manufactures a group relation' do
-          @relation.group(@attribute1, @attribute2).should == Group.new(@relation, @attribute1, @attribute2)
+          group = @relation.group(@attribute1, @attribute2)
+          group.relation.should == @relation
+          group.groupings.should == [@attribute1, @attribute2]
+          group.should be_kind_of Group
+          sql = group.to_sql
+          sql.should =~ /GROUP BY/
         end
 
         describe 'when given blank groupings' do
@@ -145,11 +181,14 @@ module Arel
         end
       end
 
-      describe Relation::Operable::Writable do
+      describe 'relation is writable' do
         describe '#delete' do
           it 'manufactures a deletion relation' do
-            Session.start do
-              Session.new.should_receive(:delete).with(Deletion.new(@relation))
+            Session.start do |s|
+              s.should_receive(:delete) do |delete|
+                delete.relation.should == @relation
+                delete.should be_kind_of Deletion
+              end
               @relation.delete
             end
           end
@@ -157,9 +196,14 @@ module Arel
 
         describe '#insert' do
           it 'manufactures an insertion relation' do
-            Session.start do
-              record = { @relation[:name] => 'carl' }
-              Session.new.should_receive(:create).with(Insert.new(@relation, record))
+            Session.start do |s|
+              record = { @relation[:name] => Value.new('carl', @relation) }
+              s.should_receive(:create) do |insert|
+                insert.relation.should == @relation
+                insert.record.should == record
+                insert.should be_kind_of Insert
+                insert
+              end
               @relation.insert(record)
             end
           end
@@ -167,9 +211,14 @@ module Arel
 
         describe '#update' do
           it 'manufactures an update relation' do
-            Session.start do
+            Session.start do |s|
               assignments = { @relation[:name] => Value.new('bob', @relation) }
-              Session.new.should_receive(:update).with(Update.new(@relation, assignments))
+              s.should_receive(:update) do |update|
+                update.relation.should == @relation
+                update.assignments.should == assignments
+                update.should be_kind_of Update
+                update
+              end
               @relation.update(assignments)
             end
           end
@@ -177,7 +226,7 @@ module Arel
       end
     end
 
-    describe Relation::Enumerable do
+    describe 'is enumerable' do
       it "implements enumerable" do
         @relation.map { |value| value }.should ==
         @relation.session.read(@relation).map { |value| value }

data/spec/algebra/unit/session/session_spec.rb

@@ -10,16 +10,16 @@ module Arel
     describe '::start' do
       describe '::instance' do
         it "it is a singleton within the started session" do
-          Session.start do
-            Session.new.should == Session.new
+          Session.start do |session|
+            Session.instance.should == session
           end
         end
 
         it "is a singleton across nested sessions" do
-          Session.start do
-            outside = Session.new
-            Session.start do
-              Session.new.should == outside
+          Session.start do |s1|
+            outside = Session.instance
+            Session.start do |s2|
+              Session.instance.should == outside
             end
           end
         end
@@ -30,7 +30,7 @@ module Arel
       end
     end
 
-    describe Session::CRUD do
+    describe 'session crud' do
       before do
         @insert = Insert.new(@relation, @relation[:name] => 'nick')
         @update = Update.new(@relation, @relation[:name] => 'nick')