axiom 0.1.1 → 0.2.0

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

@@ -12,7 +12,7 @@ describe Relation, '.new' do
   context 'with no body' do
     subject { object.new(header) }
 
-    it { should be_instance_of(Relation::Materialized) }
+    it { should be_instance_of(Relation::Empty) }
 
     it { should be_empty }
   end
@@ -23,14 +23,14 @@ describe Relation, '.new' do
     it { should == body.dup }
 
     it 'does not freeze the body' do
-      body.should_not be_frozen
+      expect(body).not_to be_frozen
       expect { subject }.to_not change(body, :frozen?)
     end
   end
 
   context 'with a body that returns nil for #size' do
     before do
-      body.should_receive(:size).and_return(nil)
+      expect(body).to receive(:size).and_return(nil)
     end
 
     it { should be_instance_of(object) }
@@ -38,14 +38,14 @@ describe Relation, '.new' do
     it { should == body.dup }
 
     it 'does not freeze the body' do
-      body.should_not be_frozen
+      expect(body).not_to be_frozen
       expect { subject }.to_not change(body, :frozen?)
     end
   end
 
   context 'with a body that returns Float::INFINITY for #size' do
     before do
-      body.should_receive(:size).and_return(Float::INFINITY)
+      expect(body).to receive(:size).and_return(Float::INFINITY)
     end
 
     it { should be_instance_of(object) }
@@ -53,7 +53,7 @@ describe Relation, '.new' do
     it { should == body.dup }
 
     it 'does not freeze the body' do
-      body.should_not be_frozen
+      expect(body).not_to be_frozen
       expect { subject }.to_not change(body, :frozen?)
     end
   end
@@ -70,7 +70,7 @@ describe Relation, '.new' do
     it { should == body.dup }
 
     it 'does not freeze the body' do
-      body.should_not be_frozen
+      expect(body).not_to be_frozen
       expect { subject }.to_not change(body, :frozen?)
     end
   end

data/spec/unit/axiom/relation/directions_spec.rb

@@ -9,12 +9,12 @@ describe Relation, '#directions' do
   let(:object) { described_class.new([[:id, Integer]], body) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it_should_behave_like 'an idempotent method'
 
-  it { should be_instance_of(Relation::Operation::Order::DirectionSet) }
+  it { should be_instance_of(Relation::Operation::Sorted::DirectionSet) }
 
   it { should be_empty }
 end

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

@@ -11,19 +11,19 @@ describe Relation, '#each' do
   let(:yields) { []                                  }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it_should_behave_like 'an #each method'
 
   it 'yields only tuples' do
     subject
-    yields.each { |tuple| tuple.should be_instance_of(Tuple) }
+    yields.each { |tuple| expect(tuple).to be_instance_of(Tuple) }
   end
 
   it 'yields only tuples with the expected header' do
     subject
-    yields.each { |tuple| tuple.header.should be(object.header) }
+    yields.each { |tuple| expect(tuple.header).to be(object.header) }
   end
 
   it 'yields only tuples with the expected data' do
@@ -41,12 +41,12 @@ describe Relation do
   let(:object) { described_class           }
 
   before do
-    subject.should be_instance_of(object)
+    expect(subject).to be_instance_of(object)
   end
 
   it { should be_kind_of(Enumerable) }
 
   it 'case matches Enumerable' do
-    (Enumerable === subject).should be(true)
+    expect(Enumerable === subject).to be(true)
   end
 end

data/spec/unit/axiom/relation/element_reader_spec.rb

@@ -10,7 +10,7 @@ describe Relation, '#[]' do
   let(:object)    { described_class.new([attribute], LazyEnumerable.new) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it { should be(attribute) }

data/spec/unit/axiom/relation/empty/each_spec.rb

@@ -13,6 +13,6 @@ describe Relation::Empty, '#each' do
 
   it 'yields no tuples' do
     subject
-    yields.should be_empty
+    expect(yields).to be_empty
   end
 end

data/spec/unit/axiom/relation/empty_predicate_spec.rb

@@ -9,7 +9,7 @@ describe Relation, '#empty?' do
   let(:object) { described_class.new(header, body) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   context 'with a body containing no entries' do

data/spec/unit/axiom/relation/eql_spec.rb

@@ -10,7 +10,7 @@ describe Relation, '#eql?' do
   let(:object) { described_class.new(header, body) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   context 'with the same object' do

data/spec/unit/axiom/relation/equality_operator_spec.rb

@@ -10,7 +10,7 @@ describe Relation, '#==' do
   let(:object) { described_class.new(header, body) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   context 'with the same object' do

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

@@ -12,8 +12,8 @@ describe Relation::Header, '.coerce' do
     subject { object.coerce(argument, &block) }
 
     context 'when the argument is a Header' do
-      let(:argument) { header                            }
-      let(:block)    { proc { raise 'should not raise' } }
+      let(:argument) { header                          }
+      let(:block)    { proc { fail 'should not fail' } }
 
       it { should be(header) }
     end

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

@@ -26,7 +26,7 @@ describe Relation::Header, '.new' do
     it { should == attributes }
 
     it 'does not freeze the attributes' do
-      attributes.should_not be_frozen
+      expect(attributes).not_to be_frozen
       expect { subject }.to_not change(attributes, :frozen?)
     end
   end
@@ -42,12 +42,12 @@ describe Relation::Header, '.new' do
     it { should == attributes }
 
     it 'does not freeze the attributes' do
-      attributes.should_not be_frozen
+      expect(attributes).not_to be_frozen
       expect { subject }.to_not change(attributes, :frozen?)
     end
 
     it 'does not freeze the options' do
-      options.should_not be_frozen
+      expect(options).not_to be_frozen
       expect { subject }.to_not change(options, :frozen?)
     end
   end

data/spec/unit/axiom/relation/header/context_spec.rb

@@ -7,11 +7,11 @@ describe Relation::Header, '#context' do
 
   let(:object)    { described_class.coerce([attribute]) }
   let(:attribute) { Attribute::Integer.new(:id)         }
-  let(:block)     { ->(context) { }                     }
+  let(:block)     { ->(context) {}                      }
   let(:context)   { double('context')                   }
 
   before do
-    Axiom::Evaluator::Context.should_receive(:new).with(object)
+    expect(Evaluator::Context).to receive(:new).with(object)
       .and_yield(context)
       .and_return(context)
   end

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

@@ -13,7 +13,7 @@ describe Relation::Header, '#each' do
 
   it 'yields only attributes' do
     subject
-    yields.each { |attribute| attribute.should be_kind_of(Attribute) }
+    yields.each { |attribute| expect(attribute).to be_kind_of(Attribute) }
   end
 
   it 'yields each attribute' do
@@ -31,6 +31,6 @@ describe Relation::Header do
   it { should be_kind_of(Enumerable) }
 
   it 'case matches Enumerable' do
-    (Enumerable === subject).should be(true)
+    expect(Enumerable === subject).to be(true)
   end
 end

data/spec/unit/axiom/relation/header/extend_spec.rb

@@ -15,7 +15,7 @@ describe Relation::Header, '#extend' do
     it { should be_instance_of(described_class) }
 
     it 'uses the attribute object' do
-      subject[:name].should be(attribute)
+      expect(subject[:name]).to be(attribute)
     end
 
     its(:to_ary) { should == [[:id, Integer], [:name, String]] }

data/spec/unit/axiom/relation/header/{call_spec.rb → fetch_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-[:call, :[]].each do |method|
+[:fetch, :[]].each do |method|
   describe Relation::Header, "##{method}" do
     subject { object.send(method, name) }
 

data/spec/unit/axiom/relation/header/project_spec.rb

@@ -15,7 +15,7 @@ describe Relation::Header, '#project' do
     it { should be_instance_of(described_class) }
 
     it 'uses the attribute object' do
-      subject[:id].should be(attribute)
+      expect(subject[:id]).to be(attribute)
     end
 
     its(:to_ary) { should == [[:id, Integer]] }

data/spec/unit/axiom/relation/header/rename_spec.rb

@@ -6,14 +6,28 @@ describe Relation::Header, '#rename' do
   subject { object.rename(aliases) }
 
   let(:object)  { described_class.coerce([[:id, Integer], [:name, String]], keys: keys) }
-  let(:aliases) { Algebra::Rename::Aliases.coerce(object, id: :other_id)                }
+  let(:aliases) { { id: :other_id }                                                     }
   let(:keys)    { Relation::Keys.new([described_class.coerce([[:id, Integer]])])        }
 
-  it { should be_instance_of(described_class) }
+  context 'with aliases' do
+    let(:aliases) { Algebra::Rename::Aliases.coerce(object, super()) }
 
-  it { should_not be(object) }
+    it { should be_instance_of(described_class) }
 
-  its(:to_ary) { should == [[:other_id, Integer], [:name, String]] }
+    it { should_not be(object) }
 
-  its(:keys) { should eql(Relation::Keys.new([described_class.coerce([[:other_id, Integer]])])) }
+    its(:to_ary) { should == [[:other_id, Integer], [:name, String]] }
+
+    its(:keys) { should eql(Relation::Keys.new([described_class.coerce([[:other_id, Integer]])])) }
+  end
+
+  context 'with a Hash' do
+    it { should be_instance_of(described_class) }
+
+    it { should_not be(object) }
+
+    its(:to_ary) { should == [[:other_id, Integer], [:name, String]] }
+
+    its(:keys) { should eql(Relation::Keys.new([described_class.coerce([[:other_id, Integer]])])) }
+  end
 end

data/spec/unit/axiom/relation/header/size_spec.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Header, '#size' do
+  subject { object.size }
+
+  let(:object)     { described_class.new(attributes) }
+  let(:attributes) { [Attribute::Integer.new(:id)]   }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(1) }
+end

data/spec/unit/axiom/relation/header_spec.rb

@@ -9,7 +9,7 @@ describe Relation, '#header' do
   let(:object) { described_class.new(header, LazyEnumerable.new) }
 
   before do
-    object.should be_instance_of(described_class)
+    expect(object).to be_instance_of(described_class)
   end
 
   it_should_behave_like 'an idempotent method'

data/spec/unit/axiom/relation/index/each_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Index, '#each' do
+  subject { described_class.new(key, header) << tuple }
+
+  let(:key)    { Relation::Header.coerce([[:id, Integer]])                  }
+  let(:header) { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:tuple)  { Tuple.new(header, [1, 'John Doe'])                         }
+
+  context 'with a block' do
+    it 'returns an index' do
+      expect(subject.each {}).to be_instance_of(described_class)
+    end
+
+    it 'yields each key and tuples' do
+      expect { |block| subject.each(&block) }
+        .to yield_with_args([[1], Set[tuple]])
+    end
+  end
+
+  context 'without a block' do
+    it 'returns an enumerator' do
+      expect(subject.each).to be_instance_of(to_enum.class)
+    end
+
+    it 'yields each key and tuples' do
+      expect { |block| subject.each.each(&block) }
+        .to yield_with_args([[1], Set[tuple]])
+    end
+  end
+end

data/spec/unit/axiom/relation/index/element_reader_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Index, '#[]' do
+  subject { object[tuple] }
+
+  let(:object) { described_class.new(key, header)                           }
+  let(:key)    { Relation::Header.coerce([[:id, Integer]])                  }
+  let(:header) { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:tuple)  { Tuple.new(header, [1, 'John Doe'])                         }
+
+  it 'returns the tuples in the index' do
+    object << tuple
+    expect(object[tuple]).to eql(Set[tuple])
+  end
+end

data/spec/unit/axiom/relation/index/left_shift_operator_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Index, '#<<' do
+  subject { object << tuple }
+
+  let(:object) { described_class.new(key, header.project(name_only))        }
+  let(:key)    { Relation::Header.coerce([[:id, Integer]])                  }
+  let(:header) { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:tuple)  { Tuple.new(header, [1, 'John Doe'])                         }
+
+  let(:name_only) do
+    header.project([:name])
+  end
+
+  it_should_behave_like 'a command method'
+
+  it 'adds the tuple to the index' do
+    expect { subject }.to change { object[tuple] }
+      .from(Set[]).to(Set[tuple.project(name_only)])
+  end
+end

data/spec/unit/axiom/relation/index/merge_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Index, '#merge' do
+  subject { object.merge(tuples) }
+
+  let(:object) { described_class.new(key, header)                           }
+  let(:key)    { Relation::Header.coerce([[:id, Integer]])                  }
+  let(:header) { Relation::Header.coerce([[:id, Integer], [:name, String]]) }
+  let(:tuples) { [tuple]                                                    }
+  let(:tuple)  { Tuple.new(header, [1, 'John Doe'])                         }
+
+  it_should_behave_like 'a command method'
+
+  it 'add the tuples to the index' do
+    expect { subject }.to change { object[tuple] }.from(Set[]).to(Set[tuple])
+  end
+end

data/spec/unit/axiom/relation/keys/class_methods/coerce_spec.rb

@@ -16,9 +16,26 @@ describe Relation::Keys, '.coerce' do
   context 'when the argument responds to #to_ary' do
     let(:argument) { [[[:id]]] }
 
-    it { should be_instance_of(object) }
+    context 'with a block' do
+      subject { object.coerce(argument, &block) }
 
-    it { should == [Relation::Header.coerce([:id])] }
+      let(:block) { ->(attributes) { Relation::Header.coerce(attributes) } }
+
+      it { should be_instance_of(object) }
+
+      it { should == [Relation::Header.coerce([:id])] }
+
+      it 'yields the attributes' do
+        expect { |block| object.coerce(argument, &block) }
+          .to yield_successive_args(*argument)
+      end
+    end
+
+    context 'without a block' do
+      it { should be_instance_of(object) }
+
+      it { should == [Relation::Header.coerce([:id])] }
+    end
   end
 
   context 'when the argument is not a Keys and does not respond to #to_ary' do