veritas 0.0.1 → 0.0.2

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

@@ -1,88 +1,64 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#eql?' do
-  subject { tuple.eql?(other) }
+  subject { object.eql?(other) }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
+  let(:data)   { [ 1 ]                                      }
+  let(:object) { klass.new(header, data)                    }
 
-  context 'with the same tuple' do
-    let(:other) { tuple }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(tuple)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent tuple' do
-    let(:other) { tuple.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(tuple)
+      should == other.eql?(object)
     end
   end
 
-  context 'with a different tuple' do
-    let(:other) { Tuple.new(header, [ 2 ]) }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(header, data) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(tuple)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent tuple with a different header' do
-    let(:aliases)      { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
-    let(:other_header) { header.rename(aliases)                                    }
-    let(:other)        { Tuple.new(other_header, tuple.to_ary)                     }
+  context 'with an object having a different header' do
+    let(:other_header) { Relation::Header.new([ [ :id, Numeric ] ]) }
+    let(:other_data)   { data                                       }
+    let(:other)        { klass.new(other_header, other_data)        }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(tuple)
+      should == other.eql?(object)
     end
   end
 
-  context 'with an equivalent tuple of a different class' do
-    let(:other) { Class.new(Tuple).new(header, [ 1 ]) }
+  context 'with an object having different data' do
+    let(:other_header) { header                              }
+    let(:other_data)   { [ 2 ]                               }
+    let(:other)        { klass.new(other_header, other_data) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(tuple)
-    end
-  end
-
-  context 'with an equivalent object responding to #to_ary' do
-    let(:other) { [ 1 ] }
-
-    it { should be(false) }
-
-    specification = proc do
-      should == other.eql?(tuple)
-    end
-
-    it 'is symmetric' do
-      if RUBY_PLATFORM[/java/]
-        pending('Array#eql? does not call other#to_ary in JRuby', &specification)
-      else
-        instance_eval(&specification)
-      end
-    end
-  end
-
-  context 'with a different object responding to #to_ary' do
-    let(:other) { [ 2 ] }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should == other.eql?(tuple)
+      should == other.eql?(object)
     end
   end
 end

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

@@ -1,71 +1,74 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#==' do
-  subject { tuple == other }
+  subject { object == other }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
+  let(:data)   { [ 1 ]                                      }
+  let(:object) { klass.new(header, data)                    }
 
-  context 'with the same tuple' do
-    let(:other) { tuple }
+  context 'with the same object' do
+    let(:other) { object }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent tuple' do
-    let(:other) { tuple.dup }
+  context 'with an equivalent object' do
+    let(:other) { object.dup }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 
-  context 'with a different tuple' do
-    let(:other) { Tuple.new(header, [ 2 ]) }
+  context 'with an equivalent object of a subclass' do
+    let(:other) { Class.new(klass).new(header, data) }
 
-    it { should be(false) }
+    it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent tuple with a different header' do
-    let(:aliases)      { Algebra::Rename::Aliases.coerce(header, :id => :other_id) }
-    let(:other_header) { header.rename(aliases)                                    }
-    let(:other_tuple)  { Tuple.new(other_header, [ 1 ])                            }
-    let(:other)        { Tuple.new(other_header, other_tuple.to_ary)               }
+  context 'with an object having a different header' do
+    let(:other_header) { Relation::Header.new([ [ :id, Numeric ] ]) }
+    let(:other_data)   { data                                       }
+    let(:other)        { klass.new(other_header, other_data)        }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 
-  context 'with an equivalent tuple of a different class' do
-    let(:other) { Class.new(Tuple).new(header, [ 1 ]) }
+  context 'with an object having different data' do
+    let(:other_header) { header                              }
+    let(:other_data)   { [ 2 ]                               }
+    let(:other)        { klass.new(other_header, other_data) }
 
-    it { should be(true) }
+    it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 
   context 'with an equivalent object responding to #to_ary' do
-    let(:other) { [ 1 ] }
+    let(:other) { data }
 
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 
@@ -75,7 +78,7 @@ describe 'Veritas::Tuple#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == tuple)
+      should == (other == object)
     end
   end
 end

data/spec/unit/veritas/tuple/extend_spec.rb

@@ -3,12 +3,13 @@ require 'spec_helper'
 describe 'Veritas::Tuple#extend' do
   subject { object.extend(new_header, extensions) }
 
+  let(:klass)      { Tuple                                                         }
   let(:header)     { Relation::Header.new([ [ :id, Integer ], [ :name, String ] ]) }
   let(:new_header) { header | [ [ :test, Integer ] ]                               }
   let(:extensions) { [ lambda { |tuple| 1 } ]                                      }
-  let(:object)     { Tuple.new(header, [ 1, 'Dan Kubb' ])                          }
+  let(:object)     { klass.new(header, [ 1, 'Dan Kubb' ])                          }
 
-  it { should be_kind_of(Tuple) }
+  it { should be_kind_of(klass) }
 
   its(:header) { should equal(new_header) }
 

data/spec/unit/veritas/tuple/hash_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#hash' do
-  subject { tuple.hash }
+  subject { object.hash }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
+  let(:data)   { [ 1 ]                                      }
+  let(:object) { klass.new(header, data)                    }
 
-  it { should be_kind_of(Integer) }
+  it_should_behave_like 'a hash method'
 
-  it { should == header.hash ^ [ 1 ].hash }
-
-  it_should_behave_like 'an idempotent method'
+  it { should == klass.hash ^ header.hash ^ data.hash }
 end

data/spec/unit/veritas/tuple/header_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#header' do
-  subject { tuple.header }
+  subject { object.header }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
-
-  it { should equal(header) }
+  let(:object) { klass.new(header, [ 1 ])                   }
 
   it_should_behave_like 'an idempotent method'
+
+  it { should equal(header) }
 end

data/spec/unit/veritas/tuple/inspect_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#inspect' do
-  subject { tuple.inspect }
+  subject { object.inspect }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
+  let(:object) { klass.new(header, [ 1 ])                   }
 
   it { should be_kind_of(String) }
 

data/spec/unit/veritas/tuple/join_spec.rb

@@ -3,12 +3,13 @@ require 'spec_helper'
 describe 'Veritas::Tuple#join' do
   subject { object.join(new_header, values) }
 
+  let(:klass)      { Tuple                                      }
   let(:header)     { Relation::Header.new([ [ :id, Integer ] ]) }
   let(:new_header) { header | [ [ :name, String ] ]             }
   let(:values)     { [ 'Dan Kubb' ]                             }
-  let(:object)     { Tuple.new(header, [ 1 ])                   }
+  let(:object)     { klass.new(header, [ 1 ])                   }
 
-  it { should be_kind_of(Tuple) }
+  it { should be_kind_of(klass) }
 
   its(:header) { should equal(new_header) }
 

data/spec/unit/veritas/tuple/project_spec.rb

@@ -1,13 +1,14 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#project' do
-  subject { tuple.project(reversed_header) }
+  subject { object.project(reversed_header) }
 
+  let(:klass)           { Tuple                                                         }
   let(:header)          { Relation::Header.new([ [ :name, String ], [ :id, Integer ] ]) }
   let(:reversed_header) { Relation::Header.new(header.to_a.reverse)                     }
-  let(:tuple)           { Tuple.new(header, [ 'Dan Kubb', 1 ])                          }
+  let(:object)          { klass.new(header, [ 'Dan Kubb', 1 ])                          }
 
-  it { should be_kind_of(Tuple) }
+  it { should be_kind_of(klass) }
 
   its(:header) { should equal(reversed_header) }
 

data/spec/unit/veritas/tuple/to_ary_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
 describe 'Veritas::Tuple#to_ary' do
-  subject { tuple.to_ary }
+  subject { object.to_ary }
 
+  let(:klass)  { Tuple                                      }
   let(:header) { Relation::Header.new([ [ :id, Integer ] ]) }
-  let(:tuple)  { Tuple.new(header, [ 1 ])                   }
+  let(:object) { klass.new(header, [ 1 ])                   }
 
-  it { should be_instance_of(Array) }
+  it { should be_kind_of(Array) }
 
   it { should == [ 1 ] }
 end

data/spec/unit/veritas/visitable/accept_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'Veritas::Visitable#accept' do
+  subject { object.accept(visitor) }
+
+  let(:klass)   { Class.new { include Visitable } }
+  let(:visitor) { mock('Visitor', :visit => nil)  }
+  let(:object)  { klass.new                       }
+
+  it_should_behave_like 'a command method'
+
+  it 'sends self to visitor#visit' do
+    visitor.should_receive(:visit).with(object)
+    subject
+  end
+end

data/tasks/quality/heckle.rake

@@ -10,7 +10,7 @@ begin
   require 'mspec'
   require 'mspec/utils/name_map'
 
-  MEMOIZED_PATTERN = /\A__memoized_([a-z](?:_?[a-z])+)\z/.freeze
+  SKIP_METHODS = %w[ blank_slate_method_added ].freeze
 
   class NameMap
     def file_name(method, constant)
@@ -113,11 +113,12 @@ begin
                                ancestor.private_instance_methods(false)
       end
 
-      other_class_methods.reject! { |method| method.to_s == 'allocate' }
+      other_class_methods.reject! do |method|
+        method.to_s == 'allocate' || SKIP_METHODS.include?(method.to_s)
+      end
 
       other_class_methods.reject! do |method|
-        next unless method.to_s =~ MEMOIZED_PATTERN &&
-                    spec_class_methods.any? { |specced| specced.to_s == $1 }
+        next unless spec_class_methods.any? { |specced| specced.to_s == $1 }
 
         spec_class_methods << method
       end
@@ -129,8 +130,7 @@ begin
                       mod.private_instance_methods(false)
 
       other_methods.reject! do |method|
-        next unless method.to_s =~ MEMOIZED_PATTERN &&
-                    spec_methods.any? { |specced| specced.to_s == $1 }
+        next unless spec_methods.any? { |specced| specced.to_s == $1 }
 
         spec_methods << method
       end
@@ -138,7 +138,7 @@ begin
       # map the class methods to spec files
       spec_class_methods.each do |method|
         method = aliases[mod.name][method]
-        next if method.to_s =~ MEMOIZED_PATTERN
+        next if SKIP_METHODS.include?(method.to_s)
 
         spec_file = spec_prefix.join('class_methods').join(map.file_name(method, mod.name))
 
@@ -152,7 +152,7 @@ begin
       # map the instance methods to spec files
       spec_methods.each do |method|
         method = aliases[mod.name][method]
-        next if method.to_s =~ MEMOIZED_PATTERN
+        next if SKIP_METHODS.include?(method.to_s)
 
         spec_file = spec_prefix.join(map.file_name(method, mod.name))
 

data/tasks/spec.rake

@@ -35,7 +35,4 @@ rescue LoadError
   end
 end
 
-task :spec => :check_dependencies
-task :rcov => :check_dependencies
-
 task :default => :spec