Remove ActiveRelation sub-modules and refactor specs

19 files changed, 567 insertions, 534 deletions

diff --git a/spec/active_relation/predicates/binary_spec.rb b/spec/active_relation/predicates/binary_spec.rb
index be607efd95..a6878e4898 100644
--- a/spec/active_relation/predicates/binary_spec.rb
+++ b/spec/active_relation/predicates/binary_spec.rb
@@ -1,42 +1,44 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::Binary do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name1)
-    @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation2, :name2)
-    class ConcreteBinary < ActiveRelation::Predicates::Binary
-      def predicate_sql
-        "<=>"
+module ActiveRelation
+  describe Binary do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = Attribute.new(@relation1, :name1)
+      @attribute2 = Attribute.new(@relation2, :name2)
+      class ConcreteBinary < Binary
+        def predicate_sql
+          "<=>"
+        end
       end
     end
-  end
   
-  describe '==' do
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2)
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should_not == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute1)
-    end
+    describe '==' do
+      it "obtains if attribute1 and attribute2 are identical" do
+        Binary.new(@attribute1, @attribute2).should == Binary.new(@attribute1, @attribute2)
+        Binary.new(@attribute1, @attribute2).should_not == Binary.new(@attribute1, @attribute1)
+      end
     
-    it "obtains if the concrete type of the ActiveRelation::Predicates::Binarys are identical" do
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2)
-      ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2).should_not == ConcreteBinary.new(@attribute1, @attribute2)
+      it "obtains if the concrete type of the Predicates::Binarys are identical" do
+        Binary.new(@attribute1, @attribute2).should == Binary.new(@attribute1, @attribute2)
+        Binary.new(@attribute1, @attribute2).should_not == ConcreteBinary.new(@attribute1, @attribute2)
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the predicates and attributes" do
-      ConcreteBinary.new(@attribute1, @attribute2).qualify. \
-        should == ConcreteBinary.new(@attribute1.qualify, @attribute2.qualify)
+    describe '#qualify' do
+      it "distributes over the predicates and attributes" do
+        ConcreteBinary.new(@attribute1, @attribute2).qualify. \
+          should == ConcreteBinary.new(@attribute1.qualify, @attribute2.qualify)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it 'manufactures correct sql' do
-      ConcreteBinary.new(@attribute1, @attribute2).to_sql.should be_like("""
-        `foo`.`name1` <=> `bar`.`name2`
-      """)
+    describe '#to_sql' do
+      it 'manufactures correct sql' do
+        ConcreteBinary.new(@attribute1, @attribute2).to_sql.should be_like("""
+          `foo`.`name1` <=> `bar`.`name2`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/equality_spec.rb b/spec/active_relation/predicates/equality_spec.rb
index 9394e63835..d23893e438 100644
--- a/spec/active_relation/predicates/equality_spec.rb
+++ b/spec/active_relation/predicates/equality_spec.rb
@@ -1,28 +1,30 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::Equality do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-    @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation2, :name)
-  end
-  
-  describe '==' do 
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2)
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should_not == ActiveRelation::Predicates::Equality.new(@attribute1, @attribute1)
+module ActiveRelation
+  describe Equality do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = Attribute.new(@relation1, :name)
+      @attribute2 = Attribute.new(@relation2, :name)
     end
+  
+    describe '==' do 
+      it "obtains if attribute1 and attribute2 are identical" do
+        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
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should_not == ActiveRelation::Predicates::Binary.new(@attribute1, @attribute2)
-    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
-      ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2).should == ActiveRelation::Predicates::Equality.new(@attribute2, @attribute1)
+      it "is commutative on the attributes" do
+        Equality.new(@attribute1, @attribute2).should == Equality.new(@attribute2, @attribute1)
+      end
     end
-  end
   
-  describe '#to_sql' do
+    describe '#to_sql' do
+    end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/match_spec.rb b/spec/active_relation/predicates/match_spec.rb
index a01f4fb76b..3d01ce1055 100644
--- a/spec/active_relation/predicates/match_spec.rb
+++ b/spec/active_relation/predicates/match_spec.rb
@@ -1,16 +1,18 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::RelationInclusion do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute = @relation1[:baz]
-  end
+module ActiveRelation
+  describe RelationInclusion do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute = @relation1[:baz]
+    end
   
-  describe ActiveRelation::Predicates::RelationInclusion, '==' do    
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1)
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should_not == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation2)
+    describe RelationInclusion, '==' do    
+      it "obtains if attribute1 and attribute2 are identical" do
+        RelationInclusion.new(@attribute, @relation1).should == RelationInclusion.new(@attribute, @relation1)
+        RelationInclusion.new(@attribute, @relation1).should_not == RelationInclusion.new(@attribute, @relation2)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/predicates/relation_inclusion_spec.rb b/spec/active_relation/predicates/relation_inclusion_spec.rb
index de3dcf7747..05039028ee 100644
--- a/spec/active_relation/predicates/relation_inclusion_spec.rb
+++ b/spec/active_relation/predicates/relation_inclusion_spec.rb
@@ -1,25 +1,27 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Predicates::RelationInclusion do
-  before do
-    foo = ActiveRelation::Relations::Table.new(:foo)
-    @relation1 = foo.project(foo[:id])
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute = @relation1[:id]
-  end
+module ActiveRelation
+  describe RelationInclusion do
+    before do
+      foo = Table.new(:foo)
+      @relation1 = foo.project(foo[:id])
+      @relation2 = Table.new(:bar)
+      @attribute = @relation1[:id]
+    end
   
-  describe ActiveRelation::Predicates::RelationInclusion, '==' do    
-    it "obtains if attribute1 and attribute2 are identical" do
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1)
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).should_not == ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation2)
+    describe RelationInclusion, '==' do    
+      it "obtains if attribute1 and attribute2 are identical" do
+        RelationInclusion.new(@attribute, @relation1).should == RelationInclusion.new(@attribute, @relation1)
+        RelationInclusion.new(@attribute, @relation1).should_not == RelationInclusion.new(@attribute, @relation2)
+      end
     end
-  end
   
-  describe ActiveRelation::Predicates::RelationInclusion, '#to_sql' do
-    it "manufactures subselect sql" do
-      ActiveRelation::Predicates::RelationInclusion.new(@attribute, @relation1).to_sql.should be_like("""
-        `foo`.`id` IN (SELECT `foo`.`id` FROM `foo`)
-      """)
+    describe RelationInclusion, '#to_sql' do
+      it "manufactures subselect sql" do
+        RelationInclusion.new(@attribute, @relation1).to_sql.should be_like("""
+          `foo`.`id` IN (SELECT `foo`.`id` FROM `foo`)
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/primitives/aggregation_spec.rb b/spec/active_relation/primitives/aggregation_spec.rb
index 60bb4a6aa8..bdfa152bca 100644
--- a/spec/active_relation/primitives/aggregation_spec.rb
+++ b/spec/active_relation/primitives/aggregation_spec.rb
@@ -1,25 +1,27 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Primitives::Aggregation do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-  end
+module ActiveRelation
+  describe Aggregation do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+    end
   
-  describe '==' do
-    it 'obtains if the attribute and function sql are identical' do
-      @relation1[:id].sum.should == @relation1[:id].sum
-      @relation1[:id].sum.should_not == @relation1[:name].sum
-      @relation1[:id].sum.should_not == @relation1[:name].average 
-      @relation1[:id].sum.should_not == @relation2[:id].sum
+    describe '==' do
+      it 'obtains if the attribute and function sql are identical' do
+        @relation1[:id].sum.should == @relation1[:id].sum
+        @relation1[:id].sum.should_not == @relation1[:name].sum
+        @relation1[:id].sum.should_not == @relation1[:name].average 
+        @relation1[:id].sum.should_not == @relation2[:id].sum
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it 'manufactures sql with an aggregation function' do
-      @relation1[:id].maximum.to_sql.should be_like("""
-        MAX(`foo`.`id`)
-      """)
+    describe '#to_sql' do
+      it 'manufactures sql with an aggregation function' do
+        @relation1[:id].maximum.to_sql.should be_like("""
+          MAX(`foo`.`id`)
+        """)
+      end
     end
   end
-end
+end
\ No newline at end of file
diff --git a/spec/active_relation/primitives/attribute_spec.rb b/spec/active_relation/primitives/attribute_spec.rb
index f1aa404a34..6078da08f3 100644
--- a/spec/active_relation/primitives/attribute_spec.rb
+++ b/spec/active_relation/primitives/attribute_spec.rb
@@ -1,119 +1,119 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Primitives::Attribute do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-  end
-  
-  describe '#as' do
-    it "manufactures an aliased attributed when provided a parameter" do
-      @relation1[:id].as(:alias).should == ActiveRelation::Primitives::Attribute.new(@relation1, :id, :alias)
+module ActiveRelation
+  describe Attribute do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
     end
-  end
   
-  describe '#qualified_name' do
-    it "manufactures an attribute name prefixed with the relation's name" do
-      @relation1[:id].qualified_name.should == 'foo.id'
+    describe '#as' do
+      it "manufactures an aliased attributed when provided a parameter" do
+        @relation1[:id].as(:alias).should == Attribute.new(@relation1, :id, :alias)
+      end
     end
+  
+    describe '#qualified_name' do
+      it "manufactures an attribute name prefixed with the relation's name" do
+        @relation1[:id].qualified_name.should == 'foo.id'
+      end
     
-    it "manufactures an attribute name prefixed with the relation's aliased name" do
-      @relation1.as(:bar)[:id].qualified_name.should == 'bar.id'
+      it "manufactures an attribute name prefixed with the relation's aliased name" do
+        @relation1.as(:bar)[:id].qualified_name.should == 'bar.id'
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "manufactures an attribute aliased with that attributes qualified name" do
-      @relation1[:id].qualify.should == @relation1[:id].qualify
+    describe '#qualify' do
+      it "manufactures an attribute aliased with that attributes qualified name" do
+        @relation1[:id].qualify.should == @relation1[:id].qualify
+      end
     end
-  end
   
-  describe '==' do
-    it "obtains if the relation and attribute name are identical" do
-      ActiveRelation::Primitives::Attribute.new(@relation1, :name).should == ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-      ActiveRelation::Primitives::Attribute.new(@relation1, :name).should_not == ActiveRelation::Primitives::Attribute.new(@relation1, :another_name)
-      ActiveRelation::Primitives::Attribute.new(@relation1, :name).should_not == ActiveRelation::Primitives::Attribute.new(@relation2, :name)
+    describe '==' do
+      it "obtains if the relation and attribute name are identical" do
+        Attribute.new(@relation1, :name).should == Attribute.new(@relation1, :name)
+        Attribute.new(@relation1, :name).should_not == Attribute.new(@relation1, :another_name)
+        Attribute.new(@relation1, :name).should_not == Attribute.new(@relation2, :name)
+      end
     end
-  end
   
-  describe 'predications' do
-    before do
-      @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-      @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation2, :name)
-    end
+    describe 'predications' do
+      before do
+        @attribute1 = Attribute.new(@relation1, :name)
+        @attribute2 = Attribute.new(@relation2, :name)
+      end
     
-    describe '#equals' do
-      it "manufactures an equality predicate" do
-        @attribute1.equals(@attribute2).should == ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2)
+      describe '#equals' do
+        it "manufactures an equality predicate" do
+          @attribute1.equals(@attribute2).should == Equality.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#less_than' do
-      it "manufactures a less-than predicate" do
-        @attribute1.less_than(@attribute2).should == ActiveRelation::Predicates::LessThan.new(@attribute1, @attribute2)
+      describe '#less_than' do
+        it "manufactures a less-than predicate" do
+          @attribute1.less_than(@attribute2).should == LessThan.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#less_than_or_equal_to' do
-      it "manufactures a less-than or equal-to predicate" do
-        @attribute1.less_than_or_equal_to(@attribute2).should == ActiveRelation::Predicates::LessThanOrEqualTo.new(@attribute1, @attribute2)
+      describe '#less_than_or_equal_to' do
+        it "manufactures a less-than or equal-to predicate" do
+          @attribute1.less_than_or_equal_to(@attribute2).should == LessThanOrEqualTo.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#greater_than' do
-      it "manufactures a greater-than predicate" do
-        @attribute1.greater_than(@attribute2).should == ActiveRelation::Predicates::GreaterThan.new(@attribute1, @attribute2)
+      describe '#greater_than' do
+        it "manufactures a greater-than predicate" do
+          @attribute1.greater_than(@attribute2).should == GreaterThan.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#greater_than_or_equal_to' do
-      it "manufactures a greater-than or equal to predicate" do
-        @attribute1.greater_than_or_equal_to(@attribute2).should == ActiveRelation::Predicates::GreaterThanOrEqualTo.new(@attribute1, @attribute2)
+      describe '#greater_than_or_equal_to' do
+        it "manufactures a greater-than or equal to predicate" do
+          @attribute1.greater_than_or_equal_to(@attribute2).should == GreaterThanOrEqualTo.new(@attribute1, @attribute2)
+        end
       end
-    end
     
-    describe '#matches' do
-      it "manufactures a match predicate" do
-        @attribute1.matches(/.*/).should == ActiveRelation::Predicates::Match.new(@attribute1, @attribute2)
+      describe '#matches' do
+        it "manufactures a match predicate" do
+          @attribute1.matches(/.*/).should == Match.new(@attribute1, @attribute2)
+        end
       end
     end
-  end
   
-  describe 'aggregations' do
-    before do
-      @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)    
-    end
-    
-    describe '#count' do
-      it "manufactures a count aggregation" do
-        @attribute1.count.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "COUNT")
+    describe 'aggregations' do
+      before do
+        @attribute1 = Attribute.new(@relation1, :name)    
       end
-    end
     
-    describe '#sum' do
-      it "manufactures a sum aggregation" do
-        @attribute1.sum.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "SUM")
+      describe '#count' do
+        it "manufactures a count aggregation" do
+          @attribute1.count.should == Aggregation.new(@attribute1, "COUNT")
+        end
       end
-    end
     
-    describe '#maximum' do
-      it "manufactures a maximum aggregation" do
-        @attribute1.maximum.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "MAX")
+      describe '#sum' do
+        it "manufactures a sum aggregation" do
+          @attribute1.sum.should == Aggregation.new(@attribute1, "SUM")
+        end
       end
-    end
     
-    describe '#minimum' do
-      it "manufactures a minimum aggregation" do
-        @attribute1.minimum.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "MIN")
+      describe '#maximum' do
+        it "manufactures a maximum aggregation" do
+          @attribute1.maximum.should == Aggregation.new(@attribute1, "MAX")
+        end
       end
-    end
     
-    describe '#average' do
-      it "manufactures an average aggregation" do
-        @attribute1.average.should == ActiveRelation::Primitives::Aggregation.new(@attribute1, "AVG")
+      describe '#minimum' do
+        it "manufactures a minimum aggregation" do
+          @attribute1.minimum.should == Aggregation.new(@attribute1, "MIN")
+        end
       end
-    end
-    
     
+      describe '#average' do
+        it "manufactures an average aggregation" do
+          @attribute1.average.should == Aggregation.new(@attribute1, "AVG")
+        end
+      end 
+    end
   end
-end
+end
\ No newline at end of file
diff --git a/spec/active_relation/relations/alias_spec.rb b/spec/active_relation/relations/alias_spec.rb
index 6f25df3ddb..418af7fe66 100644
--- a/spec/active_relation/relations/alias_spec.rb
+++ b/spec/active_relation/relations/alias_spec.rb
@@ -1,36 +1,38 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Alias do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-    @alias_relation = @relation.as(:foo)
-  end
+module ActiveRelation
+  describe Alias do
+    before do
+      @relation = Table.new(:users)
+      @alias_relation = @relation.as(:foo)
+    end
   
-  describe '#name' do
-    it 'returns the alias' do
-      @alias_relation.name.should == :foo
+    describe '#name' do
+      it 'returns the alias' do
+        @alias_relation.name.should == :foo
+      end
     end
-  end
   
-  describe '#attributes' do
-    it 'manufactures sql deleting a table relation' do
-      @alias_relation.attributes.should == @relation.attributes.collect { |a| ActiveRelation::Primitives::Attribute.new(@alias_relation, a.name) }
+    describe '#attributes' do
+      it 'manufactures sql deleting a table relation' do
+        @alias_relation.attributes.should == @relation.attributes.collect { |a| Attribute.new(@alias_relation, a.name) }
+      end
     end
-  end
   
-  describe '[]' do
-    it 'manufactures attributes associated with the aliased relation' do
-      @alias_relation[:id].relation.should == @alias_relation
-      @alias_relation[:does_not_exist].should be_nil
+    describe '[]' do
+      it 'manufactures attributes associated with the aliased relation' do
+        @alias_relation[:id].relation.should == @alias_relation
+        @alias_relation[:does_not_exist].should be_nil
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures an aliased select query" do
-      @alias_relation.to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `users` AS `foo`
-      """)
+    describe '#to_sql' do
+      it "manufactures an aliased select query" do
+        @alias_relation.to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `users` AS `foo`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/base_spec.rb b/spec/active_relation/relations/base_spec.rb
deleted file mode 100644
index 18063757df..0000000000
--- a/spec/active_relation/relations/base_spec.rb
+++ /dev/null
@@ -1,102 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
-
-describe ActiveRelation::Relations::Base do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = ActiveRelation::Primitives::Attribute.new(@relation1, :id)
-    @attribute2 = ActiveRelation::Primitives::Attribute.new(@relation1, :name)
-  end
-  
-  describe '[]' do
-    it "manufactures an attribute when given a symbol" do
-      @relation1[:id].should == ActiveRelation::Primitives::Attribute.new(@relation1, :id)
-    end
-    
-    it "manufactures a range relation when given a range" do
-      @relation1[1..2].should == ActiveRelation::Relations::Range.new(@relation1, 1..2)
-    end
-  end
-  
-  describe '#include?' do
-    it "manufactures an inclusion predicate" do
-      @relation1.include?(@attribute1).should be_kind_of(ActiveRelation::Predicates::RelationInclusion)
-    end
-  end
-
-  describe 'read operations' do
-    describe 'joins' do
-      before do
-        @predicate = @relation1[:id].equals(@relation2[:id])
-      end
-      
-      describe '#join' do
-        it "manufactures an inner join operation between those two relations" do
-          @relation1.join(@relation2).on(@predicate).should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate)
-        end
-      end
-    
-      describe '#outer_join' do
-        it "manufactures a left outer join operation between those two relations" do
-          @relation1.outer_join(@relation2).on(@predicate).should == ActiveRelation::Relations::Join.new("LEFT OUTER JOIN", @relation1, @relation2, @predicate)
-        end      
-      end
-    end
-  
-    describe '#project' do
-      it "collapses identical projections" do
-        pending
-      end
-    
-      it "manufactures a projection relation" do
-        @relation1.project(@attribute1, @attribute2).should == ActiveRelation::Relations::Projection.new(@relation1, @attribute1, @attribute2)
-      end
-    end
-    
-    describe '#as' do
-      it "manufactures an alias relation" do
-        @relation1.as(:thucydides).should == ActiveRelation::Relations::Alias.new(@relation1, :thucydides)
-      end
-    end
-  
-    describe '#rename' do
-      it "manufactures a rename relation" do
-        @relation1.rename(@attribute1, :foo).should == ActiveRelation::Relations::Rename.new(@relation1, @attribute1 => :foo)
-      end
-    end
-  
-    describe '#select' do
-      before do
-        @predicate = ActiveRelation::Predicates::Equality.new(@attribute1, @attribute2)
-      end
-    
-      it "manufactures a selection relation" do
-        @relation1.select(@predicate).should == ActiveRelation::Relations::Selection.new(@relation1, @predicate)
-      end
-    
-      it "accepts arbitrary strings" do
-        @relation1.select("arbitrary").should == ActiveRelation::Relations::Selection.new(@relation1, "arbitrary")
-      end
-    end
-  
-    describe '#order' do
-      it "manufactures an order relation" do
-        @relation1.order(@attribute1, @attribute2).should be_kind_of(ActiveRelation::Relations::Order)
-      end
-    end
-  end
-  
-  describe 'write operations' do
-    describe '#delete' do
-      it 'manufactures a deletion relation' do
-        @relation1.delete.should be_kind_of(ActiveRelation::Relations::Deletion)
-      end
-    end
-    
-    describe '#insert' do
-      it 'manufactures an insertion relation' do
-        @relation1.insert(record = {:id => 1}).should be_kind_of(ActiveRelation::Relations::Insertion)
-      end
-    end
-  end
-end
\ No newline at end of file
diff --git a/spec/active_relation/relations/compound_spec.rb b/spec/active_relation/relations/compound_spec.rb
index f383ff4dfd..6309547c7d 100644
--- a/spec/active_relation/relations/compound_spec.rb
+++ b/spec/active_relation/relations/compound_spec.rb
@@ -1,12 +1,14 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Compound do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
+module ActiveRelation
+  describe Compound do
+    before do
+      @relation = Table.new(:users)
     
-    class ConcreteCompound < ActiveRelation::Relations::Compound
-      def initialize(relation)
-        @relation = relation
+      class ConcreteCompound < Compound
+        def initialize(relation)
+          @relation = relation
+        end
       end
     end
   end
diff --git a/spec/active_relation/relations/deletion_spec.rb b/spec/active_relation/relations/deletion_spec.rb
index ed201ac0d9..64b75d0600 100644
--- a/spec/active_relation/relations/deletion_spec.rb
+++ b/spec/active_relation/relations/deletion_spec.rb
@@ -1,24 +1,26 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Deletion do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-  end
-  
-  describe '#to_sql' do
-    it 'manufactures sql deleting a table relation' do
-      ActiveRelation::Relations::Deletion.new(@relation).to_sql.should be_like("""
-        DELETE
-        FROM `users`
-      """)
+module ActiveRelation
+  describe Deletion do
+    before do
+      @relation = Table.new(:users)
     end
+  
+    describe '#to_sql' do
+      it 'manufactures sql deleting a table relation' do
+        Deletion.new(@relation).to_sql.should be_like("""
+          DELETE
+          FROM `users`
+        """)
+      end
     
-    it 'manufactures sql deleting a selection relation' do
-      ActiveRelation::Relations::Deletion.new(@relation.select(@relation[:id].equals(1))).to_sql.should be_like("""
-        DELETE
-        FROM `users`
-        WHERE `users`.`id` = 1
-      """)
+      it 'manufactures sql deleting a selection relation' do
+        Deletion.new(@relation.select(@relation[:id].equals(1))).to_sql.should be_like("""
+          DELETE
+          FROM `users`
+          WHERE `users`.`id` = 1
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/insertion_spec.rb b/spec/active_relation/relations/insertion_spec.rb
index da39edf773..f16ab8cc23 100644
--- a/spec/active_relation/relations/insertion_spec.rb
+++ b/spec/active_relation/relations/insertion_spec.rb
@@ -1,26 +1,28 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Insertion do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-  end
-  
-  describe '#to_sql' do
-    it 'manufactures sql inserting the data for one item' do
-      ActiveRelation::Relations::Insertion.new(@relation, @relation[:name] => "nick").to_sql.should be_like("""
-        INSERT
-        INTO `users`
-        (`users`.`name`) VALUES ('nick')
-      """)
+module ActiveRelation
+  describe Insertion do
+    before do
+      @relation = Table.new(:users)
     end
+  
+    describe '#to_sql' do
+      it 'manufactures sql inserting the data for one item' do
+        Insertion.new(@relation, @relation[:name] => "nick").to_sql.should be_like("""
+          INSERT
+          INTO `users`
+          (`users`.`name`) VALUES ('nick')
+        """)
+      end
     
-    it 'manufactures sql inserting the data for multiple items' do
-      nested_insertion = ActiveRelation::Relations::Insertion.new(@relation, @relation[:name] => "cobra")
-      ActiveRelation::Relations::Insertion.new(nested_insertion, nested_insertion[:name] => "commander").to_sql.should be_like("""
-        INSERT
-        INTO `users`
-        (`users`.`name`) VALUES ('cobra'), ('commander')
-      """)
+      it 'manufactures sql inserting the data for multiple items' do
+        nested_insertion = Insertion.new(@relation, @relation[:name] => "cobra")
+        Insertion.new(nested_insertion, nested_insertion[:name] => "commander").to_sql.should be_like("""
+          INSERT
+          INTO `users`
+          (`users`.`name`) VALUES ('cobra'), ('commander')
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/join_spec.rb b/spec/active_relation/relations/join_spec.rb
index 2a84a92b70..25c505e371 100644
--- a/spec/active_relation/relations/join_spec.rb
+++ b/spec/active_relation/relations/join_spec.rb
@@ -1,43 +1,45 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Join do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @predicate = ActiveRelation::Predicates::Equality.new(@relation1[:id], @relation2[:id])
-  end
-  
-  describe '==' do
-    it 'obtains if the two relations and the predicate are identical' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate)
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).should_not == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation1, @predicate)
+module ActiveRelation
+  describe Join do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @predicate = Equality.new(@relation1[:id], @relation2[:id])
     end
   
-    it 'is commutative on the relations' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation2, @relation1, @predicate)
-    end
-  end
+    describe '==' do
+      it 'obtains if the two relations and the predicate are identical' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == Join.new("INNER JOIN", @relation1, @relation2, @predicate)
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).should_not == Join.new("INNER JOIN", @relation1, @relation1, @predicate)
+      end
   
-  describe '#qualify' do
-    it 'distributes over the relations and predicates' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).qualify. \
-        should == ActiveRelation::Relations::Join.new("INNER JOIN", @relation1.qualify, @relation2.qualify, @predicate.qualify)
+      it 'is commutative on the relations' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).should == Join.new("INNER JOIN", @relation2, @relation1, @predicate)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    before do
-      @relation1 = @relation1.select(@relation1[:id].equals(1))
+    describe '#qualify' do
+      it 'distributes over the relations and predicates' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).qualify. \
+          should == Join.new("INNER JOIN", @relation1.qualify, @relation2.qualify, @predicate.qualify)
+      end
     end
+  
+    describe '#to_sql' do
+      before do
+        @relation1 = @relation1.select(@relation1[:id].equals(1))
+      end
     
-    it 'manufactures sql joining the two tables on the predicate, merging the selects' do
-      ActiveRelation::Relations::Join.new("INNER JOIN", @relation1, @relation2, @predicate).to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`, `bar`.`name`, `bar`.`foo_id`, `bar`.`id`
-        FROM `foo`
-          INNER JOIN `bar` ON `foo`.`id` = `bar`.`id`
-        WHERE
-          `foo`.`id` = 1
-      """)
+      it 'manufactures sql joining the two tables on the predicate, merging the selects' do
+        Join.new("INNER JOIN", @relation1, @relation2, @predicate).to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`, `bar`.`name`, `bar`.`foo_id`, `bar`.`id`
+          FROM `foo`
+            INNER JOIN `bar` ON `foo`.`id` = `bar`.`id`
+          WHERE
+            `foo`.`id` = 1
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/order_spec.rb b/spec/active_relation/relations/order_spec.rb
index edf2faf455..204558daec 100644
--- a/spec/active_relation/relations/order_spec.rb
+++ b/spec/active_relation/relations/order_spec.rb
@@ -1,28 +1,30 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Order do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = @relation1[:id]
-    @attribute2 = @relation2[:id]
-  end
+module ActiveRelation
+  describe Order do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = @relation1[:id]
+      @attribute2 = @relation2[:id]
+    end
 
-  describe '#qualify' do
-    it "distributes over the relation and attributes" do
-      ActiveRelation::Relations::Order.new(@relation1, @attribute1).qualify. \
-        should == ActiveRelation::Relations::Order.new(@relation1.qualify, @attribute1.qualify)
+    describe '#qualify' do
+      it "distributes over the relation and attributes" do
+        Order.new(@relation1, @attribute1).qualify. \
+          should == Order.new(@relation1.qualify, @attribute1.qualify)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with an order clause" do
-      ActiveRelation::Relations::Order.new(@relation1, @attribute1).to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        ORDER BY `foo`.`id`
-      """)
+    describe '#to_sql' do
+      it "manufactures sql with an order clause" do
+        Order.new(@relation1, @attribute1).to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          ORDER BY `foo`.`id`
+        """)
+      end
     end
   end
-  
-end
\ No newline at end of file
+end
+  
\ No newline at end of file
diff --git a/spec/active_relation/relations/projection_spec.rb b/spec/active_relation/relations/projection_spec.rb
index 6ffdeb8e09..8d6a093af2 100644
--- a/spec/active_relation/relations/projection_spec.rb
+++ b/spec/active_relation/relations/projection_spec.rb
@@ -1,34 +1,36 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Projection do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @attribute1 = @relation1[:id]
-    @attribute2 = @relation2[:id]
-  end
+module ActiveRelation
+  describe Projection do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = @relation1[:id]
+      @attribute2 = @relation2[:id]
+    end
   
-  describe '==' do
-    it "obtains if the relations and attributes are identical" do
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1, @attribute2).should == ActiveRelation::Relations::Projection.new(@relation1, @attribute1, @attribute2)
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).should_not == ActiveRelation::Relations::Projection.new(@relation2, @attribute1)
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).should_not == ActiveRelation::Relations::Projection.new(@relation1, @attribute2)
+    describe '==' do
+      it "obtains if the relations and attributes are identical" do
+        Projection.new(@relation1, @attribute1, @attribute2).should == Projection.new(@relation1, @attribute1, @attribute2)
+        Projection.new(@relation1, @attribute1).should_not == Projection.new(@relation2, @attribute1)
+        Projection.new(@relation1, @attribute1).should_not == Projection.new(@relation1, @attribute2)
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the relation and attributes" do
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).qualify. \
-        should == ActiveRelation::Relations::Projection.new(@relation1.qualify, @attribute1.qualify)
+    describe '#qualify' do
+      it "distributes over the relation and attributes" do
+        Projection.new(@relation1, @attribute1).qualify. \
+          should == Projection.new(@relation1.qualify, @attribute1.qualify)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with a limited select clause" do
-      ActiveRelation::Relations::Projection.new(@relation1, @attribute1).to_sql.should be_like("""
-        SELECT `foo`.`id`
-        FROM `foo`
-      """)
+    describe '#to_sql' do
+      it "manufactures sql with a limited select clause" do
+        Projection.new(@relation1, @attribute1).to_sql.should be_like("""
+          SELECT `foo`.`id`
+          FROM `foo`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/range_spec.rb b/spec/active_relation/relations/range_spec.rb
index d4107259aa..f417626fed 100644
--- a/spec/active_relation/relations/range_spec.rb
+++ b/spec/active_relation/relations/range_spec.rb
@@ -1,30 +1,31 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Range do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @range1 = 1..2
-    @range2 = 4..9
-  end
+module ActiveRelation
+  describe Range do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @range1 = 1..2
+      @range2 = 4..9
+    end
 
-  describe '#qualify' do
-    it "distributes over the relation and attributes" do
-      pending
+    describe '#qualify' do
+      it "distributes over the relation and attributes" do
+        pending
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with limit and offset" do
-      range_size = @range2.last - @range2.first + 1
-      range_start = @range2.first
-      ActiveRelation::Relations::Range.new(@relation1, @range2).to_s.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        LIMIT #{range_size}
-        OFFSET #{range_start}
-      """)
+    describe '#to_sql' do
+      it "manufactures sql with limit and offset" do
+        range_size = @range2.last - @range2.first + 1
+        range_start = @range2.first
+        Range.new(@relation1, @range2).to_s.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          LIMIT #{range_size}
+          OFFSET #{range_start}
+        """)
+      end
     end
   end
-  
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/relation_spec.rb b/spec/active_relation/relations/relation_spec.rb
new file mode 100644
index 0000000000..72b7d14389
--- /dev/null
+++ b/spec/active_relation/relations/relation_spec.rb
@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+module ActiveRelation
+  describe Relation do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @attribute1 = Attribute.new(@relation1, :id)
+      @attribute2 = Attribute.new(@relation1, :name)
+    end
+  
+    describe '[]' do
+      it "manufactures an attribute when given a symbol" do
+        @relation1[:id].should == Attribute.new(@relation1, :id)
+      end
+    
+      it "manufactures a range relation when given a range" do
+        @relation1[1..2].should == Range.new(@relation1, 1..2)
+      end
+    end
+  
+    describe '#include?' do
+      it "manufactures an inclusion predicate" do
+        @relation1.include?(@attribute1).should be_kind_of(RelationInclusion)
+      end
+    end
+
+    describe 'read operations' do
+      describe 'joins' do
+        before do
+          @predicate = @relation1[:id].equals(@relation2[:id])
+        end
+      
+        describe '#join' do
+          it "manufactures an inner join operation between those two relations" do
+            @relation1.join(@relation2).on(@predicate).should == Join.new("INNER JOIN", @relation1, @relation2, @predicate)
+          end
+        end
+    
+        describe '#outer_join' do
+          it "manufactures a left outer join operation between those two relations" do
+            @relation1.outer_join(@relation2).on(@predicate).should == Join.new("LEFT OUTER JOIN", @relation1, @relation2, @predicate)
+          end      
+        end
+      end
+  
+      describe '#project' do
+        it "collapses identical projections" do
+          pending
+        end
+    
+        it "manufactures a projection relation" do
+          @relation1.project(@attribute1, @attribute2).should == Projection.new(@relation1, @attribute1, @attribute2)
+        end
+      end
+    
+      describe '#as' do
+        it "manufactures an alias relation" do
+          @relation1.as(:thucydides).should == Alias.new(@relation1, :thucydides)
+        end
+      end
+  
+      describe '#rename' do
+        it "manufactures a rename relation" do
+          @relation1.rename(@attribute1, :foo).should == Rename.new(@relation1, @attribute1 => :foo)
+        end
+      end
+  
+      describe '#select' do
+        before do
+          @predicate = Equality.new(@attribute1, @attribute2)
+        end
+    
+        it "manufactures a selection relation" do
+          @relation1.select(@predicate).should == Selection.new(@relation1, @predicate)
+        end
+    
+        it "accepts arbitrary strings" do
+          @relation1.select("arbitrary").should == Selection.new(@relation1, "arbitrary")
+        end
+      end
+  
+      describe '#order' do
+        it "manufactures an order relation" do
+          @relation1.order(@attribute1, @attribute2).should be_kind_of(Order)
+        end
+      end
+    end
+  
+    describe 'write operations' do
+      describe '#delete' do
+        it 'manufactures a deletion relation' do
+          @relation1.delete.should be_kind_of(Deletion)
+        end
+      end
+    
+      describe '#insert' do
+        it 'manufactures an insertion relation' do
+          @relation1.insert(record = {:id => 1}).should be_kind_of(Insertion)
+        end
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/spec/active_relation/relations/rename_spec.rb b/spec/active_relation/relations/rename_spec.rb
index bdc5c97492..3f8d5e3dbd 100644
--- a/spec/active_relation/relations/rename_spec.rb
+++ b/spec/active_relation/relations/rename_spec.rb
@@ -1,61 +1,63 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Rename do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:foo)
-    @renamed_relation = ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :schmid)
-  end
-
-  describe '#initialize' do
-    it "manufactures nested rename relations if multiple renames are provided" do
-      ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :humpty, @relation[:name] => :dumpty). \
-        should == ActiveRelation::Relations::Rename.new(ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :humpty), @relation[:name] => :dumpty)
+module ActiveRelation
+  describe Rename do
+    before do
+      @relation = Table.new(:foo)
+      @renamed_relation = Rename.new(@relation, @relation[:id] => :schmid)
     end
 
-    it "raises an exception if the rename provided is already used" do
-      pending
+    describe '#initialize' do
+      it "manufactures nested rename relations if multiple renames are provided" do
+        Rename.new(@relation, @relation[:id] => :humpty, @relation[:name] => :dumpty). \
+          should == Rename.new(Rename.new(@relation, @relation[:id] => :humpty), @relation[:name] => :dumpty)
+      end
+
+      it "raises an exception if the rename provided is already used" do
+        pending
+      end
     end
-  end
     
-  describe '==' do
-    it "obtains if the relation, attribute, and rename are identical" do
-      pending
+    describe '==' do
+      it "obtains if the relation, attribute, and rename are identical" do
+        pending
+      end
     end
-  end
   
-  describe '#attributes' do
-    it "manufactures a list of attributes with the renamed attribute renameed" do
-      ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :schmid).attributes.should ==
-        (@relation.attributes - [@relation[:id]]) + [@relation[:id].as(:schmid)]
+    describe '#attributes' do
+      it "manufactures a list of attributes with the renamed attribute renameed" do
+        Rename.new(@relation, @relation[:id] => :schmid).attributes.should ==
+          (@relation.attributes - [@relation[:id]]) + [@relation[:id].as(:schmid)]
+      end
     end
-  end
   
-  describe '[]' do
-    it 'indexes attributes by rename' do
-      @renamed_relation[:id].should be_nil
-      @renamed_relation[:schmid].should == @relation[:id].as(:schmid)
+    describe '[]' do
+      it 'indexes attributes by rename' do
+        @renamed_relation[:id].should be_nil
+        @renamed_relation[:schmid].should == @relation[:id].as(:schmid)
+      end
     end
-  end
   
-  describe '#schmattribute' do
-    it "should be renamed" do
-      pending
+    describe '#schmattribute' do
+      it "should be renamed" do
+        pending
+      end
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the relation and renames" do
-      ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => :schmid).qualify. \
-        should == ActiveRelation::Relations::Rename.new(@relation.qualify, @relation[:id].qualify => :schmid)
+    describe '#qualify' do
+      it "distributes over the relation and renames" do
+        Rename.new(@relation, @relation[:id] => :schmid).qualify. \
+          should == Rename.new(@relation.qualify, @relation[:id].qualify => :schmid)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it 'manufactures sql renameing the attribute' do
-      @renamed_relation.to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id` AS 'schmid'
-        FROM `foo`
-      """)
+    describe '#to_sql' do
+      it 'manufactures sql renameing the attribute' do
+        @renamed_relation.to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id` AS 'schmid'
+          FROM `foo`
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/selection_spec.rb b/spec/active_relation/relations/selection_spec.rb
index 90dc3169b6..95d9e68625 100644
--- a/spec/active_relation/relations/selection_spec.rb
+++ b/spec/active_relation/relations/selection_spec.rb
@@ -1,42 +1,44 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Selection do
-  before do
-    @relation1 = ActiveRelation::Relations::Table.new(:foo)
-    @relation2 = ActiveRelation::Relations::Table.new(:bar)
-    @predicate1 = ActiveRelation::Predicates::Equality.new(@relation1[:id], @relation2[:foo_id])
-    @predicate2 = ActiveRelation::Predicates::LessThan.new(@relation1[:age], 2)
-  end
-  
-  describe '#initialize' do
-    it "manufactures nested selection relations if multiple predicates are provided" do
-      ActiveRelation::Relations::Selection.new(@relation1, @predicate1, @predicate2). \
-        should == ActiveRelation::Relations::Selection.new(ActiveRelation::Relations::Selection.new(@relation1, @predicate2), @predicate1)
+module ActiveRelation
+  describe Selection do
+    before do
+      @relation1 = Table.new(:foo)
+      @relation2 = Table.new(:bar)
+      @predicate1 = Equality.new(@relation1[:id], @relation2[:foo_id])
+      @predicate2 = LessThan.new(@relation1[:age], 2)
     end
-  end
   
-  describe '#qualify' do
-    it "distributes over the relation and predicates" do
-      ActiveRelation::Relations::Selection.new(@relation1, @predicate1).qualify. \
-        should == ActiveRelation::Relations::Selection.new(@relation1.qualify, @predicate1.qualify)
+    describe '#initialize' do
+      it "manufactures nested selection relations if multiple predicates are provided" do
+        Selection.new(@relation1, @predicate1, @predicate2). \
+          should == Selection.new(Selection.new(@relation1, @predicate2), @predicate1)
+      end
     end
-  end
   
-  describe '#to_sql' do
-    it "manufactures sql with where clause conditions" do
-      ActiveRelation::Relations::Selection.new(@relation1, @predicate1).to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        WHERE `foo`.`id` = `bar`.`foo_id`
-      """)
+    describe '#qualify' do
+      it "distributes over the relation and predicates" do
+        Selection.new(@relation1, @predicate1).qualify. \
+          should == Selection.new(@relation1.qualify, @predicate1.qualify)
+      end
     end
+  
+    describe '#to_sql' do
+      it "manufactures sql with where clause conditions" do
+        Selection.new(@relation1, @predicate1).to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          WHERE `foo`.`id` = `bar`.`foo_id`
+        """)
+      end
     
-    it "allows arbitrary sql" do
-      ActiveRelation::Relations::Selection.new(@relation1, "asdf").to_sql.should be_like("""
-        SELECT `foo`.`name`, `foo`.`id`
-        FROM `foo`
-        WHERE asdf
-      """)
+      it "allows arbitrary sql" do
+        Selection.new(@relation1, "asdf").to_sql.should be_like("""
+          SELECT `foo`.`name`, `foo`.`id`
+          FROM `foo`
+          WHERE asdf
+        """)
+      end
     end
   end
 end
\ No newline at end of file
diff --git a/spec/active_relation/relations/table_spec.rb b/spec/active_relation/relations/table_spec.rb
index 1418ac203f..ec6e6e10bd 100644
--- a/spec/active_relation/relations/table_spec.rb
+++ b/spec/active_relation/relations/table_spec.rb
@@ -1,30 +1,32 @@
 require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
 
-describe ActiveRelation::Relations::Table do
-  before do
-    @relation = ActiveRelation::Relations::Table.new(:users)
-  end
+module ActiveRelation
+  describe Table do
+    before do
+      @relation = Table.new(:users)
+    end
   
-  describe '#to_sql' do
-    it "manufactures a simple select query" do
-      @relation.to_sql.should be_like("""
-        SELECT `users`.`name`, `users`.`id`
-        FROM `users`
-      """)
+    describe '#to_sql' do
+      it "manufactures a simple select query" do
+        @relation.to_sql.should be_like("""
+          SELECT `users`.`name`, `users`.`id`
+          FROM `users`
+        """)
+      end
     end
-  end
   
-  describe '#attributes' do
-    it 'manufactures attributes corresponding to columns in the table' do
-      pending
+    describe '#attributes' do
+      it 'manufactures attributes corresponding to columns in the table' do
+        pending
+      end
     end
-  end
   
-  describe '#qualify' do
-    it 'manufactures a rename relation with all attribute names qualified' do
-      @relation.qualify.should == ActiveRelation::Relations::Rename.new(
-        ActiveRelation::Relations::Rename.new(@relation, @relation[:id] => 'users.id'), @relation[:name] => 'users.name'
-      )
+    describe '#qualify' do
+      it 'manufactures a rename relation with all attribute names qualified' do
+        @relation.qualify.should == Rename.new(
+          Rename.new(@relation, @relation[:id] => 'users.id'), @relation[:name] => 'users.name'
+        )
+      end
     end
   end
 end
\ No newline at end of file