axiom 0.1.0 → 0.1.1

data/spec/integration/axiom/relation/efficient_enumerable_spec.rb

@@ -9,14 +9,14 @@ class InfiniteList
   include Enumerable
 
   def each(&block)
-    0.upto(Float::INFINITY) { |index| yield [ index ] }
+    0.upto(Float::INFINITY) { |index| yield [index] }
     self
   end
 end
 
 describe Relation do
   context 'Efficient Enumerable operation' do
-    let(:relation) { Relation.new([ [ :id, Integer ] ], InfiniteList.new) }
+    let(:relation) { Relation.new([[:id, Integer]], InfiniteList.new) }
 
     def sample(relation)
       Timeout.timeout(1) do
@@ -25,59 +25,59 @@ describe Relation do
     end
 
     it '#project should be efficient' do
-      projected = relation.project([ :id ])
-      sample(projected).should == [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]
+      projected = relation.project([:id])
+      sample(projected).should == [[0], [1], [2], [3], [4]]
     end
 
     it '#restrict should be efficient' do
-      restricted = relation.restrict{ |r| r.id.gt(5) }
-      sample(restricted).should == [ [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ] ]
+      restricted = relation.restrict { |r| r.id.gt(5) }
+      sample(restricted).should == [[6], [7], [8], [9], [10]]
     end
 
     it '#rename should be efficient' do
-      renamed = relation.rename(:id => :other_id)
-      sample(renamed).should == [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]
+      renamed = relation.rename(id: :other_id)
+      sample(renamed).should == [[0], [1], [2], [3], [4]]
     end
 
     describe '#join should be efficient' do
-      let(:other) { Relation.new([ [ :id, Integer ], [ :name, String ] ], [ [ 1, 'Dan Kubb' ] ]) }
+      let(:other) { Relation.new([[:id, Integer], [:name, String]], [[1, 'Dan Kubb']]) }
 
       it 'has an infinite left relation' do
         pending 'Change #join to handle infinite sets'
         join = other.join(relation)
-        sample(join).should == [ [ 1, 'Dan Kubb' ] ]
+        sample(join).should == [[1, 'Dan Kubb']]
       end
 
       it 'has an infinite right relation' do
         pending 'Change #join to handle infinite sets'
         join = relation.join(other)
-        sample(join).should == [ [ 1, 'Dan Kubb' ] ]
+        sample(join).should == [[1, 'Dan Kubb']]
       end
     end
 
     describe '#product should be efficient' do
-      let(:other) { Relation.new([ [ :name, String ] ], [ [ 'Dan Kubb' ] ]) }
+      let(:other) { Relation.new([[:name, String]], [['Dan Kubb']]) }
 
       it 'has an infinite left relation' do
         product = relation.product(other)
-        sample(product).should == [ [ 0, 'Dan Kubb' ], [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 3, 'Dan Kubb' ], [ 4, 'Dan Kubb' ] ]
+        sample(product).should == [[0, 'Dan Kubb'], [1, 'Dan Kubb'], [2, 'Dan Kubb'], [3, 'Dan Kubb'], [4, 'Dan Kubb']]
       end
 
       it 'has an infinite right relation' do
         pending 'Change #product to handle infinite sets'
         product = other.product(relation)
-        sample(product).should == [ [ 0, 'Dan Kubb' ], [ 1, 'Dan Kubb' ], [ 2, 'Dan Kubb' ], [ 3, 'Dan Kubb' ], [ 4, 'Dan Kubb' ] ]
+        sample(product).should == [[0, 'Dan Kubb'], [1, 'Dan Kubb'], [2, 'Dan Kubb'], [3, 'Dan Kubb'], [4, 'Dan Kubb']]
       end
     end
 
     it '#difference should be efficient' do
-      difference = relation.difference(Relation.new(relation.header, [ [ 1 ] ]))
-      sample(difference).should == [ [ 0 ], [ 2 ], [ 3 ], [ 4 ], [ 5 ] ]
+      difference = relation.difference(Relation.new(relation.header, [[1]]))
+      sample(difference).should == [[0], [2], [3], [4], [5]]
     end
 
     it '#union should be efficient' do
-      union = relation.union(Relation.new(relation.header, [ [ 1 ] ]))
-      sample(union).should == [ [ 0 ], [ 1 ], [ 2 ], [ 3 ], [ 4 ] ]
+      union = relation.union(Relation.new(relation.header, [[1]]))
+      sample(union).should == [[0], [1], [2], [3], [4]]
     end
   end
 end

data/spec/integration/axiom/relation/mutable_enumerator_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+# Test that tuple enumerators are not frozen
+
+class MutableEnumerator < Enumerator
+  attr_reader :mutable_array
+
+  def initialize(tuples)
+    @mutable_array = []
+    super() do |yielder|
+      tuples.each do |tuple|
+        @mutable_array << tuple
+        yielder << tuple
+      end
+    end
+  end
+end
+
+describe Relation do
+  context 'with a tuple enumerator' do
+    let(:relation)   { Relation.new([[:id, Integer]], enumerator) }
+    let(:enumerator) { MutableEnumerator.new(tuples)              }
+    let(:tuples)     { [[1], [2]]                                 }
+
+    context 'when the enumerator is materialized' do
+      it 'does not freeze the enumerator' do
+        expect { relation.materialize }
+          .to_not change(enumerator, :frozen?).from(false)
+      end
+
+      it 'allows the array to be mutated' do
+        expect { relation.materialize }
+          .to change(enumerator, :mutable_array).from([]).to(tuples)
+      end
+    end
+
+    context 'when the enumerator is materialized and restricted' do
+      it 'does not freeze the enumerator' do
+        expect { relation.restrict(id: 1).materialize }
+          .to_not change(enumerator, :frozen?).from(false)
+      end
+
+      it 'allows the array to be mutated' do
+        expect { relation.restrict(id: 1).materialize }
+          .to change(enumerator, :mutable_array).from([]).to(tuples)
+      end
+    end
+  end
+end

data/spec/integration/axiom/relation/variable/thread_safe_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+# Test that Relation::Variable is thread-safe
+
+describe Relation::Variable do
+  subject { described_class.new(relation) }
+
+  let(:object)       { described_class.new(relation)  }
+  let(:relation)     { Relation.new([[:id, Integer]]) }
+  let(:thread_count) { 10                             }
+  let(:per_thread)   { 10                             }
+
+  # Perform operation in parallel within multiple threads
+  def parallel(operation)
+    relvar = subject
+    thread_count.times.map do |index|
+      offset = index * per_thread
+      Thread.new do
+        per_thread.times do |id|
+          relvar.public_send(operation, [[id + offset]])
+        end
+      end
+    end.each(&:join)
+  end
+
+  describe '#insert' do
+    it 'is thread-safe' do
+      parallel(:insert)
+      expect(subject.count).to be(thread_count * per_thread)
+    end
+  end
+
+  describe '#delete' do
+    before do
+      parallel(:insert)
+    end
+
+    it 'is thread-safe' do
+      parallel(:delete)
+      expect(subject).to be_empty
+    end
+  end
+end

data/spec/integration/axiom/relation/writable_relations_spec.rb

@@ -6,62 +6,62 @@ describe Relation do
   context 'Relations are writable' do
     let(:relation) do
       Relation.new(
-        [ [ :id, Integer ], [ :name, String, { :required => false } ] ],
-        [ [ 1, 'John Doe' ], [ 2, 'Jane Doe' ], [ 3, 'Jane Roe' ] ]
+        [[:id, Integer], [:name, String, { required: false }]],
+        [[1, 'John Doe'], [2, 'Jane Doe'], [3, 'Jane Roe']]
       )
     end
 
     it 'Rename#insert and #delete of a disjoint relation are symmetrical' do
-      rename = relation.rename(:id => :other_id)
-      other  = [ [ 4, 'John Doe' ] ]
+      rename = relation.rename(id: :other_id)
+      other  = [[4, 'John Doe']]
       rename.insert(other).delete(other).should == rename
     end
 
     it 'Projection#insert and #delete of a disjoint relation are symmetrical' do
-      projection = relation.project([ :id ])
-      other      = [ [ 4 ] ]
+      projection = relation.project([:id])
+      other      = [[4]]
       projection.insert(other).delete(other).should == projection
     end
 
     it 'Extension#insert and #delete of a disjoint relation are symmetrical' do
       extension = relation.extend { |r| r.add(:age, 30) }
-      other     = Relation.new(relation.header, [ [ 4, 'John Doe' ] ]).extend(extension.extensions)
+      other     = Relation.new(relation.header, [[4, 'John Doe']]).extend(extension.extensions)
       extension.insert(other).delete(other).should == extension
     end
 
     it 'Restriction#insert and #delete of a disjoint relation are symmetrical' do
       restriction = relation.restrict { |r| r.id.gte(1) }
-      other       = [ [ 4, 'John Doe' ] ]
+      other       = [[4, 'John Doe']]
       restriction.insert(other).delete(other).should == restriction
     end
 
     it 'Join#insert and #delete of a disjoint relation are symmetrical' do
-      join  = relation + Relation.new([ [ :id, Integer ] ], [ [ 1 ] ])
-      other = [ [ 4, 'John Doe' ] ]
+      join  = relation + Relation.new([[:id, Integer]], [[1]])
+      other = [[4, 'John Doe']]
       join.insert(other).delete(other).should == join
     end
 
     it 'Difference#insert and #delete of a disjoint relation are symmetrical' do
       difference = relation - relation
-      other      = [ [ 4, 'John Doe' ] ]
+      other      = [[4, 'John Doe']]
       difference.insert(other).delete(other).should == difference
     end
 
     it 'Union#insert and #delete of a disjoint relation are symmetrical' do
       union  = relation | relation
-      other  = [ [ 4, 'John Doe' ] ]
+      other  = [[4, 'John Doe']]
       union.insert(other).delete(other).should == union
     end
 
     it 'Intersection#insert and #delete of a disjoint relation are symmetrical' do
       intersection = relation & relation
-      other        = [ [ 4, 'John Doe' ] ]
+      other        = [[4, 'John Doe']]
       intersection.insert(other).delete(other).should == intersection
     end
 
     it 'Order#insert and #delete of a disjoint relation are symmetrical' do
       order = relation.sort_by(relation.header)
-      other = Relation.new(relation.header, [ [ 4, 'John Doe' ] ]).sort_by(relation.header)
+      other = Relation.new(relation.header, [[4, 'John Doe']]).sort_by(relation.header)
       order.insert(other).delete(other).should == order
     end
   end

data/spec/shared/invertible_method_behaviour.rb

@@ -4,6 +4,6 @@ shared_examples_for 'an invertible method' do
   it_should_behave_like 'an idempotent method'
 
   it 'is invertible' do
-    subject.inverse.should equal(object)
+    subject.inverse.should be(object)
   end
 end

data/spec/spec_helper.rb

@@ -1,10 +1,5 @@
 # encoding: utf-8
 
-require 'backports'
-require 'backports/basic_object' unless defined?(::BasicObject)
-require 'devtools/spec_helper'
-require 'ice_nine'
-
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
   require 'coveralls'
@@ -15,32 +10,45 @@ if ENV['COVERAGE'] == 'true'
   ]
 
   SimpleCov.start do
-    command_name     'spec:unit'
-    add_filter       'config'
-    add_filter       'spec'
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'spec'
+    add_filter 'vendor'
+
     minimum_coverage 100
   end
 end
 
+require 'devtools/spec_helper'
 require 'axiom'
 
 include Axiom
 
-# require spec support files and shared behavior
-Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
-end
-
 RSpec.configure do |config|
+  config.expect_with :rspec do |expect_with|
+    expect_with.syntax = [:expect, :should]
+  end
 
   # Record the original Attribute descendants
   config.before do
-    @original_descendants = Attribute.descendants.dup
+    @original_attribute_descendants = Attribute.descendants.dup
   end
 
   # Reset the Attribute descendants
   config.after do
-    Attribute.descendants.replace(@original_descendants)
+    Attribute.descendants.replace(@original_attribute_descendants)
+  end
+
+  # Record the original Type descendants
+  config.before do
+    Axiom::Types.finalize
+    @original_type_descendants = Axiom::Types::Type.descendants.dup
   end
 
+  # Reset the Type descendants
+  config.after do
+    Axiom::Types::Type.descendants.replace(@original_type_descendants)
+    Axiom::Types.instance_variable_get(:@inference_cache).clear
+  end
 end

data/spec/support/config_alias.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'rbconfig'
 
 ::Config = RbConfig unless defined?(::Config)

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

@@ -5,11 +5,11 @@ require 'spec_helper'
 describe Aggregate, '#call' do
   subject { object.call(nil, tuple) }
 
-  let(:described_class) { Class.new(Aggregate)                }
-  let(:object)          { described_class.new(attribute)      }
-  let(:attribute)       { Attribute::Integer.new(:id)         }
-  let(:header)          { Relation::Header.new([ attribute ]) }
-  let(:tuple)           { Tuple.new(header, [ 1 ])            }
+  let(:described_class) { Class.new(Aggregate)              }
+  let(:object)          { described_class.new(attribute)    }
+  let(:attribute)       { Attribute::Integer.new(:id)       }
+  let(:header)          { Relation::Header.new([attribute]) }
+  let(:tuple)           { Tuple.new(header, [1])            }
 
   context 'when operand is an attribute' do
     before do

data/spec/unit/axiom/aggregate/class_methods/finalize_spec.rb

@@ -5,8 +5,8 @@ require 'spec_helper'
 describe Aggregate, '.finalize' do
   subject { object.finalize(accumulator) }
 
-  let(:object)      { described_class     }
-  let(:accumulator) { mock('Accumulator') }
+  let(:object)      { described_class       }
+  let(:accumulator) { double('Accumulator') }
 
-  it { should equal(accumulator) }
+  it { should be(accumulator) }
 end

data/spec/unit/axiom/aggregate/count/class_methods/call_spec.rb

@@ -13,7 +13,7 @@ describe Aggregate::Count, '.call' do
   let(:object)  { described_class }
 
   context 'when the values are not nil' do
-    let(:values) { [ 1, 2, 3, 4, 5, 6 ] }
+    let(:values) { [1, 2, 3, 4, 5, 6] }
 
     it 'returns the expected count the values' do
       should eql(6)
@@ -21,10 +21,10 @@ describe Aggregate::Count, '.call' do
   end
 
   context 'when the values are nil' do
-    let(:values) { [ nil ] }
+    let(:values) { [nil] }
 
     it 'returns the default' do
-      should equal(default)
+      should be(default)
     end
   end
 end

data/spec/unit/axiom/aggregate/count/class_methods/type_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Count, '.type' do
+  subject { object.type }
+
+  let(:object)  { described_class }
+
+  it { should be(Types::Integer) }
+end

data/spec/unit/axiom/aggregate/count/methods/count_spec.rb

@@ -10,5 +10,5 @@ describe Aggregate::Count::Methods, '#count' do
 
   it { should be_instance_of(Aggregate::Count) }
 
-  its(:operand) { should equal(object) }
+  its(:operand) { should be(object) }
 end

data/spec/unit/axiom/aggregate/default_spec.rb

@@ -10,8 +10,8 @@ describe Aggregate, '#default' do
   let(:attribute)       { Attribute::Integer.new(:id)    }
 
   it 'delegates to self.class.default' do
-    return_value = mock('Return Value')
+    return_value = double('Return Value')
     described_class.should_receive(:default).with(no_args).and_return(return_value)
-    should equal(return_value)
+    should be(return_value)
   end
 end

data/spec/unit/axiom/aggregate/finalize_spec.rb

@@ -8,11 +8,11 @@ describe Aggregate, '#finalize' do
   let(:described_class) { Class.new(Aggregate)           }
   let(:object)          { described_class.new(attribute) }
   let(:attribute)       { Attribute::Integer.new(:id)    }
-  let(:accumulator)     { mock('Accumulator')            }
+  let(:accumulator)     { double('Accumulator')          }
 
   it 'delegates to self.class.finalize' do
-    return_value = mock('Return Value')
+    return_value = double('Return Value')
     described_class.should_receive(:finalize).with(accumulator).and_return(return_value)
-    should equal(return_value)
+    should be(return_value)
   end
 end