veritas 0.0.3 → 0.0.4

data/spec/unit/veritas/{logic/predicate/inequality → function/predicate/equality}/class_methods/call_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inequality, '.call' do
+describe Function::Predicate::Equality, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }
@@ -9,13 +11,13 @@ describe Logic::Predicate::Inequality, '.call' do
     let(:left)  { true }
     let(:right) { true }
 
-    it { should be(false) }
+    it { should be(true) }
   end
 
   context 'when left is not equal to right' do
     let(:left)  { true  }
     let(:right) { false }
 
-    it { should be(true) }
+    it { should be(false) }
   end
 end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Equality, '.inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::Inequality) }
+end

data/spec/unit/veritas/{logic → function}/predicate/equality/class_methods/operation_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Equality, '.operation' do
+describe Function::Predicate::Equality, '.operation' do
   subject { object.operation }
 
   let(:object) { described_class }

data/spec/unit/veritas/{logic → function}/predicate/equality/class_methods/reverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Equality, '.reverse' do
+describe Function::Predicate::Equality, '.reverse' do
   subject { object.reverse }
 
   let(:object) { described_class }

data/spec/unit/veritas/{logic/predicate/greater_than_or_equal_to → function/predicate/equality}/inspect_spec.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThanOrEqualTo, '#inspect' do
+describe Function::Predicate::Equality, '#inspect' do
   subject { object.inspect }
 
   let(:attribute) { Attribute::Integer.new(:id)       }
   let(:object)    { described_class.new(attribute, 1) }
 
-  it { should == "#{attribute.inspect} >= 1" }
+  it { should == "(#{attribute.inspect} == 1)" }
 end

data/spec/unit/veritas/{logic/predicate/greater_than → function/predicate/equality}/inverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThan, '#inverse' do
+describe Function::Predicate::Equality, '#inverse' do
   subject { object.inverse }
 
   let(:attribute) { Attribute::Integer.new(:id)       }
@@ -8,7 +10,7 @@ describe Logic::Predicate::GreaterThan, '#inverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Logic::Predicate::LessThanOrEqualTo) }
+  it { should be_kind_of(Function::Predicate::Inequality) }
 
   its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/{logic → function}/predicate/equality/methods/eq_spec.rb

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

data/spec/unit/veritas/{logic → function}/predicate/equality/methods/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module EqualityMethodsSpecs
   class Object
-    include Logic::Predicate::Equality::Methods
+    include Function::Predicate::Equality::Methods
   end # class Object
 end # module EqualityMethodsSpecs

data/spec/unit/veritas/{logic → function}/predicate/exclusion/class_methods/call_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Exclusion, '.call' do
+describe Function::Predicate::Exclusion, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Exclusion, '.inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::Inclusion) }
+end

data/spec/unit/veritas/{logic/predicate/inclusion → function/predicate/exclusion}/inspect_spec.rb

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

data/spec/unit/veritas/{logic/predicate/inclusion → function/predicate/exclusion}/inverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inclusion, '#inverse' do
+describe Function::Predicate::Exclusion, '#inverse' do
   subject { object.inverse }
 
   let(:attribute)  { Attribute::Integer.new(:id)                }
@@ -9,7 +11,7 @@ describe Logic::Predicate::Inclusion, '#inverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Logic::Predicate::Exclusion) }
+  it { should be_kind_of(Function::Predicate::Inclusion) }
 
   its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/{logic → function}/predicate/exclusion/methods/exclude_spec.rb

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

data/spec/unit/veritas/{logic → function}/predicate/exclusion/methods/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module ExclusionMethodsSpecs
   class Object
-    include Logic::Predicate::Exclusion::Methods
+    include Function::Predicate::Exclusion::Methods
   end # class Object
 end # module ExclusionMethodsSpecs

data/spec/unit/veritas/{logic → function}/predicate/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module PredicateSpecs
-  class Object < Logic::Predicate
+  class Object < Function::Predicate
     def self.inverse
       self
     end

data/spec/unit/veritas/{logic → function}/predicate/greater_than/class_methods/call_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThan, '.call' do
+describe Function::Predicate::GreaterThan, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::GreaterThan, '.inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::LessThanOrEqualTo) }
+end

data/spec/unit/veritas/{logic → function}/predicate/greater_than/class_methods/operation_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThan, '.operation' do
+describe Function::Predicate::GreaterThan, '.operation' do
   subject { object.operation }
 
   let(:object) { described_class }

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::GreaterThan, '.reverse' do
+  subject { object.reverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::LessThan) }
+end

data/spec/unit/veritas/{logic/predicate/equality → function/predicate/greater_than}/inspect_spec.rb

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

data/spec/unit/veritas/{logic/predicate/less_than → function/predicate/greater_than}/inverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::LessThan, '#inverse' do
+describe Function::Predicate::GreaterThan, '#inverse' do
   subject { object.inverse }
 
   let(:attribute) { Attribute::Integer.new(:id)       }
@@ -8,7 +10,7 @@ describe Logic::Predicate::LessThan, '#inverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Logic::Predicate::GreaterThanOrEqualTo) }
+  it { should be_kind_of(Function::Predicate::LessThanOrEqualTo) }
 
   its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/{logic → function}/predicate/greater_than/methods/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module GreaterThanMethodsSpecs
   class Object
-    include Logic::Predicate::GreaterThan::Methods
+    include Function::Predicate::GreaterThan::Methods
   end # class Object
 end # module GreaterThanMethodsSpecs

data/spec/unit/veritas/{logic → function}/predicate/greater_than/methods/gt_spec.rb

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

data/spec/unit/veritas/{logic → function}/predicate/greater_than_or_equal_to/class_methods/call_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThanOrEqualTo, '.call' do
+describe Function::Predicate::GreaterThanOrEqualTo, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }

data/spec/unit/veritas/function/predicate/greater_than_or_equal_to/class_methods/inverse_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::GreaterThanOrEqualTo, '.inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::LessThan) }
+end

data/spec/unit/veritas/{logic → function}/predicate/greater_than_or_equal_to/class_methods/operation_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThanOrEqualTo, '.operation' do
+describe Function::Predicate::GreaterThanOrEqualTo, '.operation' do
   subject { object.operation }
 
   let(:object) { described_class }

data/spec/unit/veritas/function/predicate/greater_than_or_equal_to/class_methods/reverse_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::GreaterThanOrEqualTo, '.reverse' do
+  subject { object.reverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::LessThanOrEqualTo) }
+end

data/spec/unit/veritas/function/predicate/greater_than_or_equal_to/inspect_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::GreaterThanOrEqualTo, '#inspect' do
+  subject { object.inspect }
+
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:object)    { described_class.new(attribute, 1) }
+
+  it { should == "(#{attribute.inspect} >= 1)" }
+end

data/spec/unit/veritas/{logic → function}/predicate/greater_than_or_equal_to/inverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThanOrEqualTo, '#inverse' do
+describe Function::Predicate::GreaterThanOrEqualTo, '#inverse' do
   subject { object.inverse }
 
   let(:attribute) { Attribute::Integer.new(:id)       }
@@ -8,7 +10,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#inverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Logic::Predicate::LessThan) }
+  it { should be_kind_of(Function::Predicate::LessThan) }
 
   its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/{logic → function}/predicate/greater_than_or_equal_to/methods/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module GreaterThanOrEqualToMethodsSpecs
   class Object
-    include Logic::Predicate::GreaterThanOrEqualTo::Methods
+    include Function::Predicate::GreaterThanOrEqualTo::Methods
   end # class Object
 end # module GreaterThanOrEqualToMethodsSpecs

data/spec/unit/veritas/{logic → function}/predicate/greater_than_or_equal_to/methods/gte_spec.rb

@@ -1,12 +1,14 @@
+# encoding: utf-8
+
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe Logic::Predicate::GreaterThanOrEqualTo::Methods, '#gte' do
+describe Function::Predicate::GreaterThanOrEqualTo::Methods, '#gte' do
   subject { object.gte(other) }
 
   let(:described_class) { GreaterThanOrEqualToMethodsSpecs::Object }
   let(:other)           { 1                                        }
   let(:object)          { described_class.new                      }
 
-  it { should be_kind_of(Logic::Predicate::GreaterThanOrEqualTo) }
+  it { should be_kind_of(Function::Predicate::GreaterThanOrEqualTo) }
 end

data/spec/unit/veritas/{logic → function}/predicate/hash_spec.rb

@@ -1,7 +1,9 @@
+# encoding: utf-8
+
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe Logic::Predicate, '#hash' do
+describe Function::Predicate, '#hash' do
   subject { object.hash }
 
   let(:left)   { Attribute::Integer.new(:id)      }

data/spec/unit/veritas/{logic → function}/predicate/inclusion/class_methods/call_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inclusion, '.call' do
+describe Function::Predicate::Inclusion, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }

data/spec/unit/veritas/function/predicate/inclusion/class_methods/inverse_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Inclusion, '.inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::Exclusion) }
+end

data/spec/unit/veritas/{logic/predicate/exclusion → function/predicate/inclusion}/inspect_spec.rb

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

data/spec/unit/veritas/{logic/predicate/exclusion → function/predicate/inclusion}/inverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Exclusion, '#inverse' do
+describe Function::Predicate::Inclusion, '#inverse' do
   subject { object.inverse }
 
   let(:attribute)  { Attribute::Integer.new(:id)                }
@@ -9,7 +11,7 @@ describe Logic::Predicate::Exclusion, '#inverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Logic::Predicate::Inclusion) }
+  it { should be_kind_of(Function::Predicate::Exclusion) }
 
   its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/{logic → function}/predicate/inclusion/methods/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module InclusionMethodsSpecs
   class Object
-    include Logic::Predicate::Inclusion::Methods
+    include Function::Predicate::Inclusion::Methods
   end # class Object
 end # module InclusionMethodsSpecs

data/spec/unit/veritas/{logic → function}/predicate/inclusion/methods/include_spec.rb

@@ -1,12 +1,14 @@
+# encoding: utf-8
+
 require 'spec_helper'
 require File.expand_path('../fixtures/classes', __FILE__)
 
-describe Logic::Predicate::Inclusion::Methods, '#include' do
+describe Function::Predicate::Inclusion::Methods, '#include' do
   subject { object.include(other) }
 
   let(:described_class) { InclusionMethodsSpecs::Object }
   let(:other)           { [ true, false ]               }
   let(:object)          { described_class.new           }
 
-  it { should be_kind_of(Logic::Predicate::Inclusion) }
+  it { should be_kind_of(Function::Predicate::Inclusion) }
 end

data/spec/unit/veritas/{logic/predicate/equality → function/predicate/inequality}/class_methods/call_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Equality, '.call' do
+describe Function::Predicate::Inequality, '.call' do
   subject { object.call(left, right) }
 
   let(:object) { described_class }
@@ -9,13 +11,13 @@ describe Logic::Predicate::Equality, '.call' do
     let(:left)  { true }
     let(:right) { true }
 
-    it { should be(true) }
+    it { should be(false) }
   end
 
   context 'when left is not equal to right' do
     let(:left)  { true  }
     let(:right) { false }
 
-    it { should be(false) }
+    it { should be(true) }
   end
 end

data/spec/unit/veritas/function/predicate/inequality/class_methods/inverse_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Inequality, '.inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::Equality) }
+end

data/spec/unit/veritas/{logic → function}/predicate/inequality/class_methods/operation_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inequality, '.operation' do
+describe Function::Predicate::Inequality, '.operation' do
   subject { object.operation }
 
   let(:object) { described_class }

data/spec/unit/veritas/function/predicate/inequality/class_methods/reverse_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Inequality, '.reverse' do
+  subject { object.reverse }
+
+  let(:object) { described_class }
+
+  it { should equal(Function::Predicate::Inequality) }
+end

data/spec/unit/veritas/{logic → function}/predicate/inequality/inspect_spec.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inequality, '#inspect' do
+describe Function::Predicate::Inequality, '#inspect' do
   subject { object.inspect }
 
   let(:attribute) { Attribute::Integer.new(:id)       }
   let(:object)    { described_class.new(attribute, 1) }
 
-  it { should == "#{attribute.inspect} != 1" }
+  it { should == "(#{attribute.inspect} != 1)" }
 end

data/spec/unit/veritas/{logic/predicate/equality → function/predicate/inequality}/inverse_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Equality, '#inverse' do
+describe Function::Predicate::Inequality, '#inverse' do
   subject { object.inverse }
 
   let(:attribute) { Attribute::Integer.new(:id)       }
@@ -8,7 +10,7 @@ describe Logic::Predicate::Equality, '#inverse' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Logic::Predicate::Inequality) }
+  it { should be_kind_of(Function::Predicate::Equality) }
 
   its(:left) { should equal(attribute) }
 

data/spec/unit/veritas/{logic → function}/predicate/inequality/methods/fixtures/classes.rb

@@ -1,5 +1,7 @@
+# encoding: utf-8
+
 module InequalityMethodsSpecs
   class Object
-    include Logic::Predicate::Inequality::Methods
+    include Function::Predicate::Inequality::Methods
   end # class Object
 end # module InequalityMethodsSpecs