stronger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 61d3f70e5efe9e26b9972e5686bb01a54b068338
+  data.tar.gz: 430212356514e889ac68086bf07599ac3623b6a3
+SHA512:
+  metadata.gz: 1ddf9da54b794322d601dab9eb27c1acea7cc6627cf71a50ee9ef7e7ed9ce2a8a6f7abab1b08b103dcedc836c7ed6842a4d08a8c54584e1095a2b54822acfe53
+  data.tar.gz: d13e59be287c071627738c6fdf898797173a387b959255f15fe1f5ce267881a2afdf65ad37ea365629eaadc9fe262c3f1695ac4a2b3bca3ea3e23c342888ef29

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE

@@ -0,0 +1,17 @@
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+# Stronger
+
+Stronger is a basic run-time type-safety kit for Ruby, which introduces a couple
+of tools for simple run-time type checking.
+
+There's nothing revolutionary here.  Just a few convenient types and methods to
+ease the burden of the type-conscious rubyist.
+
+## Installation
+
+`gem install stronger` and `require 'stronger'` in your code.
+
+## Features
+
+### Collections
+
+Stronger provides some type-checking wrappers around Ruby's Hash and Array
+classes, which help give you a bit of type-safety in the values you can expect
+from these collections.
+
+##### Array
+
+Typed arrays check anything appended.
+
+```ruby
+  arr = Stronger::TypedArray.new(Integer)
+  arr.push 5
+
+  arr.push 4 # raises TypeError
+```
+
+They also refuse to concatenate with other TypedArrays not of the same type.
+
+##### Hash
+
+Typed hashes check values added to ensure type.
+
+```ruby
+  hash = Stronger::TypedHash.new(String)
+  hash[:first] = 'Groovy'
+  hash[2] = :woah_there # raises TypeError
+```
+
+### Properties
+
+Some class methods are provided in the `PropertyDefinition` module which allows
+you to define properties on classes.  Properties are required by default,
+can be set via the constructor, the private `set_properties` method, or setters.
+
+```ruby
+  class Person
+    property :name, type: String
+    property :phone_number, type: String, required: false
+  end
+
+  addr = AddressBookEntry.new(name: "Boris")
+  addr.name #=> 'Boris'
+  addr.name = 3 # Raises Stronger::InvalidProperty
+```
+
+
+### Interfaces
+
+Stronger has a very simple (and very dumb) concept of an `Interface`,
+which is just a list of methods objects must respond to encapsulated in an
+object.  These `Interface` objects can be treated as types however, which makes
+duck-typing with Collections and Properties a lot nicer.
+
+```ruby
+  AnimalInterface = Stronger::Interface.new(:move, :make_noise)
+
+  class Dog
+    def move
+    end
+
+    def make_noise
+    end
+  end
+```
+
+The `AnimalInterface` defined above can be used in place of classes for types
+in Stronger's properties and typed collections.
+
+### Type checking methods
+
+The `Stronger::TypeChecking` refinement provides a `is_strong?` method on
+`Object` which allows you to check types yourself.  It behaves like `is_a?`
+but includes support for interface checking.
+
+```ruby
+  use Stronger::TypeChecking
+
+  BoatInterface = Stronger::Interface.new(:float)
+
+  Object.new.is_strong?(Object) # => true
+  Object.new.is_strong?(Boat) # => false
+```
+
+## Contributing
+
+Fork and open a PR.  Please include tests and ensure `rake test` runs.
+
+## License
+
+See LICENSE

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'test')
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+end

data/TODO

@@ -0,0 +1 @@
+Need to use attr instead of property for struct method

data/lib/stronger.rb

@@ -0,0 +1,7 @@
+require 'stronger/interface'
+require 'stronger/type_checking'
+require 'stronger/hash'
+require 'stronger/array'
+require 'stronger/property'
+require 'stronger/property_set'
+require 'stronger/property_definition'

data/lib/stronger/array.rb

@@ -0,0 +1,16 @@
+require 'stronger/collection'
+module Stronger
+  class TypedArray < ::Array
+    include Collection
+    [:push,  :shift, :[]=, :<<].each do |name|
+      define_method(name) do |value|
+        check_value_type!(value)
+        super(value)
+      end
+    end
+
+    def concat(arr)
+      check_collection_type!(arr)
+    end
+  end
+end

data/lib/stronger/collection.rb

@@ -0,0 +1,27 @@
+module Stronger
+  module Collection
+    Interface = Stronger::Interface.new(:type)
+    using TypeChecking
+
+    attr_reader :type
+    def initialize(type, *rest)
+      @type = type
+      super(*rest)
+    end
+
+    private
+
+    def check_value_type!(val)
+      unless val.is_strong?(type)
+        raise TypeError, "#{self} expects values of type: #{type}" 
+      end
+    end
+
+    def check_collection_type!(col)
+      unless col.implements?(Collection::Interface) and col.type < type
+        raise TypeError,
+          "#{self} may only be concatenated with an array of the same type!"
+      end
+    end
+  end
+end

data/lib/stronger/hash.rb

@@ -0,0 +1,13 @@
+require 'stronger/collection'
+module Stronger
+  class TypedHash < ::Hash
+    include Collection
+
+    [:store, :[]=].each do |name|
+      define_method(name) do |key, val|
+        check_value_type!(val)
+        super(key, val)
+      end
+    end
+  end
+end

data/lib/stronger/interface.rb

@@ -0,0 +1,8 @@
+module Stronger
+  class Interface
+    attr_reader :methods
+    def initialize(*methods)
+      @methods = methods
+    end
+  end
+end

data/lib/stronger/property.rb

@@ -0,0 +1,19 @@
+module Stronger
+  class Property
+    attr_reader :name, :type
+    def initialize(name, type:, required: true)
+      @name, @type, @required = name, type, required
+    end
+
+    def required?
+      !!required
+    end
+
+    def typed?
+      !type.nil?
+    end
+
+    private
+    attr_reader :required
+  end
+end

data/lib/stronger/property_definition.rb

@@ -0,0 +1,68 @@
+module Stronger
+  module PropertyDefinition
+    module ClassMethods
+      def properties
+        @properties ||= Array.new
+      end
+
+      def property_names
+        properties.map(&:name)
+      end
+
+      def property(*names, **opts)
+        new_props = names.map {|name| Property.new(name, **opts) }
+        properties.concat(new_props)
+        new_props.each{|p| expose_property(p) unless opts.delete(:private)}
+      end
+
+      private
+
+      def expose_property(property)
+        define_property_method(property.name) do |properties|
+          properties[property.name]
+        end
+
+        define_property_method("#{property.name}=") do |properties, value|
+          properties[property.name] = value
+        end
+      end
+
+      # Defines a method by the given name using a given block, to which
+      # the properties on the instance on which the method was called
+      # will be yielded as the first argument, and the arguments given to
+      # the called method as the rest of the arguments.  PropertyErrors
+      # raised due to operations on the yielded properties will be rescued
+      # and re-raised with their stack trace origin set to the defined method.
+      def define_property_method(name, &blk)
+        define_method(name) do |*args|
+          begin
+            blk.call(properties, *args)
+          rescue PropertyError => e
+            e.set_backtrace caller
+            raise e
+          end
+        end
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(**property_values)
+      set_properties(property_values)
+    rescue PropertyError => e
+      e.set_backtrace caller
+      raise e
+    end
+
+    private
+    attr_reader :properties
+
+    def set_properties(values)
+      @properties = PropertySet.new(values, self.class.properties)
+    rescue PropertyError => e
+      raise e
+    end
+  end
+end

data/lib/stronger/property_set.rb

@@ -0,0 +1,79 @@
+require 'forwardable'
+
+module Stronger
+  class PropertyError < StandardError; end
+  class InvalidProperty < PropertyError; end
+  class UndefinedProperty < PropertyError; end
+  class MissingProperty < PropertyError; end
+
+  class PropertySet
+    extend Forwardable
+
+    # TODO: given_props should be called values
+    def initialize(given_values, config_props)
+      @config_props = config_props
+      @values = Hash.new
+
+      given_values.each {|k,v| set(k, v) }
+      validate_required_present!
+    end
+    def_delegator :values, :include?
+
+    def []=(key, value)
+      property = get_property(key)
+      validate_type!(value, property)
+      values[key] = value
+    end
+    alias_method :set, :[]=
+
+    def [](key)
+      get_property(key)
+      values[key] || (raise MissingProperty,
+        "#{key} is not required and has not been set!")
+    end
+
+    def delete(name)
+      unless get_property(name).required?
+        values.delete(name)
+      else
+        raise MissingProperty, "You can't delete required property #{name}!"
+      end
+    end
+
+    protected
+    attr_reader :config_props, :values
+
+    def values
+      @values ||= Hash.new
+    end
+
+    def validate_type!(value, property)
+      unless value.is_a?(property.type)
+        raise InvalidProperty,
+          "Property #{property.name} should be a #{property.type}"
+      end
+    end
+
+    def get_property(name)
+      property = config_props.find{|p| p.name == name}
+      return property ||
+        (raise UndefinedProperty, "#{name} is not a valid property!")
+    end
+
+    def validate_required_present!
+      config_props.select{|p| p.required?}.each do |property|
+        values.fetch(property.name) do
+          raise MissingProperty, "Property #{property.name} is required!"
+        end
+      end
+    end
+
+    def extra_property_message(extra_property_names)
+      if extra_property_names.length > 1
+        "#{extra_property_names} are not recognized property names!"
+      else
+        "#{extra_property_names.first} is not a valid property name!"
+      end
+    end
+  end
+end

data/lib/stronger/type_checking.rb

@@ -0,0 +1,55 @@
+module Stronger
+  module TypeChecking
+    refine Object do
+      def is_strong?(type)
+        if type.is_a?(Interface)
+          implements?(type)
+        elsif type.is_a?(Class) or type.is_a?(Module)
+          is_a?(type)
+        else
+          raise ArgumentError, "Don't know how to compare type of "\
+            "#{self} against #{type}.  Try using a "\
+            "Stronger::Interface, Class or Module"
+        end
+      end
+
+      def implements?(interface)
+        interface.methods.all?{|m| respond_to?(m) }
+      end
+    end
+
+    module Implementers
+      def <(type)
+        if type.is_a?(Interface)
+          instance_implements?(type)
+        else
+          super(type)
+        end
+      end
+
+      def >(type)
+        !(self <= type)
+      end
+
+      def instance_implements?(interface)
+        (interface.methods - instance_methods).empty?
+      end
+
+      def implement(interface)
+        interface.methods.each do |name|
+          define_method(name) do
+            raise NotImplementedError, "#{self.class} should implement #{name}!"
+          end
+        end
+      end
+    end
+
+    refine Class do
+      include Implementers
+    end
+
+    refine Module do
+      include Implementers
+    end
+  end
+end

data/lib/stronger/version.rb

@@ -0,0 +1,3 @@
+module Stronger
+  VERSION = '0.1.0'
+end

data/stronger.gemspec

@@ -0,0 +1,17 @@
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'stronger/version'
+
+Gem::Specification.new do |s|
+  s.name = 'stronger'
+  s.version = Stronger::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Jack Forrest']
+  s.email = ['jack@jrforrest.net']
+  s.homepage = 'https://github.com/jrforrest/stronger'
+  s.summary = 'Run-time type checking utils'
+  s.description = 'Provides several utilities for run-time type-checking with Ruby'
+  s.license = 'MIT'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files test`.split("\n")
+end

data/test/array_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module Stronger 
+  class ArrayTest < MiniTest::Test
+    include ExAssertions
+
+    DuckInterface = Interface.new(:quack)
+    class Duck
+      def quack; end
+    end
+
+    def test_array
+      array = TypedArray.new(DuckInterface)
+      refute_ex_raised TypeError, ->{array.push(Duck.new)},
+        "The array allows objects of its configured type to be pushed."
+      assert_ex_raised TypeError, ->{array.push(Object.new)},
+        "Types not implementing the array's type will raise a TypeError "\
+        "when pushed."
+      assert_ex_raised TypeError, -> {array << Object.new},
+        "Type checking works on << alias for array"
+    end
+
+    def test_concat
+      assert_ex_raised TypeError,
+        ->{ TypedArray.new(DuckInterface).concat(::Array.new) },
+        "Can not concatenate a typed array with an un-typed array."
+      assert_ex_raised TypeError,
+        ->{ TypedArray.new(String).concat(Array.new(Fixnum)) },
+        "Can not concatenate a typed array with a typed array "\
+        "with an incompatible type"
+      refute_ex_raised TypeError,
+        ->{ TypedArray.new(Numeric).concat(TypedArray.new(Fixnum)) },
+        "A typed array may be concatenated with another typed array which has "\
+        "a type that implements its own type."
+    end
+  end
+end

data/test/ex_assertions.rb

@@ -0,0 +1,21 @@
+# A couple of assertions for testing exceptions.
+#
+# These already exist in MiniTest but I don't like the way they work.
+module ExAssertions
+  private
+
+  def refute_ex_raised(ex, lam, message = nil)
+    refute(raised?(ex, &lam), message)
+  end
+
+  def assert_ex_raised(ex, lam, message = nil)
+    assert(raised?(ex, &lam), message)
+  end
+
+  def raised?(ex)
+    yield
+    return false
+  rescue ex => e
+    return true
+  end
+end

data/test/hash_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Stronger
+  class HashTest < MiniTest::Test
+    include ExAssertions
+
+    def test_hash
+      hash = TypedHash.new(String)
+      assert_ex_raised TypeError, ->{ hash[:one] = 1 },
+        "Trying to set a value in the hash which is not of the type "\
+        "with which the hash was instantiated should raise a TypeError"
+      hash[:two] = "2"
+      assert_equal "2", hash[:two],
+        "Setting a hash value with the appropriate type should work."
+      assert_ex_raised TypeError, ->{ hash.store(:three, 3)},
+        "Store shouldn't work either."
+    end
+  end
+end

data/test/property_definition_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+module Stronger
+  class PropertyDefinitionTest < MiniTest::Test
+    include ExAssertions
+
+    class PropertyDefinitionDummy
+      include PropertyDefinition
+
+      property :name, type: String
+      property :address, type: String, required: false
+    end
+
+    def test_valid
+      assert valid_dummy,
+        "The valid dummy should instantiate with no errors"
+      assert_equal valid_values[:name], valid_dummy.name,
+        "The name method should expose the name"
+    end
+
+    def test_invalid
+      assert_ex_raised MissingProperty, ->{invalid_dummy},
+        "Creating an instance without all of the required properties "\
+        "should result in a MissingProperty exception"
+    end
+
+    def test_set_invalid
+      assert_ex_raised InvalidProperty, ->{valid_dummy.address = 25},
+        "Attempting to set a property to the wrong type should raise an "\
+        "InvalidProperty exception"
+    end
+
+    private
+
+    def valid_dummy
+      @valid_dummy ||= make_dummy(valid_values)
+    end
+
+    def invalid_dummy
+      @invalid_dummuy ||= make_dummy(invalid_values)
+    end
+
+    def make_dummy(values)
+      PropertyDefinitionDummy.new(**values)
+    end
+
+    def invalid_values
+      {address: "one"}
+    end
+
+    def valid_values
+      {name: "Riiiiiiick!"}
+    end
+  end
+end

data/test/property_set_test.rb

@@ -0,0 +1,123 @@
+require 'test_helper'
+
+module Stronger
+  class PropertySetTest < Minitest::Test
+    include ExAssertions
+
+    def test_valid_properties
+      refute_ex_raised PropertyError, ->{make_set(valid_properties)},
+        "Creating a propety set with valid values should not raise "\
+        "an exception"
+    end
+
+    def test_extra_properties
+      assert_ex_raised UndefinedProperty, ->{make_set(extra_properties)},
+        "Extra values given to a property set should result in an "\
+        "InvalidProperty exception"
+    end
+
+    def test_invalid_type
+      assert_ex_raised InvalidProperty,
+        ->{make_set(improperly_typed_properties)},
+        "Giving values with the wrong type should result in "\
+        "an InvalidProperty exception"
+    end
+
+    def test_missing_required
+      assert_ex_raised MissingProperty, ->{make_set(insufficient_properties)},
+        "Failing to supply required values should result in a MissingProperty "\
+        "error"
+    end
+
+    def test_value_accessors
+      name = 'Baron Bower'
+
+      valid_set[:name] = name
+      assert_equal name, valid_set[:name],
+        "A property can be set and get using hash syntax"
+      assert_ex_raised UndefinedProperty, ->{valid_set[:bobbyhill]},
+        "Attempting to access a property not defined on the set "\
+        "should result in an undefined property exception"
+    end
+
+    def test_set_invalid_value
+      assert_ex_raised InvalidProperty, ->{valid_set[:name] = 25},
+        "Attempting to set a property to an invalid value should raise an "\
+        "invalid property exception"
+      assert_ex_raised UndefinedProperty, ->{valid_set[:bobbyhill] = 25},
+        "Attempting to set a property which does not exist should result "\
+        "in an undefined property error"
+      assert_ex_raised InvalidProperty, ->{valid_set[:name] = nil},
+        "Attempting to make a property nil should result in "\
+        " an InvalidProperty exception"
+    end
+
+    def test_delete_value
+      address = valid_set[:address]
+      assert_equal address, valid_set.delete(:address),
+        "Deleting a non-required value should return that value"
+      assert_ex_raised MissingProperty, ->{valid_set.delete(:name)},
+        "Deleting a required value should result in a MissingProperty "\
+        "exception"
+    end
+
+    def test_access_missing_value
+      assert_ex_raised MissingProperty, ->{partial_valid_set[:address]},
+        "A MissingProperty error should be raised when a property "\
+        "which is not present is accessed"
+    end
+
+    def test_include?
+      refute partial_valid_set.include?(:address),
+        "Include returns false for a value which is not present"
+
+      partial_valid_set[:address] = "hiya"
+      assert partial_valid_set.include?(:address),
+        "Include returns true for a value which is present"
+
+      partial_valid_set.delete(:address)
+      refute partial_valid_set.include?(:address),
+        "Include still returns false for a valid which was present "\
+        "but was deleted"
+    end
+      
+
+    private
+
+    def partial_valid_set
+      @partial_avlid_set ||=
+        make_set(valid_properties.tap{|p| p.delete :address})
+    end
+
+    def valid_set
+      @valid_set ||= make_set(valid_properties)
+    end
+
+    def make_set(properties)
+      PropertySet.new(properties, configured_properties)
+    end
+
+    def configured_properties
+      @props ||= [
+        Property.new(:name, type: String, required: true),
+        Property.new(:address, type: String, required: false) ]
+    end
+
+    def insufficient_properties
+      valid_properties.tap{|h| h.delete(:name) }
+    end
+
+    def improperly_typed_properties
+      valid_properties.tap {|h| h[:name] = 25}
+    end
+
+    def valid_properties
+      { name: "Joseph Miller",
+        address: "2344 whatever dr. Raleigh NC 27610" }
+    end
+
+    def extra_properties
+      valid_properties.merge({dog: 'Betty Beagle'})
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'stronger'
+require 'pry'
+
+# Test Helpers
+require 'ex_assertions'

data/test/type_checking_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+module Stronger
+  class TypeCheckingTest < MiniTest::Test
+    include ExAssertions
+    using TypeChecking
+
+    DuckInterface = Interface.new(:quack, :walk)
+    KickInterface = Interface.new(:give_it_the_boot)
+
+    module Puntable
+      implement KickInterface
+    end
+
+    class Duck
+      implement DuckInterface
+      include Puntable
+
+      def quack; end
+      def walk; end
+    end
+
+    class Goose
+      def quack; end
+      def walk; end
+    end
+
+    def test_class_type
+      assert String.new.is_strong?(String),
+        "Stronger typecheck should match on the class of the object"
+    end
+
+    def test_interface_instance
+      assert duck.is_strong?(DuckInterface),
+        "An object responding to all of the methods required by an "\
+        "interface should be identify with that interface as a type"
+      assert duck.is_strong?(Duck),
+        "An object of a class should be identified with that class as "\
+        "a type."
+      assert duck.is_strong?(Puntable),
+        "An object belonging to a class which includes a module should "\
+        "be identified as a type of that module."
+      assert_ex_raised NotImplementedError, ->{duck.give_it_the_boot},
+        "An object belonging to an interface should have that method "\
+        "defined with a default behavior of raising a NotImplementedError"
+    end
+
+    def test_ducktyped_interface
+      assert Goose.instance_implements?(DuckInterface),
+        "Even a class which does not explicitly implement an interface will "\
+        "identify with that interface if it implements all "\
+        "the necessary methods"
+      refute Goose.instance_implements?(KickInterface),
+        "A class does not implement an interface if it does not satisfy "\
+        "all of its methods"
+    end
+
+    def test_instance_implements
+      assert Duck.instance_implements?(KickInterface)
+    end
+
+    protected
+
+    def duck
+      @duck ||= Duck.new
+    end
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: stronger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jack Forrest
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-28 00:00:00.000000000 Z
+dependencies: []
+description: Provides several utilities for run-time type-checking with Ruby
+email:
+- jack@jrforrest.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- Rakefile
+- TODO
+- lib/stronger.rb
+- lib/stronger/array.rb
+- lib/stronger/collection.rb
+- lib/stronger/hash.rb
+- lib/stronger/interface.rb
+- lib/stronger/property.rb
+- lib/stronger/property_definition.rb
+- lib/stronger/property_set.rb
+- lib/stronger/type_checking.rb
+- lib/stronger/version.rb
+- stronger.gemspec
+- test/array_test.rb
+- test/ex_assertions.rb
+- test/hash_test.rb
+- test/property_definition_test.rb
+- test/property_set_test.rb
+- test/test_helper.rb
+- test/type_checking_test.rb
+homepage: https://github.com/jrforrest/stronger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Run-time type checking utils
+test_files:
+- test/array_test.rb
+- test/ex_assertions.rb
+- test/hash_test.rb
+- test/property_definition_test.rb
+- test/property_set_test.rb
+- test/test_helper.rb
+- test/type_checking_test.rb
+has_rdoc: