axiom-types 0.0.2 → 0.0.3

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

@@ -2,27 +2,28 @@
 
 require 'spec_helper'
 
-describe Axiom::Types::Encodable, '.extended', :if => RUBY_VERSION >= '1.9' do
+describe Axiom::Types::Encodable, '.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.
+    # 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(:undef_method, :extended)
     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)
+    expect { subject }.to change { object.respond_to?(:encoding) }
+      .from(false).to(true)
   end
 
   it 'sets the encoding default to UTF-8' do

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

@@ -2,11 +2,19 @@
 
 require 'spec_helper'
 
-describe Axiom::Types::Encodable, '#finalize', :if => RUBY_VERSION >= '1.9' do
+describe Axiom::Types::Encodable, '#finalize' do
   subject { object.finalize }
 
   let(:object) { Class.new(Axiom::Types::Type).extend(described_class) }
 
+  # Test if Symbol encoding is supported
+  let(:symbol_encoding) do
+    ! RUBY_PLATFORM.include?('java') && begin
+      encoding = Encoding::UTF_32BE
+      ''.force_encoding(encoding).to_sym.encoding.equal?(encoding)
+    end
+  end
+
   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'
@@ -15,14 +23,24 @@ describe Axiom::Types::Encodable, '#finalize', :if => RUBY_VERSION >= '1.9' do
 
     its(:constraint) { should be_frozen }
 
-    defined?(::Encoding) && Encoding.list.each do |encoding|
-      if encoding.ascii_compatible?
+    Encoding.list.each do |encoding|
+      if encoding.equal?(Encoding::UTF_8)
+        string = '𝒜wesome'.force_encoding(encoding)
+        it "adds a constraint that returns true for #{encoding} encoding" do
+          should include(string)
+          should include(string.to_sym) if symbol_encoding
+        end
+      elsif encoding.ascii_compatible?
+        string = ''.force_encoding(encoding)
         it "adds a constraint that returns true for #{encoding} encoding" do
-          should include(''.force_encoding(encoding))
+          should include(string)
+          should include(string.to_sym) if symbol_encoding
         end
       else
+        string = ''.force_encoding(encoding)
         it "adds a constraint that returns false for #{encoding} encoding" do
-          should_not include(''.force_encoding(encoding))
+          should_not include(string)
+          should_not include(string.to_sym) if symbol_encoding
         end
       end
     end
@@ -40,14 +58,18 @@ describe Axiom::Types::Encodable, '#finalize', :if => RUBY_VERSION >= '1.9' do
 
     its(:constraint) { should be_frozen }
 
-    defined?(::Encoding) && Encoding.list.each do |encoding|
+    Encoding.list.each do |encoding|
       if encoding.equal?(Encoding::UTF_16BE)
+        string = '𝒜wesome'.force_encoding(encoding)
         it "adds a constraint that returns true for #{encoding} encoding" do
-          should include(''.force_encoding(encoding))
+          should include(string)
+          should include(string.to_sym) if symbol_encoding
         end
       else
+        string = ''.force_encoding(encoding)
         it "adds a constraint that returns false for #{encoding} encoding" do
-          should_not include(''.force_encoding(encoding))
+          should_not include(string)
+          should_not include(string.to_sym) if symbol_encoding
         end
       end
     end

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

@@ -12,25 +12,25 @@ describe Axiom::Types::Hash, '.infer' do
   context 'with Axiom::Types::Hash' do
     let(:object) { described_class }
 
-    context 'when the argument is the type object' do
+    context 'with a type object' do
       let(:arg) { object }
 
       it { should be(object) }
     end
 
-    context 'when the argument is ::Hash' do
+    context 'with a ::Hash' do
       let(:arg) { ::Hash }
 
       it { should be(object) }
     end
 
-    context 'when the argument is an empty Hash' do
+    context 'with 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
+    context 'with an Hash with a key type and nil value' do
       let(:arg) { ::Hash[object => nil] }
 
       its(:ancestors) { should include(object) }
@@ -42,7 +42,7 @@ describe Axiom::Types::Hash, '.infer' do
       its(:value_type) { should be(Axiom::Types::Object) }
     end
 
-    context 'when the argument is an Hash with a nil key and value type' do
+    context 'with an Hash with a nil key and value type' do
       let(:arg) { ::Hash[nil => object] }
 
       its(:ancestors) { should include(object) }
@@ -54,7 +54,7 @@ describe Axiom::Types::Hash, '.infer' do
       its(:value_type) { should be(object) }
     end
 
-    context 'when the argument is an Hash with key and value types' do
+    context 'with an Hash with key and value types' do
       let(:arg) { ::Hash[object => object] }
 
       its(:ancestors) { should include(object) }
@@ -66,7 +66,7 @@ describe Axiom::Types::Hash, '.infer' do
       its(:value_type) { should be(object) }
     end
 
-    context 'when the argument is an Hash with a key primitive and nil value' do
+    context 'with an Hash with a key primitive and nil value' do
       let(:arg) { ::Hash[::Hash => nil] }
 
       its(:ancestors) { should include(object) }
@@ -78,7 +78,7 @@ describe Axiom::Types::Hash, '.infer' do
       its(:value_type) { should be(Axiom::Types::Object) }
     end
 
-    context 'when the argument is an Hash with a nil key and value primitive' do
+    context 'with an Hash with a nil key and value primitive' do
       let(:arg) { ::Hash[nil => ::Hash] }
 
       its(:ancestors) { should include(object) }
@@ -90,7 +90,7 @@ describe Axiom::Types::Hash, '.infer' do
       its(:value_type) { should be(object) }
     end
 
-    context 'when the argument is an Hash with key and value primitives' do
+    context 'with an Hash with key and value primitives' do
       let(:arg) { ::Hash[::Hash => ::Hash] }
 
       its(:ancestors) { should include(object) }
@@ -124,49 +124,49 @@ describe Axiom::Types::Hash, '.infer' do
       it { should be(object) }
     end
 
-    context 'when the argument is an empty Hash' do
+    context 'with 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
+    context 'with 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
+    context 'with 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
+    context 'with 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
+    context 'with 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
+    context 'with 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
+    context 'with 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
+    context 'with a nil' do
       let(:arg) { nil }
 
       it { should be_nil }

data/spec/unit/axiom/types/infinity/class_methods/coerce_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Infinity, '.coerce' do
+  subject { object.coerce(other) }
+
+  let(:object) { described_class }
+
+  [
+    1,                # Fixnum
+    2**63,            # Bignum
+    1.0,              # Float
+    Rational(1, 1),   # Rational
+    BigDecimal('1'),  # BigDecimal
+  ].each do |number|
+    context "when other is a #{number.class}" do
+      let(:other) { number }
+
+      it 'coerces into an array containing inverse and self' do
+        should eql([Axiom::Types::NegativeInfinity, object])
+      end
+
+      it 'coerces when comparing' do
+        expect(other).to     be < object
+        expect(other).to_not be == object
+      end
+    end
+  end
+
+  context 'when other is a Float::INFINITY' do
+    let(:other) { Float::INFINITY }
+
+    it 'coerces into an array containing inverse and self' do
+      should eql([Axiom::Types::Infinity, object])
+    end
+
+    it 'coerces when comparing' do
+      expect(other).to_not be < object
+      expect(other).to     be == object
+    end
+  end
+
+  context 'when other is a -Float::INFINITY' do
+    let(:other) { -Float::INFINITY }
+
+    it 'coerces into an array containing inverse and self' do
+      should eql([Axiom::Types::NegativeInfinity, object])
+    end
+
+    it 'coerces when comparing' do
+      expect(other).to     be < object
+      expect(other).to_not be == object
+    end
+  end
+
+  context 'when other is not a number' do
+    let(:other) { 'string' }
+
+    specify do
+      expect { subject }.to raise_error(TypeError, 'String cannot be coerced')
+    end
+  end
+end

data/spec/unit/axiom/types/infinity/class_methods/spaceship_operator_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::Infinity, '.<=>' do
+  subject { object <=> other }
+
+  let(:object) { described_class }
+
+  [
+    1,                # Fixnum
+    2**63,            # Bignum
+    1.0,              # Float
+    Rational(1, 1),   # Rational
+    BigDecimal('1'),  # BigDecimal
+  ].each do |number|
+    context "when other object is a #{number.class}" do
+      let(:other) { number }
+
+      it { should be(1) }
+
+      it 'is symmetric' do
+        should be(-(other <=> object))
+      end
+    end
+  end
+
+  context 'when the other object is negative infinity' do
+    let(:other) { Axiom::Types::NegativeInfinity }
+
+    it { should be(1) }
+
+    it 'is symmetric' do
+      should be(-(other <=> object))
+    end
+  end
+
+  context 'when the other object is infinity' do
+    let(:other) { object }
+
+    it { should be(0) }
+
+    it 'is symmetric' do
+      should be(-(other <=> object))
+    end
+  end
+
+  context 'when the other object is Float::INFINITY' do
+    let(:other) { Float::INFINITY }
+
+    it { should be(0) }
+
+    it 'is symmetric' do
+      should be(-(other <=> object))
+    end
+  end
+
+  context 'when the other object is not comparable' do
+    let(:other) { 'string' }
+
+    it { should be_nil }
+
+    it 'is symmetric' do
+      should be(other <=> object)
+    end
+  end
+end

data/spec/unit/axiom/types/infinity/class_methods/succ_spec.rb

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

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

@@ -9,24 +9,33 @@ describe Axiom::Types::LengthComparable, '.extended' do
 
   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.
+    # 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(:undef_method, :extended)
     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)
+    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)
+    expect { subject }.to change { object.respond_to?(:maximum_length) }
+      .from(false).to(true)
+  end
+
+  it 'sets the default minimum_length' do
+    expect(subject.minimum_length).to equal(Axiom::Types::Infinity)
+  end
+
+  it 'sets the default maximum_length' do
+    expect(subject.maximum_length).to equal(Axiom::Types::NegativeInfinity)
   end
 end

data/spec/unit/axiom/types/negative_infinity/class_methods/spaceship_operator_spec.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Axiom::Types::NegativeInfinity, '.<=>' do
+  subject { object <=> other }
+
+  let(:object) { described_class }
+
+  [
+    1,                # Fixnum
+    2**63,            # Bignum
+    1.0,              # Float
+    Rational(1, 1),   # Rational
+    BigDecimal('1'),  # BigDecimal
+  ].each do |number|
+    context "when other object is a #{number.class}" do
+      let(:other) { number }
+
+      it { should be(-1) }
+
+      it 'is symmetric' do
+        should be(-(other <=> object))
+      end
+    end
+  end
+
+  context 'when the other object is infinity' do
+    let(:other) { Axiom::Types::Infinity }
+
+    it { should be(-1) }
+
+    it 'is symmetric' do
+      should be(-(other <=> object))
+    end
+  end
+
+  context 'when the other object is negative infinity' do
+    let(:other) { object }
+
+    it { should be(0) }
+
+    it 'is symmetric' do
+      should be(other <=> object)
+    end
+  end
+
+  context 'when the other object is -Float::INFINITY' do
+    let(:other) { -Float::INFINITY }
+
+    it { should be(0) }
+
+    it 'is symmetric' do
+      should be(other <=> object)
+    end
+  end
+
+  context 'when the other object is not comparable' do
+    let(:other) { 'string' }
+
+    it { should be_nil }
+
+    it 'is symmetric' do
+      should be(other <=> object)
+    end
+  end
+end