axiom 0.1.0

data/spec/integration/axiom/algebra/summarization_spec.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Algebra::Summarization do
+  subject { relation.summarize(summarize_per) { |r| r.add(:count) { |accumulator, _| accumulator.to_i + 1 } } }
+
+  let(:header)    { [ [ :name, String ], [ :qty, Integer ] ]                       }
+  let(:relation)  { Relation.new(header, [ [ 'Dan Kubb', 1 ], [ 'John Doe', 1 ] ]) }
+  let(:by_header) { header.values_at(0)                                            }
+
+  context 'summarize on the same set' do
+    let(:summarize_per) { Relation.new(by_header, [ [ 'Dan Kubb' ], [ 'John Doe' ] ]) }
+
+    it 'returns a relation with a single tuple' do
+      should == [ [ 'Dan Kubb', 1 ], [ 'John Doe', 1 ] ]
+    end
+  end
+
+  context 'summarize on a smaller set' do
+    let(:summarize_per) { Relation.new(by_header, [ [ 'Dan Kubb' ] ]) }
+
+    it 'returns a relation with a single tuple' do
+      should == [ [ 'Dan Kubb', 1 ] ]
+    end
+  end
+
+  context 'summarize on a larger set' do
+    let(:summarize_per) { Relation.new(by_header, [ [ 'Dan Kubb' ], [ 'Dane Largy' ] ]) }
+
+    it 'returns a relation with a single tuple' do
+      should == [ [ 'Dan Kubb', 1 ], [ 'Dane Largy', nil ] ]
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'timeout'
+
+# use an infinite list to simulate handling a large Array.
+# if any operation is inefficient, then the specs will never exit
+class InfiniteList
+  include Enumerable
+
+  def each(&block)
+    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) }
+
+    def sample(relation)
+      Timeout.timeout(1) do
+        relation.to_enum.take(5)
+      end
+    end
+
+    it '#project should be efficient' do
+      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 ] ]
+    end
+
+    it '#rename should be efficient' do
+      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' ] ]) }
+
+      it 'has an infinite left relation' do
+        pending 'Change #join to handle infinite sets'
+        join = other.join(relation)
+        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' ] ]
+      end
+    end
+
+    describe '#product should be efficient' do
+      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' ] ]
+      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' ] ]
+      end
+    end
+
+    it '#difference should be efficient' do
+      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 ] ]
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+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' ] ]
+      )
+    end
+
+    it 'Rename#insert and #delete of a disjoint relation are symmetrical' do
+      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.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)
+      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' ] ]
+      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.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' ] ]
+      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' ] ]
+      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' ] ]
+      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)
+      order.insert(other).delete(other).should == order
+    end
+  end
+end

data/spec/shared/invertible_method_behaviour.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+shared_examples_for 'an invertible method' do
+  it_should_behave_like 'an idempotent method'
+
+  it 'is invertible' do
+    subject.inverse.should equal(object)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# 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'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    command_name     'spec:unit'
+    add_filter       'config'
+    add_filter       'spec'
+    minimum_coverage 100
+  end
+end
+
+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|
+
+  # Record the original Attribute descendants
+  config.before do
+    @original_descendants = Attribute.descendants.dup
+  end
+
+  # Reset the Attribute descendants
+  config.after do
+    Attribute.descendants.replace(@original_descendants)
+  end
+
+end

data/spec/support/config_alias.rb

@@ -0,0 +1,3 @@
+require 'rbconfig'
+
+::Config = RbConfig unless defined?(::Config)

data/spec/support/ice_nine_config.rb

@@ -0,0 +1,6 @@
+module IceNine
+  class Freezer
+    class RSpec < NoFreeze
+    end
+  end
+end

data/spec/support/lazy_enumerable.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+class LazyEnumerable < BasicObject
+  def initialize(enumerable = [])
+    @enumerable = enumerable
+  end
+
+  def size
+    nil
+  end
+
+private
+
+  def method_missing(*args, &block)
+    @enumerable.__send__(*args, &block)
+  end
+
+end

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

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+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 ])            }
+
+  context 'when operand is an attribute' do
+    before do
+      described_class.class_eval do
+        def self.call(accumulator, value)
+          value
+        end
+      end
+    end
+
+    it { should eql(1) }
+  end
+
+  context 'when operand is a literal value' do
+    let(:object) { described_class.new(2) }
+
+    before do
+      described_class.class_eval do
+        def self.call(accumulator, value)
+          value
+        end
+      end
+    end
+
+    it { should eql(2) }
+  end
+
+  context 'when .call is not defined' do
+    specify { expect { subject }.to raise_error(NotImplementedError, "#{described_class}.call is not implemented") }
+  end
+end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '.call' do
+  subject { object.call }
+
+  let(:object) { described_class }
+
+  specify { expect { subject }.to raise_error(NotImplementedError, "#{object}.call is not implemented") }
+end

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

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '.default' do
+  subject { object.default }
+
+  let(:object) { described_class }
+
+  specify { expect { subject }.to raise_error(NameError) }
+end

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '.finalize' do
+  subject { object.finalize(accumulator) }
+
+  let(:object)      { described_class     }
+  let(:accumulator) { mock('Accumulator') }
+
+  it { should equal(accumulator) }
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Count, '.call' do
+  subject do
+    values.reduce(default) do |accumulator, value|
+      object.call(accumulator, value)
+    end
+  end
+
+  let(:default) { object.default  }
+  let(:object)  { described_class }
+
+  context 'when the values are not nil' do
+    let(:values) { [ 1, 2, 3, 4, 5, 6 ] }
+
+    it 'returns the expected count the values' do
+      should eql(6)
+    end
+  end
+
+  context 'when the values are nil' do
+    let(:values) { [ nil ] }
+
+    it 'returns the default' do
+      should equal(default)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Count::Methods, '#count' do
+  subject { object.count }
+
+  let(:described_class) { Class.new { include Aggregate::Count::Methods } }
+  let(:object)          { described_class.new.freeze                      }
+
+  it { should be_instance_of(Aggregate::Count) }
+
+  its(:operand) { should equal(object) }
+end

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate::Count, '#type' do
+  subject { object.type }
+
+  let(:object)  { described_class.new(operand) }
+  let(:operand) { Attribute::Integer.new(:id)  }
+
+  it { should equal(Attribute::Integer) }
+end

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Aggregate, '#default' do
+  subject { object.default }
+
+  let(:described_class) { Class.new(Aggregate)           }
+  let(:object)          { described_class.new(attribute) }
+  let(:attribute)       { Attribute::Integer.new(:id)    }
+
+  it 'delegates to self.class.default' do
+    return_value = mock('Return Value')
+    described_class.should_receive(:default).with(no_args).and_return(return_value)
+    should equal(return_value)
+  end
+end