typecheck 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a7fc2715192b042a94bf221a43234bb59c613c3f
+  data.tar.gz: 1115a334c7936dd145fb090c6ba1675e5e92a470
+SHA512:
+  metadata.gz: ccd6d3916e84953acc37f4b78d929e633f75790ccf0ecb803c1f08f1188e3e8a4e36e371a1eb885b96c20700a5a67864c52923dfbafa34d347af161f6c7864ea
+  data.tar.gz: ae6bcf095e29626885089680b6ed9464cf5bf2378a5f2b14e03c0eed8f5da3d0d76f3723958274023793116be1677b945bbf8f224ccd0f4a984d33b8b4ddee27

data/Gemfile

@@ -0,0 +1,5 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+# gem "rails"
+gemspec

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    typecheck (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    anima (0.2.0)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.1)
+      equalizer (~> 0.0.8)
+    ast (1.1.0)
+    concord (0.1.5)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    diff-lcs (1.2.5)
+    equalizer (0.0.9)
+    ice_nine (0.11.0)
+    inflecto (0.0.2)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
+    morpher (0.2.2)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.2.0)
+      ast (~> 1.1.0)
+      concord (~> 0.1.4)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.0)
+      procto (~> 0.0.2)
+    mutant (0.5.10)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.2.0)
+      concord (~> 0.1.4)
+      diff-lcs (~> 1.2)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.0)
+      inflecto (~> 0.0.2)
+      memoizable (~> 0.4.2)
+      morpher (~> 0.2.1)
+      parser (~> 2.1)
+      procto (~> 0.0.2)
+      unparser (~> 0.1.10)
+    mutant-rspec (0.5.10)
+      mutant (~> 0.5.10)
+      rspec-core (>= 2.14.1, <= 3.0.0.beta2)
+    parser (2.1.8)
+      ast (~> 1.1)
+      slop (~> 3.4, >= 3.4.5)
+    procto (0.0.2)
+    rake (10.3.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    slop (3.5.0)
+    thread_safe (0.3.3)
+    unparser (0.1.12)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.4)
+      equalizer (~> 0.0.9)
+      parser (~> 2.1)
+      procto (~> 0.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mutant-rspec (~> 0.5.10)
+  rake (~> 10.2)
+  rspec (~> 2.14)
+  typecheck!

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2014 Arne Brasseur
+
+MIT License
+
+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,71 @@
+[![Gem Version](https://badge.fury.io/rb/typecheck.png)][gem]
+[![Build Status](https://secure.travis-ci.org/plexus/typecheck.png?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/plexus/typecheck.png)][codeclimate]
+
+[gem]: https://rubygems.org/gems/typecheck
+[travis]: https://travis-ci.org/plexus/typecheck
+[codeclimate]: https://codeclimate.com/github/plexus/typecheck
+
+# Typecheck
+
+Type checking for Ruby methods.
+
+Validate the arguments and return value of a function, based on a type signature. Supports duck-type checking.
+
+Example below is for Ruby 2.1, for 2.0 and earlier pass the function name explicitly :
+
+```ruby
+def foo(..)
+end
+typecheck '...', :foo
+```
+
+Features by example:
+
+```ruby
+require 'typecheck'
+
+class Checked
+  extend Typecheck
+
+  typecheck 'Numeric -> Numeric',
+  def double_me(num)
+    num + num
+  end
+
+  typecheck 'String, Symbol -> Fixnum',
+  def strsym_num(str, sym)
+    str.length
+  end
+
+  # Duck typing FTW!
+  typecheck '#to_str -> Symbol',
+  def duck(str)
+    str.to_str.upcase.intern
+  end
+
+  typecheck '#begin;#end -> Symbol',
+  def multi(range)
+    ('x' * range.end).chars.drop(range.begin).join.intern
+  end
+
+  typecheck '#to_str|Fixnum -> Symbol',
+  def choice(x)
+    :foo
+  end
+
+  typecheck '[Fixnum],[String] -> Numeric',
+  def arrays(nums, strings)
+    (nums + strings.map(&:length)).inject(:+)
+  end
+
+  typecheck 'Fixnum,String,Symbol -> Numeric',
+  def optional(num, str = nil, sym = nil)
+    num
+  end
+end
+```
+
+## LICENSE
+
+Copyright (c) 2014 Arne Brasseur, MIT License. See LICENSE file.

data/Rakefile

@@ -0,0 +1,30 @@
+########################################
+# Testing
+
+require 'rspec/core/rake_task'
+require 'mutant'
+
+RSpec::Core::RakeTask.new
+
+task :default => :mutant
+
+task :mutant do
+  pattern = ENV.fetch('PATTERN', 'Typecheck*')
+  result  = Mutant::CLI.run(%w[-Ilib -rtypecheck --use rspec --score 100] + [pattern])
+  fail unless result == Mutant::CLI::EXIT_SUCCESS
+end
+
+########################################
+# Packaging
+
+require 'rubygems/package_task'
+spec = Gem::Specification.load(File.expand_path('../typecheck.gemspec', __FILE__))
+gem = Gem::PackageTask.new(spec)
+gem.define
+
+desc "Push gem to rubygems.org"
+task :push => :gem do
+#  sh "git tag v#{Typecheck::VERSION}"
+  sh "git push --tags"
+  sh "gem push pkg/typecheck-#{Typecheck::VERSION}.gem"
+end

data/lib/typecheck.rb

@@ -0,0 +1,93 @@
+module Typecheck
+  VERSION = '0.1.0'
+
+  def typecheck(signature, method)
+    alias_method "#{method}_unchecked", method
+    define_method method, &SignatureCompiler.new.call(signature, method)
+  end
+
+  class SignatureCompiler
+    def call(signature, method)
+      unchecked_method = "#{method}_unchecked"
+      check_args, check_out = parse_sig(signature)
+      ->(*args) do
+        check_args.(*args)
+        send(unchecked_method, *args).tap do |result|
+          check_out.(result)
+        end
+      end
+    end
+
+    def parse_sig(sig)
+      in_t, out_t = sig.split('->').map(&:strip)
+      in_ts = in_t.split(',').map(&:strip)
+
+      in_checks = in_ts.map(&method(:parse_type_list))
+      out_check = parse_type_list(out_t)
+
+      args_checker = ->(*args) {
+        args.each.with_index do |arg, idx|
+          in_checks[idx].(arg)
+        end
+      }
+      [args_checker, out_check]
+    end
+
+    def pred_or(preds)
+      ->(value) { preds.any?{|pred| pred.(value) } }
+    end
+
+    def pred_and(preds)
+      ->(value) { preds.all?{|pred| pred.(value) } }
+    end
+
+    def parse_type_list(choices)
+      types = choices.split('|').map(&:strip)
+      pred_or [
+        pred_or(types.map {|choice|
+            parse_type(choice, :check)
+          }),
+        pred_or(types.map {|choice|
+            parse_type(choice, :raise)
+          })
+      ]
+    end
+
+    def parse_type(subtype, check_or_raise)
+      pred_and subtype.split(';').map(&:strip).map { |type|
+        case type
+        when /#(.*)/
+          method("#{check_or_raise}_respond_to").to_proc.curry.($1)
+        when /\[(.*)\]/
+          method("#{check_or_raise}_array").to_proc.curry.(eval($1))
+        else
+          method("#{check_or_raise}_class").to_proc.curry.(eval(type))
+        end
+      }
+    end
+
+    def check_respond_to(method, value)
+      value.respond_to? method
+    end
+
+    def raise_respond_to(method, value)
+      raise "Expected #{value.inspect}, to respond_to #{method}" unless check_respond_to(method, value)
+    end
+
+    def check_array(type, array)
+      array.all? {|element| check_class(type, element) }
+    end
+
+    def raise_array(type, array)
+      raise "Bad type: #{array.inspect} to only contain #{klz}" unless check_array(type, array)
+    end
+
+    def check_class(klz, value)
+      value.is_a? klz
+    end
+
+    def raise_class(klz, value)
+      raise "Bad type: #{value.inspect}, expected #{klz}" unless check_class(klz, value)
+    end
+  end
+end

data/spec/integration/typecheck_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Typecheck do
+  shared_examples 'valid' do |method, args, result|
+    it 'should call the original method' do
+      expect(subject.send(method, *args)).to eq result
+    end
+  end
+
+  shared_examples 'invalid' do |method, args|
+    it 'should typecheck' do
+      expect{subject.send(method, *args)}.to raise_exception
+    end
+  end
+
+  let(:checked_class) do
+    Class.new do
+      extend Typecheck
+
+      def double_me(num)
+        num + num
+      end
+      typecheck 'Numeric -> Numeric', :double_me
+
+      def bad_out(num)
+        :sym
+      end
+      typecheck 'Numeric -> Numeric', :bad_out
+
+      def strsym_num(str, sym)
+        str.length
+      end
+      typecheck 'String, Symbol -> Fixnum', :strsym_num
+
+      def duck(str)
+        str.to_str.upcase.intern
+      end
+      typecheck '#to_str -> Symbol', :duck
+
+      def multi(range)
+        ('x' * range.end).chars.drop(range.begin).join.intern
+      end
+      typecheck '#begin;#end -> Symbol', :multi
+
+      def choice(x)
+        :foo
+      end
+      typecheck '#to_str|Fixnum -> Symbol', :choice
+
+      def arrays(nums, strings)
+        (nums + strings.map(&:length)).inject(:+)
+      end
+      typecheck '[Fixnum],[String] -> Numeric', :arrays
+
+      def optional(num, str = nil, sym = nil)
+        num
+      end
+      typecheck 'Fixnum,String,Symbol -> Numeric', :optional
+    end
+  end
+
+  subject { checked_class.new }
+
+  include_examples 'valid',   :double_me,  [7], 14
+  include_examples 'invalid', :double_me,  ['foo']
+  include_examples 'invalid', :double_me,  []
+
+  include_examples 'invalid', :bad_out,    [42]
+
+  include_examples 'valid',   :strsym_num, ['foo', :bar], 3
+  include_examples 'invalid', :strsym_num, [:foo, 'bar']
+
+  include_examples 'valid',   :duck,       ['foo'], :FOO
+  include_examples 'invalid', :duck,       [7]
+
+  include_examples 'valid',   :multi,      [3..5], :xx
+  include_examples 'invalid', :multi,      [Class.new { def begin ; end }.new]
+  include_examples 'invalid', :multi,      [7]
+
+  include_examples 'valid',   :choice,     ['foo'], :foo
+  include_examples 'valid',   :choice,     [9], :foo
+  include_examples 'invalid', :choice,     [5..9]
+  include_examples 'invalid', :choice,     [5.9]
+
+  include_examples 'valid',   :arrays,     [[1,2], ['x', 'y']], 5
+  include_examples 'invalid', :arrays,     [[:foo], ['x']]
+
+  include_examples 'valid',   :optional,   [1, 'x', :foo], 1
+  include_examples 'valid',   :optional,   [1, 'x'], 1
+  include_examples 'valid',   :optional,   [1], 1
+  include_examples 'invalid', :optional,   [1, 'x', 'y'], 1
+  include_examples 'invalid', :optional,   []
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'typecheck'

data/typecheck.gemspec

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/typecheck', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'typecheck'
+  gem.version     = Typecheck::VERSION
+  gem.authors     = [ 'Arne Brasseur' ]
+  gem.email       = [ 'arne@arnebrasseur.net' ]
+  gem.description = 'Type checking for Ruby methods.'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/plexus/typecheck'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec`.split($/)
+  gem.extra_rdoc_files = %w[README.md LICENSE]
+
+  gem.add_development_dependency 'rake'         , '~> 10.2'
+  gem.add_development_dependency 'rspec'        , '~> 2.14'
+  gem.add_development_dependency 'mutant-rspec' , '~> 0.5.10'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: typecheck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arne Brasseur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: mutant-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.10
+description: Type checking for Ruby methods.
+email:
+- arne@arnebrasseur.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/typecheck.rb
+- spec/integration/typecheck_spec.rb
+- spec/spec_helper.rb
+- typecheck.gemspec
+homepage: https://github.com/plexus/typecheck
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Type checking for Ruby methods.
+test_files:
+- spec/integration/typecheck_spec.rb
+- spec/spec_helper.rb