veritas 0.0.1 → 0.0.2

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

@@ -1,17 +1,18 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#joinable?' do
-  subject { attribute.joinable?(other) }
+  subject { object.joinable?(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.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 
@@ -21,17 +22,17 @@ describe 'Veritas::Attribute#joinable?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     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.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 
@@ -41,7 +42,7 @@ describe 'Veritas::Attribute#joinable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 end

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

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#name' do
-  subject { attribute.name }
+  subject { object.name }
 
-  let(:name)      { :id                          }
-  let(:attribute) { Attribute::Integer.new(name) }
+  let(:klass)  { Attribute::Integer }
+  let(:name)   { :id                }
+  let(:object) { klass.new(name)    }
 
   it { should == name }
 end

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

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

data/spec/unit/veritas/attribute/numeric/joinable_spec.rb

@@ -1,27 +1,29 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Numeric#joinable?' do
-  subject { attribute.joinable?(other) }
+  subject { object.joinable?(other) }
 
-  let(:attribute) { Attribute::Numeric.new(:numeric, :size => 10..20) }
+  let(:klass)  { Attribute::Numeric                 }
+  let(:size)   { 10..20                             }
+  let(:object) { klass.new(:numeric, :size => size) }
 
   context 'when the attribute types and sizes are the same' do
-    let(:other) { Attribute::Numeric.new(:numeric, :size => 10..20) }
+    let(:other) { klass.new(:numeric, :size => size) }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 
   context 'when the attribute types are the same and the sizes are different' do
-    let(:other) { Attribute::Numeric.new(:numeric, :size => 1..20) }
+    let(:other) { klass.new(:numeric, :size => 1..20) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 
@@ -31,7 +33,7 @@ describe 'Veritas::Attribute::Numeric#joinable?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 end

data/spec/unit/veritas/attribute/numeric/size_spec.rb

@@ -2,16 +2,18 @@ require 'spec_helper'
 
 [ :size, :range ].each do |method|
   describe "Veritas::Attribute::Numeric##{method}" do
-    subject { attribute.send(method) }
+    subject { object.send(method) }
+
+    let(:klass) { Attribute::Numeric }
 
     context 'without :size option passed to constructor' do
-      let(:attribute) { Attribute::Numeric.new(:id) }
+      let(:object) { klass.new(:id) }
 
       it { should == (0..2**31-1) }
     end
 
     context 'with :size option passed to constructor' do
-      let(:attribute) { Attribute::Numeric.new(:id, :size => 1..100) }
+      let(:object) { klass.new(:id, :size => 1..100) }
 
       it { should == (1..100) }
     end

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

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Numeric#valid_value?' do
-  subject { attribute.valid_value?(value) }
+  subject { object.valid_value?(value) }
 
-  let(:attribute) { Veritas::Attribute::Numeric.new(:numeric, :size => 1..50) }
+  let(:klass)  { Attribute::Numeric                  }
+  let(:object) { klass.new(:numeric, :size => 1..50) }
 
   context 'with a numeric value' do
     context 'that is within the allowed size range' do

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

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

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

@@ -1,31 +1,36 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#options' do
-  subject { attribute.options }
+  subject { object.options }
 
-  let(:name)      { :id                                   }
-  let(:attribute) { Attribute::Integer.new(name, options) }
+  let(:klass) { Attribute::Integer }
 
   context 'when no options are provided' do
-    let(:attribute) { Attribute::Integer.new(name) }
+    let(:object) { klass.new(:id) }
 
-    it { should eql({}) }
+    it { should be_kind_of(Hash) }
+
+    it { should be_empty }
 
     it { should be_frozen }
   end
 
   context 'when options are frozen' do
-    let(:options) { {}.freeze }
+    let(:options) { {}.freeze               }
+    let(:object)  { klass.new(:id, options) }
 
     it { should equal(options) }
   end
 
   context 'when options are not frozen' do
-    let(:options) { {} }
+    let(:options) { {}                      }
+    let(:object)  { klass.new(:id, options) }
 
     it { should_not equal(options) }
 
-    it { should eql(options) }
+    it { should be_kind_of(Hash) }
+
+    it { should == options }
 
     it { should be_frozen }
   end

data/spec/unit/veritas/attribute/orderable/asc_spec.rb

@@ -2,9 +2,10 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Attribute::Orderable#asc' do
-  subject { comparable.asc }
+  subject { object.asc }
 
-  let(:comparable) { OrderableSpecs::Object.new }
+  let(:klass)  { OrderableSpecs::Object }
+  let(:object) { klass.new              }
 
   it { should be_kind_of(Relation::Operation::Order::Ascending) }
 end

data/spec/unit/veritas/attribute/orderable/desc_spec.rb

@@ -2,9 +2,10 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Attribute::Orderable#desc' do
-  subject { comparable.desc }
+  subject { object.desc }
 
-  let(:comparable) { OrderableSpecs::Object.new }
+  let(:klass)  { OrderableSpecs::Object }
+  let(:object) { klass.new              }
 
   it { should be_kind_of(Relation::Operation::Order::Descending) }
 end

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

@@ -1,25 +1,26 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#rename' do
-  subject { attribute.rename(name) }
+  subject { object.rename(name) }
 
-  let(:attribute) { Attribute::Integer.new(:id, :size => 1..10) }
+  let(:klass)  { Attribute::Integer             }
+  let(:object) { klass.new(:id, :size => 1..10) }
 
   context 'when the new name is the same' do
-    let(:name) { attribute.name }
+    let(:name) { object.name }
 
-    it { should equal(attribute) }
+    it { should equal(object) }
   end
 
   context 'when the new name is different' do
     let(:name) { :other_id }
 
-    it { should be_kind_of(Attribute) }
+    it { should be_kind_of(klass) }
 
-    it { should_not equal(attribute) }
+    it { should_not equal(object) }
 
     its(:name) { should equal(name) }
 
-    its(:options) { should equal(attribute.options) }
+    its(:options) { should equal(object.options) }
   end
 end

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

@@ -1,22 +1,24 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#required?' do
-  subject { attribute.required? }
+  subject { object.required? }
+
+  let(:klass) { Attribute::Integer }
 
   context 'without :required option passed to constructor' do
-    let(:attribute) { Attribute::Integer.new(:id) }
+    let(:object) { klass.new(:id) }
 
     it { should be(true) }
   end
 
   context 'with :required => true option passed to constructor' do
-    let(:attribute) { Attribute::Integer.new(:id, :required => true) }
+    let(:object) { klass.new(:id, :required => true) }
 
     it { should be(true) }
   end
 
   context 'with :required => false option passed to constructor' do
-    let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+    let(:object) { klass.new(:id, :required => false) }
 
     it { should be(false) }
   end

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

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

data/spec/unit/veritas/attribute/string/joinable_spec.rb

@@ -1,37 +1,38 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::String#joinable?' do
-  subject { attribute.joinable?(other) }
+  subject { object.joinable?(other) }
 
-  let(:attribute) { Attribute::String.new(:string, :length => 10..20) }
+  let(:klass)  { Attribute::String                     }
+  let(:object) { klass.new(:string, :length => 10..20) }
 
   context 'when the attribute types and lengths are the same' do
-    let(:other) { Attribute::String.new(:string, :length => 10..20) }
+    let(:other) { klass.new(:string, :length => object.length) }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 
   context 'when the attribute types are the same and the lengths are different' do
-    let(:other) { Attribute::String.new(:string, :length => 1..20) }
+    let(:other) { klass.new(:string, :length => 1..20) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 
   context 'when the attribute types are different' do
-    let(:other) { Attribute::String.new(:different) }
+    let(:other) { Attribute::Integer.new(:different) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(attribute)
+      should == other.joinable?(object)
     end
   end
 end

data/spec/unit/veritas/attribute/string/length_spec.rb

@@ -2,18 +2,21 @@ require 'spec_helper'
 
 [ :length, :range ].each do |method|
   describe "Veritas::Attribute::String##{method}" do
-    subject { attribute.send(method) }
+    subject { object.send(method) }
+
+    let(:klass) { Attribute::String }
 
     context 'without :length option passed to constructor' do
-      let(:attribute) { Attribute::String.new(:name) }
+      let(:object) { klass.new(:name) }
 
       it { should == (0..50) }
     end
 
     context 'with :length option passed to constructor' do
-      let(:attribute) { Attribute::String.new(:name, :length => 1..100) }
+      let(:length) { 1..100                              }
+      let(:object) { klass.new(:name, :length => length) }
 
-      it { should == (1..100) }
+      it { should == length }
     end
   end
 end

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

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::String#valid_value?' do
-  subject { attribute.valid_value?(value) }
+  subject { object.valid_value?(value) }
 
-  let(:attribute) { Veritas::Attribute::String.new(:string, :length => 1..50) }
+  let(:klass)  { Attribute::String                    }
+  let(:object) { klass.new(:string, :length => 1..50) }
 
   context 'with a string value' do
     context 'that is within the allowed length range' do

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

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

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

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute::Time#range' do
-  subject { attribute.range }
+  subject { object.range }
 
-  let(:attribute) { Veritas::Attribute::Time.new(:time) }
+  let(:klass)  { Attribute::Time  }
+  let(:object) { klass.new(:time) }
 
   it { should == (Time.at(0)..Time.at(2**31-1)) }
 end

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

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

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

@@ -1,34 +1,36 @@
 require 'spec_helper'
 
 describe 'Veritas::Attribute#valid_value?' do
-  subject { attribute.valid_value?(value) }
+  subject { object.valid_value?(value) }
+
+  let(:klass) { Attribute::Integer }
 
   context 'when value is nil' do
     let(:value) { nil }
 
     context 'and the attribute is required' do
-      let(:attribute) { Attribute::Integer.new(:id) }
+      let(:object) { klass.new(:id) }
 
       it { should be(false) }
     end
 
     context 'and the attribute not required' do
-      let(:attribute) { Attribute::Integer.new(:id, :required => false) }
+      let(:object) { klass.new(:id, :required => false) }
 
       it { should be(true) }
     end
   end
 
   context 'when the value is a valid primitive' do
-    let(:attribute) { Attribute::Integer.new(:id) }
-    let(:value)     { 1                           }
+    let(:object) { klass.new(:id) }
+    let(:value)  { 1              }
 
     it { should be(true) }
   end
 
   context 'when the value is not a valid primitive' do
-    let(:attribute) { Attribute::Integer.new(:id) }
-    let(:value)     { 'a'                         }
+    let(:object) { klass.new(:id) }
+    let(:value)  { 'a'            }
 
     it { should be(false) }
   end

data/spec/unit/veritas/evaluator/expression/add_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
 describe 'Veritas::Evaluator::Expression#add' do
-  subject { klass.new(&expression) }
-
-  let(:klass)     { Veritas::Evaluator::Expression }
-  let(:attribute) { Attribute::Integer.new(:id)    }
+  let(:klass)     { Evaluator::Expression       }
+  let(:attribute) { Attribute::Integer.new(:id) }
 
   context 'when a function is provided' do
-    let(:function)   { mock('Function')                          }
-    let(:expression) { lambda { |o| o.add(attribute, function) } }
+    subject { klass.new { |object| object.add(attribute, function) } }
+
+    let(:function) { mock('Function') }
 
     its(:expressions) { should == { attribute => function } }
   end
 
   context 'when a block is provided' do
-    let(:block)      { proc {}                                 }
-    let(:expression) { lambda { |o| o.add(attribute, &block) } }
+    subject { klass.new { |object| object.add(attribute, &block) } }
+
+    let(:block) { proc {} }
 
     its(:expressions) { should == { attribute => block } }
   end

data/spec/unit/veritas/evaluator/expression/expressions_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'Veritas::Evaluator::Expression#expressions' do
   subject { object.expressions }
 
-  let(:klass)     { Veritas::Evaluator::Expression               }
+  let(:klass)     { Evaluator::Expression                        }
   let(:attribute) { Attribute::Integer.new(:id)                  }
   let(:function)  { mock('Function')                             }
   let(:object)    { klass.new { |o| o.add(attribute, function) } }

data/spec/unit/veritas/immutable/class_methods/freeze_object_spec.rb

@@ -40,6 +40,10 @@ describe 'Veritas::Immutable.freeze_object' do
 
     it { should_not equal(value) }
 
-    it { should eql(value) }
+    it { should be_kind_of(String) }
+
+    it { should == value }
+
+    it { should be_frozen }
   end
 end

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

@@ -2,11 +2,11 @@ require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
 describe 'Veritas::Immutable::ClassMethods#new' do
-  subject { klass.new }
+  subject { object.new }
 
-  let(:klass) { ImmutableSpecs::Object }
+  let(:object) { ImmutableSpecs::Object }
 
-  it { should be_kind_of(klass) }
+  it { should be_kind_of(object) }
 
   it { should be_frozen }
 end

data/spec/unit/veritas/immutable/dup_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Immutable#dup' do
-  subject { immutable.dup }
+  subject { object.dup }
 
-  let(:klass)     { ImmutableSpecs::Object }
-  let(:immutable) { klass.new              }
+  let(:klass)  { ImmutableSpecs::Object }
+  let(:object) { klass.new              }
 
-  it { should equal(immutable) }
+  it { should equal(object) }
 end

data/spec/unit/veritas/immutable/memoize_methods/freeze_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
 describe 'Veritas::Immutable::MemoizeMethods#freeze' do
-  subject { immutable.freeze }
+  subject { object.freeze }
 
   let(:klass) { Class.new(ImmutableSpecs::Object) }
 
@@ -11,32 +11,34 @@ describe 'Veritas::Immutable::MemoizeMethods#freeze' do
   end
 
   context 'with an unfrozen object' do
-    let(:immutable) { klass.allocate }
+    let(:object) { klass.allocate }
 
-    it { should equal(immutable) }
+    it { should equal(object) }
 
     it 'freezes the object' do
-      expect { subject }.to change(immutable, :frozen?).from(false).to(true)
+      expect { subject }.to change(object, :frozen?).
+        from(false).
+        to(true)
     end
 
     it 'sets a memoization instance variable' do
-      immutable.should_not be_instance_variable_defined(:@__memory)
+      object.should_not be_instance_variable_defined(:@__memory)
       subject
-      immutable.instance_variable_get(:@__memory).should be_kind_of(Immutable::Memory)
+      object.instance_variable_get(:@__memory).should be_kind_of(Immutable::Memory)
     end
   end
 
   context 'with a frozen object' do
-    let(:immutable) { klass.new }
+    let(:object) { klass.new }
 
-    it { should equal(immutable) }
+    it { should equal(object) }
 
     it 'does not change the frozen state of the object' do
-      expect { subject }.to_not change(immutable, :frozen?)
+      expect { subject }.to_not change(object, :frozen?)
     end
 
     it 'does not change the memoization instance variable' do
-      expect { subject }.to_not change { immutable.instance_variable_get(:@__memory) }
+      expect { subject }.to_not change { object.instance_variable_get(:@__memory) }
     end
 
     it 'sets an instance variable for memoization' do