veritas 0.0.1 → 0.0.2

data/spec/unit/veritas/logic/proposition/class_methods/new_spec.rb

@@ -1,23 +1,27 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition.new' do
-  subject { Logic::Proposition.new(*args) }
-
-  context 'with no arguments' do
-    let(:args) { [] }
-
-    it { should be_kind_of(Logic::Proposition) }
-  end
+  let(:object) { Logic::Proposition }
 
   context 'with true argument' do
-    let(:args) { [ true ] }
+    subject { object.new(argument) }
+
+    let(:argument) { true }
 
     it { should equal(Logic::Proposition::True.instance) }
   end
 
   context 'with false argument' do
-    let(:args) { [ false ] }
+    subject { object.new(argument) }
+
+    let(:argument) { false }
 
     it { should equal(Logic::Proposition::False.instance) }
   end
+
+  context 'with no arguments' do
+    subject { object.new }
+
+    specify { pending { expect { subject }.to raise_error(NotImplementedError, "#{object} is an abstract class") } }
+  end
 end

data/spec/unit/veritas/logic/proposition/eql_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Logic::Proposition#eql?' do
-  subject { proposition.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:proposition) { PropositionSpecs::Object.new }
+  let(:klass)  { Class.new(Logic::Proposition) }
+  let(:object) { klass.new                     }
 
   context 'with the same class' do
-    let(:other) { PropositionSpecs::Object.new }
+    let(:other) { klass.new }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(proposition)
+      should == other.eql?(object)
     end
   end
 
@@ -22,7 +22,7 @@ describe 'Veritas::Logic::Proposition#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(proposition)
+      should == other.eql?(object)
     end
   end
 end

data/spec/unit/veritas/logic/proposition/false/and_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::False#and' do
-  subject { false_proposition.and(other) }
+  subject { object.and(other) }
 
-  let(:other)             { mock('other')                      }
-  let(:false_proposition) { Logic::Proposition::False.instance }
+  let(:klass)  { Logic::Proposition::False }
+  let(:other)  { mock('other')             }
+  let(:object) { klass.instance            }
 
-  it { should equal(false_proposition) }
+  it { should equal(object) }
 end

data/spec/unit/veritas/logic/proposition/false/class_methods/call_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::False.call' do
-  subject { Logic::Proposition::False.call }
+  subject { object.call }
+
+  let(:object) { Logic::Proposition::False }
 
   it { should be(false) }
 end

data/spec/unit/veritas/logic/proposition/false/class_methods/inverse_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::False.inverse' do
-  subject { Logic::Proposition::False.inverse }
+  subject { object.inverse }
+
+  let(:object) { Logic::Proposition::False }
 
   it { should equal(Logic::Proposition::True) }
 end

data/spec/unit/veritas/logic/proposition/false/inspect_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::False#inspect' do
-  subject { false_proposition.inspect }
+  subject { object.inspect }
 
-  let(:false_proposition) { Logic::Proposition::False.instance }
+  let(:klass)  { Logic::Proposition::False }
+  let(:object) { klass.instance            }
 
   it { should == 'false' }
 end

data/spec/unit/veritas/logic/proposition/false/inverse_spec.rb

@@ -1,15 +1,16 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::False#inverse' do
-  subject { false_proposition.inverse }
+  subject { object.inverse }
 
-  let(:false_proposition) { Logic::Proposition::False.instance }
+  let(:klass)  { Logic::Proposition::False }
+  let(:object) { klass.instance            }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(Logic::Proposition::True.instance) }
 
   it 'is invertible' do
-    subject.inverse.should equal(false_proposition)
+    subject.inverse.should equal(object)
   end
-
-  it_should_behave_like 'an idempotent method'
 end

data/spec/unit/veritas/logic/proposition/false/or_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::False#or' do
-  subject { false_proposition.or(other) }
+  subject { object.or(other) }
 
-  let(:other)             { mock('other')                      }
-  let(:false_proposition) { Logic::Proposition::False.instance }
+  let(:klass)  { Logic::Proposition::False }
+  let(:other)  { mock('other')             }
+  let(:object) { klass.instance            }
 
   it { should equal(other) }
 end

data/spec/unit/veritas/logic/proposition/hash_spec.rb

@@ -1,19 +1,12 @@
 require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Logic::Proposition#hash' do
-  subject { proposition.hash }
+  subject { object.hash }
 
-  let(:proposition) { PropositionSpecs::Object.new }
+  let(:klass)  { Class.new(Logic::Proposition) }
+  let(:object) { klass.new                     }
 
-  before do
-    @response = mock('#call response')
-    PropositionSpecs::Object.should_receive(:call).at_least(:once).and_return(@response)
-  end
+  it_should_behave_like 'a hash method'
 
-  it 'hashes the results of self.class.call' do
-    should == @response.hash
-  end
-
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash }
 end

data/spec/unit/veritas/logic/proposition/inspect_spec.rb

@@ -1,10 +1,14 @@
 require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Logic::Proposition#inspect' do
-  subject { proposition.inspect }
+  subject { object.inspect }
 
-  let(:proposition) { PropositionSpecs::Object.new }
+  let(:klass)  { Class.new(Logic::Proposition) }
+  let(:object) { klass.new                     }
 
-  specify { expect { subject }.to raise_error(NotImplementedError, 'Veritas::Logic::Proposition.call must be implemented') }
+  before do
+    klass.stub!(:name).and_return('Veritas::Logic::Proposition')
+  end
+
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{klass.name}.call must be implemented") }
 end

data/spec/unit/veritas/logic/proposition/inverse_spec.rb

@@ -1,13 +1,12 @@
 require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
 
 describe 'Veritas::Logic::Proposition#inverse' do
-  subject { proposition.inverse }
+  subject { object.inverse }
 
-  let(:klass)            { Class.new(PropositionSpecs::Object)                  }
-  let(:proposition)      { klass.new                                            }
+  let(:klass)            { Class.new(Logic::Proposition)                        }
   let(:inverse_class)    { mock('Inverse Class', :instance => inverse_instance) }
   let(:inverse_instance) { mock('Inverse Instance')                             }
+  let(:object)           { klass.new                                            }
 
   before do
     klass.stub!(:inverse).and_return(inverse_class)

data/spec/unit/veritas/logic/proposition/true/and_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::True#and' do
-  subject { true_proposition.and(other) }
+  subject { object.and(other) }
 
-  let(:other)            { mock('other')                     }
-  let(:true_proposition) { Logic::Proposition::True.instance }
+  let(:klass)  { Logic::Proposition::True }
+  let(:other)  { mock('other')            }
+  let(:object) { klass.instance           }
 
   it { should equal(other) }
 end

data/spec/unit/veritas/logic/proposition/true/class_methods/call_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::True.call' do
-  subject { Logic::Proposition::True.call }
+  subject { object.call }
+
+  let(:object) { Logic::Proposition::True }
 
   it { should be(true) }
 end

data/spec/unit/veritas/logic/proposition/true/class_methods/inverse_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::True.inverse' do
-  subject { Logic::Proposition::True.inverse }
+  subject { object.inverse }
+
+  let(:object) { Logic::Proposition::True }
 
   it { should equal(Logic::Proposition::False) }
 end

data/spec/unit/veritas/logic/proposition/true/inspect_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::True#inspect' do
-  subject { true_proposition.inspect }
+  subject { object.inspect }
 
-  let(:true_proposition) { Logic::Proposition::True.instance }
+  let(:klass)  { Logic::Proposition::True }
+  let(:object) { klass.instance           }
 
   it { should == 'true' }
 end

data/spec/unit/veritas/logic/proposition/true/inverse_spec.rb

@@ -1,15 +1,16 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::True#inverse' do
-  subject { true_proposition.inverse }
+  subject { object.inverse }
 
-  let(:true_proposition) { Logic::Proposition::True.instance }
+  let(:klass)  { Logic::Proposition::True }
+  let(:object) { klass.instance           }
+
+  it_should_behave_like 'an idempotent method'
 
   it { should equal(Logic::Proposition::False.instance) }
 
   it 'is invertible' do
-    subject.inverse.should equal(true_proposition)
+    subject.inverse.should equal(object)
   end
-
-  it_should_behave_like 'an idempotent method'
 end

data/spec/unit/veritas/logic/proposition/true/or_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Logic::Proposition::True#or' do
-  subject { true_proposition.or(other) }
+  subject { object.or(other) }
 
-  let(:other)            { mock('other')                     }
-  let(:true_proposition) { Logic::Proposition::True.instance }
+  let(:klass)  { Logic::Proposition::True }
+  let(:other)  { mock('other')            }
+  let(:object) { klass.instance           }
 
-  it { should equal(true_proposition) }
+  it { should equal(object) }
 end

data/spec/unit/veritas/operation/binary/eql_spec.rb

@@ -1,52 +1,64 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Binary#eql?' do
-  subject { binary_operation.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:klass)            { Class.new { include Operation::Binary } }
-  let(:left)             { mock('Left')                            }
-  let(:right)            { mock('Right')                           }
-  let(:binary_operation) { klass.new(left, right)                  }
+  let(:klass)  { Class.new { include Operation::Binary } }
+  let(:left)   { mock('Left')                            }
+  let(:right)  { mock('Right')                           }
+  let(:object) { klass.new(left, right)                  }
 
-  context 'with the same binary operation' do
-    let(:other) { binary_operation }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(binary_operation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent binary operation' do
-    let(:other) { binary_operation.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(binary_operation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different binary operation' do
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(left, right) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an object having a different left' do
     let(:other_left)  { mock('Other Left')                 }
-    let(:other_right) { mock('Other Right')                }
+    let(:other_right) { right                              }
     let(:other)       { klass.new(other_left, other_right) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(binary_operation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent binary operation of a different class' do
-    let(:other) { Class.new(klass).new(left, right) }
+  context 'with an object having a different right' do
+    let(:other_left)  { left                               }
+    let(:other_right) { mock('Other Right')                }
+    let(:other)       { klass.new(other_left, other_right) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(binary_operation)
+      should == other.eql?(object)
     end
   end
 end

data/spec/unit/veritas/operation/binary/hash_spec.rb

@@ -1,16 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Binary#hash' do
-  subject { binary_operation.hash }
+  subject { object.hash }
 
-  let(:klass)            { Class.new { include Operation::Binary } }
-  let(:left)             { mock('Left')                            }
-  let(:right)            { mock('Right')                           }
-  let(:binary_operation) { klass.new(left, right)                  }
+  let(:klass)  { Class.new { include Operation::Binary } }
+  let(:left)   { mock('Left').freeze                     }
+  let(:right)  { mock('Right').freeze                    }
+  let(:object) { klass.new(left, right)                  }
 
-  it { should be_kind_of(Integer) }
+  it_should_behave_like 'a hash method'
 
-  it { should == left.hash ^ right.hash }
-
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ left.hash ^ right.hash }
 end

data/spec/unit/veritas/operation/binary/left_spec.rb

@@ -1,12 +1,25 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Binary#left' do
-  subject { binary_operation.left }
+  subject { object.left }
 
-  let(:klass)            { Class.new { include Operation::Binary } }
-  let(:left)             { mock('Left')                            }
-  let(:right)            { mock('Right')                           }
-  let(:binary_operation) { klass.new(left, right)                  }
+  let(:klass)  { Class.new { include Operation::Binary } }
+  let(:right)  { 'Right'                                 }
+  let(:object) { klass.new(left, right)                  }
 
-  it { should equal(left) }
+  context 'when left operand is frozen' do
+    let(:left) { 'Left'.freeze }
+
+    it { should equal(left) }
+  end
+
+  context 'when left operand is not frozen' do
+    let(:left) { 'Left' }
+
+    it { should_not equal(left) }
+
+    it { should be_frozen }
+
+    it { should == left }
+  end
 end

data/spec/unit/veritas/operation/binary/right_spec.rb

@@ -1,12 +1,25 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Binary#right' do
-  subject { binary_operation.right }
+  subject { object.right }
 
-  let(:klass)            { Class.new { include Operation::Binary } }
-  let(:left)             { mock('Left')                            }
-  let(:right)            { mock('Right')                           }
-  let(:binary_operation) { klass.new(left, right)                  }
+  let(:klass)  { Class.new { include Operation::Binary } }
+  let(:left)   { 'Left'                                  }
+  let(:object) { klass.new(left, right)                  }
 
-  it { should equal(right) }
+  context 'when right operand is frozen' do
+    let(:right) { 'Right'.freeze }
+
+    it { should equal(right) }
+  end
+
+  context 'when right operand is not frozen' do
+    let(:right) { 'Right' }
+
+    it { should_not equal(right) }
+
+    it { should be_frozen }
+
+    it { should == right }
+  end
 end

data/spec/unit/veritas/operation/unary/eql_spec.rb

@@ -1,51 +1,50 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Unary#eql?' do
-  subject { unary_operation.eql?(other) }
+  subject { object.eql?(other) }
 
-  let(:klass)           { Class.new { include Operation::Unary } }
-  let(:operand)         { mock('Operand')                        }
-  let(:unary_operation) { klass.new(operand)                     }
+  let(:klass)   { Class.new { include Operation::Unary } }
+  let(:operand) { mock('Operand')                        }
+  let(:object)  { klass.new(operand)                     }
 
-  context 'with the same unary operation' do
-    let(:other) { unary_operation }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(unary_operation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent unary operation' do
-    let(:other) { unary_operation.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(unary_operation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different unary operation' do
-    let(:other_klass) { Class.new { include Operation::Unary } }
-    let(:other)       { other_klass.new(operand)               }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(operand) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(unary_operation)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent unary operation of a different class' do
-    let(:other_klass) { Class.new(klass)         }
-    let(:other)       { other_klass.new(operand) }
+  context 'with an object having a different operand' do
+    let(:other_operand) { mock('Other Operand')    }
+    let(:other)         { klass.new(other_operand) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(unary_operation)
+      should == other.eql?(object)
     end
   end
 end

data/spec/unit/veritas/operation/unary/hash_spec.rb

@@ -1,15 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Unary#hash' do
-  subject { unary_operation.hash }
+  subject { object.hash }
 
-  let(:klass)           { Class.new { include Operation::Unary } }
-  let(:operand)         { mock('Operand')                        }
-  let(:unary_operation) { klass.new(operand)                     }
+  let(:klass)   { Class.new { include Operation::Unary } }
+  let(:operand) { mock('Operand').freeze                 }
+  let(:object)  { klass.new(operand)                     }
 
-  it { should be_kind_of(Integer) }
+  it_should_behave_like 'a hash method'
 
-  it { should == operand.hash }
-
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ operand.hash }
 end

data/spec/unit/veritas/operation/unary/operand_spec.rb

@@ -1,11 +1,24 @@
 require 'spec_helper'
 
 describe 'Veritas::Operation::Unary#operand' do
-  subject { unary_operation.operand }
+  subject { object.operand }
 
-  let(:klass)           { Class.new { include Operation::Unary } }
-  let(:operand)         { mock('Operand')                        }
-  let(:unary_operation) { klass.new(operand)                     }
+  let(:klass)  { Class.new { include Operation::Unary } }
+  let(:object) { klass.new(operand)                     }
 
-  it { should equal(operand) }
+  context 'when operand is frozen' do
+    let(:operand) { 'Operand'.freeze }
+
+    it { should equal(operand) }
+  end
+
+  context 'when operand is not frozen' do
+    let(:operand) { 'Operand' }
+
+    it { should_not equal(operand) }
+
+    it { should be_frozen }
+
+    it { should == operand }
+  end
 end

data/spec/unit/veritas/optimizable/class_methods/optimizer_spec.rb

@@ -3,8 +3,7 @@ require 'spec_helper'
 describe 'Veritas::Optimizable::ClassMethods#optimizer' do
   subject { object.optimizer }
 
-  let(:klass)  { Class.new { include Optimizable, Immutable } }
-  let(:object) { klass                                        }
+  let(:object) { Class.new { include Optimizable, Immutable } }
 
   context 'when the optimizer is not set' do
     it { should be_nil }
@@ -24,9 +23,8 @@ end
 describe 'Veritas::Optimizable::ClassMethods#optimizer=' do
   subject { object.optimizer = optimizer }
 
-  let(:klass)     { Class.new { include Optimizable, Immutable } }
   let(:optimizer) { mock('Optimizer')                            }
-  let(:object)    { klass                                        }
+  let(:object)    { Class.new { include Optimizable, Immutable } }
 
   it 'sets the optimizer' do
     expect { subject }.to change { object.optimizer }.from(nil).to(optimizer)

data/spec/unit/veritas/optimizer/algebra/extension/unoptimized_operand/optimizable_spec.rb

@@ -15,7 +15,7 @@ describe 'Veritas::Optimizer::Algebra::Extension::UnoptimizedOperand#optimizable
   end
 
   context 'when the operand is optimizable' do
-    let(:operand) { base.project(header) }
+    let(:operand) { base.rename({}) }
 
     it { should be(true) }
   end