veritas 0.0.2 → 0.0.3

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate::Comparable.call' do
+describe Logic::Predicate::Comparable, '.call' do
   subject { object.call(left, right) }
 
   let(:left)   { 1                                }

data/spec/unit/veritas/logic/predicate/comparable/inspect_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate::Comparable#inspect' do
+describe Logic::Predicate::Comparable, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)  { PredicateComparableSpecs::Object          }
-  let(:left)   { mock('Expression', :inspect => '<left>')  }
-  let(:right)  { mock('Expression', :inspect => '<right>') }
-  let(:object) { klass.new(left, right)                    }
+  let(:described_class) { PredicateComparableSpecs::Object          }
+  let(:left)            { mock('Expression', :inspect => '<left>')  }
+  let(:right)           { mock('Expression', :inspect => '<right>') }
+  let(:object)          { described_class.new(left, right)          }
 
   it { should == '<left> == <right>' }
 end

data/spec/unit/veritas/logic/predicate/enumerable/class_methods/compare_method_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Enumerable.compare_method' do
+describe Logic::Predicate::Enumerable, '.compare_method' do
   subject { object.compare_method(enumerable) }
 
-  let(:object) { Logic::Predicate::Enumerable }
+  let(:object) { self.class.described_type }
 
-  describe 'the enumerable is a Range' do
+  context 'the enumerable is a Range' do
     let(:enumerable) { 1..2 }
 
     it { should == :cover? }
   end
 
-  describe 'the enumerable is an Array' do
+  context 'the enumerable is an Array' do
     let(:enumerable) { [ 1, 2 ] }
 
     it { should == :include? }

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

@@ -1,13 +1,12 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate#eql?' do
+describe Logic::Predicate, '#eql?' do
   subject { object.eql?(other) }
 
-  let(:klass)  { PredicateSpecs::Object      }
-  let(:left)   { Attribute::Integer.new(:id) }
-  let(:right)  { 1                           }
-  let(:object) { klass.new(left, right)      }
+  let(:left)   { Attribute::Integer.new(:id)      }
+  let(:right)  { 1                                }
+  let(:object) { described_class.new(left, right) }
 
   context 'with the same object' do
     let(:other) { object }
@@ -30,7 +29,7 @@ describe 'Veritas::Logic::Predicate#eql?' do
   end
 
   context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(klass).new(left, right) }
+    let(:other) { Class.new(described_class).new(left, right) }
 
     it { should be(false) }
 
@@ -39,10 +38,10 @@ describe 'Veritas::Logic::Predicate#eql?' do
     end
   end
 
-  context 'with an object having a different left' do
-    let(:other_left)  { Attribute::String.new(:name)       }
-    let(:other_right) { right                              }
-    let(:other)       { klass.new(other_left, other_right) }
+  context 'with an object having a different left operand' do
+    let(:other_left)  { Attribute::String.new(:name)                 }
+    let(:other_right) { right                                        }
+    let(:other)       { described_class.new(other_left, other_right) }
 
     it { should be(false) }
 
@@ -51,10 +50,10 @@ describe 'Veritas::Logic::Predicate#eql?' do
     end
   end
 
-  context 'with an object having a different right' do
-    let(:other_left)  { left                               }
-    let(:other_right) { 2                                  }
-    let(:other)       { klass.new(other_left, other_right) }
+  context 'with an object having a different right operand' do
+    let(:other_left)  { left                                         }
+    let(:other_right) { 2                                            }
+    let(:other)       { described_class.new(other_left, other_right) }
 
     it { should be(false) }
 

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

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Logic::Predicate, '#==' do
+  subject { object == other }
+
+  let(:left)   { Attribute::Integer.new(:id)      }
+  let(:right)  { 1                                }
+  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::String.new(:name)                 }
+    let(:other_right) { right                                        }
+    let(:other)       { described_class.new(other_left, other_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_left)  { left                                         }
+    let(:other_right) { 2                                            }
+    let(:other)       { described_class.new(other_left, other_right) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == (other == object)
+    end
+  end
+end

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

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

data/spec/unit/veritas/logic/predicate/equality/class_methods/inverse_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Equality.inverse' do
+describe Logic::Predicate::Equality, '.inverse' do
   subject { object.inverse }
 
-  let(:object) { Logic::Predicate::Equality }
+  let(:object) { described_class }
 
   it { should equal(Logic::Predicate::Inequality) }
 end

data/spec/unit/veritas/logic/predicate/equality/class_methods/operation_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Equality.operation' do
+describe Logic::Predicate::Equality, '.operation' do
   subject { object.operation }
 
-  let(:object) { Logic::Predicate::Equality }
+  let(:object) { described_class }
 
   it { should be(:==) }
 end

data/spec/unit/veritas/logic/predicate/equality/class_methods/reverse_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Equality.reverse' do
+describe Logic::Predicate::Equality, '.reverse' do
   subject { object.reverse }
 
-  let(:object) { Logic::Predicate::Equality }
+  let(:object) { described_class }
 
   it { should equal(object) }
 end

data/spec/unit/veritas/logic/predicate/equality/inspect_spec.rb

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

data/spec/unit/veritas/logic/predicate/equality/inverse_spec.rb

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

data/spec/unit/veritas/logic/predicate/equality/methods/eq_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate::Equality::Methods#eq' do
+describe Logic::Predicate::Equality::Methods, '#eq' do
   subject { object.eq(other) }
 
-  let(:klass)   { EqualityMethodsSpecs::Object }
-  let(:other)   { true                         }
-  let(:object)  { klass.new                    }
+  let(:described_class) { EqualityMethodsSpecs::Object }
+  let(:other)           { true                         }
+  let(:object)          { described_class.new          }
 
   it { should be_kind_of(Logic::Predicate::Equality) }
 end

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

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Exclusion.call' do
+describe Logic::Predicate::Exclusion, '.call' do
   subject { object.call(left, right) }
 
-  let(:object) { Logic::Predicate::Exclusion }
+  let(:object) { described_class }
 
   context 'when left is excluded from right' do
     let(:left)  { 1     }

data/spec/unit/veritas/logic/predicate/exclusion/class_methods/inverse_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Exclusion.inverse' do
+describe Logic::Predicate::Exclusion, '.inverse' do
   subject { object.inverse }
 
-  let(:object) { Logic::Predicate::Exclusion }
+  let(:object) { described_class }
 
   it { should equal(Logic::Predicate::Inclusion) }
 end

data/spec/unit/veritas/logic/predicate/exclusion/inspect_spec.rb

@@ -2,12 +2,11 @@
 
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Exclusion#inspect' do
+describe Logic::Predicate::Exclusion, '#inspect' do
   subject { object.inspect }
 
-  let(:klass)     { Logic::Predicate::Exclusion }
-  let(:attribute) { Attribute::Integer.new(:id) }
-  let(:object)    { klass.new(attribute, [ 1 ]) }
+  let(:attribute) { Attribute::Integer.new(:id)           }
+  let(:object)    { described_class.new(attribute, [ 1 ]) }
 
   it { should == "#{attribute.inspect} ∉ #{[ 1 ].inspect}" }
 end

data/spec/unit/veritas/logic/predicate/exclusion/inverse_spec.rb

@@ -1,12 +1,11 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::Exclusion#inverse' do
+describe Logic::Predicate::Exclusion, '#inverse' do
   subject { object.inverse }
 
-  let(:klass)      { Logic::Predicate::Exclusion      }
-  let(:attribute)  { Attribute::Integer.new(:id)      }
-  let(:enumerable) { [ 1 ].freeze                     }
-  let(:object)     { klass.new(attribute, enumerable) }
+  let(:attribute)  { Attribute::Integer.new(:id)                }
+  let(:enumerable) { [ 1 ].freeze                               }
+  let(:object)     { described_class.new(attribute, enumerable) }
 
   it_should_behave_like 'an idempotent method'
 

data/spec/unit/veritas/logic/predicate/exclusion/methods/exclude_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate::Exclusion::Methods#exclude' do
+describe Logic::Predicate::Exclusion::Methods, '#exclude' do
   subject { object.exclude(other) }
 
-  let(:klass)  { ExclusionMethodsSpecs::Object }
-  let(:other)  { [ true, false ]               }
-  let(:object) { klass.new                     }
+  let(:described_class) { ExclusionMethodsSpecs::Object }
+  let(:other)           { [ true, false ]               }
+  let(:object)          { described_class.new           }
 
   it { should be_kind_of(Logic::Predicate::Exclusion) }
 end

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

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::GreaterThan.call' do
+describe Logic::Predicate::GreaterThan, '.call' do
   subject { object.call(left, right) }
 
-  let(:object) { Logic::Predicate::GreaterThan }
+  let(:object) { described_class }
 
   context 'when left is equal to right' do
     let(:left)  { 1 }

data/spec/unit/veritas/logic/predicate/greater_than/class_methods/inverse_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::GreaterThan.inverse' do
+describe Logic::Predicate::GreaterThan, '.inverse' do
   subject { object.inverse }
 
-  let(:object) { Logic::Predicate::GreaterThan }
+  let(:object) { described_class }
 
   it { should equal(Logic::Predicate::LessThanOrEqualTo) }
 end

data/spec/unit/veritas/logic/predicate/greater_than/class_methods/operation_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::GreaterThan.operation' do
+describe Logic::Predicate::GreaterThan, '.operation' do
   subject { object.operation }
 
-  let(:object) { Logic::Predicate::GreaterThan }
+  let(:object) { described_class }
 
   it { should be(:>) }
 end

data/spec/unit/veritas/logic/predicate/greater_than/class_methods/reverse_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe 'Veritas::Logic::Predicate::GreaterThan.reverse' do
+describe Logic::Predicate::GreaterThan, '.reverse' do
   subject { object.reverse }
 
-  let(:object) { Logic::Predicate::GreaterThan }
+  let(:object) { described_class }
 
   it { should equal(Logic::Predicate::LessThan) }
 end

data/spec/unit/veritas/logic/predicate/greater_than/inspect_spec.rb

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

data/spec/unit/veritas/logic/predicate/greater_than/inverse_spec.rb

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

data/spec/unit/veritas/logic/predicate/greater_than/methods/gt_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe 'Veritas::Logic::Predicate::GreaterThan::Methods#gt' do
+describe Logic::Predicate::GreaterThan::Methods, '#gt' do
   subject { object.gt(other) }
 
-  let(:klass)  { GreaterThanMethodsSpecs::Object }
-  let(:other)  { 1                               }
-  let(:object) { klass.new                       }
+  let(:described_class) { GreaterThanMethodsSpecs::Object }
+  let(:other)           { 1                               }
+  let(:object)          { described_class.new             }
 
   it { should be_kind_of(Logic::Predicate::GreaterThan) }
 end