veritas 0.0.2 → 0.0.3

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

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Evaluator::Expression#expressions' do
+describe Evaluator::Expression, '#expressions' do
   subject { object.expressions }
 
-  let(:klass)     { Evaluator::Expression                        }
-  let(:attribute) { Attribute::Integer.new(:id)                  }
-  let(:function)  { mock('Function')                             }
-  let(:object)    { klass.new { |o| o.add(attribute, function) } }
+  let(:attribute) { Attribute::Integer.new(:id)                            }
+  let(:function)  { mock('Function')                                       }
+  let(:object)    { described_class.new { |o| o.add(attribute, function) } }
 
   it { should == { attribute => function } }
 

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

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Immutable.freeze_object' do
+describe Immutable, '.freeze_object' do
   subject { object.freeze_object(value) }
 
-  let(:object) { Immutable }
+  let(:object) { self.class.described_type }
 
   context 'with a numeric value' do
     let(:value) { 1 }

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
-describe 'Veritas::Immutable::ClassMethods#new' do
+describe Immutable::ClassMethods, '#new' do
   subject { object.new }
 
   let(:object) { ImmutableSpecs::Object }

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

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

data/spec/unit/veritas/immutable/{memoize_methods/freeze_spec.rb → freeze_spec.rb}

@@ -1,17 +1,17 @@
 require 'spec_helper'
-require File.expand_path('../../fixtures/classes', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Immutable::MemoizeMethods#freeze' do
+describe Immutable, '#freeze' do
   subject { object.freeze }
 
-  let(:klass) { Class.new(ImmutableSpecs::Object) }
+  let(:described_class) { Class.new(ImmutableSpecs::Object) }
 
   before do
-    klass.memoize(:test)
+    described_class.memoize(:test)
   end
 
   context 'with an unfrozen object' do
-    let(:object) { klass.allocate }
+    let(:object) { described_class.allocate }
 
     it { should equal(object) }
 
@@ -29,7 +29,7 @@ describe 'Veritas::Immutable::MemoizeMethods#freeze' do
   end
 
   context 'with a frozen object' do
-    let(:object) { klass.new }
+    let(:object) { described_class.new }
 
     it { should equal(object) }
 

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

@@ -1,13 +1,20 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Immutable#memoize' do
-  subject { object.memoize(name, value) }
+describe Immutable, '#memoize' do
+  subject { object.memoize(method, value) }
 
-  let(:klass)  { ImmutableSpecs::Object }
-  let(:name)   { mock('Name')           }
-  let(:value)  { mock('Value')          }
-  let(:object) { klass.new              }
+  let(:described_class) { Class.new(ImmutableSpecs::Object) }
+  let(:object)          { described_class.new               }
+  let(:method)          { :test                             }
+  let(:value)           { String.new.freeze                 }
 
-  it { should equal(object) }
+  before do
+    described_class.memoize(method)
+  end
+
+  it 'sets the memoized value for the method to the value' do
+    subject
+    object.send(method).should equal(value)
+  end
 end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Immutable, '#memoized' do
+  subject { object.memoized(method) }
+
+  let(:described_class) { Class.new(ImmutableSpecs::Object) }
+  let(:method)          { :test                             }
+  let(:value)           { String.new.freeze                 }
+  let(:object)          { described_class.new               }
+
+  before do
+    described_class.memoize(method)
+  end
+
+  context 'when a method is memoized' do
+    before do
+      object.memoize(method, value)
+    end
+
+    it { should equal(value) }
+  end
+
+  context 'when a method is not memoized' do
+    it { should be_nil }
+  end
+end

data/spec/unit/veritas/immutable/memory/element_reference_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Immutable::Memory#[]' do
+describe Immutable::Memory, '#[]' do
   subject { object[key] }
 
-  let(:klass)  { Immutable::Memory }
-  let(:object) { klass.new         }
+  let(:object) { described_class.new }
 
   context 'with known key' do
     let(:key)   { '@key'        }

data/spec/unit/veritas/immutable/memory/element_set_spec.rb

@@ -1,10 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Immutable::Memory#[]=' do
+describe Immutable::Memory, '#[]=' do
   subject { object[key] = value }
 
-  let(:klass)  { Immutable::Memory               }
-  let(:object) { klass.new                       }
+  let(:object) { described_class.new             }
   let(:key)    { '@key'                          }
   let(:value)  { mock('Value', :frozen? => true) }
 

data/spec/unit/veritas/immutable/module_methods/included_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
-describe 'Veritas::Immutable::ModuleMethods#included' do
+describe Immutable::ModuleMethods, '#included' do
   subject { object.included(object) }
 
   let(:object) { ImmutableSpecs::Object }

data/spec/unit/veritas/immutable/module_methods/memoize_spec.rb

@@ -18,7 +18,7 @@ shared_examples_for 'memoizes method' do
     file, line = object.new.send(method).first.split(':')[0, 2]
 
     File.expand_path(file).should == File.expand_path('../../../../../../lib/veritas/support/immutable.rb', __FILE__)
-    line.to_i.should == 156
+    line.to_i.should == 177
   end
 
   it 'sets the file and line number properly' do
@@ -30,7 +30,7 @@ shared_examples_for 'memoizes method' do
   end
 end
 
-describe 'Veritas::Immutable::ModuleMethods#memoize' do
+describe Immutable::ModuleMethods, '#memoize' do
   subject { object.memoize(method) }
 
   let(:object) { Class.new(ImmutableSpecs::Object) }

data/spec/unit/veritas/logic/connective/binary/call_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Connective::Binary#call' do
+describe Logic::Connective::Binary, '#call' do
   subject { object.call(tuple) }
 
-  let(:klass)    { BinarySpecs::Object                            }
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])     }
-  let(:left)     { Logic::Predicate::Equality.new(header[:id], 1) }
-  let(:right)    { Logic::Predicate::Equality.new(header[:id], 2) }
-  let(:tuple)    { Tuple.new(header, [ 1 ])                       }
-  let(:response) { mock('#call response')                         }
-  let(:object)   { klass.new(left, right)                         }
+  let(:described_class) { BinarySpecs::Object                            }
+  let(:header)          { Relation::Header.new([ [ :id, Integer ] ])     }
+  let(:left)            { Logic::Predicate::Equality.new(header[:id], 1) }
+  let(:right)           { Logic::Predicate::Equality.new(header[:id], 2) }
+  let(:tuple)           { Tuple.new(header, [ 1 ])                       }
+  let(:response)        { mock('#call response')                         }
+  let(:object)          { described_class.new(left, right)               }
 
   before do
-    klass.should_receive(:call).with(true, false).and_return(response)
+    described_class.should_receive(:call).with(true, false).and_return(response)
   end
 
   it { should equal(response) }

data/spec/unit/veritas/logic/connective/binary/equal_value_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Logic::Connective::Binary, '#==' do
+  subject { object == other }
+
+  let(:described_class) { BinarySpecs::Object                 }
+  let(:attribute)       { Attribute::Integer.new(:id)         }
+  let(:header)          { Relation::Header.new([ attribute ]) }
+  let(:left)            { attribute.eq(1)                     }
+  let(:right)           { attribute.eq(2)                     }
+  let(:object)          { described_class.new(left, right)    }
+
+  context 'with the same object' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(described_class).new(left, right) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an object having a different left operand' do
+    let(:other_left) { attribute.ne(1)                        }
+    let(:other)      { described_class.new(other_left, right) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an object having a different right operand' do
+    let(:other_right) { attribute.ne(2)                        }
+    let(:other)       { described_class.new(left, other_right) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+end

data/spec/unit/veritas/logic/connective/binary/rename_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Connective::Binary#rename' do
+describe Logic::Connective::Binary, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:klass)     { BinarySpecs::Object                                       }
-  let(:attribute) { Attribute::Integer.new(:id)                               }
-  let(:other)     { attribute.rename(:other_id)                               }
-  let(:header)    { Relation::Header.new([ attribute ])                       }
-  let(:aliases)   { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
-  let(:object)    { klass.new(left, right)                                    }
+  let(:described_class) { BinarySpecs::Object                                       }
+  let(:attribute)       { Attribute::Integer.new(:id)                               }
+  let(:other)           { attribute.rename(:other_id)                               }
+  let(:header)          { Relation::Header.new([ attribute ])                       }
+  let(:aliases)         { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
+  let(:object)          { described_class.new(left, right)                          }
 
   context 'left and right are renamed' do
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.eq(2) }
 
-    it { should be_kind_of(klass) }
+    it { should be_kind_of(described_class) }
 
     its(:left) { should == other.eq(1) }
 
@@ -26,7 +26,7 @@ describe 'Veritas::Logic::Connective::Binary#rename' do
     let(:left)  { attribute.eq(1) }
     let(:right) { other.eq(2)     }
 
-    it { should be_kind_of(klass) }
+    it { should be_kind_of(described_class) }
 
     its(:left) { should == other.eq(1) }
 
@@ -37,7 +37,7 @@ describe 'Veritas::Logic::Connective::Binary#rename' do
     let(:left)  { other.eq(1)     }
     let(:right) { attribute.eq(2) }
 
-    it { should be_kind_of(klass) }
+    it { should be_kind_of(described_class) }
 
     its(:left) { should equal(left) }
 

data/spec/unit/veritas/logic/connective/conjunction/class_methods/call_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective::Conjunction.call' do
+describe Logic::Connective::Conjunction, '.call' do
   subject { object.call(left, right) }
 
-  let(:object) { Logic::Connective::Conjunction }
+  let(:object) { described_class }
 
   context 'when left is true and right is true' do
     let(:left)  { true }

data/spec/unit/veritas/logic/connective/conjunction/inspect_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective::Conjunction#inspect' do
+describe Logic::Connective::Conjunction, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)     { Logic::Connective::Conjunction }
-  let(:attribute) { Attribute::Integer.new(:id)    }
-  let(:left)      { attribute.gt(1)                }
-  let(:right)     { attribute.lt(3)                }
-  let(:object)    { klass.new(left, right)         }
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:left)      { attribute.gt(1)                  }
+  let(:right)     { attribute.lt(3)                  }
+  let(:object)    { described_class.new(left, right) }
 
-  it { should == "(#{left.inspect} AND #{right.inspect})"}
+  it { should == "(#{left.inspect} AND #{right.inspect})" }
 end

data/spec/unit/veritas/logic/connective/conjunction/methods/and_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 [ :and, :& ].each do |method|
-  describe "Veritas::Logic::Connective::Conjunction::Methods##{method}" do
+  describe Logic::Connective::Conjunction::Methods, "##{method}" do
     subject { object.send(method, predicate) }
 
-    let(:klass)     { ConjunctionMethodsSpecs::Object            }
-    let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
-    let(:predicate) { header[:id].eq(1)                          }
-    let(:object)    { klass.new.freeze                           }
+    let(:described_class) { ConjunctionMethodsSpecs::Object            }
+    let(:header)          { Relation::Header.new([ [ :id, Integer ] ]) }
+    let(:predicate)       { header[:id].eq(1)                          }
+    let(:object)          { described_class.new.freeze                 }
 
     it 'returns a conjunction of the proposition and predicate' do
       should eql(Logic::Connective::Conjunction.new(object, predicate))

data/spec/unit/veritas/logic/connective/disjunction/class_methods/call_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective::Disjunction.call' do
+describe Logic::Connective::Disjunction, '.call' do
   subject { object.call(left, right) }
 
-  let(:object) { Logic::Connective::Disjunction }
+  let(:object) { described_class }
 
   context 'when left is true and right is true' do
     let(:left)  { true }

data/spec/unit/veritas/logic/connective/disjunction/inspect_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective::Disjunction#inspect' do
+describe Logic::Connective::Disjunction, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)     { Logic::Connective::Disjunction }
-  let(:attribute) { Attribute::Integer.new(:id)    }
-  let(:left)      { attribute.gt(1)                }
-  let(:right)     { attribute.lt(3)                }
-  let(:object)    { klass.new(left, right)         }
+  let(:attribute) { Attribute::Integer.new(:id)      }
+  let(:left)      { attribute.gt(1)                  }
+  let(:right)     { attribute.lt(3)                  }
+  let(:object)    { described_class.new(left, right) }
 
-  it { should == "(#{left.inspect} OR #{right.inspect})"}
+  it { should == "(#{left.inspect} OR #{right.inspect})" }
 end

data/spec/unit/veritas/logic/connective/disjunction/methods/or_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 [ :or, :| ].each do |method|
-  describe "Veritas::Logic::Connective::Disjunction::Methods##{method}" do
+  describe Logic::Connective::Disjunction::Methods, "##{method}" do
     subject { object.send(method, predicate) }
 
-    let(:klass)     { DisjunctionMethodsSpecs::Object            }
-    let(:header)    { Relation::Header.new([ [ :id, Integer ] ]) }
-    let(:predicate) { header[:id].eq(1)                          }
-    let(:object)    { klass.new.freeze                           }
+    let(:described_class) { DisjunctionMethodsSpecs::Object            }
+    let(:header)          { Relation::Header.new([ [ :id, Integer ] ]) }
+    let(:predicate)       { header[:id].eq(1)                          }
+    let(:object)          { described_class.new.freeze                 }
 
     it 'returns a disjunction of the proposition and predicate' do
       should eql(Logic::Connective::Disjunction.new(object, predicate))