veritas 0.0.1 → 0.0.2

data/spec/unit/veritas/algebra/union/each_spec.rb

@@ -1,30 +1,35 @@
 require 'spec_helper'
 
 describe 'Veritas::Algebra::Union#each' do
-  subject { union.each { |tuple| yields << tuple } }
+  subject { object.each { |tuple| yields << tuple } }
 
+  let(:klass)  { Algebra::Union                  }
   let(:header) { [ [ :id, Integer ] ]            }
   let(:left)   { Relation.new(header, [ [ 1 ] ]) }
+  let(:object) { klass.new(left, right)          }
   let(:yields) { []                              }
 
   context 'with relations having similar bodies' do
-    let(:union) { Algebra::Union.new(left, left.dup) }
+    let(:right) { left.dup }
 
-    it { should equal(union) }
+    it_should_behave_like 'a command method'
 
-    it 'yields the union' do
-      expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ] ])
+    it 'yields each tuple' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to([ [ 1 ] ])
     end
   end
 
   context 'with relations having different bodies' do
     let(:right) { Relation.new(header, [ [ 2 ] ]) }
-    let(:union) { Algebra::Union.new(left, right) }
 
-    it { should equal(union) }
+    it_should_behave_like 'a command method'
 
-    it 'yields the union' do
-      expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ], [ 2 ] ])
+    it 'yields each tuple' do
+      expect { subject }.to change { yields.dup }.
+        from([]).
+        to([ [ 1 ], [ 2 ] ])
     end
   end
 end

data/spec/unit/veritas/algebra/union/methods/union_spec.rb

@@ -2,16 +2,17 @@ require 'spec_helper'
 
 [ :union, :| ].each do |method|
   describe "Veritas::Algebra::Union::Methods##{method}" do
-    subject { relation.send(method, other) }
+    subject { object.send(method, other) }
 
-    let(:header)   { [ [ :id, Integer ] ]            }
-    let(:relation) { Relation.new(header, [ [ 1 ] ]) }
-    let(:other)    { Relation.new(header, [ [ 2 ] ]) }
+    let(:klass)  { Relation                          }
+    let(:header) { [ [ :id, Integer ] ]              }
+    let(:other)  { klass.new(header, [ [ 2 ] ].each) }
+    let(:object) { klass.new(header, [ [ 1 ] ].each) }
 
     it { should be_kind_of(Algebra::Union) }
 
     it 'behaves the same as Array#|' do
-      should == (relation.to_a | other.to_a)
+      should == (object.to_a | other.to_a)
     end
   end
 end

data/spec/unit/veritas/aliasable/inheritable_alias_spec.rb

@@ -2,18 +2,18 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Aliasable#inheritable_alias' do
-  subject { klass.inheritable_alias(aliases) }
+  subject { object.inheritable_alias(aliases) }
 
-  let(:klass)     { Class.new(AliasableSpecs::Object) }
-  let(:aliasable) { klass.new                         }
   let(:aliases)   { { :other => :test }               }
+  let(:object)    { Class.new(AliasableSpecs::Object) }
+  let(:aliasable) { object.new                        }
 
-  it 'returns the class' do
-    should equal(klass)
-  end
+  it_should_behave_like 'a command method'
 
   it 'creates a method #other' do
-    expect { subject }.to change { aliasable.respond_to?(:other) }.from(false).to(true)
+    expect { subject }.to change { aliasable.respond_to?(:other) }.
+      from(false).
+      to(true)
   end
 
   it 'aliases #other to #test' do
@@ -24,7 +24,7 @@ describe 'Veritas::Aliasable#inheritable_alias' do
   end
 
   specification = proc do
-    klass.class_eval do
+    object.class_eval do
       def test
         caller
       end

data/spec/unit/veritas/attribute/boolean/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Boolean.primitive' do
-  subject { Attribute::Boolean.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::Boolean }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(TrueClass) }
 end

data/spec/unit/veritas/attribute/boolean/valid_value_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Boolean#valid_value?' do
-  subject { attribute.valid_value?(value) }
+  subject { object.valid_value?(value) }
 
-  let(:attribute) { Veritas::Attribute::Boolean.new(:boolean) }
+  let(:klass)  { Attribute::Boolean  }
+  let(:object) { klass.new(:boolean) }
 
   context 'with a true value' do
     let(:value) { true }

data/spec/unit/veritas/attribute/call_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#call' do
-  subject { attribute.call(tuple) }
+  subject { object.call(tuple) }
 
-  let(:attribute) { Attribute::Integer.new(:id)         }
-  let(:header)    { Relation::Header.new([ attribute ]) }
-  let(:tuple)     { Tuple.new(header, [ 1 ])            }
+  let(:klass)  { Attribute::Integer                  }
+  let(:object) { klass.new(:id)                      }
+  let(:header) { Relation::Header.new([ object ])    }
+  let(:tuple)  { Tuple.new(header, [ 1 ])            }
 
   it { should == 1 }
 end

data/spec/unit/veritas/attribute/class/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Class.primitive' do
-  subject { Attribute::Class.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::Class }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(Class) }
 end

data/spec/unit/veritas/attribute/class_methods/coerce_spec.rb

@@ -1,28 +1,34 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute.coerce' do
-  subject { Attribute.coerce(object) }
+  subject { object.coerce(argument) }
 
-  context 'when the object is an Attribute' do
-    let(:object) { Attribute::Integer.new(:id) }
+  let(:object) { Attribute }
 
-    it { should equal(object) }
+  context 'when the argument is an Attribute' do
+    let(:argument) { Attribute::Integer.new(:id) }
+
+    it { should equal(argument) }
   end
 
-  context 'when the object responds to #to_ary' do
-    let(:object) { [ :id, Integer ] }
+  context 'when the argument responds to #to_ary' do
+    let(:argument) { [ :id, Integer ] }
+
+    it { should be_kind_of(Attribute::Integer) }
 
-    it { should eql(Attribute::Integer.new(:id)) }
+    its(:name) { should == :id }
   end
 
-  context 'when the object does not respond to #to_ary, but does respond to #to_sym' do
-    let(:object) { :id }
+  context 'when the argument does not respond to #to_ary, but does respond to #to_sym' do
+    let(:argument) { :id }
+
+    it { should be_kind_of(Attribute::Object) }
 
-    it { should eql(Attribute::Object.new(:id)) }
+    its(:name) { should == :id }
   end
 
-  context 'when the object does not respond to #to_ary or #to_sym' do
-    let(:object) { Integer }
+  context 'when the argument does not respond to #to_ary or #to_sym' do
+    let(:argument) { Integer }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

data/spec/unit/veritas/attribute/class_methods/name_from_spec.rb

@@ -1,28 +1,30 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute.name_from' do
-  subject { Attribute.name_from(object) }
+  subject { object.name_from(argument) }
 
-  context 'object is an Attribute' do
-    let(:object) { Attribute::Integer.new(:id) }
+  let(:object) { Attribute }
+
+  context 'argument is an Attribute' do
+    let(:argument) { Attribute::Integer.new(:id) }
 
     it { should == :id }
   end
 
-  context 'object that responds to #to_ary' do
-    let(:object) { [ :id, Integer ] }
+  context 'argument that responds to #to_ary' do
+    let(:argument) { [ :id, Integer ] }
 
     it { should == :id }
   end
 
-  context 'object that responds to #to_sym' do
-    let(:object) { 'id' }
+  context 'argument that responds to #to_sym' do
+    let(:argument) { 'id' }
 
     it { should == :id }
   end
 
-  context 'object that is not an Attribute, does not respond to #to_ary or #to_sym' do
-    let(:object) { Object.new }
+  context 'argument that is not an Attribute, does not respond to #to_ary or #to_sym' do
+    let(:argument) { Object.new }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

data/spec/unit/veritas/attribute/class_methods/new_spec.rb

@@ -1,13 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute.new' do
-  subject { klass.new(:id) }
+  subject { object.new(name) }
 
-  context 'when called on the Attribute class' do
-    let(:klass) { Attribute }
-
-    specify { expect { subject }.to raise_error(NotImplementedError, 'Veritas::Attribute is an abstract class') }
-  end
+  let(:name) { :id }
 
   [
     Attribute::Boolean,
@@ -23,11 +19,15 @@ describe 'Veritas::Attribute.new' do
     Attribute::Time,
   ].each do |klass|
     context "when called on the Attribute subclass #{klass}" do
-      let(:klass) { klass }
-
-      it { should be_kind_of(Attribute) }
+      let(:object) { klass }
 
-      it { should be_kind_of(klass) }
+      it { should be_kind_of(object) }
     end
   end
+
+  context 'when called on the Attribute class' do
+    let(:object) { Attribute }
+
+    specify { expect { subject }.to raise_error(NotImplementedError, "#{object} is an abstract class") }
+  end
 end

data/spec/unit/veritas/attribute/comparable/comparable_spec.rb

@@ -1,17 +1,18 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Comparable#comparable?' do
-  subject { attribute.comparable?(other) }
+  subject { object.comparable?(other) }
 
-  let(:attribute) { Attribute::Integer.new(:id) }
+  let(:klass)  { Attribute::Integer }
+  let(:object) { klass.new(:id)     }
 
   context 'when the other attribute is the same type' do
-    let(:other) { attribute.dup }
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.comparable?(attribute)
+      should == other.comparable?(object)
     end
   end
 
@@ -22,28 +23,28 @@ describe 'Veritas::Attribute::Comparable#comparable?' do
 
     it 'is not be symmetric' do
       expect {
-        other.comparable?(attribute)
+        other.comparable?(object)
       }.to raise_error(NoMethodError)
     end
   end
 
   context 'when the other attribute is a descendant type' do
-    let(:other) { Class.new(Attribute::Integer).new(:descendant) }
+    let(:other) { Class.new(klass).new(:descendant) }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.comparable?(attribute)
+      should == other.comparable?(object)
     end
   end
 
   context 'when the other attribute shares a common type' do
-    let(:other) { Attribute::Numeric.new(:ancestor) }
+    let(:other) { klass.superclass.new(:ancestor) }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.comparable?(attribute)
+      should == other.comparable?(object)
     end
   end
 end

data/spec/unit/veritas/attribute/date/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Date.primitive' do
-  subject { Attribute::Date.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::Date }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(Date) }
 end

data/spec/unit/veritas/attribute/date/range_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Date#range' do
-  subject { attribute.range }
+  subject { object.range }
 
-  let(:attribute) { Veritas::Attribute::Date.new(:date) }
+  let(:klass)  { Attribute::Date  }
+  let(:object) { klass.new(:date) }
 
   it { should == (Date.new..Date::Infinity.new) }
 end

data/spec/unit/veritas/attribute/date_time/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::DateTime.primitive' do
-  subject { Attribute::DateTime.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::DateTime }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(DateTime) }
 end

data/spec/unit/veritas/attribute/date_time/range_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::DateTime#range' do
-  subject { attribute.range }
+  subject { object.range }
 
-  let(:attribute) { Veritas::Attribute::DateTime.new(:datetime) }
+  let(:klass)  { Attribute::DateTime  }
+  let(:object) { klass.new(:datetime) }
 
   it { should == (DateTime.new..DateTime::Infinity.new) }
 end

data/spec/unit/veritas/attribute/decimal/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Decimal.primitive' do
-  subject { Attribute::Decimal.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::Decimal }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(BigDecimal) }
 end

data/spec/unit/veritas/attribute/eql_spec.rb

@@ -1,48 +1,50 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#eql?' do
-  subject { attribute.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:name)      { :id                          }
-  let(:attribute) { Attribute::Integer.new(name) }
+  let(:klass)  { Attribute::Integer }
+  let(:name)   { :id                }
+  let(:object) { klass.new(name)    }
 
-  context 'with the same attribute' do
-    let(:other) { attribute }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(attribute)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent attribute' do
-    let(:other) { attribute.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(attribute)
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different attribute' do
-    let(:other) { Attribute::String.new(:name) }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(name) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(attribute)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent attribute of a different class' do
-    let(:other) { Class.new(Attribute::Integer).new(name) }
+  context 'with an object having a different name' do
+    let(:other_name) { :other_id             }
+    let(:other)      { klass.new(other_name) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(attribute)
+      should == other.eql?(object)
     end
   end
 end

data/spec/unit/veritas/attribute/equal_value_spec.rb

@@ -1,48 +1,50 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#==' do
-  subject { attribute == other }
+  subject { object == other }
 
-  let(:name)      { :id                          }
-  let(:attribute) { Attribute::Integer.new(name) }
+  let(:klass)  { Attribute::Integer }
+  let(:name)   { :id                }
+  let(:object) { klass.new(name)    }
 
-  context 'with the same attribute' do
-    let(:other) { attribute }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == attribute)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent attribute' do
-    let(:other) { attribute.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == attribute)
+      should == (other == object)
     end
   end
 
-  context 'with a different attribute' do
-    let(:other) { Attribute::String.new(:name) }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(name) }
 
-    it { should be(false) }
+    it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == attribute)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent attribute of a different class' do
-    let(:other) { Class.new(Attribute::Integer).new(name) }
+  context 'with an object having a different name' do
+    let(:other_name) { :other_id             }
+    let(:other)      { klass.new(other_name) }
 
-    it { should be(true) }
+    it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == attribute)
+      should == (other == object)
     end
   end
 end

data/spec/unit/veritas/attribute/float/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Float.primitive' do
-  subject { Attribute::Float.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::Float }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(Float) }
 end

data/spec/unit/veritas/attribute/hash_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#hash' do
-  subject { attribute.hash }
+  subject { object.hash }
 
-  let(:name)      { :id                                   }
-  let(:options)   { { :size => 1..10 }                    }
-  let(:attribute) { Attribute::Integer.new(name, options) }
+  let(:klass)   { Attribute::Integer       }
+  let(:name)    { :id                      }
+  let(:options) { { :size => 1..10 }       }
+  let(:object)  { klass.new(name, options) }
 
-  it { should be_kind_of(Integer) }
+  it_should_behave_like 'a hash method'
 
-  it { should == name.hash ^ options.hash }
-
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ name.hash ^ options.hash }
 end

data/spec/unit/veritas/attribute/inspect_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#inspect' do
-  subject { attribute.inspect }
+  subject { object.inspect }
 
-  let(:attribute) { Attribute::Integer.new(:id) }
+  let(:klass)  { Attribute::Integer }
+  let(:object) { klass.new(:id)     }
 
   it { should be_kind_of(String) }
 

data/spec/unit/veritas/attribute/integer/class_methods/primitive_spec.rb

@@ -1,7 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Integer.primitive' do
-  subject { Attribute::Integer.primitive }
+  subject { object.primitive }
+
+  let(:object) { Attribute::Integer }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(Integer) }
 end