veritas 0.0.1

data/spec/unit/veritas/algebra/restriction/each_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Restriction#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:klass)    { Algebra::Restriction                          }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:object)   { klass.new(relation, proc { true })            }
+  let(:yields)   { []                                            }
+
+  it { should equal(object) }
+
+  it 'yields each tuple' do
+    expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ] ])
+  end
+end

data/spec/unit/veritas/algebra/restriction/eql_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Restriction#eql?' do
+  subject { object.eql?(other) }
+
+  let(:klass)    { Algebra::Restriction                          }
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:object)   { klass.new(relation, proc { true })            }
+
+  context 'with the same restriction' do
+    let(:other) { object }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent restriction' do
+    let(:other) { object.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with a different restriction' do
+    let(:other) { klass.new(relation, proc { false }) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+
+  context 'with an equivalent restriction of a different class' do
+    let(:other) { Class.new(klass).new(relation, proc { true }) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(object)
+    end
+  end
+end

data/spec/unit/veritas/algebra/restriction/methods/restrict_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Restriction::Methods#restrict' do
+  subject { relation.restrict(*args, &block) }
+
+  let(:relation) { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  context 'with predicate arguments' do
+    let(:predicate) { relation[:id].eq(1) }
+    let(:args)      { [ predicate ]       }
+    let(:block)     { nil                 }
+
+    it { should be_kind_of(Algebra::Restriction) }
+
+    it 'sets the predicate' do
+      subject.predicate.should equal(predicate)
+    end
+
+    it 'behaves the same as Enumerable#select' do
+      should == relation.select { |tuple| tuple[:id] == 1 }
+    end
+  end
+
+  context 'with a block' do
+    let(:args)  { []                                        }
+    let(:block) { lambda { |relation| relation[:id].eq(1) } }
+
+    it { should be_kind_of(Algebra::Restriction) }
+
+    it 'sets the predicate' do
+      subject.predicate.should eql(block.call(relation))
+    end
+
+    it 'behaves the same as Enumerable#select' do
+      should == relation.select { |tuple| tuple[:id] == 1 }
+    end
+  end
+end

data/spec/unit/veritas/algebra/restriction/predicate_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Restriction#predicate' do
+  subject { object.predicate }
+
+  let(:klass)     { Algebra::Restriction                          }
+  let(:relation)  { Relation.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+  let(:predicate) { relation[:id].ne(0)                           }
+  let(:object)    { klass.new(relation, predicate)                }
+
+  it { should equal(predicate) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/summarization/class_methods/summarize_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Summarization.summarize' do
+  subject { object.summarize(tuple, summary, summarizer) }
+
+  let(:header)     { Relation::Header.new([ [ :id, Integer ] ]) }
+  let(:tuple)      { Tuple.new(header, [ 1 ])                   }
+  let(:summarizer) { lambda { |acc, tuple| acc.to_i + 1 }       }
+  let(:object)     { Algebra::Summarization                     }
+
+  context 'when the accumulator is uninitialized' do
+    let(:summary) { {} }
+
+    it { should equal(object) }
+
+    it { expect { subject }.to change { summary.dup }.from({}).to({ summarizer => 1 }) }
+  end
+
+  context 'when the accumulator is initialized' do
+    let(:summary) { { summarizer => 1 } }
+
+    it { should equal(object) }
+
+    it { expect { subject }.to change { summary.dup }.from({ summarizer => 1 }).to({ summarizer => 2 }) }
+  end
+end

data/spec/unit/veritas/algebra/summarization/each_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Summarization#each' do
+  subject { object.each { |tuple| yields << tuple } }
+
+  let(:klass)       { Algebra::Summarization                               }
+  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:summarizers) { { :count => lambda { |acc, tuple| acc.to_i + 1 } }   }
+  let(:object)      { klass.new(operand, operand.project([]), summarizers) }
+  let(:yields)      { []                                                   }
+
+  it { should equal(object) }
+
+  it 'yields each tuple' do
+    expect { subject }.to change { yields.dup }.from([]).to([ [ 2 ] ])
+  end
+end

data/spec/unit/veritas/algebra/summarization/header_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Summarization#header' do
+  subject { object.header }
+
+  let(:klass)       { Algebra::Summarization                               }
+  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:object)      { klass.new(operand, operand, summarizers)             }
+
+  it { should be_kind_of(Relation::Header) }
+
+  it { should == [ [ :id, Integer ], [ :test, Object ] ] }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/summarization/methods/summarize_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Summarization::Methods#summarize' do
+  subject { object.summarize(summarize_by, &block) }
+
+  let(:klass)       { Relation                                   }
+  let(:summarizers) { [ :test, lambda { |acc, tuple| 1 } ]       }
+  let(:block)       { lambda { |r| r.add(*summarizers) }         }
+  let(:object)      { klass.new([ [ :id, Integer ] ], [ [ 1 ] ]) }
+
+  context 'when summarizing by a relation' do
+    let(:summarize_by) { object }
+
+    it { should be_kind_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_by) { should equal(summarize_by) }
+  end
+
+  context 'when summarizing by a header' do
+    let(:summarize_by) { [ :id ] }
+
+    it { should be_kind_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_by) { should == object.project(summarize_by) }
+  end
+end

data/spec/unit/veritas/algebra/summarization/summarize_by_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Summarization#summarize_by' do
+  subject { object.summarize_by }
+
+  let(:klass)       { Algebra::Summarization                               }
+  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:object)      { klass.new(operand, operand, summarizers)             }
+
+  it { should equal(operand) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/summarization/summarizers_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Summarization#summarizers' do
+  subject { object.summarizers }
+
+  let(:klass)       { Algebra::Summarization                               }
+  let(:operand)     { Relation.new([ [ :id, Integer ] ], [ [ 1 ], [ 2 ] ]) }
+  let(:summarizers) { { :test => lambda { |acc, tuple| 1 } }               }
+  let(:object)      { klass.new(operand, operand, summarizers)             }
+
+  it { should equal(summarizers) }
+
+  it_should_behave_like 'an idempotent method'
+end

data/spec/unit/veritas/algebra/union/each_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Veritas::Algebra::Union#each' do
+  subject { union.each { |tuple| yields << tuple } }
+
+  let(:header) { [ [ :id, Integer ] ]            }
+  let(:left)   { Relation.new(header, [ [ 1 ] ]) }
+  let(:yields) { []                              }
+
+  context 'with relations having similar bodies' do
+    let(:union) { Algebra::Union.new(left, left.dup) }
+
+    it { should equal(union) }
+
+    it 'yields the union' do
+      expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ] ])
+    end
+  end
+
+  context 'with relations having different bodies' do
+    let(:right) { Relation.new(header, [ [ 2 ] ]) }
+    let(:union) { Algebra::Union.new(left, right) }
+
+    it { should equal(union) }
+
+    it 'yields the union' do
+      expect { subject }.to change { yields.dup }.from([]).to([ [ 1 ], [ 2 ] ])
+    end
+  end
+end

data/spec/unit/veritas/algebra/union/methods/union_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+[ :union, :| ].each do |method|
+  describe "Veritas::Algebra::Union::Methods##{method}" do
+    subject { relation.send(method, other) }
+
+    let(:header)   { [ [ :id, Integer ] ]            }
+    let(:relation) { Relation.new(header, [ [ 1 ] ]) }
+    let(:other)    { Relation.new(header, [ [ 2 ] ]) }
+
+    it { should be_kind_of(Algebra::Union) }
+
+    it 'behaves the same as Array#|' do
+      should == (relation.to_a | other.to_a)
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module AliasableSpecs
+  class Object
+    extend Aliasable
+
+    def test; end
+  end # class Object
+end # module AliasableSpecs

data/spec/unit/veritas/aliasable/inheritable_alias_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe 'Veritas::Aliasable#inheritable_alias' do
+  subject { klass.inheritable_alias(aliases) }
+
+  let(:klass)     { Class.new(AliasableSpecs::Object) }
+  let(:aliasable) { klass.new                         }
+  let(:aliases)   { { :other => :test }               }
+
+  it 'returns the class' do
+    should equal(klass)
+  end
+
+  it 'creates a method #other' do
+    expect { subject }.to change { aliasable.respond_to?(:other) }.from(false).to(true)
+  end
+
+  it 'aliases #other to #test' do
+    subject
+    retval = mock('Return Value')
+    aliasable.should_receive(:test).and_return(retval)
+    aliasable.other.should equal(retval)
+  end
+
+  specification = proc do
+    klass.class_eval do
+      def test
+        caller
+      end
+    end
+
+    subject
+
+    file, line = aliasable.other.first.split(':')[0, 2]
+
+    File.expand_path(file).should == File.expand_path('../../../../../lib/veritas/support/aliasable.rb', __FILE__)
+    line.to_i.should == 21
+  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

data/spec/unit/veritas/attribute/boolean/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Boolean.primitive' do
+  subject { Attribute::Boolean.primitive }
+
+  it { should equal(TrueClass) }
+end

data/spec/unit/veritas/attribute/boolean/valid_value_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Boolean#valid_value?' do
+  subject { attribute.valid_value?(value) }
+
+  let(:attribute) { Veritas::Attribute::Boolean.new(:boolean) }
+
+  context 'with a true value' do
+    let(:value) { true }
+
+    it { should be(true) }
+  end
+
+  context 'with a false value' do
+    let(:value) { false }
+
+    it { should be(true) }
+  end
+
+  context 'with a value that is not true or false' do
+    let(:value) { 1 }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/attribute/call_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#call' do
+  subject { attribute.call(tuple) }
+
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:header)    { Relation::Header.new([ attribute ]) }
+  let(:tuple)     { Tuple.new(header, [ 1 ])            }
+
+  it { should == 1 }
+end

data/spec/unit/veritas/attribute/class/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Class.primitive' do
+  subject { Attribute::Class.primitive }
+
+  it { should equal(Class) }
+end

data/spec/unit/veritas/attribute/class_methods/coerce_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute.coerce' do
+  subject { Attribute.coerce(object) }
+
+  context 'when the object is an Attribute' do
+    let(:object) { Attribute::Integer.new(:id) }
+
+    it { should equal(object) }
+  end
+
+  context 'when the object responds to #to_ary' do
+    let(:object) { [ :id, Integer ] }
+
+    it { should eql(Attribute::Integer.new(:id)) }
+  end
+
+  context 'when the object does not respond to #to_ary, but does respond to #to_sym' do
+    let(:object) { :id }
+
+    it { should eql(Attribute::Object.new(:id)) }
+  end
+
+  context 'when the object does not respond to #to_ary or #to_sym' do
+    let(:object) { Integer }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

data/spec/unit/veritas/attribute/class_methods/name_from_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute.name_from' do
+  subject { Attribute.name_from(object) }
+
+  context 'object is an Attribute' do
+    let(:object) { Attribute::Integer.new(:id) }
+
+    it { should == :id }
+  end
+
+  context 'object that responds to #to_ary' do
+    let(:object) { [ :id, Integer ] }
+
+    it { should == :id }
+  end
+
+  context 'object that responds to #to_sym' do
+    let(:object) { 'id' }
+
+    it { should == :id }
+  end
+
+  context 'object that is not an Attribute, does not respond to #to_ary or #to_sym' do
+    let(:object) { Object.new }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

data/spec/unit/veritas/attribute/class_methods/new_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute.new' do
+  subject { klass.new(:id) }
+
+  context 'when called on the Attribute class' do
+    let(:klass) { Attribute }
+
+    specify { expect { subject }.to raise_error(NotImplementedError, 'Veritas::Attribute is an abstract class') }
+  end
+
+  [
+    Attribute::Boolean,
+    Attribute::Class,
+    Attribute::Date,
+    Attribute::DateTime,
+    Attribute::Decimal,
+    Attribute::Float,
+    Attribute::Integer,
+    Attribute::Numeric,
+    Attribute::Object,
+    Attribute::String,
+    Attribute::Time,
+  ].each do |klass|
+    context "when called on the Attribute subclass #{klass}" do
+      let(:klass) { klass }
+
+      it { should be_kind_of(Attribute) }
+
+      it { should be_kind_of(klass) }
+    end
+  end
+end

data/spec/unit/veritas/attribute/comparable/comparable_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Comparable#comparable?' do
+  subject { attribute.comparable?(other) }
+
+  let(:attribute) { Attribute::Integer.new(:id) }
+
+  context 'when the other attribute is the same type' do
+    let(:other) { attribute.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.comparable?(attribute)
+    end
+  end
+
+  context 'when the other attribute is a different class' do
+    let(:other) { Attribute::String.new(:different) }
+
+    it { should be(false) }
+
+    it 'is not be symmetric' do
+      expect {
+        other.comparable?(attribute)
+      }.to raise_error(NoMethodError)
+    end
+  end
+
+  context 'when the other attribute is a descendant type' do
+    let(:other) { Class.new(Attribute::Integer).new(:descendant) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.comparable?(attribute)
+    end
+  end
+
+  context 'when the other attribute shares a common type' do
+    let(:other) { Attribute::Numeric.new(:ancestor) }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.comparable?(attribute)
+    end
+  end
+end

data/spec/unit/veritas/attribute/comparable/fixtures/classes.rb

@@ -0,0 +1,5 @@
+module ComparableSpecs
+  class Object
+    include Attribute::Comparable
+  end # class Object
+end # module ComparableSpecs

data/spec/unit/veritas/attribute/date/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Date.primitive' do
+  subject { Attribute::Date.primitive }
+
+  it { should equal(Date) }
+end

data/spec/unit/veritas/attribute/date/range_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Date#range' do
+  subject { attribute.range }
+
+  let(:attribute) { Veritas::Attribute::Date.new(:date) }
+
+  it { should == (Date.new..Date::Infinity.new) }
+end

data/spec/unit/veritas/attribute/date_time/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::DateTime.primitive' do
+  subject { Attribute::DateTime.primitive }
+
+  it { should equal(DateTime) }
+end

data/spec/unit/veritas/attribute/date_time/range_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::DateTime#range' do
+  subject { attribute.range }
+
+  let(:attribute) { Veritas::Attribute::DateTime.new(:datetime) }
+
+  it { should == (DateTime.new..DateTime::Infinity.new) }
+end

data/spec/unit/veritas/attribute/decimal/class_methods/primitive_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute::Decimal.primitive' do
+  subject { Attribute::Decimal.primitive }
+
+  it { should equal(BigDecimal) }
+end

data/spec/unit/veritas/attribute/eql_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe 'Veritas::Attribute#eql?' do
+  subject { attribute.eql?(other) }
+
+  let(:name)      { :id                          }
+  let(:attribute) { Attribute::Integer.new(name) }
+
+  context 'with the same attribute' do
+    let(:other) { attribute }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(attribute)
+    end
+  end
+
+  context 'with an equivalent attribute' do
+    let(:other) { attribute.dup }
+
+    it { should be(true) }
+
+    it 'is symmetric' do
+      should == other.eql?(attribute)
+    end
+  end
+
+  context 'with a different attribute' do
+    let(:other) { Attribute::String.new(:name) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(attribute)
+    end
+  end
+
+  context 'with an equivalent attribute of a different class' do
+    let(:other) { Class.new(Attribute::Integer).new(name) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should == other.eql?(attribute)
+    end
+  end
+end