veritas-optimizer 0.0.3 → 0.0.4

data/spec/integration/veritas/{logic → function}/connective/disjunction/optimize_spec.rb

@@ -1,12 +1,14 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Connective::Disjunction, '#optimize' do
+describe Function::Connective::Disjunction, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)      }
   let(:object)    { described_class.new(left, right) }
 
-  it_should_behave_like 'Logic::Connective::Binary#optimize'
+  it_should_behave_like 'Function::Connective::Binary#optimize'
 
   context 'left and right are predicates' do
     let(:left)  { attribute.gt(1) }
@@ -18,13 +20,13 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'left and right are inverse predicates' do
-    let(:left)  { Logic::Connective::Negation.new(attribute.gt(1)) }
-    let(:right) { Logic::Connective::Negation.new(attribute.lt(3)) }
+    let(:left)  { Function::Connective::Negation.new(attribute.gt(1)) }
+    let(:right) { Function::Connective::Negation.new(attribute.lt(3)) }
 
     it { should_not equal(object) }
 
     it 'reverses the operands' do
-      should eql(Logic::Connective::Disjunction.new(attribute.lte(1), attribute.gte(3)))
+      should eql(Function::Connective::Disjunction.new(attribute.lte(1), attribute.gte(3)))
     end
 
     it_should_behave_like 'an optimize method'
@@ -40,8 +42,8 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'left and right are tautologys' do
-    let(:left)  { Logic::Proposition::Tautology.instance }
-    let(:right) { Logic::Proposition::Tautology.instance }
+    let(:left)  { Function::Proposition::Tautology.instance }
+    let(:right) { Function::Proposition::Tautology.instance }
 
     it { should equal(left) }
 
@@ -49,8 +51,8 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'left and right are contradictions' do
-    let(:left)  { Logic::Proposition::Contradiction.instance }
-    let(:right) { Logic::Proposition::Contradiction.instance }
+    let(:left)  { Function::Proposition::Contradiction.instance }
+    let(:right) { Function::Proposition::Contradiction.instance }
 
 
     it { should equal(left) }
@@ -59,8 +61,8 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'right is a tautology' do
-    let(:left)  { attribute.gt(1)                        }
-    let(:right) { Logic::Proposition::Tautology.instance }
+    let(:left)  { attribute.gt(1)                           }
+    let(:right) { Function::Proposition::Tautology.instance }
 
     it { should equal(right) }
 
@@ -68,8 +70,8 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'left is a tautology' do
-    let(:left)  { Logic::Proposition::Tautology.instance }
-    let(:right) { attribute.lt(3)                        }
+    let(:left)  { Function::Proposition::Tautology.instance }
+    let(:right) { attribute.lt(3)                           }
 
     it { should equal(left) }
 
@@ -77,8 +79,8 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'right is a contradiction' do
-    let(:left)  { attribute.gt(1)                            }
-    let(:right) { Logic::Proposition::Contradiction.instance }
+    let(:left)  { attribute.gt(1)                               }
+    let(:right) { Function::Proposition::Contradiction.instance }
 
     it { should equal(left) }
 
@@ -86,8 +88,8 @@ describe Logic::Connective::Disjunction, '#optimize' do
   end
 
   context 'left is a contradiction' do
-    let(:left)  { Logic::Proposition::Contradiction.instance }
-    let(:right) { attribute.lt(3)                            }
+    let(:left)  { Function::Proposition::Contradiction.instance }
+    let(:right) { attribute.lt(3)                               }
 
     it { should equal(right) }
 
@@ -107,7 +109,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.ne(3) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -116,7 +118,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.eq(1) }
     let(:right) { attribute.ne(1) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -125,7 +127,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.ne(1) }
     let(:right) { attribute.eq(1) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -134,7 +136,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.include([ 1, 2 ]) }
     let(:right) { attribute.exclude([ 1, 2 ]) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -143,7 +145,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.exclude([ 1, 2 ]) }
     let(:right) { attribute.include([ 1, 2 ]) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -152,7 +154,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gt(1)  }
     let(:right) { attribute.lte(1) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -161,7 +163,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.lte(1) }
     let(:right) { attribute.gt(1)  }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -170,7 +172,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.gte(1) }
     let(:right) { attribute.lt(1)  }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -179,7 +181,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)  { attribute.lt(1)  }
     let(:right) { attribute.gte(1) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -189,7 +191,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)      { attribute.match(/Dan Kubb/)    }
     let(:right)     { attribute.no_match(/Dan Kubb/) }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end
@@ -199,7 +201,7 @@ describe Logic::Connective::Disjunction, '#optimize' do
     let(:left)      { attribute.no_match(/Dan Kubb/) }
     let(:right)     { attribute.match(/Dan Kubb/)    }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/veritas/{logic → function}/connective/negation/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Connective::Negation, '#optimize' do
+describe Function::Connective::Negation, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)  }
@@ -24,17 +26,17 @@ describe Logic::Connective::Negation, '#optimize' do
   end
 
   context 'operand is a tautology' do
-    let(:operand) { Logic::Proposition::Tautology.instance }
+    let(:operand) { Function::Proposition::Tautology.instance }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end
 
   context 'operand is a contradiction' do
-    let(:operand) { Logic::Proposition::Contradiction.instance }
+    let(:operand) { Function::Proposition::Contradiction.instance }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/veritas/{logic/expression → function}/optimize_spec.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Expression, '#optimize' do
+describe Function, '#optimize' do
   subject { object.optimize(*args) }
 
-  let(:described_class) { Class.new(Logic::Expression) }
-  let(:object)          { described_class.new          }
+  let(:described_class) { Class.new(Function) }
+  let(:object)          { described_class.new }
 
   before do
     described_class.class_eval do

data/spec/integration/veritas/{logic → function}/predicate/equality/optimize_spec.rb

@@ -1,6 +1,8 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Equality, '#optimize' do
+describe Function::Predicate::Equality, '#optimize' do
   subject { object.optimize }
 
   let(:attribute) { Attribute::Integer.new(:id)      }
@@ -10,7 +12,7 @@ describe Logic::Predicate::Equality, '#optimize' do
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -18,7 +20,7 @@ describe Logic::Predicate::Equality, '#optimize' do
     context 'and are not joinable' do
       let(:right) { Attribute::String.new(:other) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -44,7 +46,7 @@ describe Logic::Predicate::Equality, '#optimize' do
     context 'right is an invalid value' do
       let(:right) { 'a' }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -62,7 +64,7 @@ describe Logic::Predicate::Equality, '#optimize' do
     context 'left is an invalid value' do
       let(:left) { 'a' }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -73,7 +75,7 @@ describe Logic::Predicate::Equality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -82,7 +84,7 @@ describe Logic::Predicate::Equality, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/veritas/{logic → function}/predicate/exclusion/optimize_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Exclusion, '#optimize' do
+describe Function::Predicate::Exclusion, '#optimize' do
   subject { object.optimize }
 
-  let(:left)   { Attribute::Integer.new(:id)      }
-  let(:object) { described_class.new(left, right) }
+  let(:left)   { Attribute::Integer.new(:id, :size => 1..2**31-1) }
+  let(:object) { described_class.new(left, right)                 }
 
   context 'right is a Range' do
     context 'that is inclusive' do
       context 'and empty' do
         let(:right) { 1..0 }
 
-        it { should equal(Logic::Proposition::Tautology.instance) }
+        it { should equal(Function::Proposition::Tautology.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -29,7 +31,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
       context 'and empty' do
         let(:right) { 1...1 }
 
-        it { should equal(Logic::Proposition::Tautology.instance) }
+        it { should equal(Function::Proposition::Tautology.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -49,7 +51,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
       let(:left)  { Attribute::String.new(:string) }
       let(:right) { 'a'..'z'                       }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -57,7 +59,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
     context 'that is greater than the left range' do
       let(:right) { 2**31..2**31 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -65,7 +67,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
     context 'that is less than the left range' do
       let(:right) { -1..-1 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -75,7 +77,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
     context 'that is empty' do
       let(:right) { [] }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -83,7 +85,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
     context 'that is empty after filtering invalid entries' do
       let(:right) { [ 'a' ] }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -124,7 +126,7 @@ describe Logic::Predicate::Exclusion, '#optimize' do
   context 'right is a nil' do
     let(:right) { nil }
 
-    it { should equal(Logic::Proposition::Tautology.instance) }
+    it { should equal(Function::Proposition::Tautology.instance) }
 
     it_should_behave_like 'an optimize method'
   end

data/spec/integration/veritas/{logic → function}/predicate/greater_than/optimize_spec.rb

@@ -1,16 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThan, '#optimize' do
+describe Function::Predicate::GreaterThan, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
-  let(:left)      { attribute                                       }
-  let(:right)     { attribute                                       }
-  let(:object)    { described_class.new(left, right)                }
+  let(:attribute) { Attribute::Integer.new(:id, :required => false, :size => 1..2**31-1) }
+  let(:left)      { attribute                                                            }
+  let(:right)     { attribute                                                            }
+  let(:object)    { described_class.new(left, right)                                     }
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -18,7 +20,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -27,7 +29,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
       let(:left)  { attribute                                                 }
       let(:right) { Attribute::Integer.new(:right, :size => 2**31-1..2**31-1) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -36,7 +38,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
       let(:left)  { attribute                                       }
       let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -54,7 +56,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -62,9 +64,9 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
 
   context 'right is an attribute' do
     context 'left is a valid value' do
-      let(:left) { 1 }
+      let(:left) { 2 }
 
-      it { should eql(Logic::Predicate::LessThan.new(attribute, 1)) }
+      it { should eql(Function::Predicate::LessThan.new(attribute, 2)) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -72,7 +74,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -83,7 +85,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
       let(:left)  { 2 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -92,7 +94,7 @@ describe Logic::Predicate::GreaterThan, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/veritas/{logic → function}/predicate/greater_than_or_equal_to/optimize_spec.rb

@@ -1,16 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
+describe Function::Predicate::GreaterThanOrEqualTo, '#optimize' do
   subject { object.optimize }
 
-  let(:attribute) { Attribute::Integer.new(:id, :required => false) }
-  let(:left)      { attribute                                       }
-  let(:right)     { attribute                                       }
-  let(:object)    { described_class.new(left, right)                }
+  let(:attribute) { Attribute::Integer.new(:id, :required => false, :size => 1..2**31-1) }
+  let(:left)      { attribute                                                            }
+  let(:right)     { attribute                                                            }
+  let(:object)    { described_class.new(left, right)                                     }
 
   context 'left and right are attributes' do
     context 'and equivalent' do
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -18,7 +20,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'and are not comparable' do
       let(:right) { Attribute::Float.new(:float) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -27,7 +29,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
       let(:left)  { attribute                                             }
       let(:right) { Attribute::Integer.new(:right, :size => 2**31..2**31) }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -36,7 +38,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
       let(:left)  { attribute                                       }
       let(:right) { Attribute::Integer.new(:right, :size => -1..-1) }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -44,7 +46,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
 
   context 'left is an attribute' do
     context 'right is a valid value' do
-      let(:right) { 1 }
+      let(:right) { 2 }
 
       it { should equal(object) }
 
@@ -54,7 +56,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'right is an invalid primitive' do
       let(:right) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -64,7 +66,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'left is a valid value' do
       let(:left) { 1 }
 
-      it { should eql(Logic::Predicate::LessThanOrEqualTo.new(attribute, 1)) }
+      it { should eql(Function::Predicate::LessThanOrEqualTo.new(attribute, 1)) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -72,7 +74,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
     context 'left is an invalid primitive' do
       let(:left) { nil }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -83,7 +85,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 1 }
 
-      it { should equal(Logic::Proposition::Tautology.instance) }
+      it { should equal(Function::Proposition::Tautology.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -92,7 +94,7 @@ describe Logic::Predicate::GreaterThanOrEqualTo, '#optimize' do
       let(:left)  { 1 }
       let(:right) { 2 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end

data/spec/integration/veritas/{logic → function}/predicate/inclusion/optimize_spec.rb

@@ -1,17 +1,19 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe Logic::Predicate::Inclusion, '#optimize' do
+describe Function::Predicate::Inclusion, '#optimize' do
   subject { object.optimize }
 
-  let(:left)   { Attribute::Integer.new(:id)      }
-  let(:object) { described_class.new(left, right) }
+  let(:left)   { Attribute::Integer.new(:id, :size => 1..2**31-1) }
+  let(:object) { described_class.new(left, right)                 }
 
   context 'right is a Range' do
     context 'that is inclusive' do
       context 'and empty' do
         let(:right) { 1..0 }
 
-        it { should equal(Logic::Proposition::Contradiction.instance) }
+        it { should equal(Function::Proposition::Contradiction.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -29,7 +31,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
       context 'and empty' do
         let(:right) { 1...1 }
 
-        it { should equal(Logic::Proposition::Contradiction.instance) }
+        it { should equal(Function::Proposition::Contradiction.instance) }
 
         it_should_behave_like 'an optimize method'
       end
@@ -49,7 +51,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
       let(:left)  { Attribute::String.new(:string) }
       let(:right) { 'a'..'z'                       }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -57,7 +59,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
     context 'that is greater than the left range' do
       let(:right) { 2**31..2**31 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -65,7 +67,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
     context 'that is less than the left range' do
       let(:right) { -1..-1 }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -75,7 +77,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
     context 'that is empty' do
       let(:right) { [] }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -83,7 +85,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
     context 'that is empty after filtering invalid entries' do
       let(:right) { [ 'a' ] }
 
-      it { should equal(Logic::Proposition::Contradiction.instance) }
+      it { should equal(Function::Proposition::Contradiction.instance) }
 
       it_should_behave_like 'an optimize method'
     end
@@ -124,7 +126,7 @@ describe Logic::Predicate::Inclusion, '#optimize' do
   context 'right is a nil' do
     let(:right) { nil }
 
-    it { should equal(Logic::Proposition::Contradiction.instance) }
+    it { should equal(Function::Proposition::Contradiction.instance) }
 
     it_should_behave_like 'an optimize method'
   end