axiom-types 0.0.1 → 0.0.2

data/spec/spec_helper.rb

@@ -1,8 +1,6 @@
 # encoding: utf-8
 
-require 'devtools'
-
-Devtools.init_spec_helper
+require 'devtools/spec_helper'
 
 if ENV['COVERAGE'] == 'true'
   require 'simplecov'
@@ -25,13 +23,24 @@ require 'axiom-types'
 
 include Axiom::Types
 
-# require spec support files and shared behavior
+# Require spec support files and shared behavior
 Dir[File.expand_path('../{support,shared}/**/*.rb', __FILE__)].each do |file|
-  require file
+  require file.chomp('.rb')
 end
 
 RSpec.configure do |config|
   config.expect_with :rspec do |expect_with|
     expect_with.syntax = :expect
   end
+
+  # Record the original Type descendants
+  config.before do
+    @original_descendants = Axiom::Types::Type.descendants.dup
+  end
+
+  # Reset the Type descendants
+  config.after do
+    Axiom::Types::Type.descendants.replace(@original_descendants)
+    Axiom::Types.instance_variable_get(:@inference_cache).clear
+  end
 end

data/spec/unit/axiom/types/array/class_methods/infer_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Array, '.infer' do
+  subject { object.infer(arg) }
+
+  before do
+    object.finalize
+  end
+
+  context 'with Axiom::Types::Array' do
+    let(:object) { described_class }
+
+    context 'when the argument is the type object' do
+      let(:arg) { object }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is ::Array' do
+      let(:arg) { ::Array }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an empty Array' do
+      let(:arg) { ::Array[] }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an Array with a type' do
+      let(:arg) { ::Array[object] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:member_type) { should be(object) }
+    end
+
+    context 'when the argument is an Array with a primitive' do
+      let(:arg) { ::Array[::Array] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:member_type) { should be(object) }
+    end
+
+    context 'when the argument is nil' do
+      let(:arg) { nil }
+
+      it { should be_nil }
+    end
+  end
+
+  context 'with Axiom::Types::Array subclass' do
+    let(:object) { Class.new(described_class) }
+
+    context 'when the argument is the type object' do
+      let(:arg) { object }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is ::Array' do
+      let(:arg) { ::Array }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an empty Array' do
+      let(:arg) { ::Array[] }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an Array with a type' do
+      let(:arg) { ::Array[object] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an Array with a primitive' do
+      let(:arg) { ::Array[::Array] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is nil' do
+      let(:arg) { nil }
+
+      it { should be_nil }
+    end
+  end
+end

data/spec/unit/axiom/types/boolean/class_methods/infer_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Boolean, '.infer' do
+  subject { object.infer(arg) }
+
+  let(:object) { described_class }
+
+  context 'when the argument is the type object' do
+    let(:arg) { object }
+
+    it { should be(object) }
+  end
+
+  context 'when the argument is ::TrueClass' do
+    let(:arg) { ::TrueClass }
+
+    it { should be(object) }
+  end
+
+  context 'when the argument is ::FalseClass' do
+    let(:arg) { ::FalseClass }
+
+    it { should be(object) }
+  end
+
+  context 'when the argument is nil' do
+    let(:arg) { nil }
+
+    it { should be_nil }
+  end
+end

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

@@ -5,13 +5,8 @@ require 'spec_helper'
 describe Axiom::Types, '.finalize' do
   subject { object.finalize }
 
-  let(:object)      { described_class                   }
-  let(:descendants) { [ descendant ]                    }
-  let(:descendant)  { mock('descendant').as_null_object }
-
-  before do
-    object::Type.should_receive(:descendants).and_return(descendants)
-  end
+  let(:object)      { described_class               }
+  let(:descendant)  { Class.new(Axiom::Types::Type) }
 
   it_should_behave_like 'a command method'
 

data/spec/unit/axiom/types/class_methods/infer_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types, '.infer' do
+  subject { object.infer(type) }
+
+  let(:object) { described_class }
+
+  before do
+    object.finalize
+  end
+
+  Axiom::Types::Type.descendants.each do |descendant|
+    context "when the type is #{descendant}" do
+      let(:type) { descendant }
+
+      it { should be(descendant) }
+    end
+
+    if descendant.equal?(Axiom::Types::Boolean)
+      context 'when the type is TrueClass' do
+        let(:type) { ::TrueClass }
+
+        it { should be(descendant) }
+      end
+
+      context 'when the type is FalseClass' do
+        let(:type) { ::FalseClass }
+
+        it { should be(descendant) }
+      end
+    else
+      primitive = descendant.primitive
+
+      context "when the type is #{primitive}" do
+        let(:type) { primitive }
+
+        it { should be(descendant) }
+      end
+    end
+  end
+
+  context 'with a custom type' do
+    let(:type) do
+      Axiom::Types::String.new do
+        minimum_length 1
+        maximum_length 100
+      end
+    end
+
+    it { should be(type) }
+  end
+end

data/spec/unit/axiom/types/collection/class_methods/finalize_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Collection, '.finalize' do
+  subject { object.finalize }
+
+  let(:object) { Class.new(Axiom::Types::Collection) }
+
+  context 'with the default member constraints' do
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_frozen }
+
+    its(:constraint) { should be_frozen }
+
+    it 'adds a constraint that returns true for a collection' do
+      should include([ Object.new ])
+    end
+
+    it 'adds a constraint that returns false for a non-collection' do
+      should_not include(Object.new)
+    end
+  end
+
+  context 'with custom member constraints' do
+    let(:member) { :name }
+
+    before do
+      object.member_type Axiom::Types::Symbol
+    end
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_frozen }
+
+    its(:constraint) { should be_frozen }
+
+    it 'adds a constraint that returns true for a valid member' do
+      should include([ member ])
+    end
+
+    it 'adds a constraint that returns false for an invalid member' do
+      should_not include([ member.to_s ])
+    end
+  end
+end

data/spec/unit/axiom/types/collection/class_methods/infer_spec.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Collection, '.infer' do
+  subject { object.infer(arg) }
+
+  before do
+    object.finalize
+  end
+
+  context 'with a base class' do
+    let(:object) do
+      Class.new(described_class) do
+        primitive ::SortedSet
+
+        def self.base?
+          true
+        end
+      end
+    end
+
+    context 'when the argument is the type object' do
+      let(:arg) { object }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is ::SortedSet' do
+      let(:arg) { ::SortedSet }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an empty SortedSet' do
+      let(:arg) { ::SortedSet[] }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an SortedSet with a type' do
+      let(:arg) { ::SortedSet[object] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:member_type) { should be(object) }
+    end
+
+    context 'when the argument is an SortedSet with a primitive' do
+      let(:arg) { ::SortedSet[::SortedSet] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:member_type) { should be(object) }
+    end
+
+    context 'when the argument is nil' do
+      let(:arg) { nil }
+
+      it { should be_nil }
+    end
+  end
+
+  context 'with a a non-base class' do
+    let(:object) do
+      Class.new(described_class) do
+        primitive ::SortedSet
+      end
+    end
+
+    context 'when the argument is the type object' do
+      let(:arg) { object }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is ::SortedSet' do
+      let(:arg) { ::SortedSet }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an empty SortedSet' do
+      let(:arg) { ::SortedSet[] }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an SortedSet with a type' do
+      let(:arg) { ::SortedSet[object] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an SortedSet with a primitive' do
+      let(:arg) { ::SortedSet[::SortedSet] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is nil' do
+      let(:arg) { nil }
+
+      it { should be_nil }
+    end
+  end
+end

data/spec/unit/axiom/types/hash/class_methods/infer_spec.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Hash, '.infer' do
+  subject { object.infer(arg) }
+
+  before do
+    object.finalize
+  end
+
+  context 'with Axiom::Types::Hash' do
+    let(:object) { described_class }
+
+    context 'when the argument is the type object' do
+      let(:arg) { object }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is ::Hash' do
+      let(:arg) { ::Hash }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an empty Hash' do
+      let(:arg) { ::Hash[] }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an Hash with a key type and nil value' do
+      let(:arg) { ::Hash[object => nil] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:key_type) { should be(object) }
+
+      its(:value_type) { should be(Axiom::Types::Object) }
+    end
+
+    context 'when the argument is an Hash with a nil key and value type' do
+      let(:arg) { ::Hash[nil => object] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:key_type) { should be(Axiom::Types::Object) }
+
+      its(:value_type) { should be(object) }
+    end
+
+    context 'when the argument is an Hash with key and value types' do
+      let(:arg) { ::Hash[object => object] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:key_type) { should be(object) }
+
+      its(:value_type) { should be(object) }
+    end
+
+    context 'when the argument is an Hash with a key primitive and nil value' do
+      let(:arg) { ::Hash[::Hash => nil] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:key_type) { should be(object) }
+
+      its(:value_type) { should be(Axiom::Types::Object) }
+    end
+
+    context 'when the argument is an Hash with a nil key and value primitive' do
+      let(:arg) { ::Hash[nil => ::Hash] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:key_type) { should be(Axiom::Types::Object) }
+
+      its(:value_type) { should be(object) }
+    end
+
+    context 'when the argument is an Hash with key and value primitives' do
+      let(:arg) { ::Hash[::Hash => ::Hash] }
+
+      its(:ancestors) { should include(object) }
+
+      its(:primitive) { should be(object.primitive) }
+
+      its(:key_type) { should be(object) }
+
+      its(:value_type) { should be(object) }
+    end
+
+    context 'when the argument is nil' do
+      let(:arg) { nil }
+
+      it { should be_nil }
+    end
+  end
+
+  context 'with Axiom::Types::Hash subclass' do
+    let(:object) { Class.new(described_class) }
+
+    context 'when the argument is the type object' do
+      let(:arg) { object }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is ::Hash' do
+      let(:arg) { ::Hash }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an empty Hash' do
+      let(:arg) { ::Hash[] }
+
+      it { should be(object) }
+    end
+
+    context 'when the argument is an Hash with a key type and nil value' do
+      let(:arg) { ::Hash[object => nil] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an Hash with a nil key and value type' do
+      let(:arg) { ::Hash[nil => object] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an Hash with key and value types' do
+      let(:arg) { ::Hash[object => object] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an Hash with a key primitive and nil value' do
+      let(:arg) { ::Hash[::Hash => nil] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an Hash with a nil key and value primitive' do
+      let(:arg) { ::Hash[nil => ::Hash] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is an Hash with key and value primitives' do
+      let(:arg) { ::Hash[::Hash => ::Hash] }
+
+      it { should be_nil }
+    end
+
+    context 'when the argument is nil' do
+      let(:arg) { nil }
+
+      it { should be_nil }
+    end
+  end
+end