gorillib-model 0.0.1

data/lib/gorillib/model/serialization.rb

@@ -0,0 +1,41 @@
+require_relative 'serialization/to_wire'
+require_relative 'serialization/lines'
+require_relative 'serialization/csv'
+require_relative 'serialization/tsv'
+require_relative 'serialization/json'
+
+class Array
+  def to_tsv
+    to_wire.join("\t")
+  end
+end
+
+module Gorillib
+  module Model
+
+    def to_wire(options={})
+      compact_attributes.merge(:_type => self.class.typename).inject({}) do |acc, (key,attr)|
+        acc[key] = attr.respond_to?(:to_wire) ? attr.to_wire(options) : attr
+        acc
+      end
+    end
+    def as_json(*args) to_wire(*args) ; end
+
+    def to_json(options={})
+      MultiJson.dump(to_wire(options), options)
+    end
+
+    def to_tsv(options={})
+      attributes.map do |key, attr|
+        attr.respond_to?(:to_wire) ? attr.to_wire(options) : attr
+      end.join("\t")
+    end
+
+    module ClassMethods
+      def from_tuple(*vals)
+        receive Hash[field_names[0..vals.length-1].zip(vals)]
+      end
+    end
+
+  end
+end

data/lib/gorillib/model/type/extended.rb

@@ -0,0 +1,83 @@
+require_relative 'ip_address'
+require_relative 'url'
+
+::Long      = Class.new ::Integer
+::Double    = Class.new ::Float
+::Binary    = Class.new ::String
+
+::Guid      = Class.new ::String
+::Hostname  = Class.new ::String
+
+::EpochTime = Class.new ::Integer
+::IntTime   = Class.new ::EpochTime
+
+module Gorillib
+  module Factory
+    class GuidFactory      < StringFactory ; self.product = ::Guid      ; register_factory! ; end
+    class HostnameFactory  < StringFactory ; self.product = ::Hostname  ; register_factory! ; end
+    class IpAddressFactory < StringFactory ; self.product = ::IpAddress ; register_factory! ; end
+
+    class DateFactory  < ConvertingFactory
+      self.product = Date
+      FLAT_DATE_RE = /\A\d{8}Z?\z/
+      register_factory!
+      #
+      def convert(obj)
+        case obj
+        when FLAT_DATE_RE  then product.new(obj[0..3].to_i, obj[4..5].to_i, obj[6..7].to_i)
+        when Time          then Date.new(obj.year, obj.month, obj.day)
+        when String        then Date.parse(obj)
+        else                    mismatched!(obj)
+        end
+      rescue ArgumentError => err
+        raise if err.is_a?(TypeMismatchError)
+        warn "Cannot parse time #{obj}: #{err}"
+        return nil
+      end
+    end
+
+    class EpochTimeFactory < ConvertingFactory
+      self.product = Integer
+      def self.typename() :epoch_time ; end
+      register_factory!   :epoch_time, EpochTime
+      #
+      def convert(obj)
+        case obj
+        when Numeric           then obj.to_f
+        when Time              then obj.to_f
+        when /\A\d{14}Z?\z/    then Time.parse(obj)
+        when String            then Time.parse_safely(obj).to_f
+        end
+      end
+    end
+
+    class IntTimeFactory < EpochTimeFactory
+      def self.typename() :int_time ; end
+      register_factory!   :int_time, IntTime
+      #
+      def convert(obj)
+        result = super
+        result.nil? ? nil : result.to_i
+      end
+    end
+
+    class Boolean10Factory < BooleanFactory
+      def self.typename() :boolean_10 ; end
+      register_factory!   :boolean_10
+      #
+      def convert(obj)
+        case obj.to_s
+        when "0" then false
+        when "1" then true
+        else          super
+        end
+      end
+    end
+
+    class SetFactory < EnumerableFactory
+      self.product = Set
+      register_factory!
+    end
+
+  end
+end

data/lib/gorillib/model/type/ip_address.rb

@@ -0,0 +1,153 @@
+module IpAddresslike
+  ONES = 0xFFFFFFFF
+
+  # Masks off all but the `bitness` most-significant-bits
+  #
+  # @example /24 keeps only the first three quads
+  #   IpAddress.new('1.2.3.4').bitness_min(24) # '1.2.3.0'
+  #
+  def bitness_min(bitness)
+    raise ArgumentError, "IP addresses have only 32 bits (got #{bitness.inspect})" unless (0..32).include?(bitness)
+    lsbs = 32 - bitness
+    (packed >> lsbs) << lsbs
+  end
+
+  # Masks off all but the `bitness` most-significant-bits, filling with ones
+  #
+  # @example /24 fills the last quad
+  #   IpAddress.new('1.2.3.4').bitness_min(24) # '1.2.3.255'
+  #
+  def bitness_max(bitness)
+    raise ArgumentError, "IP addresses have only 32 bits (got #{bitness.inspect})" unless (0..32).include?(bitness)
+    packed | (ONES >> bitness)
+  end
+
+  def to_hex
+    "%08x" % packed
+  end
+
+  def to_s
+    dotted
+  end
+
+end
+
+class ::IpAddress < ::String
+  include IpAddresslike
+
+  def dotted
+    self
+  end
+
+  def to_i
+    packed
+  end
+
+  # @return [Integer] the 32-bit integer for this IP address
+  def packed
+    ip_a, ip_b, ip_c, ip_d = quads
+    ((ip_a << 24) + (ip_b << 16) + (ip_c << 8) + (ip_d))
+  end
+
+  def quads
+    self.split(".", 4).map{|qq| Integer(qq) }
+  end
+
+  # === class methods ===
+
+  def self.from_packed(pi)
+    str = [ (pi >> 24) & 0xFF, (pi >> 16) & 0xFF, (pi >>  8) & 0xFF, (pi) & 0xFF ].join(".")
+    new(str)
+  end
+
+  def self.from_dotted(str)
+    new(str)
+  end
+end
+
+# Stores an IP address in numeric form.
+#
+# IpNumeric instances are immutable, and memoize most of their methods.
+class ::IpNumeric
+  include IpAddresslike
+  include Comparable
+
+  def receive(val)
+    new(val)
+  end
+
+  def initialize(addr)
+    @packed = addr.to_int
+  end
+
+  def to_i       ; packed ; end
+  def to_int     ; packed ; end
+  def ==(other)  ; packed  == other.to_int ; end
+  def <=>(other) ; packed <=> other.to_int ; end
+  def +(int)     ; self.class.new(to_int + int) ; end
+
+
+  def packed ; @packed ; end
+
+  def dotted
+    @dotted ||= quads.join('.').freeze
+  end
+
+  def quads
+    @quads ||= [ (@packed >> 24) & 0xFF, (@packed >> 16) & 0xFF, (@packed >>  8) & 0xFF, (@packed) & 0xFF ].freeze
+  end
+
+  # === class methods ===
+
+  def self.from_packed(pi)
+    new(pi)
+  end
+
+  def self.from_dotted(dotted)
+    ip_a, ip_b, ip_c, ip_d = quads = dotted.split(".", 4).map(&:to_i)
+    obj = new((ip_a << 24) + (ip_b << 16) + (ip_c << 8) + (ip_d))
+    obj.instance_variable_set('@dotted', dotted.freeze)
+    obj.instance_variable_set('@quads',  quads.freeze)
+    obj
+  end
+end
+
+class ::IpRange < Range
+
+  def initialize(min_or_range, max=nil, exclusive=false)
+    if max.nil?
+      min       = min_or_range.min
+      max       = min_or_range.max
+      exclusive = min_or_range.exclude_end?
+    else
+      min       = min_or_range
+    end
+    raise ArgumentError, "Only inclusive #{self.class.name}s are implemented" if exclusive
+    super( IpNumeric.new(min), IpNumeric.new(max), false )
+  end
+
+  def bitness_blocks(bitness)
+    raise ArgumentError, "IP addresses have only 32 bits (got #{bitness.inspect})" unless (0..32).include?(bitness)
+    return [] if min.nil?
+    lsbs = 32 - bitness
+    middle_min = min.bitness_max(bitness) + 1
+    return [[min, max]] if max < middle_min
+    middle_max = max.bitness_min(bitness)
+    blks = []
+    stride = 1 << lsbs
+    #
+    blks << [min, IpNumeric.new(middle_min-1)]
+    (middle_min ... middle_max).step(stride){|beg| blks << [IpNumeric.new(beg), IpNumeric.new(beg+stride-1)] }
+    blks << [IpNumeric.new(middle_max), max]
+    blks
+  end
+
+  CIDR_RE = %r{\A(\d+\.\d+\.\d+\.\d+)/([0-3]\d)\z}
+
+  def self.from_cidr(cidr_str)
+    cidr_str =~ CIDR_RE or raise ArgumentError, "CIDR string should look like an ip address and bitness, eg 1.2.3.4/24 (got #{cidr_str})"
+    bitness    = $2.to_i
+    ip_address = IpNumeric.from_dotted($1)
+    new( ip_address.bitness_min(bitness), ip_address.bitness_max(bitness) )
+  end
+end

data/lib/gorillib/model/type/url.rb

@@ -0,0 +1,11 @@
+require 'addressable/uri'
+
+::Url = Class.new Addressable::URI
+
+module Gorillib::Factory
+  class UrlFactory < Gorillib::Factory::ConvertingFactory
+    self.product = ::Url
+    def convert(obj) product.parse(obj) ; end
+    register_factory!
+  end
+end

data/lib/gorillib/model/validate.rb

@@ -0,0 +1,22 @@
+module Gorillib
+  module Model
+    module Validate
+      module_function
+
+      VALID_NAME_RE = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+      def identifier!(name)
+        raise TypeError,     "can't convert #{name.class} into Symbol", caller unless name.respond_to? :to_sym
+        raise ArgumentError, "Name must start with [A-Za-z_] and subsequently contain only [A-Za-z0-9_]", caller unless name =~ VALID_NAME_RE
+      end
+
+      def hashlike!(val)
+        return true if val.respond_to?(:[]) && val.respond_to?(:has_key?)
+        raise ArgumentError, "#{block_given? ? yield : 'value'} should be something that behaves like a hash: #{val.inspect}", caller
+      end
+
+      def included_in!(desc, val, colxn)
+        raise ArgumentError, "#{desc} must be one of #{colxn.inspect}: got #{val.inspect}", caller unless colxn.include?(val)
+      end
+    end
+  end
+end

data/lib/gorillib/model/version.rb

@@ -0,0 +1,5 @@
+module Gorillib
+  module Model
+    VERSION = '0.0.1'
+  end
+end

data/lib/gorillib/model.rb

@@ -0,0 +1,34 @@
+require 'set'
+require 'time'
+require 'date'
+require 'pathname'
+
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/hash/compact'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/inflector'
+
+require 'gorillib/core_ext/datetime'
+require 'gorillib/core_ext/exception'
+require 'gorillib/core_ext/module'
+require 'gorillib/core_ext/object'
+
+require 'gorillib/model/version'
+require 'gorillib/model/factories'
+require 'gorillib/model/named_schema'
+require 'gorillib/model/validate'
+require 'gorillib/model/errors'
+require 'gorillib/model/base'
+require 'gorillib/model/schema_magic'
+require 'gorillib/model/field'
+require 'gorillib/model/defaults'
+require 'gorillib/model/collection'
+

data/spec/builder_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+require 'gorillib/builder'
+
+describe Gorillib::Builder, :model_spec => true, :builder_spec => true do
+
+  it_behaves_like 'a model'
+
+  context 'examples:' do
+    let(:subject_class  ){ car_class }
+    it 'type-converts values' do
+      obj = subject_class.receive( :name => 'wildcat', :make_model => 'Buick Wildcat', :year => "1968", :doors => "2" )
+      obj.attributes.should == {   :name => :wildcat,  :make_model => 'Buick Wildcat', :year =>  1968,  :doors =>  2, :engine => nil }
+    end
+    it 'handles nested structures' do
+      obj = subject_class.receive(
+        :name => 'wildcat', :make_model => 'Buick Wildcat', :year => "1968", :doors => "2",
+        :engine => { :carburetor => 'edelbrock', :volume => "455", :cylinders => '8' })
+      obj.attributes.values_at(:name, :make_model, :year, :doors).should == [:wildcat, 'Buick Wildcat', 1968,  2 ]
+      obj.engine.attributes.values_at(:carburetor, :volume, :cylinders).should == [:edelbrock, 455, 8 ]
+    end
+    it 'lets you dive down' do
+      wildcat.engine.attributes.values_at(:carburetor, :volume, :cylinders).should == [:stock, 455, 8 ]
+      wildcat.engine(:cylinders => 6) do
+        volume   383
+      end
+      wildcat.engine.attributes.values_at(:carburetor, :volume, :cylinders).should == [:stock, 383, 6 ]
+    end
+    it 'lazily autovivifies members' do
+      ford_39.read_attribute(:engine).should be_nil
+      ford_39.engine(:cylinders => 6)
+      ford_39.read_attribute(:engine).should be_a(Gorillib::Test::Engine)
+      ford_39.engine.read_attribute(:cylinders).should == 6
+    end
+  end
+
+  context 'receive!' do
+    it 'with a block, instance evals the block' do
+      expect_7 = nil ; expect_obj = nil
+      wildcat.receive!({}){    expect_7 = 7 ; expect_obj = self }
+      expect_7.should == 7 ; expect_obj.should  == wildcat
+    end
+    it 'with a block of arity 1, calls the block passing self' do
+      expect_7 = nil ; expect_obj = nil
+      wildcat.receive!({}){|c| expect_7 = 7 ; expect_obj = c }
+      expect_7.should    == 7 ; expect_obj.should  == wildcat
+    end
+    it 'with a block, returns its return value' do
+      val = mock_val
+      wildcat.receive!{      val }.should == val
+      wildcat.receive!{|obj| val }.should == val
+    end
+    it 'with no block, returns nil' do
+      wildcat.receive!.should be_nil
+    end
+  end
+
+  context ".magic" do
+    let(:subject_class){ car_class }
+    context do
+      subject{ car_class.new }
+      let(:sample_val){ 'fiat' }
+      let(:raw_val   ){ :fiat  }
+      it_behaves_like "a model field", :make_model
+      it("#read_attribute is nil if never set"){ subject.read_attribute(:make_model).should == nil }
+    end
+
+    it "does not create a writer method #foo=" do
+      subject_class.should     be_method_defined(:doors)
+      subject_class.should_not be_method_defined(:doors=)
+    end
+
+    context 'calling the getset "#foo" method' do
+      subject{ wildcat }
+
+      it "with no args calls read_attribute(:foo)" do
+        subject.write_attribute(:doors, mock_val)
+        subject.should_receive(:read_attribute).with(:doors).at_least(:once).and_return(mock_val)
+        subject.doors.should == mock_val
+      end
+      it "with an argument calls write_attribute(:foo)" do
+        subject.write_attribute(:doors, 'gone')
+        subject.should_receive(:write_attribute).with(:doors, mock_val).and_return('returned')
+        result = subject.doors(mock_val)
+        result.should == 'returned'
+      end
+      it "with multiple arguments is an error" do
+        expect{ subject.doors(1, 2) }.to raise_error(ArgumentError, "wrong number of arguments (2 for 0..1)")
+      end
+    end
+  end
+
+  context ".member" do
+    subject{ car_class.new }
+    let(:sample_val){ example_engine }
+    let(:raw_val   ){ example_engine.attributes }
+    it_behaves_like "a model field", :engine
+    it("#read_attribute is nil if never set"){ subject.read_attribute(:engine).should == nil }
+
+    it "calling the getset method #foo with no args calls read_attribute(:foo)" do
+      wildcat.write_attribute(:doors, mock_val)
+      wildcat.should_receive(:read_attribute).with(:doors).at_least(:once).and_return(mock_val)
+      wildcat.doors.should == mock_val
+    end
+    it "calling the getset method #foo with an argument calls write_attribute(:foo)" do
+      wildcat.write_attribute(:doors, 'gone')
+      wildcat.should_receive(:write_attribute).with(:doors, mock_val).and_return('returned')
+      result = wildcat.doors(mock_val)
+      result.should == 'returned'
+    end
+    it "calling the getset method #foo with multiple arguments is an error" do
+      ->{ wildcat.doors(1, 2) }.should raise_error(ArgumentError, "wrong number of arguments (2 for 0..1)")
+    end
+    it "does not create a writer method #foo=" do
+      wildcat.should     respond_to(:doors)
+      wildcat.should_not respond_to(:doors=)
+    end
+
+
+  end
+
+  context 'collections' do
+    subject{ garage }
+    let(:sample_val){ Gorillib::ModelCollection.receive([wildcat], key_method: :name, item_type: car_class) }
+    let(:raw_val   ){ [ wildcat.attributes ] }
+    it_behaves_like "a model field", :cars
+    it("#read_attribute is an empty collection if never set"){ subject.read_attribute(:cars).should == Gorillib::ModelCollection.new(key_method: :to_key) }
+
+    it 'a collection holds named objects' do
+      garage.cars.should be_empty
+
+      # create a car with a hash of attributes
+      garage.car(:cadzilla, :make_model => 'Cadillac, Mostly')
+      # ...and retrieve it by name
+      cadzilla = garage.car(:cadzilla)
+
+      # add a car explicitly
+      garage.car(:wildcat,  wildcat)
+      garage.car(:wildcat).should     equal(wildcat)
+
+      # duplicate a car
+      garage.car(:ford_39, ford_39.attributes.compact)
+      garage.car(:ford_39).should     ==(ford_39)
+      garage.car(:ford_39).should_not equal(ford_39)
+
+      # examine the whole collection
+      garage.cars.keys.should == [:cadzilla, :wildcat, :ford_39]
+      garage.cars.should == Gorillib::ModelCollection.receive([cadzilla, wildcat, ford_39], key_method: :name, item_type: car_class)
+    end
+
+    it 'lazily autovivifies collection items' do
+      garage.cars.should be_empty
+      garage.car(:chimera).should be_a(car_class)
+      garage.cars.should == Gorillib::ModelCollection.receive([{:name => :chimera}], key_method: :name, item_type: car_class)
+    end
+
+    context 'collection getset method' do
+      it 'clxn(:name, existing_object) -- replaces with given object, does not call block' do
+        test = nil
+        subject.car(:wildcat, wildcat).should equal(wildcat){ test = 3 }
+        test.should be_nil
+      end
+      it 'clxn(:name) (missing & no attributes given) -- autovivifies' do
+        subject.car(:cadzilla).should == Gorillib::Test::Car.new(:name => :cadzilla)
+      end
+      it 'clxn(:name, &block) (missing & no attributes given) -- autovivifies, execs block' do
+        test = nil
+        subject.car(:cadzilla){ test = 7 }
+        test.should == 7
+      end
+      it 'clxn(:name, :attr => val) (missing, attributes given) -- creates item' do
+        subject.car(:cadzilla, :doors => 3).should == Gorillib::Test::Car.new(:name => :cadzilla, :doors => 3)
+      end
+      it 'clxn(:name, :attr => val) (missing, attributes given) -- creates item, execs block' do
+        test = nil
+        subject.car(:cadzilla, :doors => 3){ test = 7 }
+        test.should == 7
+      end
+      it 'clxn(:name, :attr => val) (present, attributes given) -- updates item' do
+        subject.car(:wildcat, wildcat)
+        subject.car(:wildcat, :doors => 9)
+        wildcat.doors.should == 9
+      end
+      it 'clxn(:name, :attr => val) (present, attributes given) -- updates item, execs block' do
+        subject.car(:wildcat, wildcat)
+        subject.car(:wildcat, :doors => 9){ self.make_model 'WILDCAT' }
+        wildcat.doors.should == 9
+        wildcat.make_model.should == 'WILDCAT'
+      end
+
+    end
+  end
+end

data/spec/core_ext/datetime_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Time, :datetime_spec => true do
+  describe '#parse_safely' do
+    before do
+      @time_utc  = Time.parse("2011-02-03T04:05:06 UTC")
+      @time_cst  = Time.parse("2011-02-02T22:05:06-06:00")
+      @time_flat    = "20110203040506"
+      @time_iso_utc = "2011-02-03T04:05:06+00:00"
+      @time_iso_cst = "2011-02-02T22:05:06-06:00"
+    end
+
+    it 'with a Time, passes it through.' do
+      Time.parse_safely(@time_utc).should == @time_utc
+      Time.parse_safely(@time_cst).should == @time_cst
+    end
+
+    it 'with a Time, converts to UTC.' do
+      Time.parse_safely(@time_utc).utc_offset.should == 0
+      Time.parse_safely(@time_cst).utc_offset.should == 0
+    end
+
+    it 'with a flat time, converts to UTC Time instance' do
+      Time.parse_safely(@time_flat).should == @time_utc
+      Time.parse_safely(@time_flat).utc_offset.should == 0
+    end
+
+    it 'with a flat time and Z, converts to UTC Time instance' do
+      Time.parse_safely(@time_flat+'Z').should == @time_utc
+      Time.parse_safely(@time_flat+'Z').utc_offset.should == 0
+    end
+
+    it 'parses a regular time string, converting to UTC' do
+      Time.parse_safely(@time_iso_utc).should == @time_utc
+      Time.parse_safely(@time_iso_utc).utc_offset.should == 0
+      Time.parse_safely(@time_iso_cst).should == @time_utc
+      Time.parse_safely(@time_iso_cst).utc_offset.should == 0
+    end
+
+  end
+end

data/spec/core_ext/exception.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe 'raisers' do
+  def should_raise_my_error(msg=nil)
+    msg ||= error_message
+    expect{ yield }.to raise_error(described_class, msg)
+  end
+  def should_return_true
+    yield.should be_true
+  end
+  # different rubies have different error messages ARRGH.
+  def capture_error
+    message = 'should have raised, did not'
+    begin
+      yield
+    rescue described_class => err
+      message = err.message
+    end
+    return message.gsub(/of arguments\(/, 'of arguments (')
+  end
+
+  describe ArgumentError do
+
+    context '.check_arity!' do
+      let(:error_message){ /wrong number of arguments/ }
+      it 'checks against a range' do
+        should_raise_my_error{ described_class.check_arity!(['a'], 2..5) }
+        should_raise_my_error{ described_class.check_arity!(['a'], 2..2) }
+        should_return_true{    described_class.check_arity!(['a'], 0..5) }
+        should_return_true{    described_class.check_arity!(['a'], 1..1) }
+      end
+      it 'checks against an array' do
+        should_raise_my_error{ described_class.check_arity!( ['a', 'b'], [1, 3, 5] ) }
+        should_return_true{    described_class.check_arity!( ['a', 'b'], [1, 2] ) }
+      end
+      it 'given a single number, requires exactly that many args' do
+        should_raise_my_error{ described_class.check_arity!( ['a', 'b'], 1 ) }
+        should_raise_my_error{ described_class.check_arity!( ['a', 'b'], 3 ) }
+        should_return_true{    described_class.check_arity!( ['a', 'b'], 2 ) }
+      end
+      it 'matches the message a native arity error would' do
+        should_raise_my_error(capture_error{ [].fill()   }){ described_class.check_arity!([],  1..3) }
+        should_raise_my_error(capture_error{ [].to_s(1)  }){ described_class.check_arity!([1], 0) }
+      end
+      it 'appends result of block (if given) to message' do
+        str = "esiar no delave ylno"
+        ->{ described_class.check_arity!([],  1..3){ str.reverse! } }.should raise_error(/only evaled on raise/)
+        str.should == "only evaled on raise"
+      end
+    end
+
+    context '.arity_at_least!' do
+      let(:error_message){ /wrong number of arguments/ }
+      it 'raises if there are fewer than that many args' do
+        should_raise_my_error{ described_class.arity_at_least!(['a'], 2) }
+        should_raise_my_error{ described_class.arity_at_least!([],    1) }
+      end
+      it ('returns true if there are that many args or more') do
+        should_return_true{    described_class.arity_at_least!([],    0) }
+        should_return_true{    described_class.arity_at_least!(['a'], 0) }
+        should_return_true{    described_class.arity_at_least!(['a'], 1) }
+      end
+    end
+  end
+
+  describe TypeMismatchError do
+    context '.mismatched!' do
+      let(:error_message){ /.+ has mismatched type/ }
+      it 'raises an error' do
+        should_raise_my_error{ described_class.mismatched!("string", Integer) }
+        should_raise_my_error{ described_class.mismatched!(Object.new) }
+      end
+    end
+
+    context '.check_type!' do
+      let(:error_message){ /.+ has mismatched type; expected .+/ }
+      it 'raises true if any type matches' do
+        should_return_true{    described_class.check_type!("string", [Integer, String]) }
+      end
+      it 'raises an error if nothing matches' do
+        should_raise_my_error{ described_class.check_type!("string", [Integer, Float]) }
+        should_raise_my_error{ described_class.check_type!("string", [Integer]) }
+        should_raise_my_error{ described_class.check_type!("string", Integer) }
+      end
+      it 'checks is_a? given a class' do
+        should_return_true{    described_class.check_type!("string", [Integer, String]) }
+        should_return_true{    described_class.check_type!(7,        [Integer, String]) }
+        should_raise_my_error{ described_class.check_type!(:symbol,  [Integer, String]) }
+      end
+      it 'checks responds_to? given a symbol' do
+        should_return_true{    described_class.check_type!("string", [:to_str, :to_int]) }
+        should_return_true{    described_class.check_type!(7,        [:to_str, :to_int]) }
+        should_raise_my_error{ described_class.check_type!(:symbol,  [:to_str, :to_int]) }
+      end
+    end
+  end
+
+end