veritas 0.0.4 → 0.0.5

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

@@ -15,7 +15,7 @@ describe Algebra::Restriction, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -25,7 +25,7 @@ describe Algebra::Restriction, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -35,7 +35,7 @@ describe Algebra::Restriction, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -47,7 +47,7 @@ describe Algebra::Restriction, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -59,7 +59,7 @@ describe Algebra::Restriction, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

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

@@ -9,7 +9,7 @@ describe Algebra::Restriction::Methods, '#restrict' do
 
   subject { object.restrict(&block) }
 
-  it { should be_kind_of(Algebra::Restriction) }
+  it { should be_instance_of(Algebra::Restriction) }
 
   it 'sets the predicate' do
     subject.predicate.should eql(block.call(object))

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

@@ -13,7 +13,7 @@ describe Algebra::Summarization, '.new' do
   context 'with a summarize_per that has a subset of the headers in the operand' do
     let(:summarize_per) { TABLE_DEE }
 
-    it { should be_kind_of(object) }
+    it { should be_instance_of(object) }
   end
 
   context 'with a summarize_per that has equivalent headers to the headers in the operand' do

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

@@ -16,7 +16,7 @@ describe Algebra::Summarization, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -26,7 +26,7 @@ describe Algebra::Summarization, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -36,7 +36,7 @@ describe Algebra::Summarization, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -49,20 +49,20 @@ describe Algebra::Summarization, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
   context 'with an object having a different summarize_by' do
     let(:other_operand)      { operand                                                                   }
-    let(:other_summarize_by) { operand.project([]).order                                                 }
+    let(:other_summarize_by) { operand.project([]).sort_by {}                                            }
     let(:other_summarizers)  { summarizers                                                               }
     let(:other)              { described_class.new(other_operand, other_summarize_by, other_summarizers) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -75,7 +75,7 @@ describe Algebra::Summarization, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

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

@@ -11,7 +11,7 @@ describe Algebra::Summarization, '#header' do
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_kind_of(Relation::Header) }
+  it { should be_instance_of(Relation::Header) }
 
   it { should == [ [ :test, Object ] ] }
 end

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

@@ -10,29 +10,39 @@ describe Algebra::Summarization::Methods, '#summarize' do
   let(:block)           { lambda { |r| r.add(*summarizers) }                                                       }
   let(:object)          { described_class.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ].each) }
 
-  context 'when summarizing per a relation' do
+  context 'with no arguments' do
+    subject { object.summarize(&block) }
+
+    it { should be_instance_of(Algebra::Summarization) }
+
+    its(:operand) { should equal(object) }
+
+    its(:summarize_per) { should equal(TABLE_DEE) }
+  end
+
+  context 'with a relation' do
     let(:summarize_with) { object.project([]) }
 
-    it { should be_kind_of(Algebra::Summarization) }
+    it { should be_instance_of(Algebra::Summarization) }
 
     its(:operand) { should equal(object) }
 
     its(:summarize_per) { should equal(summarize_with) }
   end
 
-  context 'when summarizing by a header' do
-    let(:summarize_with) { [] }
+  context 'with a header' do
+    let(:summarize_with) { object.project([]).header }
 
-    it { should be_kind_of(Algebra::Summarization) }
+    it { should be_instance_of(Algebra::Summarization) }
 
     its(:operand) { should equal(object) }
 
     its(:summarize_per) { should == object.project(summarize_with) }
   end
 
-  context 'when using a summarized-on attribute in the context' do
-    let(:summarize_with) { object.project([ :id ])                    }
-    let(:block)          { lambda { |r| r.add(:count, r[:id].count) } }
+  context 'with a header containing an attribute used in the context block' do
+    let(:summarize_with) { object.project([ :id ])                  }
+    let(:block)          { lambda { |r| r.add(:count, r.id.count) } }
 
     specify { expect { subject }.to raise_error(NoMethodError) }
   end

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

@@ -19,8 +19,8 @@ describe Algebra::Summarization::Summaries, '#summarize_by' do
   it 'aggregates the value returned by the summarizer' do
     subject
     key, value = subject.to_hash.first
-    key.should == :count
-    value.should be_kind_of(Algebra::Summarization::Summary)
-    value.call(tuple).should == 1
+    key.should eql(:count)
+    value.should be_instance_of(Algebra::Summarization::Summary)
+    value.call(tuple).should eql(1)
   end
 end

data/spec/unit/veritas/algebra/summarization/summaries/to_hash_spec.rb

@@ -10,7 +10,7 @@ describe Algebra::Summarization::Summaries, '#to_hash' do
 
   it 'matches the expected value' do
     key, value = subject.first
-    key.should == :count
-    value.should be_kind_of(Algebra::Summarization::Summary)
+    key.should eql(:count)
+    value.should be_instance_of(Algebra::Summarization::Summary)
   end
 end

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

@@ -15,6 +15,6 @@ describe Algebra::Summarization::Summary, '#summarize_by' do
 
   it 'aggregates the value returned by the summarizer' do
     2.times { instance_eval(&self.class.subject) }  # bypass subject cache
-    object.call(projection).should == 2
+    object.call(projection).should eql(2)
   end
 end

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

@@ -11,10 +11,10 @@ require 'spec_helper'
     let(:other)           { described_class.new(header, [ [ 2 ] ].each) }
     let(:object)          { described_class.new(header, [ [ 1 ] ].each) }
 
-    it { should be_kind_of(Algebra::Union) }
+    it { should be_instance_of(Algebra::Union) }
 
     it 'behaves the same as Array#|' do
-      should == (object.to_a | other.to_a)
+      should == object.to_a | other.to_a
     end
   end
 end

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

@@ -36,8 +36,8 @@ describe Aliasable, '#inheritable_alias' do
 
     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 == 23
+    File.expand_path(file).should eql(File.expand_path('../../../../../lib/veritas/support/aliasable.rb', __FILE__))
+    line.to_i.should eql(23)
   end
 
   it 'sets the file and line number properly' do

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

@@ -16,7 +16,7 @@ describe Attribute, '.coerce' do
   context 'when the argument responds to #to_ary' do
     let(:argument) { [ :id, Integer ] }
 
-    it { should be_kind_of(Attribute::Integer) }
+    it { should be_instance_of(Attribute::Integer) }
 
     its(:name) { should == :id }
   end
@@ -24,7 +24,7 @@ describe Attribute, '.coerce' do
   context 'when the argument does not respond to #to_ary, but does respond to #to_sym' do
     let(:argument) { :id }
 
-    it { should be_kind_of(Attribute::Object) }
+    it { should be_instance_of(Attribute::Object) }
 
     its(:name) { should == :id }
   end
@@ -50,7 +50,7 @@ describe Attribute::Boolean, '.coerce' do
   context 'when the argument responds to #to_ary' do
     let(:argument) { [ :id, Integer ] }
 
-    it { should be_kind_of(Attribute::Integer) }
+    it { should be_instance_of(Attribute::Integer) }
 
     its(:name) { should == :id }
   end
@@ -58,7 +58,7 @@ describe Attribute::Boolean, '.coerce' do
   context 'when the argument does not respond to #to_ary, but does respond to #to_sym' do
     let(:argument) { :id }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     its(:name) { should == :id }
   end

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

@@ -14,14 +14,10 @@ describe Attribute, '.descendants' do
   end
 
   context 'when there are descendants' do
-    let(:descendant) { Class.new(object) }
-
-    before do
-      descendant  # trigger the class inhertance
-    end
+    let!(:descendant) { Class.new(object) }
 
     it_should_behave_like 'an idempotent method'
 
-    it { should == [ descendant ] }
+    it { should eql([ descendant ]) }
   end
 end

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

@@ -23,7 +23,7 @@ describe Attribute, '.new' do
     context "when called on the Attribute subclass #{described_class}" do
       let(:object) { described_class }
 
-      it { should be_kind_of(object) }
+      it { should be_instance_of(object) }
     end
   end
 

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

@@ -14,7 +14,7 @@ describe Attribute::Comparable, '#comparable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.comparable?(object)
+      should eql(other.comparable?(object))
     end
   end
 
@@ -34,7 +34,7 @@ describe Attribute::Comparable, '#comparable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.comparable?(object)
+      should eql(other.comparable?(object))
     end
   end
 
@@ -44,7 +44,7 @@ describe Attribute::Comparable, '#comparable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.comparable?(object)
+      should eql(other.comparable?(object))
     end
   end
 end

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

@@ -15,7 +15,7 @@ describe Attribute, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -25,7 +25,7 @@ describe Attribute, '#eql?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -35,7 +35,7 @@ describe Attribute, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 
@@ -46,7 +46,7 @@ describe Attribute, '#eql?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.eql?(object)
+      should eql(other.eql?(object))
     end
   end
 end

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

@@ -15,7 +15,7 @@ describe Attribute, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -25,7 +25,7 @@ describe Attribute, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -35,7 +35,7 @@ describe Attribute, '#==' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 
@@ -46,7 +46,7 @@ describe Attribute, '#==' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == (other == object)
+      should eql(other == object)
     end
   end
 end

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

@@ -8,7 +8,7 @@ describe Attribute, '#inspect' do
   let(:described_class) { Attribute::Integer       }
   let(:object)          { described_class.new(:id) }
 
-  it { should be_kind_of(String) }
+  it { should be_instance_of(String) }
 
   it { should == '<Attribute::Integer name: id>' }
 end

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

@@ -14,7 +14,7 @@ describe Attribute, '#joinable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 
@@ -24,7 +24,7 @@ describe Attribute, '#joinable?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 
@@ -34,7 +34,7 @@ describe Attribute, '#joinable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 
@@ -44,7 +44,7 @@ describe Attribute, '#joinable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 end

data/spec/unit/veritas/attribute/numeric/joinable_spec.rb

@@ -14,7 +14,7 @@ describe Attribute::Numeric, '#joinable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 
@@ -24,7 +24,7 @@ describe Attribute::Numeric, '#joinable?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 
@@ -34,7 +34,7 @@ describe Attribute::Numeric, '#joinable?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 end

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

@@ -10,7 +10,7 @@ describe Attribute, '#options' do
   context 'when no options are provided' do
     let(:object) { described_class.new(:id) }
 
-    it { should be_kind_of(Hash) }
+    it { should be_instance_of(Hash) }
 
     it { should be_empty }
 
@@ -30,7 +30,7 @@ describe Attribute, '#options' do
 
     it { should_not equal(options) }
 
-    it { should be_kind_of(Hash) }
+    it { should be_instance_of(Hash) }
 
     it { should == options }
 

data/spec/unit/veritas/attribute/orderable/asc_spec.rb

@@ -9,5 +9,5 @@ describe Attribute::Orderable, '#asc' do
   let(:described_class) { OrderableSpecs::Object }
   let(:object)          { described_class.new    }
 
-  it { should be_kind_of(Relation::Operation::Order::Ascending) }
+  it { should be_instance_of(Relation::Operation::Order::Ascending) }
 end

data/spec/unit/veritas/attribute/orderable/desc_spec.rb

@@ -9,5 +9,5 @@ describe Attribute::Orderable, '#desc' do
   let(:described_class) { OrderableSpecs::Object }
   let(:object)          { described_class.new    }
 
-  it { should be_kind_of(Relation::Operation::Order::Descending) }
+  it { should be_instance_of(Relation::Operation::Order::Descending) }
 end

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

@@ -17,7 +17,7 @@ describe Attribute, '#rename' do
   context 'when the new name is different' do
     let(:name) { :other_id }
 
-    it { should be_kind_of(described_class) }
+    it { should be_instance_of(described_class) }
 
     it { should_not equal(object) }
 

data/spec/unit/veritas/attribute/string/joinable_spec.rb

@@ -13,17 +13,27 @@ describe Attribute::String, '#joinable?' do
     it { should be(true) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 
-  context 'when the attribute types are the same and the lengths are different' do
+  context 'when the attribute types are the same and the min_length is different' do
     let(:other) { described_class.new(:string, :min_length => 1, :max_length => 20) }
 
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
+    end
+  end
+
+  context 'when the attribute types are the same and the max_length is different' do
+    let(:other) { described_class.new(:string, :min_length => 10, :max_length => 30) }
+
+    it { should be(false) }
+
+    it 'is symmetric' do
+      should eql(other.joinable?(object))
     end
   end
 
@@ -33,7 +43,7 @@ describe Attribute::String, '#joinable?' do
     it { should be(false) }
 
     it 'is symmetric' do
-      should == other.joinable?(object)
+      should eql(other.joinable?(object))
     end
   end
 end

data/spec/unit/veritas/evaluator/context/method_missing_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Evaluator::Context, '#method_missing' do
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:header)    { Relation::Header.new([ attribute ]) }
+  let(:object)    { described_class.new(header) {}      }
+
+  context 'with a valid attribute' do
+    subject { object.id }
+
+    it { should equal(attribute) }
+  end
+
+  context 'with a valid attribute and extra arguments' do
+    subject { object.id(args) }
+
+    let(:args) { mock('Arguments') }
+
+    specify { expect { subject }.to raise_error(ArgumentError, 'wrong number of arguments (1 for 0)') }
+  end
+
+  context 'with an unknown attribute' do
+    subject { object.unknown }
+
+    specify { expect { subject }.to raise_error(NoMethodError) }
+  end
+end

data/spec/unit/veritas/evaluator/context/respond_to_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Evaluator::Context, '#respond_to?' do
+  subject { object.respond_to?(method) }
+
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:header)    { Relation::Header.new([ attribute ]) }
+  let(:object)    { described_class.new(header) {}      }
+
+  context 'when the method is an attribute name and include_private is true' do
+    let(:method)          { attribute.name }
+    let(:include_private) { true           }
+
+    it { should be(true) }
+  end
+
+  context 'when the method is an attribute name and include_private is false' do
+    let(:method)          { attribute.name }
+    let(:include_private) { false          }
+
+    it { should be(true) }
+  end
+
+  context 'when the method is not an attribute name and include_private is true' do
+    let(:method)          { :unknown }
+    let(:include_private) { true     }
+
+    it { should be(false) }
+  end
+
+  context 'when the method is not an attribute name and include_private is false' do
+    let(:method)          { :unknown }
+    let(:include_private) { false    }
+
+    it { should be(false) }
+  end
+end

data/spec/unit/veritas/evaluator/context/send_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Evaluator::Context, '#send' do
+  subject { object.send(method, args, &block) }
+
+  let(:attribute) { Attribute::Integer.new(:id)         }
+  let(:header)    { Relation::Header.new([ attribute ]) }
+  let(:object)    { described_class.new(header) {}      }
+  let(:method)    { :test                               }
+  let(:args)      { mock('Arguments')                   }
+  let(:block)     { proc {}                             }
+
+  before do
+    def object.test(args, &block)
+      return args, block
+    end
+  end
+
+  it 'delegates the arguments to the method' do
+    subject[0].should equal(args)
+  end
+
+  it 'delegates the block to the method' do
+    subject[1].should equal(block)
+  end
+end