axiom 0.1.0

data/spec/unit/axiom/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/axiom/function/predicate/greater_than_or_equal_to/inverse_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::GreaterThanOrEqualTo, '#inverse' do
+  subject { object.inverse }
+
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:object)    { described_class.new(attribute, 1) }
+
+  it_should_behave_like 'an invertible method'
+
+  it { should be_instance_of(Function::Predicate::LessThan) }
+
+  its(:left) { should equal(attribute) }
+
+  its(:right) { should == 1 }
+end

data/spec/unit/axiom/function/predicate/greater_than_or_equal_to/methods/fixtures/classes.rb

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

data/spec/unit/axiom/function/predicate/greater_than_or_equal_to/methods/gte_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+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_instance_of(Function::Predicate::GreaterThanOrEqualTo) }
+end

data/spec/unit/axiom/function/predicate/hash_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Function::Predicate, '#hash' do
+  subject { object.hash }
+
+  let(:left)   { Attribute::Integer.new(:id)      }
+  let(:right)  { 1                                }
+  let(:object) { described_class.new(left, right) }
+
+  it_should_behave_like 'a hash method'
+
+  it { should == described_class.hash ^ left.hash ^ right.hash }
+end

data/spec/unit/axiom/function/predicate/inclusion/class_methods/call_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Inclusion, '.call' do
+  subject { object.call(left, right) }
+
+  let(:object) { described_class }
+
+  context 'when left is included in right' do
+    let(:left)  { 1     }
+    let(:right) { [ 1 ] }
+
+    it { should be(true) }
+  end
+
+  context 'when left is not included in right' do
+    let(:left)  { 1     }
+    let(:right) { [ 0 ] }
+
+    it { should be(false) }
+  end
+end

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

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

data/spec/unit/axiom/function/predicate/inclusion/inverse_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Inclusion, '#inverse' do
+  subject { object.inverse }
+
+  let(:attribute)  { Attribute::Integer.new(:id)                }
+  let(:enumerable) { [ 1 ].freeze                               }
+  let(:object)     { described_class.new(attribute, enumerable) }
+
+  it_should_behave_like 'an invertible method'
+
+  it { should be_instance_of(Function::Predicate::Exclusion) }
+
+  its(:left) { should equal(attribute) }
+
+  its(:right) { should equal(enumerable) }
+end

data/spec/unit/axiom/function/predicate/inclusion/methods/fixtures/classes.rb

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

data/spec/unit/axiom/function/predicate/inclusion/methods/include_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+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_instance_of(Function::Predicate::Inclusion) }
+end

data/spec/unit/axiom/function/predicate/inequality/class_methods/call_spec.rb

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

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

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

data/spec/unit/axiom/function/predicate/inequality/class_methods/operation_spec.rb

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

data/spec/unit/axiom/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/axiom/function/predicate/inequality/inverse_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::Inequality, '#inverse' do
+  subject { object.inverse }
+
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:object)    { described_class.new(attribute, 1) }
+
+  it_should_behave_like 'an invertible method'
+
+  it { should be_instance_of(Function::Predicate::Equality) }
+
+  its(:left) { should equal(attribute) }
+
+  its(:right) { should == 1 }
+end

data/spec/unit/axiom/function/predicate/inequality/methods/fixtures/classes.rb

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

data/spec/unit/axiom/function/predicate/inequality/methods/ne_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Function::Predicate::Inequality::Methods, '#ne' do
+  subject { object.ne(other) }
+
+  let(:described_class) { InequalityMethodsSpecs::Object }
+  let(:other)           { true                           }
+  let(:object)          { described_class.new            }
+
+  it { should be_instance_of(Function::Predicate::Inequality) }
+end

data/spec/unit/axiom/function/predicate/inverse_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Function::Predicate, '#inverse' do
+  subject { object.inverse }
+
+  let(:object) { described_class.new(1, 1) }
+
+  specify { expect { subject }.to raise_error(NoMethodError) }
+
+  it 'calls the class inverse method' do
+    described_class.should_receive(:inverse).and_return(described_class)
+    should eql(object)
+  end
+end

data/spec/unit/axiom/function/predicate/less_than/class_methods/call_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::LessThan, '.call' do
+  subject { object.call(left, right) }
+
+  let(:object) { described_class }
+
+  context 'when left is equal to right' do
+    let(:left)  { 1 }
+    let(:right) { 1 }
+
+    it { should be(false) }
+  end
+
+  context 'when left is greater than right' do
+    let(:left)  { 2 }
+    let(:right) { 1 }
+
+    it { should be(false) }
+  end
+
+  context 'when left is less than right' do
+    let(:left)  { 1 }
+    let(:right) { 2 }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/axiom/function/predicate/less_than/class_methods/inverse_spec.rb

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

data/spec/unit/axiom/function/predicate/less_than/class_methods/operation_spec.rb

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

data/spec/unit/axiom/function/predicate/less_than/class_methods/reverse_spec.rb

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

data/spec/unit/axiom/function/predicate/less_than/inverse_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::LessThan, '#inverse' do
+  subject { object.inverse }
+
+  let(:attribute) { Attribute::Integer.new(:id)       }
+  let(:object)    { described_class.new(attribute, 1) }
+
+  it_should_behave_like 'an invertible method'
+
+  it { should be_instance_of(Function::Predicate::GreaterThanOrEqualTo) }
+
+  its(:left) { should equal(attribute) }
+
+  its(:right) { should == 1 }
+end

data/spec/unit/axiom/function/predicate/less_than/methods/fixtures/classes.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+module LessThanMethodsSpecs
+  class Object
+    include Function::Predicate::LessThan::Methods
+  end # class Object
+end # module LessThanMethodsSpecs

data/spec/unit/axiom/function/predicate/less_than/methods/lt_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe Function::Predicate::LessThan::Methods, '#lt' do
+  subject { object.lt(other) }
+
+  let(:described_class) { LessThanMethodsSpecs::Object }
+  let(:other)           { 1                            }
+  let(:object)          { described_class.new          }
+
+  it { should be_instance_of(Function::Predicate::LessThan) }
+end

data/spec/unit/axiom/function/predicate/less_than_or_equal_to/class_methods/call_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Predicate::LessThanOrEqualTo, '.call' do
+  subject { object.call(left, right) }
+
+  let(:object) { described_class }
+
+  context 'when left is equal to right' do
+    let(:left)  { 1 }
+    let(:right) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'when left is greater than right' do
+    let(:left)  { 2 }
+    let(:right) { 1 }
+
+    it { should be(false) }
+  end
+
+  context 'when left is less than right' do
+    let(:left)  { 1 }
+    let(:right) { 2 }
+
+    it { should be(true) }
+  end
+end

data/spec/unit/axiom/function/predicate/less_than_or_equal_to/class_methods/inverse_spec.rb

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