veritas 0.0.6 → 0.0.7

data/spec/unit/veritas/function/numeric/unary_plus/class_methods/operation_spec.rb

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

data/spec/unit/veritas/function/unary/callable/call_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Unary::Callable, '#call' do
+  subject { object.call(value) }
+
+  let(:object)    { mock('object', :operation => :op).extend(self.class.described_type) }
+  let(:value)     { mock('value', :send => response)                                    }
+  let(:response)  { mock('response')                                                    }
+
+  it { should equal(response) }
+
+  it 'uses the operation from the object' do
+    object.should_receive(:operation)
+    subject
+  end
+
+  it 'delegates the operation to the value' do
+    value.should_receive(:send).with(:op)
+    subject
+  end
+end

data/spec/unit/veritas/function/unary/callable/included_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Unary::Callable, '#included' do
+  subject { object.included(descendant) }
+
+  let(:object)     { Class.new(superklass).extend(self.class.described_type) }
+  let(:superklass) { Class.new                                               }
+  let(:descendant) { mock('descendant')                                      }
+
+  it { should equal(object) }
+
+  it 'delegates to the superclass #included method' do
+    superklass.should_receive(:included).with(descendant)
+    subject
+  end
+
+  it 'extends the descendant with Callable' do
+    descendant.should_receive(:extend).with(self.class.described_type)
+    subject
+  end
+end

data/spec/unit/veritas/function/unary/inspect_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Function::Unary, '#inspect' do
+  subject { object.inspect }
+
+  let(:described_class) { Class.new { include Function::Unary } }
+  let(:object)          { described_class.new(1)                }
+
+  context 'when the operation ends in "@"' do
+    before do
+      described_class.class_eval do
+        def self.operation
+          :+@
+        end
+      end
+    end
+
+    it { should == '+(1)' }
+  end
+
+  context 'when the operation includes a downcased string' do
+    before do
+      described_class.class_eval do
+        def self.operation
+          :op
+        end
+      end
+    end
+
+    it { should == 'OP(1)' }
+  end
+end

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

@@ -9,19 +9,19 @@ module ImmutableSpecs
     end
 
     def public_method
-      'public_method'
+      caller
     end
 
   protected
 
     def protected_method
-      'protected_method'
+      caller
     end
 
   private
 
     def private_method
-      'private_method'
+      caller
     end
 
   end # class Object

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

@@ -12,30 +12,40 @@ shared_examples_for 'memoizes method' do
 
   it 'creates a method that returns a frozen value' do
     subject
-    instance = object.new
-    instance.send(method).should be_frozen
+    object.new.send(method).should be_frozen
   end
 
   specification = proc do
-    object.send(:define_method, method) do
-      caller
-    end
-
     subject
-
     file, line = object.new.send(method).first.split(':')[0, 2]
-
     File.expand_path(file).should eql(File.expand_path('../../../../../../lib/veritas/support/immutable.rb', __FILE__))
-    line.to_i.should eql(185)
+    line.to_i.should eql(210)
   end
 
   it 'sets the file and line number properly' do
-    if RUBY_PLATFORM[/java/]
+    if RUBY_PLATFORM.include?('java')
       pending('Kernel#caller returns the incorrect line number in JRuby', &specification)
     else
       instance_eval(&specification)
     end
   end
+
+  context 'when the initializer calls the memoized method' do
+    before do
+      method = self.method
+      object.send(:define_method, :initialize) { send(method) }
+    end
+
+    it 'allows the memoized method to be called within the initializer' do
+      subject
+      expect { object.new }.to_not raise_error(NoMethodError)
+    end
+
+    it 'memoizes the methdod inside the initializer' do
+      subject
+      object.new.memoized(method).should_not be_nil
+    end
+  end
 end
 
 describe Immutable::ModuleMethods, '#memoize' do

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation, '.coerce' do
+  subject { object.coerce(header, argument) }
+
+  let(:header)   { [ [ :id, Integer ] ]            }
+  let(:object)   { described_class                 }
+  let(:relation) { Relation.new(header, [ [ 1 ] ]) }
+
+  context 'when the argument is a Relation' do
+    let(:argument) { relation }
+
+    it { should equal(relation) }
+  end
+
+  context 'when the argument is an Array' do
+    let(:argument) { [ [ 1 ] ] }
+
+    it { should eql(relation) }
+  end
+end

data/spec/unit/veritas/relation/each_spec.rb

@@ -28,7 +28,7 @@ describe Relation do
 
   let(:header) { [ [ :id, Integer ] ] }
   let(:body)   { [ [ 1 ] ].each       }
-  let(:object) { Relation             }
+  let(:object) { described_class      }
 
   before do
     subject.should be_instance_of(object)

data/spec/unit/veritas/relation/equal_value_spec.rb

@@ -103,4 +103,16 @@ describe Relation, '#==' do
       should eql(other == object)
     end
   end
+
+  context 'with a different object having a superset of the headers' do
+    let(:other_header) { [ [ :id, Integer ], [ :name, String ] ]       }
+    let(:other_body)   { [ [ 1, 'Dan Kubb' ] ].each                    }
+    let(:other)        { described_class.new(other_header, other_body) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
 end

data/spec/unit/veritas/relation/header/call_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+[ :call, :[] ].each do |method|
+  describe Relation::Header, "##{method}" do
+    subject { object.send(method, name) }
+
+    let(:object) { described_class.new([ [ :id, Integer ] ]) }
+
+    context 'with a known attribute name' do
+      let(:name) { :id }
+
+      it { should == [ :id, Integer ] }
+    end
+
+    context 'with an unknown attribute name' do
+      let(:name) { :name }
+
+      it { should be_nil }
+    end
+  end
+end

data/spec/unit/veritas/relation/header/class_methods/coerce_spec.rb

@@ -22,7 +22,7 @@ describe Relation::Header, '.coerce' do
   end
 
   context 'when the argument is not a Header and does not respond to #to_ary' do
-    let(:argument) { { :id => Integer } }
+    let(:argument) { Object.new }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

data/spec/unit/veritas/relation/header/class_methods/new_spec.rb

@@ -26,11 +26,11 @@ describe Relation::Header, '.new' do
   context 'with an argument that responds to #to_ary and contain duplicates' do
     let(:argument) { [ [ :id ], [ :id ], [ :name ], [ :name ], [ :age ] ] }
 
-    specify { expect { subject }.to raise_error(DuplicateAttributeError, 'duplicate attributes: id, name') }
+    specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: id, name') }
   end
 
   context 'with an argument that does not respond to #to_ary' do
-    let(:argument) { { :id => Integer } }
+    let(:argument) { Object.new }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

data/spec/unit/veritas/relation/header/each_spec.rb

@@ -21,7 +21,7 @@ end
 describe Relation::Header do
   subject { object.new }
 
-  let(:object) { Relation::Header }
+  let(:object) { described_class }
 
   it { should be_kind_of(Enumerable) }
 

data/spec/unit/veritas/relation/header/empty_spec.rb

@@ -5,15 +5,16 @@ require 'spec_helper'
 describe Relation::Header, '#empty?' do
   subject { object.empty? }
 
+  let(:object) { described_class.new(entries) }
 
-  context 'with attributes' do
-    let(:object) { described_class.new([ [ :id, Integer ] ]) }
+  context 'with entries' do
+    let(:entries) { [ [ :id, Integer ] ] }
 
     it { should be(false) }
   end
 
-  context 'without attributes' do
-    let(:object) { described_class.new }
+  context 'without entries' do
+    let(:entries) { [] }
 
     it { should be(true) }
   end

data/spec/unit/veritas/relation/header/intersect_spec.rb

@@ -6,11 +6,25 @@ require 'spec_helper'
   describe Relation::Header, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:other)  { described_class.new([ [ :name, String  ] ]) }
-    let(:object) { described_class.new([ [ :id,   Integer ] ]) }
+    let(:other)  { described_class.new(attributes)       }
+    let(:object) { described_class.new(other_attributes) }
 
-    it { should be_instance_of(described_class) }
+    context 'when the attributes overlap' do
+      let(:attributes)       { [ [ :name, String ] ] }
+      let(:other_attributes) { [ [ :name, String ] ] }
 
-    it { should be_empty }
+      it { should be_instance_of(described_class) }
+
+      it { should == [ [ :name, String ] ] }
+    end
+
+    context 'when the attributes do not overlap' do
+      let(:attributes)       { [ [ :name, String  ] ] }
+      let(:other_attributes) { [ [ :id,   Integer ] ] }
+
+      it { should be_instance_of(described_class) }
+
+      it { should be_empty }
+    end
   end
 end

data/spec/unit/veritas/relation/operation/binary/class_methods/new_spec.rb

@@ -3,38 +3,38 @@
 require 'spec_helper'
 require File.expand_path('../../fixtures/classes', __FILE__)
 
- context 'Veritas::Relation::Operation::Binary::ClassMethods#new' do
-   subject { object.new(left, right) }
+context 'Veritas::Relation::Operation::Binary::ClassMethods#new' do
+  subject { object.new(left, right) }
 
-   let(:original_left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
-   let(:original_right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
-   let(:object)         { BinaryRelationOperationSpecs::Object                     }
+  let(:original_left)  { Relation.new([ [ :id,   Integer ] ], [ [ 1 ] ])          }
+  let(:original_right) { Relation.new([ [ :name, String  ] ], [ [ 'Dan Kubb' ] ]) }
+  let(:object)         { BinaryRelationOperationSpecs::Object                     }
 
-   context 'with left and right ordered' do
-     let(:left)  { original_left.sort_by  { |r| r.id   } }
-     let(:right) { original_right.sort_by { |r| r.name } }
+  context 'with left and right ordered' do
+    let(:left)  { original_left.sort_by  { |r| r.id   } }
+    let(:right) { original_right.sort_by { |r| r.name } }
 
-     it { should be_instance_of(object) }
-   end
+    it { should be_instance_of(object) }
+  end
 
-   context 'with left and right unordered' do
-     let(:left)  { original_left  }
-     let(:right) { original_right }
+  context 'with left and right unordered' do
+    let(:left)  { original_left  }
+    let(:right) { original_right }
 
-     it { should be_instance_of(object) }
-   end
+    it { should be_instance_of(object) }
+  end
 
-   context 'with left ordered, and right unordered' do
-     let(:left)  { original_left.sort_by { |r| r.id } }
-     let(:right) { original_right                     }
+  context 'with left ordered, and right unordered' do
+    let(:left)  { original_left.sort_by { |r| r.id } }
+    let(:right) { original_right                     }
 
-     specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
-   end
+    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
+  end
 
-   context 'with right ordered, and left unordered' do
-     let(:left)  { original_left                         }
-     let(:right) { original_right.sort_by { |r| r.name } }
+  context 'with right ordered, and left unordered' do
+    let(:left)  { original_left                         }
+    let(:right) { original_right.sort_by { |r| r.name } }
 
-     specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
-   end
+    specify { expect { subject }.to raise_error(RelationMismatchError, 'both relations must be ordered or neither may be ordered') }
+  end
 end

data/spec/unit/veritas/relation/operation/order/direction/name_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Order::Direction, '#name' do
+  subject { object.name }
+
+  let(:described_class) { Class.new(Relation::Operation::Order::Direction) }
+  let(:attribute)       { Attribute::Integer.new(:id)                      }
+  let(:object)          { described_class.new(attribute)                   }
+
+  it { should equal(:id) }
+end

data/spec/unit/veritas/relation/operation/order/direction_set/class_methods/new_spec.rb

@@ -21,7 +21,7 @@ describe Relation::Operation::Order::DirectionSet, '.new' do
   context 'with an argument that responds to #to_ary and contain duplicates' do
     let(:argument) { [ id, id, name, name, age ] }
 
-    specify { expect { subject }.to raise_error(DuplicateAttributeError, 'duplicate attributes: id, name') }
+    specify { expect { subject }.to raise_error(DuplicateNameError, 'duplicate names: id, name') }
   end
 
   context 'with an argument that does not respond to #to_ary' do

data/spec/unit/veritas/relation/operation/order/direction_set/equal_value_spec.rb

@@ -49,6 +49,19 @@ describe Relation::Operation::Order::DirectionSet, '#==' do
     end
   end
 
+  context 'with an object having equivalent attributes in a different order' do
+    let(:attribute1) { Attribute::Integer.new(:id)                     }
+    let(:attribute2) { Attribute::String.new(:name)                    }
+    let(:object)     { described_class.new([ attribute1, attribute2 ]) }
+    let(:other)      { described_class.new([ attribute2, attribute1 ]) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other == object)
+    end
+  end
+
   context 'with an equivalent object responding to #to_ary' do
     let(:other) { attributes }