type 0.1.0

data/.githooks/pre-commit/ruby-appraiser

@@ -0,0 +1,17 @@
+#!/bin/bash
+echo -e "\033[0;36mRuby Appraiser: running\033[0m"
+bundle exec ruby-appraiser --mode=staged
+result_code=$?
+if [ $result_code -gt "0" ]; then
+  echo -en "\033[0;31m" # RED
+  echo "[✘] Ruby Appraiser found newly-created defects and "
+  echo "    has blocked your commit."
+  echo "    Fix the defects and commit again."
+  echo "    To bypass, commit again with --no-verify."
+  echo -en "\033[0m" # RESET
+  exit $result_code
+else
+  echo -en "\033[0;32m" # GREEN
+  echo "[✔] Ruby Appraiser ok"
+  echo -en "\033[0m" #RESET
+fi

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## Next release (TBD)
+
+## 0.1.0 (2014-01-29)
+
+ - Initial Implementation

data/CONTRIBUTING.md

@@ -0,0 +1,41 @@
+# Contributing
+
+`Type` is [Apache-liennsed](LICENSE.txt).
+
+## Git-Flow
+
+`Type` follows the [git-flow][] branching model, which means that every
+commit on `master` is a release. The default working branch is `develop`, so
+in general please keep feature pull-requests based against the current
+`develop`.
+
+ - fork the repo on github
+ - use the git-flow model to start your feature (based on develop) or
+   hotfix (based on master)
+ - make some commits (please include specs & changelog)
+ - submit a pull-request
+
+## Bug Reporting
+
+Please include clear steps-to-reproduce. Spec files are especially welcome;
+a failing spec can be contributed as a pull-request against `master`, but make
+sure it's not already fixed in develop.
+
+## Documentation
+
+`Type` uses YARDOC, and so must your pull-requests if you add functionality or
+change the api.
+
+## Ruby Appraiser
+
+`Type` uses the [ruby-appraiser][] gem via [pre-commit][] hook, which can be
+activated by installing [icefox/git-hooks][] and running `git-hooks --install`.
+Reek and Rubocop are strong guidelines; use them to reduce defects as much as
+you can, but if you believe clarity will be sacrificed they can be bypassed
+with the `--no-verify` flag.
+
+[git-flow]: http://nvie.com/posts/a-successful-git-branching-model/
+[pre-commit]: .githooks/pre-commit/ruby-appraiser
+[ruby-appraiser]: https://github.com/simplymeasured/ruby-appraiser
+[icefox/git-hooks]: https://github.com/icefox/git-hooks
+[pull-request-hack]: http://felixge.de/2013/03/11/the-pull-request-hack.html

data/Gemfile

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+source 'https://rubygems.org'
+
+# Gem dependencies are specified in the gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2013 Simply Measured
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,218 @@
+# Type
+
+`Type` is a ruby library for type validation and type casting. It allows you to
+have guarantees on data structures, and is exceptionally useful for working with
+external APIs that blow up opaquely on type errors.
+
+See [the Changelog](CHANGELOG.md) for version history.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'type'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install type
+
+## Basic API
+
+`Type::Definition`s respond to two public methods: `#cast!` and `valid?`, each
+of which take a single argument and either cast or validate the given object.
+For convenience, named type definitions have global aliases defined on `Type`:
+
+~~~ ruby
+# For example, `Type::Int32`, which is a built-in `Type::Definition`
+Type::Int32?(input) # alias for Type::Int32.valid?(input)
+Type::Int32!(input) # alias for Type::Int32.cast!(input)
+~~~
+
+## Usage
+
+`Type` comes with a variety of built-in type defintions, which can be used for
+validation or casting.
+
+### Scalar Type Definitions:
+
+The most basic type definitions are scalar
+
+~~~ ruby
+# Validating
+Type::Int32?(1)
+# => true
+Type::Int32?(8_589_934_592) # out of Int32 range
+# => false
+Type::Int32?(3.14)
+# => false
+Type::Int32?('three')
+# => false
+
+# Casting
+Type::Int32!(1)
+# => 1
+Type::Int32!(1<<33)
+Type::CastError: Could not cast 8589934592(Fixnum) with Type::Int32
+Type::Int32!(3.14)
+# => 3
+Type::Int32!('three')
+#! Type::CastError: Could not cast "three"(String) with Type::Int32
+~~~
+
+### Nilable Type Definitions:
+
+Any `Type::Definition` can be declared nilable -- that is, it will report `nil`
+as a valid value, and will ignore `nil` when casting.
+
+~~~ ruby
+# Validating
+Type::Int32.valid?(nil)
+# => false
+Type::Int32.nilable.valid?(nil)
+# => true
+
+# Casting
+Type::Int32.cast!(nil)
+#! Type::CastError: Could not cast nil(NilClass) with Type::Int32
+Type::Int32.nilable.cast!(nil)
+# => nil
+~~~
+
+### Collection Type Definitions:
+
+`Type` also comes with built-in, named definitions for `Array`, `Set`, and
+`Hash` collections, which are available in the same manner:
+
+~~~ ruby
+# Validating
+Type::Array?([1,2,3])
+# => true
+Type::Hash?({'foo'=>'bar'})
+# => true
+Type::Set?([1,2,3])
+# => false
+Type::Set?(Set.new([1,2,3]))
+# => true
+
+# Casting
+Type::Array!([1,2,3])
+# => [1,2,3]
+Type::Hash!([['foo','bar']])
+# => {'foo'=>'bar'}
+Type::Set!([1,2,3])
+# => <Set: {1, 2, 3}>
+Type::Set!('foo')
+#! Type::CastError: Could not cast "foo"(String) with Type::Set
+~~~
+
+### Constrained Collection Type Definitions:
+
+The real power of type-casting collections is when their contents can also be
+constrained:
+
+~~~ ruby
+# Validating:
+# specify any Type::Definition, or the name of a globally-registered one:
+Type::Array.of(Type::Int32).valid?([12, 13])
+# => true
+Type::Array.of(:Int32).valid?(['12', '13'])
+# => false
+Type::Array.of(:Int32).valid?(['three','two'])
+# => false
+Type::Hash.of(:String => :Int64).valid?({'id'=>'1234567890'})
+# => false
+Type::Hash.of(:String => :Int64).valid?({'id'=>1234567890})
+# => true
+
+# Casting:
+Type::Array.of(:Int32).cast!([12, 13])
+# => [12, 13]
+Type::Array.of(:Int32).cast!(['12', '13'])
+# => [12, 13]
+Type::Array.of(:Int32).cast!(['three','two'])
+#! Type::CastError: Could not cast ["three", "two"](Array) with Type::Array(Int32),
+#!                  caused by <Type::CastError: Could not cast "three"(String) with Type::Int32>
+Type::Hash.of(:String => :Int64).cast!({'id'=>'1234567890'})
+# => {'id'=>1234567890}
+Type::Hash.of(:String => :Int64).cast!({'id'=>1234567890})
+# => {'id'=>1234567890}
+~~~
+
+### Nilable Constrained Collection Type Definitions
+
+The contents of your constrained collections can also be nilable:
+
+~~~ ruby
+# Validating:
+Type::Array.of(Type::Int32.nilable).valid?([nil, 3])
+# => true
+Type::Array.of(:Int32?).valid?([nil,4])
+# => true
+
+# Casting
+Type::Array.of(Type::Int32.nilable).cast!([nil, '3'])
+# => [nil, 3]
+Type::Array.of(:Int32?).cast!([nil,4])
+# => [nil, 4]
+~~~
+
+## Advanced Usage
+
+### Custom Type Defintions
+
+~~~ ruby
+my_int32 = Type.scalar do
+  int32_range = (-(1 << 31) ... (1 << 31))
+  validate do |input|
+    input.kind_of?(Integer) && int32_range.include?(input)
+  end
+  cast do |input|
+    Kernel::Integer(input)
+  end
+end
+
+my_int32.valid?('100') # => false
+my_int32.valid?(100) # => true
+my_int32.cast!(1<<10) # => 1024
+my_int32.cast!("100") # => 100
+
+
+simple_int32 = Type.scalar.from(Integer) do
+  int32_range = (-(1 << 31) ... (1 << 31))
+  validate do |input|
+    int32_range.include?(input)
+  end
+end
+
+simple_int32.valid?('100') # => false
+simple_int32.valid?(100) # => true
+simple_int32.cast!(1<<10) # => 1024
+simple_int32.cast!("100") # => 100
+
+Type.scalar(:OddInt).from(:Integer) do
+  validate(&:odd?)
+  cast do |input|
+    input.even? ? input + 1 : input
+  end
+end
+
+Type::OddInt?(4)
+# => false
+Type::OddInt!(4)
+# => 5
+~~~
+
+If you find that you're using one or more custom type definitions on a regular
+basis, please consider contributing them.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.verbose = true
+end

data/lib/type.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'type/version'
+require 'type/error'
+require 'type/definition'
+
+# Type is a library for type-casting and type-validation
+module Type
+  class << self
+    # @overload find(query)
+    #   @param query [Type::Definition]
+    # @overload find(query)
+    #   @param query [String, Symbol]
+    #     Find a named Type::Defintion. If the query ends with a ?,
+    #     a nilable representation of the reolved type definition is returned.
+    # @return [Type::Definition]
+    def find(query)
+      return query if query.kind_of?(Definition)
+
+      query = String(query)
+      nilable = query.end_with?('?') && query.slice!(-1)
+
+      definition = const_get(query)
+      (nilable ? definition.nilable : definition)
+    end
+    alias_method :[], :find
+
+    # @api private
+    # @param [Type::Definition]
+    # @return [void]
+    def register(definition)
+      if (name = definition.name)
+        const_set(name, definition)
+        (class << self; self; end).instance_exec do
+          define_method("#{name}!") { |x| definition.cast!(x) }
+          define_method("#{name}?") { |x| definition.valid?(x) }
+        end
+      end
+    end
+  end
+
+  # Required after, since they rely on the above methods.
+  require 'type/builtin'
+end

data/lib/type/builtin.rb

@@ -0,0 +1,111 @@
+# 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