veritas 0.0.2 → 0.0.3

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

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective#inspect' do
+describe Logic::Connective, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)  { Class.new(Logic::Connective) }
-  let(:object) { klass.new                    }
+  let(:described_class) { Class.new(Logic::Connective) }
+  let(:object)          { described_class.new          }
 
-  specify { expect { subject }.to raise_error(NotImplementedError, "#{klass}#inspect must be implemented") }
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#inspect must be implemented") }
 end

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

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective#inverse' do
+describe Logic::Connective, '#inverse' do
   subject { object.inverse }
 
+  let(:described_class) { Class.new(Logic::Connective) }
+  let(:object)          { described_class.new          }
+
   before do
-    klass.class_eval do
+    described_class.class_eval do
       def inspect
         'Connective()'
       end
     end
   end
 
-  let(:klass)  { Class.new(Logic::Connective) }
-  let(:object) { klass.new                    }
-
   it_should_behave_like 'an idempotent method'
 
   it { should be_kind_of(Logic::Connective::Negation) }

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

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

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

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective::Negation#inspect' do
+describe Logic::Connective::Negation, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)     { Logic::Connective::Negation }
-  let(:attribute) { Attribute::Integer.new(:id) }
-  let(:operand)   { attribute.eq(1)             }
-  let(:object)    { klass.new(operand)          }
+  let(:attribute) { Attribute::Integer.new(:id)  }
+  let(:operand)   { attribute.eq(1)              }
+  let(:object)    { described_class.new(operand) }
 
   it { should == "not(#{operand.inspect})" }
 end

data/spec/unit/veritas/logic/connective/negation/inverse_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Connective::Negation#inverse' do
+describe Logic::Connective::Negation, '#inverse' do
   subject { object.inverse }
 
-  let(:klass)     { Logic::Connective::Negation }
-  let(:attribute) { Attribute::Integer.new(:id) }
-  let(:operand)   { attribute.eq(1)             }
-  let(:object)    { klass.new(operand)          }
+  let(:attribute) { Attribute::Integer.new(:id)  }
+  let(:operand)   { attribute.eq(1)              }
+  let(:object)    { described_class.new(operand) }
 
   it_should_behave_like 'an idempotent method'
 

data/spec/unit/veritas/logic/connective/negation/methods/not_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
 [ :not, :- ].each do |method|
-  describe "Veritas::Logic::Connective::Negation::Methods##{method}" do
+  describe Logic::Connective::Negation::Methods, "##{method}" do
     subject { object.send(method, predicate) }
 
-    let(:klass)     { NegationMethodsSpecs::Object                   }
-    let(:header)    { Relation::Header.new([ [ :id, Integer ] ])     }
-    let(:predicate) { Logic::Predicate::Equality.new(header[:id], 1) }
-    let(:object)    { klass.new                                      }
+    let(:described_class) { NegationMethodsSpecs::Object                   }
+    let(:header)          { Relation::Header.new([ [ :id, Integer ] ])     }
+    let(:predicate)       { Logic::Predicate::Equality.new(header[:id], 1) }
+    let(:object)          { described_class.new                            }
 
     before do
       def object.eql?(other)

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

@@ -1,18 +1,18 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Connective::Unary#call' do
+describe Logic::Connective::Unary, '#call' do
   subject { object.call(tuple) }
 
-  let(:klass)    { UnarySpecs::Object                         }
-  let(:header)   { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:operand)  { header[:id].eq(1)                          }
-  let(:tuple)    { Tuple.new(header, [ 1 ])                   }
-  let(:response) { mock('#call response')                     }
-  let(:object)   { klass.new(operand)                         }
+  let(:described_class) { UnarySpecs::Object                         }
+  let(:header)          { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:operand)         { header[:id].eq(1)                          }
+  let(:tuple)           { Tuple.new(header, [ 1 ])                   }
+  let(:response)        { mock('#call response')                     }
+  let(:object)          { described_class.new(operand)               }
 
   before do
-    klass.should_receive(:call).with(true).and_return(response)
+    described_class.should_receive(:call).with(true).and_return(response)
   end
 
   it { should equal(response) }

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Logic::Connective::Unary, '#==' do
+  subject { object == other }
+
+  let(:described_class) { UnarySpecs::Object                  }
+  let(:attribute)       { Attribute::Integer.new(:id)         }
+  let(:header)          { Relation::Header.new([ attribute ]) }
+  let(:operand)         { attribute.eq(1)                     }
+  let(:object)          { described_class.new(operand)        }
+
+  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(operand) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+
+  context 'with an object having a different operand' do
+    let(:other_operand) { attribute.ne(1)                    }
+    let(:other)         { described_class.new(other_operand) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+end

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

@@ -1,20 +1,20 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Connective::Unary#rename' do
+describe Logic::Connective::Unary, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:klass)     { UnarySpecs::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(operand)                                        }
+  let(:described_class) { UnarySpecs::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(operand)                              }
 
   context 'operand is renamed' do
     let(:operand) { attribute.eq(1) }
 
-    it { should be_kind_of(klass) }
+    it { should be_kind_of(described_class) }
 
     its(:operand) { should == other.eq(1) }
   end

data/spec/unit/veritas/logic/expression/class_methods/call_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Expression.call' do
+describe Logic::Expression, '.call' do
   subject { object.call }
 
-  let(:object) { Logic::Expression }
+  let(:object) { described_class }
 
   specify { expect { subject }.to raise_error(NotImplementedError, "#{object}.call must be implemented") }
 end

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

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Expression#eql?' do
+describe Logic::Expression, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:klass)  { ExpressionSpecs::Object }
-  let(:other)  { klass.new               }
-  let(:object) { klass.new               }
+  let(:described_class) { ExpressionSpecs::Object }
+  let(:other)           { described_class.new     }
+  let(:object)          { described_class.new     }
 
   specify { expect { subject }.to raise_error(NotImplementedError, 'ExpressionSpecs::Object#eql? must be implemented') }
 end

data/spec/unit/veritas/logic/expression/equal_value_spec.rb

@@ -1,60 +1,12 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Expression#==' do
+describe Logic::Expression, '#==' do
   subject { object == other }
 
-  let(:klass)  { Class.new(ExpressionSpecs::Object) }
-  let(:object) { klass.new                          }
+  let(:described_class) { ExpressionSpecs::Object }
+  let(:other)           { described_class.new     }
+  let(:object)          { described_class.new     }
 
-  before do
-    klass.class_eval do
-      def eql?(other)
-        instance_of?(other.class)
-      end
-    end
-  end
-
-  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 two equivalent unoptimized object' do
-    let(:object) { klass.new & klass.new }
-    let(:other)  { klass.new & klass.new }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
-
-  context 'with two different unoptimized object' do
-    let(:object)   { klass.new & klass.new       }
-    let(:subclass) { Class.new(klass)            }
-    let(:other)    { subclass.new & subclass.new }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should == (other == object)
-    end
-  end
+  specify { expect { subject }.to raise_error(NotImplementedError, 'ExpressionSpecs::Object#== must be implemented') }
 end

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

@@ -1,11 +1,11 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Expression#hash' do
+describe Logic::Expression, '#hash' do
   subject { object.hash }
 
-  let(:klass)  { ExpressionSpecs::Object }
-  let(:object) { klass.new               }
+  let(:described_class) { ExpressionSpecs::Object }
+  let(:object)          { described_class.new     }
 
-  specify { expect { subject }.to raise_error(NotImplementedError, "#{klass}#hash must be implemented") }
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#hash must be implemented") }
 end

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

@@ -1,11 +1,11 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Expression#inspect' do
+describe Logic::Expression, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)  { ExpressionSpecs::Object }
-  let(:object) { klass.new               }
+  let(:described_class) { ExpressionSpecs::Object }
+  let(:object)          { described_class.new     }
 
-  specify { expect { subject }.to raise_error(NotImplementedError, "#{klass}#inspect must be implemented") }
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#inspect must be implemented") }
 end

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

@@ -5,12 +5,12 @@ methods = [ :inverse ]
 methods << '!' if respond_to?('!')  # available in Ruby 1.9
 
 methods.each do |method|
-  describe "Veritas::Logic::Expression##{method}" do
+  describe Logic::Expression, "##{method}" do
     subject { object.send(method) }
 
-    let(:klass)  { ExpressionSpecs::Object }
-    let(:object) { klass.new               }
+    let(:described_class) { ExpressionSpecs::Object }
+    let(:object)          { described_class.new     }
 
-    specify { expect { subject }.to raise_error(NotImplementedError, "#{klass}#inverse must be implemented") }
+    specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}#inverse must be implemented") }
   end
 end

data/spec/unit/veritas/logic/expression/rename_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Expression#rename' do
+describe Logic::Expression, '#rename' do
   subject { object.rename(aliases) }
 
-  let(:klass)   { ExpressionSpecs::Object          }
-  let(:header)  { TABLE_DUM.header                 }
-  let(:aliases) { Algebra::Rename::Aliases.new({}) }
-  let(:object)  { klass.new                        }
+  let(:described_class) { ExpressionSpecs::Object          }
+  let(:header)          { TABLE_DUM.header                 }
+  let(:aliases)         { Algebra::Rename::Aliases.new({}) }
+  let(:object)          { described_class.new              }
 
   it 'returns self' do
     should equal(object)

data/spec/unit/veritas/logic/predicate/call_spec.rb

@@ -1,17 +1,16 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate#call' do
+describe Logic::Predicate, '#call' do
   subject { object.call(tuple) }
 
-  let(:klass)  { PredicateSpecs::Object                     }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:tuple)  { Tuple.new(header, [ 1 ])                   }
-  let(:object) { klass.new(header[:id], 1)                  }
+  let(:object) { described_class.new(header[:id], 1)        }
 
   it 'sends the left and right value to self.class.call' do
     response = mock('#call response')
-    klass.should_receive(:call).with(1, 1).and_return(response)
+    described_class.should_receive(:call).with(1, 1).and_return(response)
     should equal(response)
   end
 end

data/spec/unit/veritas/logic/predicate/class_methods/call_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate.call' do
+describe Logic::Predicate, '.call' do
   subject { object.call(left, right) }
 
-  let(:left)   { 1                }
-  let(:right)  { 1                }
-  let(:object) { Logic::Predicate }
+  let(:left)   { 1               }
+  let(:right)  { 1               }
+  let(:object) { described_class }
 
   specify { expect { subject }.to raise_error(NotImplementedError, "#{object}.call must be implemented") }
 end

data/spec/unit/veritas/logic/predicate/class_methods/extract_value_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate.extract_value' do
+describe Logic::Predicate, '.extract_value' do
   subject { object.extract_value(operand, tuple) }
 
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:tuple)  { Tuple.new(header, [ 1 ])                   }
-  let(:object) { Logic::Predicate                           }
+  let(:object) { described_class                            }
 
   context 'when the operand responds to #call' do
     let(:operand) { header[:id] }