axiom 0.1.1 → 0.2.0

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Aggregate, '#hash' do
-  subject { object.hash }
-
-  let(:described_class) { Class.new(Aggregate)           }
-  let(:object)          { described_class.new(attribute) }
-  let(:attribute)       { Attribute::Integer.new(:id)    }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ attribute.hash }
-end

data/spec/unit/axiom/algebra/extension/hash_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Algebra::Extension, '#hash' do
-  subject { object.hash }
-
-  let(:operand)    { Relation.new([[:id, Integer]], [[1], [2]]) }
-  let(:extensions) { { Attribute::Integer.new(:test) => 1 }     }
-  let(:object)     { described_class.new(operand, extensions)   }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ operand.hash ^ extensions.hash }
-end

data/spec/unit/axiom/algebra/projection/hash_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Algebra::Projection, '#hash' do
-  subject { object.hash }
-
-  let(:body)       { [[1, 'Dan Kubb'], [2, 'Dan Kubb'], [2, 'Alex Kubb']]  }
-  let(:operand)    { Relation.new([[:id, Integer], [:name, String]], body) }
-  let(:attributes) { [:id]                                                 }
-  let(:object)     { described_class.new(operand, attributes)              }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ operand.hash ^ object.header.hash }
-end

data/spec/unit/axiom/algebra/rename/aliases/hash_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Algebra::Rename::Aliases, '#hash' do
-  subject { object.hash }
-
-  let(:attribute) { Attribute::Integer.new(:id)                  }
-  let(:aliases)   { { attribute => attribute.rename(:other_id) } }
-  let(:object)    { described_class.new(aliases)                 }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ aliases.hash }
-end

data/spec/unit/axiom/algebra/rename/hash_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Algebra::Rename, '#hash' do
-  subject { object.hash }
-
-  let(:operand) { Relation.new([[:id, Integer]], [[1]])       }
-  let(:aliases) { described_class::Aliases.new(id: :other_id) }
-  let(:object)  { described_class.new(operand, aliases)       }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ operand.hash ^ aliases.hash }
-end

data/spec/unit/axiom/algebra/restriction/hash_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Algebra::Restriction, '#hash' do
-  subject { object.hash }
-
-  let(:operand)   { Relation.new([[:id, Integer]], [[1]])   }
-  let(:predicate) { proc { true }                           }
-  let(:object)    { described_class.new(operand, predicate) }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ operand.hash ^ predicate.hash }
-end

data/spec/unit/axiom/algebra/summarization/hash_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Algebra::Summarization, '#hash' do
-  subject { object.hash }
-
-  let(:operand)      { Relation.new([[:id, Integer]], [[1], [2]])              }
-  let(:summarize_by) { operand.project([])                                     }
-  let(:summarizers)  { { count: ->(acc, tuple) { acc.to_i + 1 } }              }
-  let(:object)       { described_class.new(operand, summarize_by, summarizers) }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ operand.hash ^ summarize_by.hash ^ summarizers.hash }
-end

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

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Attribute, '#hash' do
-  subject { object.hash }
-
-  let(:described_class) { Class.new(Attribute)               }
-  let(:name)            { :name                              }
-  let(:required)        { true                               }
-  let(:options)         { { required: required }             }
-  let(:object)          { described_class.new(name, options) }
-
-  before do
-    described_class.stub(type: Types::Object)
-  end
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ name.hash ^ object.type.hash ^ required.hash }
-end

data/spec/unit/axiom/attribute/numeric/hash_spec.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Attribute::Numeric, '#hash' do
-  subject { object.hash }
-
-  let(:object)   { described_class.new(name, options) }
-  let(:name)     { :name                              }
-  let(:options)  { { required: required, size: size } }
-  let(:required) { true                               }
-  let(:size)     { 0..10                              }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ name.hash ^ object.type.hash ^ required.hash }
-end

data/spec/unit/axiom/attribute/string/hash_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Attribute::String, '#hash' do
-  subject { object.hash }
-
-  let(:object)         { described_class.new(name, options) }
-  let(:name)           { :name                              }
-  let(:required)       { true                               }
-  let(:minimum_length) { 0                                  }
-  let(:maximum_length) { 50                                 }
-
-  let(:options) do
-    {
-      required:       required,
-      minimum_length: minimum_length,
-      maximum_length: maximum_length,
-    }
-  end
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ name.hash ^ object.type.hash ^ required.hash }
-end

data/spec/unit/axiom/equalizer/methods/eql_spec.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Axiom::Equalizer::Methods, '#eql?' do
-  subject { object.eql?(other) }
-
-  let(:object) { described_class.new }
-
-  let(:described_class) do
-    Class.new do
-      include Axiom::Equalizer::Methods
-
-      def cmp?(comparator, other)
-        !!(comparator && other)
-      end
-    end
-  end
-
-  context 'with the same object' do
-    let(:other) { object }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { object.dup }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-end

data/spec/unit/axiom/equalizer/methods/equality_operator_spec.rb

@@ -1,85 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Axiom::Equalizer::Methods, '#==' do
-  subject { object == other }
-
-  let(:object) { described_class.new(true) }
-
-  let(:described_class) do
-    Class.new do
-      include Axiom::Equalizer::Methods
-
-      attr_reader :boolean
-
-      def initialize(boolean)
-        @boolean = boolean
-      end
-
-      def cmp?(comparator, other)
-        boolean.send(comparator, other.boolean)
-      end
-    end
-  end
-
-  context 'with the same object' do
-    let(:other) { object }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { object.dup }
-
-    it { should be(true) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-
-  context 'with an equivalent object of a subclass' do
-    let(:other) { Class.new(described_class).new(true) }
-
-    it { should be(true) }
-
-    it 'is not symmetric' do
-      should_not eql(other == object)
-    end
-  end
-
-  context 'with an object of another class' do
-    let(:other) { Class.new.new }
-
-    it { should be(false) }
-
-    it 'is symmetric' do
-      should eql(other == object)
-    end
-  end
-
-  context 'with an equivalent object after coercion' do
-    let(:other) { Object.new }
-
-    before do
-      # declare a private #coerce method
-      described_class.class_eval do
-        def coerce(other)
-          self.class.new(!!other)
-        end
-        private :coerce
-      end
-    end
-
-    it { should be(true) }
-
-    it 'is not symmetric' do
-      should_not eql(other == object)
-    end
-  end
-end

data/spec/unit/axiom/function/binary/invertible/class_methods/included_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Function::Binary::Invertible, '.included' do
-  subject { object }
-
-  let(:object) { described_class }
-  let(:klass)  { Class.new       }
-
-  before do
-    klass.stub(:memoize)
-  end
-
-  it 'memoizes the inverse method' do
-    klass.should_receive(:memoize).with(:inverse)
-    klass.send(:include, subject)
-  end
-
-  it 'delegates to the ancestor' do
-    included_ancestor = false
-    mod = Module.new do
-      define_method(:included) { |_| included_ancestor = true }
-    end
-    subject.extend mod
-    expect { klass.send(:include, subject) }
-      .to change { included_ancestor }.from(false).to(true)
-  end
-end

data/spec/unit/axiom/function/predicate/hash_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Function::Predicate, '#hash' do
-  subject { object.hash }
-
-  let(:left)   { Attribute::Integer.new(:id)      }
-  let(:right)  { 1                                }
-  let(:object) { described_class.new(left, right) }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ left.hash ^ right.hash }
-end

data/spec/unit/axiom/function/predicate/inverse_spec.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Function::Predicate, '#inverse' do
-  subject { object.inverse }
-
-  let(:object) { described_class.new(1, 1) }
-
-  specify { expect { subject }.to raise_error(NoMethodError) }
-
-  it 'calls the class inverse method' do
-    described_class.should_receive(:inverse).and_return(described_class)
-    should eql(object)
-  end
-end

data/spec/unit/axiom/function/proposition/hash_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Function::Proposition, '#hash' do
-  subject { object.hash }
-
-  let(:described_class) { Class.new(Function::Proposition) }
-  let(:object)          { described_class.new              }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash }
-end

data/spec/unit/axiom/function/unary/hash_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe Function::Unary, '#hash' do
-  subject { object.hash }
-
-  let(:described_class) { UnarySpecs::Object                   }
-  let(:attribute)       { Attribute::Integer.new(:id)          }
-  let(:header)          { Relation::Header.coerce([attribute]) }
-  let(:operand)         { attribute.eq(1)                      }
-  let(:object)          { described_class.new(operand)         }
-
-  it_should_behave_like 'a hash method'
-
-  it { should == described_class.hash ^ operand.hash }
-end

data/spec/unit/axiom/function/unary/invertible/class_methods/included_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Function::Unary::Invertible, '.included' do
-  subject { object }
-
-  let(:object) { described_class }
-  let(:klass)  { Class.new       }
-
-  before do
-    klass.stub(:memoize)
-  end
-
-  it 'memoizes the inverse method' do
-    klass.should_receive(:memoize).with(:inverse)
-    klass.send(:include, subject)
-  end
-
-  it 'delegates to the ancestor' do
-    included_ancestor = false
-    mod = Module.new do
-      define_method(:included) { |_| included_ancestor = true }
-    end
-    subject.extend mod
-    expect { klass.send(:include, subject) }
-      .to change { included_ancestor }.from(false).to(true)
-  end
-end