veritas 0.0.1

data/spec/unit/veritas/immutable/fixtures/classes.rb

@@ -0,0 +1,26 @@
+module ImmutableSpecs
+  class Object
+    include Immutable
+
+    def test
+      rand
+    end
+
+    def public_method
+      rand
+    end
+
+  protected
+
+    def protected_method
+      rand
+    end
+
+  private
+
+    def private_method
+      rand
+    end
+
+  end # class Object
+end # module ImmutableSpecs

data/spec/unit/veritas/immutable/memoize_methods/freeze_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable::MemoizeMethods#freeze' do
+  subject { immutable.freeze }
+
+  let(:klass) { Class.new(ImmutableSpecs::Object) }
+
+  before do
+    klass.memoize(:test)
+  end
+
+  context 'with an unfrozen object' do
+    let(:immutable) { klass.allocate }
+
+    it { should equal(immutable) }
+
+    it 'freezes the object' do
+      expect { subject }.to change(immutable, :frozen?).from(false).to(true)
+    end
+
+    it 'sets a memoization instance variable' do
+      immutable.should_not be_instance_variable_defined(:@__memory)
+      subject
+      immutable.instance_variable_get(:@__memory).should be_kind_of(Immutable::Memory)
+    end
+  end
+
+  context 'with a frozen object' do
+    let(:immutable) { klass.new }
+
+    it { should equal(immutable) }
+
+    it 'does not change the frozen state of the object' do
+      expect { subject }.to_not change(immutable, :frozen?)
+    end
+
+    it 'does not change the memoization instance variable' do
+      expect { subject }.to_not change { immutable.instance_variable_get(:@__memory) }
+    end
+
+    it 'sets an instance variable for memoization' do
+      subject.instance_variable_get(:@__memory).should be_kind_of(Immutable::Memory)
+    end
+  end
+end

data/spec/unit/veritas/immutable/memoize_methods/memoize_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable::MemoizeMethods#memoize' do
+  subject { immutable.memoize(method, value) }
+
+  let(:klass)     { Class.new(ImmutableSpecs::Object) }
+  let(:immutable) { klass.new                         }
+  let(:method)    { :test                             }
+  let(:value)     { String.new.freeze                 }
+
+  before do
+    klass.memoize(method)
+  end
+
+  it 'sets the memoized value for the method to the value' do
+    subject
+    immutable.send(method).should equal(value)
+  end
+end

data/spec/unit/veritas/immutable/memoize_methods/memoized_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable::MemoizeMethods#memoized' do
+  subject { object.memoized(method) }
+
+  let(:klass)  { Class.new(ImmutableSpecs::Object) }
+  let(:method) { :test                             }
+  let(:value)  { String.new.freeze                 }
+  let(:object) { klass.new                         }
+
+  before do
+    klass.memoize(method)
+  end
+
+  context 'when a method is memoized' do
+    before do
+      object.memoize(method, value)
+    end
+
+    it { should equal(value) }
+  end
+
+  context 'when a method is not memoized' do
+    it { should be_nil }
+  end
+end

data/spec/unit/veritas/immutable/memoize_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable#memoize' do
+  subject { object.memoize(name, value) }
+
+  let(:klass)  { ImmutableSpecs::Object }
+  let(:name)   { mock('Name')           }
+  let(:value)  { mock('Value')          }
+  let(:object) { klass.new              }
+
+  it { should equal(object) }
+end

data/spec/unit/veritas/immutable/memory/element_reference_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe 'Veritas::Immutable::Memory#[]' do
+  subject { memory[key] }
+
+  let(:memory) { Immutable::Memory.new }
+
+  context 'with known key' do
+    let(:key)   { '@key'        }
+    let(:value) { mock('Value') }
+
+    before do
+      memory.instance_variable_set(key, value)
+    end
+
+    it { should equal(value) }
+  end
+
+  context 'with unknown key' do
+    let(:key) { '@key' }
+
+    it { should be_nil }
+  end
+end

data/spec/unit/veritas/immutable/memory/element_set_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Veritas::Immutable::Memory#[]=' do
+  subject { memory[key] = value }
+
+  let(:memory) { Immutable::Memory.new           }
+  let(:key)    { '@key'                          }
+  let(:value)  { mock('Value', :frozen? => true) }
+
+  it { should equal(value) }
+
+  it 'sets the instance variable' do
+    memory.should_not be_instance_variable_defined(key)
+    subject
+    memory.instance_variable_get(key).should equal(value)
+  end
+end

data/spec/unit/veritas/immutable/module_methods/included_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+describe 'Veritas::Immutable::ModuleMethods#included' do
+  subject { object.included(object) }
+
+  let(:object) { ImmutableSpecs::Object }
+
+  before do
+    Veritas::Immutable.should_receive(:included).with(object).and_return(Veritas::Immutable)
+  end
+
+  it { should equal(object) }
+end

data/spec/unit/veritas/immutable/module_methods/memoize_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require File.expand_path('../../fixtures/classes', __FILE__)
+
+shared_examples_for 'memoizes method' do
+  it 'memoizes the instance method' do
+    subject
+    object = klass.new
+    object.send(method).should equal(object.send(method))
+  end
+
+  it 'adds a private method' do
+    count = klass.private_instance_methods.count
+    expect { subject }.to change { klass.private_instance_methods.count }.from(count).to(count + 1)
+  end
+
+  specification = proc do
+    klass.send(:define_method, method) do
+      caller
+    end
+
+    subject
+
+    file, line = klass.new.send(method).first.split(':')[0, 2]
+
+    File.expand_path(file).should == File.expand_path('../../../../../../lib/veritas/support/immutable.rb', __FILE__)
+    line.to_i.should == 173
+  end
+
+  it 'sets the file and line number properly' do
+    if RUBY_PLATFORM[/java/]
+      pending('Kernel#caller returns the incorrect line number in JRuby', &specification)
+    else
+      instance_eval(&specification)
+    end
+  end
+end
+
+describe 'Veritas::Immutable::ModuleMethods#memoize' do
+  subject { klass.memoize(method) }
+
+  let(:klass) { Class.new(ImmutableSpecs::Object) }
+
+  context 'public method' do
+    let(:method) { :public_method }
+
+    it { should equal(klass) }
+
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a public method' do
+      should be_public_method_defined(method)
+    end
+  end
+
+  context 'protected method' do
+    let(:method) { :protected_method }
+
+    it { should equal(klass) }
+
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a protected method' do
+      should be_protected_method_defined(method)
+    end
+  end
+
+  context 'private method' do
+    let(:method) { :private_method }
+
+    it { should equal(klass) }
+
+    it_should_behave_like 'memoizes method'
+
+    it 'is still a private method' do
+      should be_private_method_defined(method)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Logic::Connective::Binary#call' do
+  subject { object.call(tuple) }
+
+  let(:klass)    { BinarySpecs::Object                            }
+  let(:header)   { Relation::Header.new([ [ :id, Integer ] ])     }
+  let(:left)     { Logic::Predicate::Equality.new(header[:id], 1) }
+  let(:right)    { Logic::Predicate::Equality.new(header[:id], 2) }
+  let(:tuple)    { Tuple.new(header, [ 1 ])                       }
+  let(:response) { mock('#call response')                         }
+  let(:object)   { klass.new(left, right)                         }
+
+  before do
+    klass.should_receive(:call).with(true, false).and_return(response)
+  end
+
+  it { should equal(response) }
+end

data/spec/unit/veritas/logic/connective/binary/fixtures/classes.rb

@@ -0,0 +1,8 @@
+module BinarySpecs
+  class Object < Logic::Connective::Binary
+    def inspect
+      "Binary(#{left.inspect}, #{right.inspect})"
+    end
+
+  end # class Object
+end # module BinarySpecs

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Logic::Connective::Binary#rename' do
+  subject { object.rename(aliases) }
+
+  let(:klass)     { BinarySpecs::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(left, right)                                    }
+
+  context 'left and right are renamed' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { attribute.eq(2) }
+
+    it { should eql(klass.new(other.eq(1), other.eq(2))) }
+  end
+
+  context 'left is renamed' do
+    let(:left)  { attribute.eq(1) }
+    let(:right) { other.eq(2)     }
+
+    it { should eql(klass.new(other.eq(1), other.eq(2))) }
+  end
+
+  context 'right is renamed' do
+    let(:left)  { other.eq(1)     }
+    let(:right) { attribute.eq(2) }
+
+    it { should eql(klass.new(other.eq(1), other.eq(2))) }
+  end
+
+  context 'right and right are not renamed' do
+    let(:left)  { other.eq(1) }
+    let(:right) { other.eq(2) }
+
+    it { should equal(object) }
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Veritas::Logic::Connective::Conjunction.call' do
+  subject { Logic::Connective::Conjunction.call(left, right) }
+
+  context 'when left is true and right is true' do
+    let(:left)  { true }
+    let(:right) { true }
+
+    it { should be(true) }
+  end
+
+  context 'when left is true and right is false' do
+    let(:left)  { true  }
+    let(:right) { false }
+
+    it { should be(false) }
+  end
+
+  context 'when left is false and right is true' do
+    let(:left)  { false }
+    let(:right) { true  }
+
+    it { should be(false) }
+  end
+
+  context 'when left is false and right is false' do
+    let(:left)  { false }
+    let(:right) { false }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Veritas::Logic::Connective::Conjunction#inspect' do
+  subject { conjunction.inspect }
+
+  let(:attribute)   { Attribute::Integer.new(:id)                     }
+  let(:left)        { attribute.gt(1)                                 }
+  let(:right)       { attribute.lt(3)                                 }
+  let(:conjunction) { Logic::Connective::Conjunction.new(left, right) }
+
+  it { should == "(#{left.inspect} AND #{right.inspect})"}
+end

data/spec/unit/veritas/logic/connective/conjunction/methods/and_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+[ :and, :& ].each do |method|
+  describe "Veritas::Logic::Connective::Conjunction::Methods##{method}" do
+    subject { proposition.send(method, predicate) }
+
+    let(:header)      { Relation::Header.new([ [ :id, Integer ] ])     }
+    let(:predicate)   { Logic::Predicate::Equality.new(header[:id], 1) }
+    let(:proposition) { ConjunctionMethodsSpecs::Object.new            }
+
+    it 'returns a conjunction of the proposition and predicate' do
+      should eql(Logic::Connective::Conjunction.new(proposition, predicate))
+    end
+  end
+end

data/spec/unit/veritas/logic/connective/conjunction/methods/fixtures/classes.rb

@@ -0,0 +1,5 @@
+module ConjunctionMethodsSpecs
+  class Object
+    include Logic::Connective::Conjunction::Methods
+  end # class Object
+end # module ConjunctionMethodsSpecs

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Veritas::Logic::Connective::Disjunction.call' do
+  subject { Logic::Connective::Disjunction.call(left, right) }
+
+  context 'when left is true and right is true' do
+    let(:left)  { true }
+    let(:right) { true }
+
+    it { should be(true) }
+  end
+
+  context 'when left is true and right is false' do
+    let(:left)  { true  }
+    let(:right) { false }
+
+    it { should be(true) }
+  end
+
+  context 'when left is false and right is true' do
+    let(:left)  { false }
+    let(:right) { true  }
+
+    it { should be(true) }
+  end
+
+  context 'when left is false and right is false' do
+    let(:left)  { false }
+    let(:right) { false }
+
+    it { should be(false) }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Veritas::Logic::Connective::Disjunction#inspect' do
+  subject { disjunction.inspect }
+
+  let(:attribute)   { Attribute::Integer.new(:id)                     }
+  let(:left)        { attribute.gt(1)                                 }
+  let(:right)       { attribute.lt(3)                                 }
+  let(:disjunction) { Logic::Connective::Disjunction.new(left, right) }
+
+  it { should == "(#{left.inspect} OR #{right.inspect})"}
+end

data/spec/unit/veritas/logic/connective/disjunction/methods/fixtures/classes.rb

@@ -0,0 +1,5 @@
+module DisjunctionMethodsSpecs
+  class Object
+    include Logic::Connective::Disjunction::Methods
+  end # class Object
+end # module DisjunctionMethodsSpecs

data/spec/unit/veritas/logic/connective/disjunction/methods/or_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+[ :or, :| ].each do |method|
+  describe "Veritas::Logic::Connective::Disjunction::Methods##{method}" do
+    subject { proposition.send(method, predicate) }
+
+    let(:header)      { Relation::Header.new([ [ :id, Integer ] ])     }
+    let(:predicate)   { Logic::Predicate::Equality.new(header[:id], 1) }
+    let(:proposition) { DisjunctionMethodsSpecs::Object.new            }
+
+    it 'returns a disjunction of the proposition and predicate' do
+      should eql(Logic::Connective::Disjunction.new(proposition, predicate))
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Veritas::Logic::Connective::Negation.call' do
+  subject { object.call(operand) }
+
+  let(:object) { Logic::Connective::Negation }
+
+  context 'when operand is true' do
+    let(:operand) { true }
+
+    it { should be(false) }
+  end
+
+  context 'when operand is false' do
+    let(:operand) { false }
+
+    it { should be(true) }
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe 'Veritas::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)          }
+
+  it { should == "not(#{operand.inspect})" }
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Veritas::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)          }
+
+  it 'returns the operand' do
+    should equal(operand)
+  end
+
+  it 'is not invertible' do
+    subject.inverse.should_not eql(object)
+  end
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/logic/connective/negation/methods/fixtures/classes.rb

@@ -0,0 +1,6 @@
+module NegationMethodsSpecs
+  class Object
+    include Logic::Connective::Conjunction::Methods
+    include Logic::Connective::Negation::Methods
+  end # class Object
+end # module NegationMethodsSpecs

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+[ :not, :- ].each do |method|
+  describe "Veritas::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                                      }
+
+    before do
+      def object.eql?(other)
+        equal?(other)
+      end
+    end
+
+    it 'returns a conjunction of the proposition and a inverted predicate' do
+      should eql(Logic::Connective::Conjunction.new(object, Logic::Connective::Negation.new(predicate)))
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::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)                         }
+
+  before do
+    klass.should_receive(:call).with(true).and_return(response)
+  end
+
+  it { should equal(response) }
+end

data/spec/unit/veritas/logic/connective/unary/fixtures/classes.rb

@@ -0,0 +1,8 @@
+module UnarySpecs
+  class Object < Logic::Connective::Unary
+    def inspect
+      "Unary(#{operand.inspect})"
+    end
+
+  end # class Object
+end # module UnarySpecs

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::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)                                        }
+
+  context 'operand is renamed' do
+    let(:operand) { attribute.eq(1) }
+
+    it { should eql(klass.new(other.eq(1))) }
+  end
+
+  context 'operand is not renamed' do
+    let(:operand) { other.eq(1) }
+
+    it { should equal(object) }
+  end
+end