axiom 0.1.0 → 0.1.1

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

@@ -5,16 +5,19 @@ require 'spec_helper'
 describe Algebra::Summarization::Summary, '#summarize_by' do
   subject { object.summarize_by(projection, tuple) }
 
-  let(:object)     { described_class.new(summarizer)                       }
-  let(:summarizer) { lambda { |accumulator, tuple| accumulator.to_i.succ } }
-  let(:header)     { Relation::Header.coerce([ [ :id, Integer ] ])         }
-  let(:tuple)      { Tuple.new(header, [ 1 ])                              }
-  let(:projection) { tuple.project([])                                     }
+  let(:object)     { described_class.new(summarizer)                  }
+  let(:summarizer) { ->(accumulator, tuple) { accumulator.to_i.succ } }
+  let(:header)     { Relation::Header.coerce([[:id, Integer]])        }
+  let(:tuple)      { Tuple.new(header, [1])                           }
+  let(:projection) { tuple.project([])                                }
 
   it_should_behave_like 'a command method'
 
   it 'aggregates the value returned by the summarizer' do
-    2.times { subject; __memoized.delete(:subject) }  # bypass subject cache
+    2.times do
+      subject
+      __memoized.delete(:subject)  # bypass subject cache
+    end
     object.call(projection).should eql(2)
   end
 end

data/spec/unit/axiom/algebra/union/delete_spec.rb

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Algebra::Union, '#delete' do
   subject { object.delete(other) }
 
-  let(:object)         { described_class.new(left, right)       }
-  let(:left)           { Relation.new(header, [ [ 1 ], [ 2 ] ]) }
-  let(:right)          { Relation.new(header, [ [ 2 ], [ 3 ] ]) }
-  let(:other_relation) { Relation.new(header, [ [ 2 ] ])        }
-  let(:header)         { [ [ :id, Integer ] ]                   }
+  let(:object)         { described_class.new(left, right) }
+  let(:left)           { Relation.new(header, [[1], [2]]) }
+  let(:right)          { Relation.new(header, [[2], [3]]) }
+  let(:other_relation) { Relation.new(header, [[2]])      }
+  let(:header)         { [[:id, Integer]]                 }
 
   shared_examples_for 'Algebra::Union#delete' do
     it { should be_instance_of(described_class) }
@@ -20,7 +20,7 @@ describe Algebra::Union, '#delete' do
     its(:header) { should == header }
 
     it 'deletes the tuples' do
-      should == [ [ 1 ], [ 3 ] ]
+      should == [[1], [3]]
     end
   end
 

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

@@ -6,8 +6,8 @@ describe Algebra::Union, '#each' do
   subject { object.each { |tuple| yields << tuple } }
 
   let(:object) { described_class.new(left, right) }
-  let(:left)   { Relation.new(header, [ [ 1 ] ])  }
-  let(:header) { [ [ :id, Integer ] ]             }
+  let(:left)   { Relation.new(header, [[1]])      }
+  let(:header) { [[:id, Integer]]                 }
   let(:yields) { []                               }
 
   context 'with relations having similar bodies' do
@@ -26,14 +26,14 @@ describe Algebra::Union, '#each' do
     end
 
     it 'yields only tuples with the expected data' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to([ [ 1 ] ])
+      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(:right) { Relation.new(header, [[2]]) }
 
     it_should_behave_like 'an #each method'
 
@@ -48,9 +48,9 @@ describe Algebra::Union, '#each' do
     end
 
     it 'yields only tuples with the expected data' do
-      expect { subject }.to change { yields.dup }.
-        from([]).
-        to([ [ 1 ], [ 2 ] ])
+      expect { subject }.to change { yields.dup }
+        .from([])
+        .to([[1], [2]])
     end
   end
 end

data/spec/unit/axiom/algebra/union/insert_spec.rb

@@ -6,10 +6,10 @@ describe Algebra::Union, '#insert' do
   subject { object.insert(other) }
 
   let(:object)         { described_class.new(left, right) }
-  let(:left)           { Relation.new(header, [ [ 1 ] ])  }
-  let(:right)          { Relation.new(header, [ [ 2 ] ])  }
-  let(:other_relation) { Relation.new(header, [ [ 3 ] ])  }
-  let(:header)         { [ [ :id, Integer ] ]             }
+  let(:left)           { Relation.new(header, [[1]])      }
+  let(:right)          { Relation.new(header, [[2]])      }
+  let(:other_relation) { Relation.new(header, [[3]])      }
+  let(:header)         { [[:id, Integer]]                 }
 
   shared_examples_for 'Algebra::Union#insert' do
     it { should be_instance_of(described_class) }
@@ -20,7 +20,7 @@ describe Algebra::Union, '#insert' do
     its(:header) { should == header }
 
     it 'inserts the tuples' do
-      should == [ [ 1 ], [ 2 ], [ 3 ] ]
+      should == [[1], [2], [3]]
     end
   end
 

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

@@ -2,14 +2,14 @@
 
 require 'spec_helper'
 
-[ :union, :| ].each do |method|
+[:union, :|].each do |method|
   describe Algebra::Union::Methods, "##{method}" do
     subject { object.send(method, other) }
 
-    let(:described_class) { Relation                                                   }
-    let(:header)          { [ [ :id, Integer ] ]                                       }
-    let(:other)           { described_class.new(header, LazyEnumerable.new([ [ 2 ] ])) }
-    let(:object)          { described_class.new(header, LazyEnumerable.new([ [ 1 ] ])) }
+    let(:described_class) { Relation                                               }
+    let(:header)          { [[:id, Integer]]                                       }
+    let(:other)           { described_class.new(header, LazyEnumerable.new([[2]])) }
+    let(:object)          { described_class.new(header, LazyEnumerable.new([[1]])) }
 
     it { should be_instance_of(Algebra::Union) }
 

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

@@ -6,23 +6,23 @@ require File.expand_path('../fixtures/classes', __FILE__)
 describe Aliasable, '#inheritable_alias' do
   subject { object.inheritable_alias(aliases) }
 
-  let(:aliases)   { { :other => :test }               }
+  let(:aliases)   { { other: :test }                  }
   let(:object)    { Class.new(AliasableSpecs::Object) }
   let(:aliasable) { object.new                        }
 
   it_should_behave_like 'a command method'
 
   it 'creates a method #other' do
-    expect { subject }.to change { aliasable.respond_to?(:other) }.
-      from(false).
-      to(true)
+    expect { subject }.to change { aliasable.respond_to?(:other) }
+      .from(false)
+      .to(true)
   end
 
   it 'aliases #other to #test' do
     subject
-    retval = mock('Return Value')
+    retval = double('Return Value')
     aliasable.should_receive(:test).and_return(retval)
-    aliasable.other.should equal(retval)
+    aliasable.other.should be(retval)
   end
 
   specification = proc do

data/spec/unit/axiom/attribute/{date/class_methods/primitive_spec.rb → boolean/class_methods/type_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe Attribute::Date, '.primitive' do
-  subject { object.primitive }
+describe Attribute::Boolean, '.type' do
+  subject { object.type }
 
   let(:object) { described_class }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(Date) }
+  it { should be(Types::Boolean) }
 end

data/spec/unit/axiom/attribute/boolean/{valid_value_predicate_spec.rb → include_predicate_spec.rb}

@@ -2,8 +2,8 @@
 
 require 'spec_helper'
 
-describe Attribute::Boolean, '#valid_value?' do
-  subject { object.valid_value?(value) }
+describe Attribute::Boolean, '#include?' do
+  subject { object.include?(value) }
 
   let(:object) { described_class.new(:boolean) }
 

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

@@ -5,10 +5,14 @@ require 'spec_helper'
 describe Attribute, '#call' do
   subject { object.call(tuple) }
 
-  let(:described_class) { Class.new(Attribute)             }
-  let(:object)          { described_class.new(:name)       }
-  let(:header)          { Relation::Header.new([ object ]) }
-  let(:tuple)           { Tuple.new(header, [ 1 ])         }
+  let(:described_class) { Class.new(Attribute)           }
+  let(:object)          { described_class.new(:name)     }
+  let(:header)          { Relation::Header.new([object]) }
+  let(:tuple)           { Tuple.new(header, [1])         }
+
+  before do
+    described_class.stub(type: Types::Object)
+  end
 
   it { should == 1 }
 end

data/spec/unit/axiom/attribute/{time/class_methods/primitive_spec.rb → class/class_methods/type_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe Attribute::Time, '.primitive' do
-  subject { object.primitive }
+describe Attribute::Class, '.type' do
+  subject { object.type }
 
   let(:object) { described_class }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(Time) }
+  it { should be(Types::Class) }
 end

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

@@ -10,11 +10,11 @@ describe Attribute, '.coerce' do
   context 'when the argument is an Attribute' do
     let(:argument) { Attribute::Integer.new(:id) }
 
-    it { should equal(argument) }
+    it { should be(argument) }
   end
 
   context 'when the argument responds to #to_ary and does not include options' do
-    let(:argument) { [ :id, Integer ] }
+    let(:argument) { [:id, Integer] }
 
     it { should be_instance_of(Attribute::Integer) }
 
@@ -22,7 +22,7 @@ describe Attribute, '.coerce' do
   end
 
   context 'when the argument responds to #to_ary and includes options' do
-    let(:argument) { [ :id, Integer, { :required => false } ] }
+    let(:argument) { [:id, Integer, { required: false }] }
 
     it { should be_instance_of(Attribute::Integer) }
 
@@ -54,11 +54,11 @@ describe Attribute::Boolean, '.coerce' do
   context 'when the argument is an Attribute' do
     let(:argument) { Attribute::Integer.new(:id) }
 
-    it { should equal(argument) }
+    it { should be(argument) }
   end
 
   context 'when the argument responds to #to_ary and does not include options' do
-    let(:argument) { [ :id, Integer ] }
+    let(:argument) { [:id, Integer] }
 
     it { should be_instance_of(Attribute::Integer) }
 
@@ -66,7 +66,7 @@ describe Attribute::Boolean, '.coerce' do
   end
 
   context 'when the argument responds to #to_ary and includes options' do
-    let(:argument) { [ :id, Integer, { :required => false } ] }
+    let(:argument) { [:id, Integer, { required: false }] }
 
     it { should be_instance_of(Attribute::Integer) }
 

data/spec/unit/axiom/attribute/class_methods/infer_type_spec.rb

@@ -11,7 +11,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { Attribute::Integer.new(:id) }
 
     it 'returns the type of the attribute' do
-      should equal(operand.type)
+      should be(operand.type)
     end
   end
 
@@ -19,7 +19,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { Attribute::String.new(:name).length }
 
     it 'returns the type of the function' do
-      should equal(operand.type)
+      should be(operand.type)
     end
   end
 
@@ -27,7 +27,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { Attribute::Integer.new(:id).sum }
 
     it 'returns the type of the function' do
-      should equal(operand.type)
+      should be(operand.type)
     end
   end
 
@@ -35,7 +35,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { true }
 
     it 'returns a Boolean type' do
-      should equal(Attribute::Boolean)
+      should be(Types::Boolean)
     end
   end
 
@@ -43,7 +43,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { false }
 
     it 'returns a Boolean type' do
-      should equal(Attribute::Boolean)
+      should be(Types::Boolean)
     end
   end
 
@@ -51,7 +51,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { Class.new }
 
     it 'returns a Class type' do
-      should equal(Attribute::Class)
+      should be(Types::Class)
     end
   end
 
@@ -59,7 +59,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { DateTime.now }
 
     it 'returns a DateTime type' do
-      should equal(Attribute::DateTime)
+      should be(Types::DateTime)
     end
   end
 
@@ -67,7 +67,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { Date.today }
 
     it 'returns a Date type' do
-      should equal(Attribute::Date)
+      should be(Types::Date)
     end
   end
 
@@ -75,7 +75,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { BigDecimal('1') }
 
     it 'returns a Decimal type' do
-      should equal(Attribute::Decimal)
+      should be(Types::Decimal)
     end
   end
 
@@ -83,7 +83,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { 1.0 }
 
     it 'returns a Float type' do
-      should equal(Attribute::Float)
+      should be(Types::Float)
     end
   end
 
@@ -91,7 +91,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { 1 }
 
     it 'returns an Integer type' do
-      should equal(Attribute::Integer)
+      should be(Types::Integer)
     end
   end
 
@@ -99,7 +99,7 @@ describe Attribute, '.infer_type' do
     let(:operand) { 'string' }
 
     it 'returns an String type' do
-      should equal(Attribute::String)
+      should be(Types::String)
     end
   end
 
@@ -107,15 +107,15 @@ describe Attribute, '.infer_type' do
     let(:operand) { Time.now }
 
     it 'returns an Time type' do
-      should equal(Attribute::Time)
+      should be(Types::Time)
     end
   end
 
   context 'when the operand is an unhandled type' do
-    let(:operand) { mock('Unhandled') }
+    let(:operand) { double('Unhandled') }
 
     it 'returns an Object type' do
-      should equal(Attribute::Object)
+      should be(Types::Object)
     end
   end
 end

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

@@ -10,19 +10,19 @@ describe Attribute, '.name_from' do
   context 'argument is an Attribute' do
     let(:argument) { Attribute::Integer.new(:id) }
 
-    it { should equal(:id) }
+    it { should be(:id) }
   end
 
   context 'argument that responds to #to_ary' do
-    let(:argument) { [ :id, Integer ] }
+    let(:argument) { [:id, Integer] }
 
-    it { should equal(:id) }
+    it { should be(:id) }
   end
 
   context 'argument that responds to #to_sym' do
     let(:argument) { 'id' }
 
-    it { should equal(:id) }
+    it { should be(:id) }
   end
 
   context 'argument that is not an Attribute, does not respond to #to_ary or #to_sym' do

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

@@ -20,7 +20,7 @@ describe Attribute, '.new' do
     Attribute::Object,
     Attribute::String,
     Attribute::Time,
-  ].each do |described_class|
+ ].each do |described_class|
     context "when called on the Attribute subclass #{described_class}" do
       let(:object) { described_class }
 

data/spec/unit/axiom/attribute/{float/class_methods/primitive_spec.rb → date/class_methods/type_spec.rb}

@@ -2,12 +2,12 @@
 
 require 'spec_helper'
 
-describe Attribute::Float, '.primitive' do
-  subject { object.primitive }
+describe Attribute::Date, '.type' do
+  subject { object.type }
 
   let(:object) { described_class }
 
   it_should_behave_like 'an idempotent method'
 
-  it { should equal(Float) }
+  it { should be(Types::Date) }
 end