axiom-types 0.0.1

data/spec/unit/axiom/types/encodable/class_methods/extended_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Encodable, '.extended', :if => RUBY_VERSION >= '1.9' do
+  subject { object.extend(described_class) }
+
+  let(:object) { Class.new(Axiom::Types::Type) }
+
+  it 'delegates to the ancestor' do
+    # RSpec will reset stubbed methods after the example. A normal expectation
+    # causes a SystemStackError to be thrown, so we stub it first so that RSpec
+    # tracks the original method (if any), then we add our own stub that
+    # actually works, and finally when the example finishes RSpec will reset the
+    # Module#extended method back to it's original state.
+    Module.any_instance.stub(:extended).with(object)
+
+    delegated_ancestor = false
+    Module.send(:define_method, :extended) { |_| delegated_ancestor = true }
+    expect { subject }.to change { delegated_ancestor }.from(false).to(true)
+  end
+
+  it 'adds encoding method' do
+    expect { subject }.to change { object.respond_to?(:encoding) }.
+      from(false).to(true)
+  end
+
+  it 'sets the encoding default to UTF-8' do
+    expect(subject.encoding).to be(Encoding::UTF_8)
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Encodable, '#finalize', :if => RUBY_VERSION >= '1.9' do
+  subject { object.finalize }
+
+  let(:object) { Class.new(Axiom::Types::Type).extend(described_class) }
+
+  context 'when an ascii compatible encoding (UTF-8) is used' do
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_frozen }
+
+    its(:constraint) { should be_frozen }
+
+    defined?(::Encoding) && Encoding.list.each do |encoding|
+      if encoding.ascii_compatible?
+        it "adds a constraint that returns true for #{encoding} encoding" do
+          should include(''.force_encoding(encoding))
+        end
+      else
+        it "adds a constraint that returns false for #{encoding} encoding" do
+          should_not include(''.force_encoding(encoding))
+        end
+      end
+    end
+  end
+
+  context 'when an non-ascii compatible encoding (UTF-16BE) is used' do
+    before do
+      object.encoding Encoding::UTF_16BE
+    end
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'an idempotent method'
+
+    it { should be_frozen }
+
+    its(:constraint) { should be_frozen }
+
+    defined?(::Encoding) && Encoding.list.each do |encoding|
+      if encoding.equal?(Encoding::UTF_16BE)
+        it "adds a constraint that returns true for #{encoding} encoding" do
+          should include(''.force_encoding(encoding))
+        end
+      else
+        it "adds a constraint that returns false for #{encoding} encoding" do
+          should_not include(''.force_encoding(encoding))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Hash, '.finalize' do
+  subject { object.finalize }
+
+  let(:object) { Class.new(Axiom::Types::Hash) }
+
+  context 'with the default key and value 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 Hash' do
+      should include(Object.new => Object.new)
+    end
+
+    it 'adds a constraint that returns false for a non-Hash' do
+      should_not include(Object.new)
+    end
+  end
+
+  context 'with custom key and value constraints' do
+    let(:key)   { :name      }
+    let(:value) { 'Dan Kubb' }
+
+    before do
+      object.key_type   Axiom::Types::Symbol
+      object.value_type Axiom::Types::String
+    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 valid keys and values' do
+      should include(key => value)
+    end
+
+    it 'adds a constraint that returns false for an invalid key' do
+      should_not include(key.to_s => value)
+    end
+
+    it 'adds a constraint that returns false for an invalid value' do
+      should_not include(key => value.to_sym)
+    end
+  end
+end

data/spec/unit/axiom/types/length_comparable/class_methods/extended_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::LengthComparable, '.extended' do
+  subject { object.extend(described_class) }
+
+  let(:object) { Class.new(Axiom::Types::Type) }
+
+  it 'delegates to the ancestor' do
+    # RSpec will reset stubbed methods after the example. A normal expectation
+    # causes a SystemStackError to be thrown, so we stub it first so that RSpec
+    # tracks the original method (if any), then we add our own stub that
+    # actually works, and finally when the example finishes RSpec will reset the
+    # Module#extended method back to it's original state.
+    Module.any_instance.stub(:extended).with(object)
+
+    delegated_ancestor = false
+    Module.send(:define_method, :extended) { |_| delegated_ancestor = true }
+    expect { subject }.to change { delegated_ancestor }.from(false).to(true)
+  end
+
+  it 'adds minimum_length method' do
+    expect { subject }.to change { object.respond_to?(:minimum_length) }.
+      from(false).to(true)
+  end
+
+  it 'adds maxumum_length method' do
+    expect { subject }.to change { object.respond_to?(:maximum_length) }.
+      from(false).to(true)
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::LengthComparable, '#finalize' do
+  subject { object.finalize }
+
+  let(:object) do
+    Class.new(Axiom::Types::Type) do
+      extend Axiom::Types::LengthComparable
+      minimum_length 1
+      maximum_length 2
+    end
+  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 length within range' do
+    should include('a')
+    should include('ab')
+  end
+
+  it 'adds a constraint that returns false for a length not within range' do
+    should_not include('')
+    should_not include('abc')
+  end
+end

data/spec/unit/axiom/types/object/class_methods/coercion_method_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Object, '.coercion_method' do
+  let(:object)          { Class.new(described_class) }
+  let(:coercion_method) { :to_object                 }
+
+  context 'with no arguments' do
+    subject { object.coercion_method }
+
+    it { should be(coercion_method) }
+  end
+
+  context 'with a symbol' do
+    subject { object.coercion_method(symbol) }
+
+    let(:symbol) { :to_string }
+
+    it_should_behave_like 'a command method'
+
+    it 'sets the coercion_method' do
+      expect { subject }.to change { object.coercion_method }.
+        from(coercion_method).to(symbol)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Object, '.finalize' do
+  subject { object.finalize }
+
+  let(:object) do
+    # Class.new { ... } does not work with this on 1.8.7
+    object = Class.new(described_class)
+    object.primitive(::String)
+    object
+  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 primitive' do
+    should include('string')
+  end
+
+  it 'adds a constraint that returns false for an invalid primitive' do
+    should_not include(nil)
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Object, '.primitive' do
+  let(:object)    { Class.new(described_class)                      }
+  let(:primitive) { RUBY_VERSION < '1.9' ? ::Object : ::BasicObject }
+
+  context 'with no arguments' do
+    subject { object.primitive }
+
+    it { should be(primitive) }
+  end
+
+  context 'with a class' do
+    subject { object.primitive(klass) }
+
+    let(:klass) { ::String }
+
+    it_should_behave_like 'a command method'
+
+    it 'sets the primitive' do
+      expect { subject }.to change { object.primitive.object_id }.
+        from(primitive.object_id).to(klass.object_id)
+    end
+  end
+end

data/spec/unit/axiom/types/options/accept_options_spec.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Options, '#accept_options' do
+  subject { object.accept_options(*new_options) }
+
+  let(:object)     { Class.new { extend Options, DescendantsTracker } }
+  let(:descendant) { Class.new(object)                                }
+
+  context 'with valid options' do
+    let(:new_options) { [ :primitive, :coerce_method ] }
+
+    it_should_behave_like 'a command method'
+    it_should_behave_like 'an idempotent method'
+
+    it 'adds methods to the object' do
+      expect(object).to_not respond_to(*new_options)
+      subject
+      expect(object).to respond_to(*new_options)
+    end
+
+    it 'adds methods to the object that can set a value' do
+      subject
+      object.primitive(::Symbol)
+      expect(object.primitive).to be(::Symbol)
+    end
+
+    context 'with the descendant class' do
+      let(:default) { ::String }
+
+      def force_inherit
+        descendant
+      end
+
+      context 'option added before inherited' do
+        before do
+          subject
+          expect(object.primitive(default)).to be(object)
+          force_inherit
+        end
+
+        it 'is idempotent' do
+          expect(descendant.accept_options(:primitive)).to be(descendant)
+        end
+
+        it 'adds the method to the descendants' do
+          expect(descendant).to respond_to(*new_options)
+        end
+
+        it 'sets the descendant defaults' do
+          expect(descendant.primitive).to be(default)
+        end
+
+        it 'adds methods to the descendant that can set a value' do
+          descendant.primitive(::Symbol)
+          expect(descendant.primitive).to be(::Symbol)
+        end
+      end
+
+      context 'option added after inherited' do
+        before do
+          force_inherit
+          subject
+          expect(object.primitive(default)).to be(object)
+        end
+
+        it 'is idempotent' do
+          expect(descendant.accept_options(:primitive)).to be(descendant)
+        end
+
+        it 'adds the method to the descendants' do
+          expect(descendant).to respond_to(*new_options)
+        end
+
+        it 'does not set the descendant defaults' do
+          expect(descendant.primitive).to be_nil
+        end
+
+        it 'adds methods to the descendant that can set a value' do
+          descendant.primitive(::Symbol)
+          expect(descendant.primitive).to be(::Symbol)
+        end
+      end
+    end
+  end
+
+  context 'with an option that conflicts with an existing method' do
+    let(:new_options) { [ :name ] }
+
+    specify do
+      expect { subject }.to raise_error(
+        Axiom::Types::Options::ReservedMethodError,
+        'method named `:name` is already defined'
+      )
+    end
+  end
+end

data/spec/unit/axiom/types/options/inherited_spec.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Options, '#inherited' do
+  subject { descendant }
+
+  let(:object) do
+    Class.new(ancestor) do
+      extend Options, DescendantsTracker
+      accept_options :primitive, :coerce_method
+      primitive ::String
+    end
+  end
+
+  let(:ancestor) do
+    Class.new
+  end
+
+  let(:descendant) do
+    Class.new(object)
+  end
+
+  it 'delegates to the ancestor' do
+    ancestor.should_receive(:inherited).twice
+    subject
+  end
+
+  it 'adds the accepted option to the descendant' do
+    subject
+    expect(descendant).to respond_to(:primitive, :coerce_method)
+  end
+
+  it 'sets the default value for the descendant' do
+    subject
+    expect(descendant.primitive).to be(::String)
+  end
+end

data/spec/unit/axiom/types/type/class_methods/constraint_spec.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Type, '.constraint' do
+  let(:object) { Class.new(described_class) }
+
+  context 'with no arguments or block' do
+    subject { object.constraint }
+
+    it { should respond_to(:call) }
+    it { should be(Tautology)     }
+  end
+
+  context 'with a callable object' do
+    subject { object.constraint(Contradiction) }
+
+    it_should_behave_like 'a command method'
+
+    its(:constraint) { should respond_to(:call) }
+    its(:constraint) { should_not be(Tautology) }
+  end
+
+  context 'with a block' do
+    subject { object.constraint { false } }
+
+    it_should_behave_like 'a command method'
+
+    its(:constraint) { should respond_to(:call) }
+    its(:constraint) { should_not be(Tautology) }
+  end
+end