type 0.1.0 → 0.2.0

data/.travis.yml

@@ -0,0 +1,9 @@
+---
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Next release (TBD)
 
+## 0.2.0 (2014-02-01)
+
+ - Improve Type::Boolean to cast truthy and falsy objects to true and false.
+ - Improve exception message when casting an out-of-range integer via one of
+   the range-limited Integer type definitions (e.g., Int32)
+ - Improve performance when casting already-valid objects.
+ - Fixed tests for JRuby and Type::Int64
+ - Fixed Type::Hash to make it less surprising on Ruby 2+ via `Kernel::Hash()`
+
 ## 0.1.0 (2014-01-29)
 
  - Initial Implementation

data/CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributing
 
-`Type` is [Apache-liennsed](LICENSE.txt).
+`Type` is [Apache-licensed](LICENSE.txt).
 
 ## Git-Flow
 

data/Gemfile

@@ -2,5 +2,12 @@
 
 source 'https://rubygems.org'
 
+platforms :rbx do
+  # These are the ruby standard library dependencies
+  gem 'rubysl-irb'
+  gem 'rubysl-singleton'
+  gem 'rubysl-set'
+end
+
 # Gem dependencies are specified in the gemspec
 gemspec

data/README.md

@@ -37,6 +37,12 @@ Type::Int32!(input) # alias for Type::Int32.cast!(input)
 `Type` comes with a variety of built-in type defintions, which can be used for
 validation or casting.
 
+ - [Scalar](#scalar-type-definitions)
+ - [Nilable Modifier](#nilable-type-definitions)
+ - [Collection](#collection-type-definitions)
+ - [Constrained Collections](#constrained-collection-type-definitions)
+ - [Nilable Constrained Collections](#nilable-constrained-collection-type-definitions)
+
 ### Scalar Type Definitions:
 
 The most basic type definitions are scalar
@@ -63,6 +69,21 @@ Type::Int32!('three')
 #! Type::CastError: Could not cast "three"(String) with Type::Int32
 ~~~
 
+The complete list of built-in scalar type definitions is:
+
+~~~ ruby
+Type::Integer # {x∈ℤ}
+Type::Int32   # {x∈ℤ|[-2^31,2^31)}
+Type::Int64   # {x∈ℤ|[-2^63,2^63)}
+Type::UInt32  # {x∈ℕ|[0,2^32)}
+Type::UInt64  # {x∈ℕ|[0,2^64)}
+Type::Float   # {x∈ℝ,+∞,-∞}
+Type::Float32 # {x∈ℝ}
+Type::Float64 # {x∈ℝ}
+Type::Boolean # {true,false}
+Type::String  # any string
+~~~
+
 ### Nilable Type Definitions:
 
 Any `Type::Definition` can be declared nilable -- that is, it will report `nil`
@@ -109,6 +130,14 @@ Type::Set!('foo')
 #! Type::CastError: Could not cast "foo"(String) with Type::Set
 ~~~
 
+The complete list of built-in collection type definitions is:
+
+~~~ ruby
+Type::Array
+Type::Set
+Type::Hash
+~~~
+
 ### Constrained Collection Type Definitions:
 
 The real power of type-casting collections is when their contents can also be

data/lib/type/builtin.rb

@@ -1,111 +1,4 @@
 # encoding: utf-8
 
-# The built-in types are defined here.
-module Type
-  scalar(:Integer) do
-    validate do |input|
-      input.kind_of?(::Integer)
-    end
-    cast do |input|
-      Kernel::Integer(input)
-    end
-  end
-
-  scalar(:Int32).from(:Integer) do
-    int32_range = (-(1 << 31) ... (1 << 31))
-    validate do |input|
-      int32_range.include?(input)
-    end
-  end
-
-  scalar(:Int64).from(:Integer) do
-    int64_range = (-(1 << 63) ... (1 << 63))
-    validate do |input|
-      int64_range.include?(input)
-    end
-  end
-
-  scalar(:UInt32).from(:Integer) do
-    int32_range = (0 ... (1 << 32))
-    validate do |input|
-      int32_range.include?(input)
-    end
-  end
-
-  scalar(:UInt64).from(:Integer) do
-    int64_range = (0 ... (1 << 64))
-    validate do |input|
-      int64_range.include?(input)
-    end
-  end
-
-  scalar(:Float) do
-    validate do |input|
-      input.kind_of?(::Float)
-    end
-    cast do |input|
-      Kernel::Float(input)
-    end
-  end
-
-  scalar(:Float32).from(:Float) do
-    validate do |input|
-      input.finite?
-    end
-  end
-
-  scalar(:Float64).from(:Float) do
-    validate do |input|
-      input.finite?
-    end
-  end
-
-  scalar(:Boolean) do
-    require 'set'
-    booleans = Set.new([true, false])
-    validate do |input|
-      booleans.include?(input)
-    end
-  end
-
-  scalar(:String) do
-    validate do |input|
-      input.kind_of?(::String)
-    end
-    cast do |input|
-      Kernel::String(input)
-    end
-  end
-
-  collection(:Array) do
-    validate do |input|
-      input.kind_of?(::Array)
-    end
-    cast do |input|
-      Kernel::Array(input)
-    end
-  end
-
-  collection(:Hash) do
-    validate do |input|
-      input.kind_of?(::Hash)
-    end
-    cast do |input|
-      if Kernel.respond_to?(:Hash)
-        Kernel::Hash(input)
-      else
-        ::Hash[input]
-      end
-    end
-  end
-
-  collection(:Set) do
-    require 'set'
-    validate do |input|
-      input.kind_of?(::Set)
-    end
-    cast do |input|
-      ::Set.new(input)
-    end
-  end
-end
+require 'type/builtin/scalar'
+require 'type/builtin/collection'

data/lib/type/builtin/collection.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+# The built-in collection types are defined here.
+module Type
+  collection(:Array) do
+    validate do |input|
+      input.kind_of?(::Array)
+    end
+    cast do |input|
+      Kernel::Array(input)
+    end
+  end
+
+  collection(:Hash) do
+    validate do |input|
+      input.kind_of?(::Hash)
+    end
+
+    cast_1_9 = proc do |input|
+      ::Hash[input]
+    end
+
+    cast_2_0 = proc do |input|
+      begin
+        Kernel::Hash(input)
+      rescue TypeError
+        cast_1_9[input]
+      end
+    end
+
+    cast do |input|
+      if Kernel.respond_to?(:Hash)
+        cast_2_0[input]
+      else
+        cast_1_9[input]
+      end
+    end
+  end
+
+  collection(:Set) do
+    require 'set'
+    validate do |input|
+      input.kind_of?(::Set)
+    end
+    cast do |input|
+      ::Set.new(input)
+    end
+  end
+end

data/lib/type/builtin/scalar.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+# The built-in scalar types are defined here.
+module Type
+  scalar(:Integer) do
+    validate do |input|
+      input.kind_of?(::Integer)
+    end
+    cast do |input|
+      Kernel::Integer(input)
+    end
+  end
+
+  scalar(:Int32).from(:Integer) do
+    int32_range = (-(1 << 31) ... (1 << 31))
+    validate do |input|
+      unless int32_range.include?(input)
+        raise RangeError.new("#{input} not in #{int32_range}")
+      end
+      true
+    end
+  end
+
+  scalar(:Int64).from(:Integer) do
+    int64_range = (-(1 << 63) ... (1 << 63))
+    validate do |input|
+      unless int64_range.include?(input)
+        raise RangeError.new("#{input} not in #{int64_range}")
+      end
+      true
+    end
+  end
+
+  scalar(:UInt32).from(:Integer) do
+    uint32_range = (0 ... (1 << 32))
+    validate do |input|
+      unless uint32_range.include?(input)
+        raise RangeError.new("#{input} not in #{uint32_range}")
+      end
+      true
+    end
+  end
+
+  scalar(:UInt64).from(:Integer) do
+    uint64_range = (0 ... (1 << 64))
+    validate do |input|
+      unless uint64_range.include?(input)
+        raise RangeError.new("#{input} not in #{uint64_range}")
+      end
+      true
+    end
+  end
+
+  scalar(:Float) do
+    validate do |input|
+      input.kind_of?(::Float)
+    end
+    cast do |input|
+      Kernel::Float(input)
+    end
+  end
+
+  scalar(:Float32).from(:Float) do
+    validate do |input|
+      input.finite?
+    end
+  end
+
+  scalar(:Float64).from(:Float) do
+    validate do |input|
+      input.finite?
+    end
+  end
+
+  scalar(:Boolean) do
+    require 'set'
+    booleans = Set.new([true, false])
+    validate do |input|
+      booleans.include?(input)
+    end
+    cast do |input|
+      input ? true : false
+    end
+  end
+
+  scalar(:String) do
+    validate do |input|
+      input.kind_of?(::String)
+    end
+    cast do |input|
+      raise TypeError if input.nil?
+      Kernel::String(input)
+    end
+  end
+end

data/lib/type/definition.rb

@@ -89,10 +89,12 @@ module Type
     attr_reader :name
 
     # @param input [Object]
+    # @param squash_exceptions [Boolean] (true)
     # @return [Boolean]
-    def valid?(input)
+    def valid?(input, squash_exceptions = true)
       validators.all? { |proc| proc[input] }
-    rescue
+    rescue Exception
+      raise unless squash_exceptions
       false
     end
 
@@ -100,12 +102,11 @@ module Type
     # @return [Object] the result of casting, guaranteed to be valid.
     # @raise [Type::CastError]
     def cast!(input)
-      input = yield if block_given?
-      raise CastError.new(input, self) if input.nil?
+      return input if valid?(input)
       castors.reduce(input) do |intermediate, castor|
         castor[intermediate]
       end.tap do |output|
-        raise ValidationError.new(output, self) unless valid?(output)
+        raise ValidationError.new(output, self) unless valid?(output, false)
       end
     rescue
       raise CastError.new(input, self)

data/lib/type/definition/collection.rb

@@ -17,7 +17,7 @@ module Type
     class Collection
       include Definition
 
-      def valid?(input, &block)
+      def valid?(input, *args, &block)
         return false unless input.kind_of?(Enumerable)
         super
       end

data/lib/type/definition/nilable.rb

@@ -25,7 +25,7 @@ module Type
       end
 
       # Returns true if input is nil *or* the input is valid
-      def valid?(input)
+      def valid?(input, *args)
         input.nil? || super
       end
 

data/lib/type/version.rb

@@ -2,5 +2,5 @@
 
 module Type
   # The Type gem is semantically versioned.
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/spec/spec_helper.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+RSpec::Matchers.define(:cast) do |input|
+  match do |definition|
+    begin
+      @actual = definition.cast!(input)
+      if @chained
+        failure_message_for_should do
+          "Expected result to be #{@expected.inspect}(#{@expected.class}) " +
+          "but got #{@actual.inspect}(#{@actual.class}) instead"
+        end
+        @expected == @actual
+      else
+        true
+      end
+    rescue Type::CastError => cast_error
+      failure_message_for_should do
+        "#{definition} failed to cast #{input.inspect}(#{input.class}) " +
+        "by raising #{cast_error}(#{cast_error.cause})."
+      end
+      false
+    end
+  end
+
+  description do
+    "cast #{input.inspect}(#{input.class})"
+  end
+
+  chain(:to) do |expected|
+    description do
+      "cast #{input.inspect}(#{input.class}) to #{expected.inspect}(#{expected.class})"
+    end
+    @chained = true
+    @expected = expected
+  end
+
+  chain(:unchanged) do
+    description do
+      "cast #{input.inspect}(#{input.class}) unchanged"
+    end
+    @chained = true
+    @expected = input
+  end
+end
+
+RSpec::Matchers.define :validate do |input|
+  match do |definition|
+    definition.valid?(input)
+  end
+  description do
+    "validate #{input.inspect}(#{input.class})"
+  end
+end
+
+shared_examples_for 'Type::Definition::Nilable compatibility' do
+  context 'when nilable' do
+    subject { described_class.nilable }
+    it { should be_a_kind_of Type::Definition::Nilable }
+    it { should be_nilable }
+    it { should cast(nil).to(nil) }
+    it { should validate(nil) }
+  end
+  it { should_not be_a_kind_of Type::Definition::Nilable }
+  it { should_not be_nilable }
+  it { should_not validate(nil) }
+end

data/spec/type/builtin/collection_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+require 'type'
+
+require_relative '../../spec_helper'
+
+describe Type::Array do
+  its(:to_s) { should match(/Type::Array/) }
+  it { should_not cast(nil) }
+  it { should be_a_kind_of Type::Definition::Collection }
+  it { should validate(['asdf']) }
+  it { should cast(['foo']).unchanged }
+  it { should cast(['asdf', 1]).unchanged }
+end
+
+describe Type::Array.of(:String) do
+  its(:to_s) { should match(/Type::Array\(.*String.*\)/) }
+  it { should_not cast(nil) }
+  it { should be_a_kind_of Type::Definition::Collection::Constrained }
+  it { should validate(['asdf']) }
+  it { should_not validate([nil, 'asdf']) }
+  it { should_not validate([:asdf]) }
+  it { should cast([:abc, 1]).to(['abc', '1']) }
+  it { should_not cast([nil, 1]) }
+end
+
+describe Type::Array.of(:String?) do
+  it { should be_a_kind_of Type::Definition::Collection::Constrained }
+  it { should_not cast(nil) }
+  it { should validate(['asdf']) }
+  it { should validate([nil, 'asdf']) }
+  it { should_not validate([:asdf]) }
+  it { should cast([:abc, 1]).to(['abc', '1']) }
+  it { should cast([nil, 1]).to([nil, '1']) }
+end
+
+describe Type::Hash do
+  its(:to_s) { should match(/Type::Hash/) }
+  it { should_not cast(nil) }
+  it { should cast([[1, 2], [3, 4]]).to(1 => 2, 3 => 4) }
+  it { should_not cast(17) }
+end
+
+describe Type::Hash.of(:String => :Integer) do
+  its(:to_s) { should match(/Type::Hash\(.*String.*Integer.*\)/) }
+  it { should_not cast(nil) }
+  it { should be_a_kind_of Type::Definition::Collection::Constrained }
+  it { should validate('foo' => 12) }
+  it { should_not validate(foo: 12) }
+  it { should_not validate('foo' => '12') }
+  it { should cast('foo' => '12', :bar => 3).to('foo' => 12, 'bar' => 3) }
+  it { should cast('foo' => 12, 'bar' => 3).unchanged }
+  it { should cast([['12', 34], [56, '78']]).to('12' => 34, '56' => 78) }
+  it { should_not cast('foo' => 'foo') }
+end
+
+describe Type::Set do
+  it { should_not cast(nil) }
+  it { should_not validate([123, 456]) }
+  it { should validate(Set.new([123, 456])) }
+  it { should_not validate(17) }
+  it { should cast([123, 456]).to(Set.new([123, 456])) }
+  it { should cast(Set.new([123, 456])).to(Set.new([123, 456])) }
+  it { should_not cast(17) }
+end
+
+describe Type::Set.of(:Integer) do
+  its(:to_s) { should match(/Type::Set(.*Integer.*)/) }
+  it { should_not cast(nil) }
+  it { should validate(Set.new([1, 2, 3, 4])) }
+  it { should_not validate([1, 2, 3, 4]) }
+  it { should cast(Set.new([1, 2, 3, 4])).unchanged }
+  it { should cast([1, 2, 3, 4]).to(Set.new([1, 2, 3, 4])) }
+end

data/spec/type/builtin/scalar_spec.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+require 'type'
+
+require_relative '../../spec_helper'
+
+shared_examples_for 'Type::Definition::Scalar' do
+  include_examples 'Type::Definition::Nilable compatibility'
+  it { should be_a_kind_of Type::Definition }
+  it { should be_a_kind_of Type::Definition::Scalar }
+end
+
+shared_examples_for 'Type::Integer' do
+  it_should_behave_like 'Type::Definition::Scalar'
+  it { should_not cast(nil) }
+
+  it { should cast(414).unchanged }
+  it { should cast('123').to(123) }
+  it { should cast(456).to(456) }
+  it { should cast(Math::PI).to(3) } # alabama ftw
+
+  it { should_not cast('not a number') }
+  it { should_not cast(Hash.new) }
+
+  it { should validate(123) }
+  it { should_not validate('123') }
+end
+
+describe Type::Integer do
+  it_should_behave_like 'Type::Integer'
+end
+
+shared_examples_for 'bounded Type::Integer' do
+  it_should_behave_like 'Type::Integer'
+
+  let(:range_max) { valid_range.end - (valid_range.exclude_end? ? 1 : 0) }
+  let(:range_min) { valid_range.begin }
+
+  it { should cast(range_max).unchanged }
+  it { should cast(range_min).unchanged }
+
+  it { should_not cast(range_max + 1) }
+  it { should_not cast(range_min - 1) }
+
+  it { should validate(range_max) }
+  it { should_not validate(range_max + 1) }
+  it { should validate(range_min) }
+  it { should_not validate(range_min - 1) }
+end
+
+describe Type::Int32 do
+  let(:valid_range) { (-1 << 31)...(1 << 31) }
+  it_should_behave_like 'bounded Type::Integer'
+end
+
+describe Type::Int64 do
+  let(:valid_range) { (-1 << 63)...(1 << 63) }
+  it_should_behave_like 'bounded Type::Integer'
+end
+
+describe Type::UInt32 do
+  let(:valid_range) { 0...(1 << 32) }
+  it_should_behave_like 'bounded Type::Integer'
+end
+
+describe Type::UInt64 do
+  let(:valid_range) { 0...(1 << 64) }
+  it_should_behave_like 'bounded Type::Integer'
+end
+
+describe Type::Boolean do
+  it_should_behave_like 'Type::Definition::Scalar'
+  it { should validate true }
+  it { should validate false }
+  it { should_not validate nil }
+  it { should_not validate 'true' }
+  it { should_not validate 'false' }
+  it { should cast(true).unchanged }
+  it { should cast(false).unchanged }
+  it { should cast(nil).to(false) }
+  it { should cast(Object.new).to(true) }
+end
+
+shared_examples_for 'Type::Float' do
+  it_should_behave_like 'Type::Definition::Scalar'
+  it { should_not cast(nil) }
+  it { should cast(10).to(10.0) }
+  it { should cast(12.3).unchanged }
+  it { should cast('12.3').to(12.3) }
+  it { should cast('123e-1').to(12.3) }
+  it { should cast('12.3e10').to(123000000000.0) }
+  it { should cast('123e10').to(1230000000000.0) }
+  it { should_not cast('a string') }
+  it { should_not cast(Hash.new) }
+  it { should validate(12.3) }
+  it { should_not validate(12) }
+end
+
+describe Type::Float do
+  include_examples 'Type::Float'
+  it { should validate(Float::INFINITY) }
+  it { should validate(-Float::INFINITY) }
+end
+
+describe Type::Float32 do
+  include_examples 'Type::Float'
+  it { should_not validate(Float::INFINITY) }
+  it { should_not validate(-Float::INFINITY) }
+end
+
+describe Type::Float64 do
+  include_examples 'Type::Float'
+  it { should_not validate(Float::INFINITY) }
+  it { should_not validate(-Float::INFINITY) }
+end
+
+describe Type::String do
+  its(:to_s) { should match(/Type::String/) }
+  it { should_not cast(nil) }
+  it_should_behave_like 'Type::Definition::Scalar'
+  it { should cast(:abc).to('abc') }
+end

data/spec/type/definition_spec.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 require 'type'
 
+require_relative '../spec_helper'
+
 Proc.const_set(:IDENTITY, ->(x) { x }) unless defined?(Proc::IDENTITY)
 
 describe Type::Definition do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: type
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-29 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,6 +101,7 @@ extra_rdoc_files: []
 files:
 - .githooks/pre-commit/ruby-appraiser
 - .gitignore
+- .travis.yml
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -109,6 +110,8 @@ files:
 - Rakefile
 - lib/type.rb
 - lib/type/builtin.rb
+- lib/type/builtin/collection.rb
+- lib/type/builtin/scalar.rb
 - lib/type/definition.rb
 - lib/type/definition/collection.rb
 - lib/type/definition/collection/constrained.rb
@@ -117,7 +120,9 @@ files:
 - lib/type/definition/scalar.rb
 - lib/type/error.rb
 - lib/type/version.rb
-- spec/type/builtin_spec.rb
+- spec/spec_helper.rb
+- spec/type/builtin/collection_spec.rb
+- spec/type/builtin/scalar_spec.rb
 - spec/type/definition_spec.rb
 - type.gemspec
 homepage: https://github.com/simplymeasured/type-gem
@@ -146,6 +151,8 @@ signing_key:
 specification_version: 3
 summary: Type validation and Type casting
 test_files:
-- spec/type/builtin_spec.rb
+- spec/spec_helper.rb
+- spec/type/builtin/collection_spec.rb
+- spec/type/builtin/scalar_spec.rb
 - spec/type/definition_spec.rb
 has_rdoc: 

data/spec/type/builtin_spec.rb

@@ -1,242 +0,0 @@
-# encoding: utf-8
-require 'type'
-
-RSpec::Matchers.define(:cast) do |input|
-  match do |definition|
-    begin
-      @actual = definition.cast!(input)
-      if @chained
-        failure_message_for_should do
-          "Expected result to be #{@expected.inspect}(#{@expected.class}) " +
-          "but got #{@actual.inspect}(#{@actual.class}) instead"
-        end
-        @expected == @actual
-      else
-        true
-      end
-    rescue Type::CastError => cast_error
-      failure_message_for_should do
-        "#{definition} failed to cast #{input.inspect}(#{input.class}) " +
-        "by raising #{cast_error}(#{cast_error.cause})."
-      end
-      false
-    end
-  end
-
-  description do
-    "cast #{input.inspect}(#{input.class})"
-  end
-
-  chain(:to) do |expected|
-    description do
-      "cast #{input.inspect}(#{input.class}) to #{expected.inspect}(#{expected.class})"
-    end
-    @chained = true
-    @expected = expected
-  end
-
-  chain(:unchanged) do
-    description do
-      "cast #{input.inspect}(#{input.class}) unchanged"
-    end
-    @chained = true
-    @expected = input
-  end
-end
-
-RSpec::Matchers.define :validate do |input|
-  match do |definition|
-    definition.valid?(input)
-  end
-  description do
-    "validate #{input.inspect}(#{input.class})"
-  end
-end
-
-shared_examples_for 'Type::Definition::Nilable compatibility' do
-  context 'when nilable' do
-    subject { described_class.nilable }
-    it { should be_a_kind_of Type::Definition::Nilable }
-    it { should be_nilable }
-    it { should cast(nil).to(nil) }
-    it { should validate(nil) }
-    it { should_not cast(Object.new) unless described_class == Type::String }
-  end
-  it { should_not be_a_kind_of Type::Definition::Nilable }
-  it { should_not be_nilable }
-  it { should_not cast(nil) }
-  it { should_not validate(nil) }
-  it { should_not cast(Object.new) unless described_class == Type::String }
-end
-
-shared_examples_for 'Type::Definition::Scalar' do
-  include_examples 'Type::Definition::Nilable compatibility'
-  it { should be_a_kind_of Type::Definition }
-  it { should be_a_kind_of Type::Definition::Scalar }
-end
-
-shared_examples_for 'Type::Integer' do
-  it_should_behave_like 'Type::Definition::Scalar'
-
-  it { should cast(414).unchanged }
-  it { should cast('123').to(123) }
-  it { should cast(456).to(456) }
-  it { should cast(Math::PI).to(3) } # alabama ftw
-
-  it { should_not cast('not a number') }
-  it { should_not cast(Hash.new) }
-
-  it { should validate(123) }
-  it { should_not validate('123') }
-end
-
-shared_examples_for 'bounded Type::Integer' do
-  it_should_behave_like 'Type::Integer'
-
-  let(:range_max) { valid_range.end - (valid_range.exclude_end? ? 1 : 0) }
-  let(:range_min) { valid_range.begin }
-
-  it { should cast(range_max).unchanged }
-  it { should cast(range_min).unchanged }
-
-  it { should_not cast(range_max.next) }
-  it { should_not cast(range_min.pred) }
-
-  it { should validate(range_max) }
-  it { should_not validate(range_max.next) }
-end
-
-describe Type::Integer do
-  it_should_behave_like 'Type::Integer'
-end
-
-describe Type::Int32 do
-  let(:valid_range) { (-1 << 31)...(1 << 31) }
-  it_should_behave_like 'bounded Type::Integer'
-end
-
-describe Type::Int64 do
-  let(:valid_range) { (-1 << 63)...(1 << 63) }
-  it_should_behave_like 'bounded Type::Integer'
-end
-
-describe Type::UInt32 do
-  let(:valid_range) { 0...(1 << 32) }
-  it_should_behave_like 'bounded Type::Integer'
-end
-
-describe Type::UInt64 do
-  let(:valid_range) { 0...(1 << 64) }
-  it_should_behave_like 'bounded Type::Integer'
-end
-
-describe Type::Boolean do
-  it_should_behave_like 'Type::Definition::Scalar'
-  it { should validate true }
-  it { should validate false }
-  it { should_not validate nil }
-  it { should_not validate 'true' }
-  it { should_not validate 'false' }
-  it { should cast(true).unchanged }
-  it { should cast(false).unchanged }
-end
-
-shared_examples_for 'Type::Float' do
-  it_should_behave_like 'Type::Definition::Scalar'
-  it { should cast(10).to(10.0) }
-  it { should cast(12.3).unchanged }
-  it { should cast('12.3').to(12.3) }
-  it { should cast('123e-1').to(12.3) }
-  it { should cast('12.3e10').to(123000000000.0) }
-  it { should cast('123e10').to(1230000000000.0) }
-  it { should_not cast('a string') }
-  it { should_not cast(Hash.new) }
-  it { should validate(12.3) }
-  it { should_not validate(12) }
-end
-
-describe Type::Float do
-  include_examples 'Type::Float'
-  it { should validate(Float::INFINITY) }
-  it { should validate(-Float::INFINITY) }
-end
-
-describe Type::Float32 do
-  include_examples 'Type::Float'
-  it { should_not validate(Float::INFINITY) }
-  it { should_not validate(-Float::INFINITY) }
-end
-
-describe Type::Float64 do
-  include_examples 'Type::Float'
-  it { should_not validate(Float::INFINITY) }
-  it { should_not validate(-Float::INFINITY) }
-end
-
-describe Type::String do
-  its(:to_s) { should match(/Type::String/) }
-  it_should_behave_like 'Type::Definition::Scalar'
-  it { should cast(:abc).to('abc') }
-end
-
-describe Type::Array do
-  its(:to_s) { should match(/Type::Array/) }
-  it { should be_a_kind_of Type::Definition::Collection }
-  it { should validate(['asdf']) }
-  it { should cast(['foo']).unchanged }
-  it { should cast(['asdf', 1]).unchanged }
-end
-
-describe Type::Array.of(:String) do
-  its(:to_s) { should match(/Type::Array\(.*String.*\)/) }
-  it { should be_a_kind_of Type::Definition::Collection::Constrained }
-  it { should validate(['asdf']) }
-  it { should_not validate([nil, 'asdf']) }
-  it { should_not validate([:asdf]) }
-  it { should cast([:abc, 1]).to(['abc', '1']) }
-  it { should_not cast([nil, 1]) }
-end
-
-describe Type::Array.of(:String?) do
-  it { should be_a_kind_of Type::Definition::Collection::Constrained }
-  it { should validate(['asdf']) }
-  it { should validate([nil, 'asdf']) }
-  it { should_not validate([:asdf]) }
-  it { should cast([:abc, 1]).to(['abc', '1']) }
-  it { should cast([nil, 1]).to([nil, '1']) }
-end
-
-describe Type::Hash do
-  its(:to_s) { should match(/Type::Hash/) }
-  it { should cast([[1, 2], [3, 4]]).to(1 => 2, 3 => 4) }
-  it { should_not cast(17) }
-end
-
-describe Type::Hash.of(:String => :Integer) do
-  its(:to_s) { should match(/Type::Hash\(.*String.*Integer.*\)/) }
-  it { should be_a_kind_of Type::Definition::Collection::Constrained }
-  it { should validate('foo' => 12) }
-  it { should_not validate(foo: 12) }
-  it { should_not validate('foo' => '12') }
-  it { should cast('foo' => '12', :bar => 3).to('foo' => 12, 'bar' => 3) }
-  it { should cast('foo' => 12, 'bar' => 3).unchanged }
-  it { should cast([['12', 34], [56, '78']]).to('12' => 34, '56' => 78) }
-  it { should_not cast('foo' => 'foo') }
-end
-
-describe Type::Set do
-  it { should_not validate([123, 456]) }
-  it { should validate(Set.new([123, 456])) }
-  it { should_not validate(17) }
-  it { should cast([123, 456]).to(Set.new([123, 456])) }
-  it { should cast(Set.new([123, 456])).to(Set.new([123, 456])) }
-  it { should_not cast(17) }
-end
-
-describe Type::Set.of(:Integer) do
-  its(:to_s) { should match(/Type::Set(.*Integer.*)/) }
-  it { should validate(Set.new([1, 2, 3, 4])) }
-  it { should_not validate([1, 2, 3, 4]) }
-  it { should cast(Set.new([1, 2, 3, 4])).unchanged }
-  it { should cast([1, 2, 3, 4]).to(Set.new([1, 2, 3, 4])) }
-end