axiom 0.1.1 → 0.2.0

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Unwrap, '#each' do
+  subject { object }
+
+  let(:object)   { described_class.new(relation, :names)           }
+  let(:relation) { Relation.new(header, body).wrap(names: [:name]) }
+  let(:header)   { [[:id, Integer], [:name, String]]               }
+  let(:body)     { [[1, 'John Doe']]                               }
+
+  it_should_behave_like 'an #each method'
+
+  it 'is a command method' do
+    expect(subject.each(&EMPTY_PROC)).to be(object)
+  end
+
+  it 'yields only tuples' do
+    expect { |block| subject.each(&block) }.to yield_with_args(Tuple)
+  end
+
+  it 'yields only tuples with the expected header' do
+    tuples = []
+    subject.each(&tuples.method(:<<))
+    expect(tuples.first.header).to eq(header)
+  end
+
+  it 'yields only tuples with the expected data' do
+    expect { |block| subject.each(&block) }
+      .to yield_with_args([1, 'John Doe'])
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Unwrap, '#header' do
+  subject { object.header }
+
+  let(:object)   { described_class.new(relation, :names)         }
+  let(:relation) { Relation.new(header, []).wrap(names: [:name]) }
+  let(:header)   { [[:id, Integer], [:name, String]]             }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Relation::Header) }
+
+  it 'returns the expected attributes' do
+    should == header
+  end
+end

data/spec/unit/axiom/relation/operation/unwrap/methods/unwrap_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Unwrap::Methods, '#unwrap' do
+  subject { object.unwrap(name) }
+
+  let(:object)          { relation.wrap(name => attributes) }
+  let(:described_class) { Relation                          }
+  let(:relation)        { described_class.new(header, body) }
+  let(:header)          { [[:id, Integer], [:name, String]] }
+  let(:body)            { [[1, 'John Doe']]                 }
+  let(:name)            { :names                            }
+  let(:attributes)      { [:name]                           }
+
+  it { should be_instance_of(Relation::Operation::Unwrap) }
+
+  its(:header) { should == header }
+
+  its(:to_a) { should eq([[1, 'John Doe']]) }
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Wrap, '#each' do
+  subject { object }
+
+  let(:object)   { described_class.new(relation, :names, [:name]) }
+  let(:relation) { Relation.new(header, body)                     }
+  let(:header)   { [[:id, Integer], [:name, String]]              }
+  let(:body)     { [[1, 'John Doe']]                              }
+
+  it_should_behave_like 'an #each method'
+
+  it 'is a command method' do
+    expect(subject.each(&EMPTY_PROC)).to be(object)
+  end
+
+  it 'yields only tuples' do
+    expect { |block| subject.each(&block) }.to yield_with_args(Tuple)
+  end
+
+  it 'yields only tuples with the expected header' do
+    tuples = []
+    subject.each(&tuples.method(:<<))
+    expect(tuples.first.header).to be(object.header)
+  end
+
+  it 'yields only tuples with the expected data' do
+    expect { |block| subject.each(&block) }
+      .to yield_with_args([1, ['John Doe']])
+  end
+end

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Wrap, '#header' do
+  subject { object.header }
+
+  let(:object)   { described_class.new(relation, :names, [:name]) }
+  let(:relation) { Relation.new(header, [])                       }
+  let(:header)   { [[:id, Integer], [:name, String]]              }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be_instance_of(Relation::Header) }
+
+  it 'returns the expected attributes' do
+    should == [
+      Attribute::Integer.new(:id),
+      Attribute::Tuple.new(:names, header: [[:name, String]]),
+    ]
+  end
+end

data/spec/unit/axiom/relation/operation/wrap/methods/wrap_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Relation::Operation::Wrap::Methods, '#wrap' do
+  subject { object.wrap(name => attributes) }
+
+  let(:object)          { described_class.new(header, body) }
+  let(:described_class) { Relation                          }
+  let(:header)          { [[:id, Integer], [:name, String]] }
+  let(:body)            { [[1, 'John Doe']]                 }
+  let(:name)            { :names                            }
+  let(:attributes)      { [:name]                           }
+
+  it { should be_instance_of(Relation::Operation::Wrap) }
+
+  its(:header) do
+    should == [
+      Attribute::Integer.new(:id),
+      Attribute::Tuple.new(:names, header: [[:name, String]]),
+    ]
+  end
+
+  its(:to_a) { should eq([[1, ['John Doe']]]) }
+end

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

@@ -25,12 +25,12 @@ describe Relation::Proxy, '#each' do
 
   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

data/spec/unit/axiom/relation/proxy/respond_to_predicate_spec.rb

@@ -3,8 +3,6 @@
 require 'spec_helper'
 
 describe Relation::Proxy, '#respond_to?' do
-  subject { object.respond_to?(method) }
-
   let(:object)          { described_class.new(relation)        }
   let(:described_class) { Class.new(Relation)                  }
   let(:relation)        { Relation.new([[:id, Integer]], body) }
@@ -20,21 +18,59 @@ describe Relation::Proxy, '#respond_to?' do
     end
   end
 
-  context 'with a known method in the proxy' do
-    let(:method) { :header }
+  context 'with include_all as false (the default)' do
+    subject { object.respond_to?(method) }
 
-    it { should be(true) }
-  end
+    context 'with a known method in the proxy' do
+      let(:method) { :header }
+
+      it { should be(true) }
+    end
+
+    context 'with a known method in the relation' do
+      let(:method) { :each }
 
-  context 'with a known method in the relation' do
-    let(:method) { :each }
+      it { should be(true) }
+    end
 
-    it { should be(true) }
+    context 'with an unknown method' do
+      let(:method) { :unknown }
+
+      it { should be(false) }
+    end
+
+    context 'with a private method' do
+      let(:method) { :initialize }
+
+      it { should be(false) }
+    end
   end
 
-  context 'with an unknown method' do
-    let(:method) { :unknown }
+  context 'with include_all as true' do
+    subject { object.respond_to?(method, true) }
 
-    it { should be(false) }
+    context 'with a known method in the proxy' do
+      let(:method) { :header }
+
+      it { should be(true) }
+    end
+
+    context 'with a known method in the relation' do
+      let(:method) { :each }
+
+      it { should be(true) }
+    end
+
+    context 'with an unknown method' do
+      let(:method) { :unknown }
+
+      it { should be(false) }
+    end
+
+    context 'with a private method' do
+      let(:method) { :initialize }
+
+      it { should be(true) }
+    end
   end
 end

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

@@ -20,18 +20,18 @@ describe Relation, '#replace' do
 
     it 'applies the left operations in the correct sequence' do
       subject = self.subject.left
-      subject.should be_instance_of(Relation::Operation::Deletion)
-      subject.left.should be(object)
-      subject.right.should be_instance_of(Algebra::Difference)
-      subject.right.left.should be(object)
-      subject.right.right.should eql(other_relation)
+      expect(subject).to be_instance_of(Relation::Operation::Deletion)
+      expect(subject.left).to be(object)
+      expect(subject.right).to be_instance_of(Algebra::Difference)
+      expect(subject.right.left).to be(object)
+      expect(subject.right.right).to eql(other_relation)
     end
 
     it 'applies the right operations in the correct sequence' do
       subject = self.subject.right
-      subject.should be_instance_of(Algebra::Difference)
-      subject.left.should eql(other_relation)
-      subject.right.should be(object)
+      expect(subject).to be_instance_of(Algebra::Difference)
+      expect(subject.left).to eql(other_relation)
+      expect(subject.right).to be(object)
     end
   end
 

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

@@ -15,7 +15,7 @@ describe Tuple, '.coerce' do
     it { should be(argument) }
   end
 
-  context 'when the argument responds to #to_ary' do
+  context 'when the argument responds to #to_ary and is the same size as the header' do
     let(:argument) { [1] }
 
     it { should be_instance_of(object) }
@@ -23,6 +23,12 @@ describe Tuple, '.coerce' do
     it { should eql(tuple) }
   end
 
+  context 'when the argument responds to #to_ary and is not the same size as the header' do
+    let(:argument) { [1, 2] }
+
+    it { should be(argument) }
+  end
+
   context 'when the argument is not a Tuple and does not respond to #to_ary' do
     let(:argument) { { id: 1 } }
 

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

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

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

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

data/spec/unit/axiom/tuple/rename_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Tuple, '#rename' do
+  subject { object.rename(new_header) }
+
+  let(:object)     { described_class.new(header, [1])                }
+  let(:header)     { Relation::Header.coerce([[:id, Integer]])       }
+  let(:new_header) { Relation::Header.coerce([[:other_id, Integer]]) }
+
+  it { should be_instance_of(described_class) }
+
+  its(:header) { should be(new_header) }
+
+  its(:to_ary) { should == [1] }
+end

data/spec/unit/axiom/tuple/size_spec.rb

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

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

@@ -5,14 +5,31 @@ require 'spec_helper'
 describe Tuple, '#to_ary' do
   subject { object.to_ary }
 
+  let(:object) { described_class.new(header, body)         }
   let(:header) { Relation::Header.coerce([[:id, Integer]]) }
-  let(:object) { described_class.new(header, [1])          }
+  let(:body)   { [1]                                       }
 
-  it_should_behave_like 'an idempotent method'
+  context 'when the body is frozen' do
+    let(:body) { super().freeze }
 
-  it { should be_instance_of(Array) }
+    it_should_behave_like 'an idempotent method'
 
-  it { should be_frozen }
+    it { should be_instance_of(Array) }
 
-  it { should == [1] }
+    it { should be_frozen }
+
+    it { should be(body) }
+  end
+
+  context 'when the body is frozen' do
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_instance_of(Array) }
+
+    it { should be_frozen }
+
+    it { should_not be(body) }
+
+    it { should eql(body) }
+  end
 end

data/spec/unit/axiom/tuple/to_hash_spec.rb

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

data/spec/unit/axiom/types/relation/class_methods/primitive_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Types::Relation, '.primitive' do
+  subject { object.primitive }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Relation) }
+end

data/spec/unit/axiom/types/tuple/class_methods/primitive_spec.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Types::Tuple, '.primitive' do
+  subject { object.primitive }
+
+  let(:object) { described_class }
+
+  it_should_behave_like 'an idempotent method'
+
+  it { should be(Tuple) }
+end