charyf_sig 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ed8055a7e00c0933a4d92636952405c230ccd016
+  data.tar.gz: 7f7d37e7b0f432b9c3e18d809101029c27d982dd
+SHA512:
+  metadata.gz: 9575a6279b50b6fd194e4f1f7045bb78732039f5843c05cde34e15501af1598b610903c6431164e06f5d9973903c8e40d1e25470d1aa5bfad1a40f8b27248694
+  data.tar.gz: 3f80d4950303c93991e5a219b6ae9414b42a935602f2d99e51cad925606a5d2af4ec1cabbd32b1225262465fc069ae4132f2338eb6ae66946405fa28abc41b5f

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+.idea

data/.travis.yml

@@ -0,0 +1,19 @@
+sudo: false
+language: ruby
+
+script: bundle exec ruby spec/sig_spec.rb
+
+rvm:
+- 2.2
+- 2.1
+- rbx-2
+- ruby-head
+- jruby-9000
+
+cache:
+- bundler
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-9000

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## CHANGELOG
+
+### 1.0.1
+
+* Improve keyword argument code, which also improves performance
+
+### 1.0.0
+
+* Inital release
+

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+gem 'minitest'
+gem 'minitest-line'
+gem 'minitest-reporters'
+# gem 'benchmark-ips'
+# gem 'rubype'
+# gem 'contracts'

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    charyf_sig (1.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.5.0)
+    builder (3.2.3)
+    coderay (1.1.2)
+    method_source (0.9.0)
+    minitest (5.10.3)
+    minitest-line (0.6.4)
+      minitest (~> 5.0)
+    minitest-reporters (1.1.18)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    pry (0.11.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (12.1.0)
+    ruby-progressbar (1.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  charyf_sig!
+  minitest
+  minitest-line
+  minitest-reporters
+  pry
+  rake
+
+BUNDLED WITH
+   1.15.4

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Jan Lelis, mail@janlelis.de
+
+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,204 @@
+# `sig`: Optional Type Assertions for Ruby methods. [![[version]](https://badge.fury.io/rb/sig.svg)](http://badge.fury.io/rb/sig)  [![[travis]](https://travis-ci.org/janlelis/sig.png)](https://travis-ci.org/janlelis/sig)
+
+This gem adds the `sig` method that allows you to add signatures to Ruby methods. When you call the method, it will verify that the method's arguments/result fit to the previously defined behavior:
+
+```ruby
+# On main object
+sig [:to_i, :to_i], Integer,
+def sum(a, b)
+  a.to_i + b.to_i
+end
+
+sum(42, false)
+# Sig::ArgumentTypeError:
+# - Expected false to respond to :to_i
+
+# In modules
+class A
+  sig [Numeric, Numeric], Numeric,
+  def mul(a, b)
+    a * b
+  end
+end
+
+A.new.mul(4,"3")
+# Sig::ArgumentTypeError:
+# - Expected "3" to be a Numeric, but is a String
+
+
+# Explicitely define signature for singleton_class
+class B
+  sig_self [:reverse],
+  def self.rev(object)
+    object.reverse
+  end
+end
+
+B.rev 42
+# Sig::ArgumentTypeError:
+# - Expected 42 to respond to :reverse
+```
+
+The first argument is an array that defines the behavior of the method arguments, and the second one the behavior of the method result. Don't forget the trailing comma, because the method definition needs to be the last argument to the `sig` method.
+
+## Features & Design Goals
+* Provide an intuitive way to define signatures
+* Only do argument/result type checks, nothing else
+* Use Ruby's inheritance chain, don't redefine methods
+* Encourage duck typing
+* Should work with keyword arguments
+* Only target Ruby 2.1+
+
+### This is not static typing. Ruby is a dynamic language:
+
+Nevertheless, nothing is wrong with ensuring specific behaviour of method arguments when you need it.
+
+### Is this better than rubype?
+
+The rubype gem achieves similar things like sig (and inspired the creation of sig). It offers a different syntax and differs in feature & implementation details, so in the end, it is a matter of taste, which gem you prefer.
+
+## Setup
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'sig'
+```
+
+## Usage
+
+See example at top for basic usage.
+
+### Supported Behavior Types
+
+You can use the following behavior types in the signature definition:
+
+Type    | Meaning
+------- | -------
+Symbol  | Argument must respond to a method with this name
+Module  | Argument must be of this module
+Array   | Argument can be of any type found in the array
+true    | Argument must be truthy
+false   | Argument must be falsy
+nil     | Wildcard for any argument
+
+### Example Signatures
+
+```ruby
+sig [:to_i], Numeric,              # takes any object that responds to :to_i as argument, numeric result
+sig [Numeric], String,             # one numeric argument, string result
+sig [Numeric, Numeric], String,    # two numeric arguments, string result
+sig [:to_s, :to_s],                # two arguments that support :to_s, don't care about result
+sig nil, String,                   # don't care about arguments, as long result is string
+sig {keyword: Integer}             # keyword argument must be an intieger
+sig [:to_f, {keyword: String}],    # mixing positional and keyword arguments is possible
+sig [[Numeric, NilClass]], Float   # one argument that must nil or numeric, result must be float
+sig [Numeric, nil,  Numeric],      # first and third argument must be numeric, don't care about type of second
+```
+
+See source(https://github.com/janlelis/sig/blob/master/lib/sig.rb) or specs(https://github.com/janlelis/sig/blob/master/spec/sig_spec.rb) for more features.
+
+## Benchmark (Take with a Grain of Salt)
+
+You can run `rake  benchmark` to run [it](https://github.com/janlelis/sig/blob/v1.0.1/Rakefile#L33-L148) on your machine.
+
+There is still a lot room for performance improvements. Feel free to suggest some faster implementation to do the type checks (even if it is crazy and not clean, as long it does not add too much "magic", a.k.a does not make debugging harder).
+
+Note: Starting with 0.3.0, rubype uses a C extension, which makes it much faster. The benchmark is still run with rubype 0.2.5, because 0.3.x currently does not work on jruby & rbx.
+
+### MRI
+
+```
+ruby version: 2.2.2
+ruby engine: ruby
+ruby description: ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-linux]
+sig version: 1.0.1
+rubype version: 0.2.5
+contracts version: 0.9
+Calculating -------------------------------------
+                pure   107.628k i/100ms
+                 sig    14.425k i/100ms
+              rubype    12.715k i/100ms
+           contracts     7.688k i/100ms
+-------------------------------------------------
+                pure      6.856M (± 0.9%) i/s -     34.333M
+                 sig    192.440k (± 1.5%) i/s -    966.475k
+              rubype    164.811k (± 0.8%) i/s -    826.475k
+           contracts     90.089k (± 0.7%) i/s -    453.592k
+
+Comparison:
+                pure:  6855615.3 i/s
+                 sig:   192439.7 i/s - 35.62x slower
+              rubype:   164810.5 i/s - 41.60x slower
+           contracts:    90088.6 i/s - 76.10x slower
+```
+
+### JRuby 9000
+
+```
+ruby version: 2.2.2
+ruby engine: jruby
+ruby description: jruby 9.0.0.0-SNAPSHOT (2.2.2) 2015-05-04 6055b79 Java HotSpot(TM) 64-Bit Server VM 24.80-b11 on 1.7.0_80-b15 +indy +jit [linux-amd64]
+sig version: 1.0.1
+rubype version: 0.2.5
+contracts version: 0.9
+Calculating -------------------------------------
+                pure    70.898k i/100ms
+                 sig     5.308k i/100ms
+              rubype     3.152k i/100ms
+           contracts   279.000  i/100ms
+-------------------------------------------------
+                pure      8.848M (±13.7%) i/s -     42.539M
+                 sig    178.169k (±10.3%) i/s -    881.128k
+              rubype    119.689k (±26.5%) i/s -    444.432k
+           contracts     56.780k (±16.8%) i/s -    265.887k
+
+Comparison:
+                pure:  8848039.4 i/s
+                 sig:   178168.8 i/s - 49.66x slower
+              rubype:   119689.0 i/s - 73.93x slower
+           contracts:    56780.4 i/s - 155.83x slower
+```
+
+### RBX 2.5.3
+
+```
+ruby version: 2.1.0
+ruby engine: rbx
+ruby description: rubinius 2.5.3.c25 (2.1.0 fbb3f1e4 2015-05-02 3.4 JI) [x86_64-linux-gnu]
+sig version: 1.0.1
+rubype version: 0.2.5
+contracts version: 0.9
+Calculating -------------------------------------
+                pure   114.964k i/100ms
+                 sig     9.654k i/100ms
+              rubype     3.775k i/100ms
+           contracts     3.964k i/100ms
+-------------------------------------------------
+                pure     23.585M (± 3.3%) i/s -    117.263M
+                 sig    134.304k (± 3.1%) i/s -    675.780k
+              rubype     56.042k (± 1.7%) i/s -    283.125k
+           contracts     69.820k (± 1.8%) i/s -    348.832k
+
+Comparison:
+                pure: 23585373.7 i/s
+                 sig:   134303.7 i/s - 175.61x slower
+           contracts:    69819.9 i/s - 337.80x slower
+              rubype:    56042.1 i/s - 420.85x slower
+```
+
+## Deactivate All Signature Checking
+
+```ruby
+require 'sig/none' # instead of require 'sig'
+```
+
+## Alternatives for Type Checking and More
+
+- https://github.com/gogotanaka/Rubype
+- https://github.com/egonSchiele/contracts.ruby
+- https://github.com/plum-umd/rtc
+
+## MIT License
+
+Copyright (C) 2015 Jan Lelis <http://janlelis.com>. Released under the MIT license.

data/Rakefile

@@ -0,0 +1,48 @@
+# # #
+# Get gemspec info
+
+gemspec_file = Dir['*.gemspec'].first
+gemspec = eval File.read(gemspec_file), binding, gemspec_file
+info = "#{gemspec.name} | #{gemspec.version} | " \
+       "#{gemspec.runtime_dependencies.size} dependencies | " \
+       "#{gemspec.files.size} files"
+
+
+# # #
+# Gem build and install task
+
+desc info
+task :gem do
+  puts info + "\n\n"
+  print "  "; sh "gem build #{gemspec_file}"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", 'pkg'
+  puts; sh %{gem install --no-document pkg/#{gemspec.name}-#{gemspec.version}.gem}
+end
+
+
+# # #
+# Start an IRB session with the gem loaded
+
+desc "#{gemspec.name} | IRB"
+task :irb do
+  sh "irb -I ./lib -r #{gemspec.name.gsub '-','/'}"
+end
+
+
+# # #
+# Benchmark: Take with a grain of salt
+
+desc "Compare with contracts and rubype"
+task :benchmark do
+  ruby "benchmark/compare.rb"
+end
+
+# # #
+# Specs
+
+desc "Run specs"
+task :spec do
+  ruby "spec/sig_spec.rb"
+end
+task default: :spec

data/benchmark/compare.rb

@@ -0,0 +1,116 @@
+require "benchmark/ips"
+
+require "rubype"
+require "rubype/version"
+require "contracts"
+require "contracts/version"
+require_relative "../lib/sig"
+
+# - - -
+
+puts "ruby version: #{RUBY_VERSION}"
+puts "ruby engine: #{RUBY_ENGINE}"
+puts "ruby description: #{RUBY_DESCRIPTION}"
+puts "sig version: #{Sig::VERSION}"
+puts "rubype version: #{Rubype::VERSION}"
+puts "contracts version: #{Contracts::VERSION}"
+
+# - - -
+
+class PureSum
+  def sum(x, y)
+    x + y
+  end
+
+  def mul(x, y)
+    x * y
+  end
+end
+pure_instance = PureSum.new
+
+# - - -
+
+class SigSum
+  sig [Numeric, Numeric], Numeric,
+  def sum(x, y)
+    x + y
+  end
+
+  sig [:to_i, :to_i], Numeric,
+  def mul(x, y)
+    x * y
+  end
+end
+sig_instance = SigSum.new
+
+# - - -
+
+class RubypeSum
+  def sum(x, y)
+    x + y
+  end
+  typesig :sum, [Numeric, Numeric] => Numeric
+
+  def mul(x, y)
+    x * y
+  end
+  typesig :mul, [:to_i, :to_i] => Numeric
+end
+rubype_instance = RubypeSum.new
+
+# - - -
+
+class ContractsSum
+  include Contracts
+
+  Contract Num, Num => Num
+  def sum(x, y)
+    x + y
+  end
+
+  Contract RespondTo[:to_i], RespondTo[:to_i] => Num
+  def mul(x, y)
+    x * y
+  end
+end
+contracts_instance = ContractsSum.new
+
+Benchmark.ips do |x|
+  x.report("pure"){ |times|
+    i = 0
+    while i < times
+      pure_instance.sum(1, 2)
+      pure_instance.mul(1, 2)
+      i += 1
+    end
+  }
+
+  x.report("sig"){ |times|
+    i = 0
+    while i < times
+      sig_instance.sum(1, 2)
+      sig_instance.mul(1, 2)
+      i += 1
+    end
+  }
+
+  x.report("rubype"){ |times|
+    i = 0
+    while i < times
+      rubype_instance.sum(1, 2)
+      rubype_instance.mul(1, 2)
+      i += 1
+    end
+  }
+
+  x.report("contracts"){ |times|
+    i = 0
+    while i < times
+      contracts_instance.sum(1, 2)
+      contracts_instance.mul(1, 2)
+      i += 1
+    end
+  }
+
+  x.compare!
+end

data/lib/charyf_sig.rb

@@ -0,0 +1,176 @@
+require_relative "sig/version"
+require_relative "sig/kernel"
+
+module Sig
+  class ArgumentTypeError < ArgumentError
+  end
+
+  class ResultTypeError < RuntimeError
+  end
+
+  def self.define(object, expected_arguments, expected_result = nil, method_name)
+    no_argument_checks = expected_arguments.nil?
+
+    expected_arguments = Array(expected_arguments)
+    if expected_arguments.last.is_a?(Hash)
+      expected_keyword_arguments = expected_arguments.delete_at(-1)
+    else
+      expected_keyword_arguments = nil
+    end
+
+    method_visibility = get_method_visibility_or_raise(object, method_name)
+    signature_checker = get_or_create_signature_checker(object)
+    signature_checker.send :define_method, method_name do |*arguments, **keyword_arguments|
+      if keyword_arguments.empty?
+        ::Sig.check_arguments(expected_arguments, arguments) unless no_argument_checks
+        result = super(*arguments)
+      else
+        ::Sig.check_arguments_with_keywords(expected_arguments, arguments,
+                                            expected_keyword_arguments,
+                                            keyword_arguments) unless no_argument_checks
+        result = super(*arguments, **keyword_arguments)
+      end
+      ::Sig.check_result(expected_result, result) unless expected_result.nil?
+
+      result
+    end
+    signature_checker.send(method_visibility, method_name)
+
+    method_name
+  end
+
+  def self.get_method_visibility_or_raise(object, method_name)
+    case
+    when object.private_method_defined?(method_name)
+      :private
+    when object.protected_method_defined?(method_name)
+      :protected
+    when object.public_method_defined?(method_name)
+      :public
+    else
+      raise ArgumentError, "No method with name :#{method_name} for object #{object.inspect}"
+    end
+  end
+
+  def self.get_or_create_signature_checker(object)
+    unless checker = object.instance_variable_get(:@_sig)
+      checker = object.instance_variable_set(:@_sig, Module.new)
+      def checker.inspect() "#<Sig:#{object_id}>" end
+      object.prepend(checker)
+    end
+
+    checker
+  end
+
+  def self.check_arguments(expected_arguments, arguments)
+    errors = ""
+
+    arguments.each_with_index{ |argument, index|
+      if error = valid_or_formatted_error(expected_arguments[index], argument)
+        errors << error
+      end
+    }
+
+    unless errors.empty?
+      raise ArgumentTypeError, errors
+    end
+  end
+
+  def self.check_arguments_with_keywords(expected_arguments, arguments,
+                                         expected_keyword_arguments, keyword_arguments)
+    errors = ""
+
+    arguments.each_with_index{ |argument, index|
+      if error = valid_or_formatted_error(expected_arguments[index], argument)
+        errors << error
+      end
+    }
+
+    if expected_keyword_arguments
+      keyword_arguments.each{ |key, keyword_argument|
+        if error = valid_or_formatted_error(expected_keyword_arguments[key], keyword_argument)
+          errors << error
+        end
+      }
+    elsif error = valid_or_formatted_error(expected_arguments[arguments.size], keyword_arguments)
+      errors << error
+    end
+
+    unless errors.empty?
+      raise ArgumentTypeError, errors
+    end
+  end
+
+  def self.check_result(expected_result, result)
+    unless matches? expected_result, result
+      raise ResultTypeError, format_error(expected_result, result)
+    end
+  end
+
+  def self.matches?(expected, value)
+    # Runtime eval the constants
+    expected = constantize(expected)
+
+    # Match
+    case expected
+    when Array
+      expected.any?{ |expected_element| matches? expected_element, value }
+    when Module
+      value.is_a?(expected)
+    when Symbol
+      value.respond_to?(expected)
+    when Proc
+      !!expected.call(value)
+    when Regexp
+      !!(expected =~ String(value))
+    when Range
+      expected.include?(value)
+    when true
+      !!value
+    when false
+      !value
+    when nil
+      true
+    else
+      raise ArgumentError, "Invalid signature definition: Unknown behavior #{expected}"
+    end
+  end
+
+  def self.constantize(expected)
+    if expected.is_a? String
+      return Object.const_get(expected)
+    elsif expected.is_a? Array
+      return expected.map { |el| constantize(el) }
+    end
+
+    expected
+  end
+
+  def self.valid_or_formatted_error(expected_argument, argument)
+    if !expected_argument.nil? && !matches?(expected_argument, argument)
+      format_error(expected_argument, argument)
+    end
+  end
+
+  def self.format_error(expected, value)
+    case expected
+    when Array
+      expected.map{ |expected_element| format_error(expected_element, value) }*" OR"
+    when Module, String
+      "\n- Expected #{value.inspect} to be a #{expected}, but is a #{value.class}"
+    when Symbol
+      "\n- Expected #{value.inspect} to respond to :#{expected}"
+    when Proc
+      "\n- Expected #{value.inspect} to return a truthy value for proc #{expected}"
+    when Regexp
+      "\n- Expected stringified #{value.inspect} to match #{expected.inspect}"
+    when Range
+      "\n- Expected #{value.inspect} to be included in #{expected.inspect}"
+    when true
+      "\n- Expected #{value.inspect} to be truthy"
+    when false
+      "\n- Expected #{value.inspect} to be falsy"
+    end
+  end
+end
+

data/lib/sig/kernel.rb

@@ -0,0 +1,29 @@
+module Kernel
+  private
+
+  # Defines a method signature for a method on this object:
+  #
+  #   sig [:to_i, :to_i], Integer,
+  #   def sum(a, b)
+  #     a.to_i + b.to_i
+  #   end
+  #
+  def sig(expected_arguments, expected_result = nil, method_name)
+    if is_a?(Module)
+      Sig.define(self, expected_arguments, expected_result, method_name)
+    else
+      sig_self(expected_arguments, expected_result, method_name)
+    end
+  end
+
+  # Defines a method signature for a method on this object's singleton class
+  #
+  #   sig_self [:to_i, :to_i], Integer,
+  #   def self.sum(a, b)
+  #     a.to_i + b.to_i
+  #   end
+  #
+  def sig_self(expected_arguments, expected_result = nil, method_name)
+    Sig.define(singleton_class, expected_arguments, expected_result, method_name)
+  end
+end

data/lib/sig/none.rb

@@ -0,0 +1,15 @@
+# require "sig/none" instead of "sig" to get fake methods that do nothing
+
+require_relative '../charyf_sig'
+
+module Kernel
+  private
+
+  def sig(_, _ = nil, method_name)
+    method_name
+  end
+  #
+  def sig_self(_, _ = nil, method_name)
+    method_name
+  end
+end

data/lib/sig/version.rb

@@ -0,0 +1,4 @@
+module Sig
+  VERSION = "1.1.0".freeze
+end
+

data/sig.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + "/lib/sig/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "charyf_sig"
+  gem.version       = Sig::VERSION
+  gem.summary       = "Optional Type Assertions for Ruby."
+  gem.description   = "Optional Type Assertions for Ruby methods."
+  gem.authors       = ["Richard Ludvigh"]
+  gem.email         = "richard@ludvigh.sk"
+  gem.homepage      = "https://github.com/Charyf/sig/"
+  gem.license       = "MIT"
+
+  gem.files         = Dir["{**/}{.*,*}"].select{ |path| File.file?(path) && path !~ /^pkg/ }
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = "~> 2.1"
+end

data/spec/sig_spec.rb

@@ -0,0 +1,342 @@
+require_relative "../lib/charyf_sig"
+require "minitest/autorun"
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::ProgressReporter.new
+
+
+describe Sig do
+  let(:instance){ klass.new }
+  let(:klass){
+    Class.new do
+      def my_method(object)
+      end
+
+      def sum(a, b)
+        a + b
+      end
+
+      def key(arg, word: 42)
+      end
+
+      def priv
+      end
+      private :priv
+
+      def prot
+      end
+      protected :prot
+
+      def self.mul(a, b)
+        a * b
+      end
+    end
+  }
+
+
+  describe "Kernel#sig" do
+    describe "self is no Module" do
+      it "will call Sig.define(...) for self's singleton_class" do
+        sig [String],
+        def bla(argument)
+        end
+
+        assert_raises Sig::ArgumentTypeError do
+          bla 42
+        end
+      end
+    end
+
+    describe "self if a Module" do
+      it "will call Sig.define(...) for self" do
+        class Klass
+          sig [String],
+          def bla(argument)
+          end
+        end
+
+        assert_raises Sig::ArgumentTypeError do
+          Klass.new.bla 42
+        end
+      end
+    end
+  end
+
+  describe "sig_self" do
+    it "will always call Sig.define(...) on self's singleton_class" do
+      class Klass
+        sig_self [String],
+        def self.blubb(argument)
+        end
+      end
+
+      assert_raises Sig::ArgumentTypeError do
+        Klass.blubb 42
+      end
+    end
+  end
+
+  describe "Types" do
+    describe "Module" do
+      it "will do nothing if value is kind of module" do
+        Sig.define klass, [Numeric], :my_method
+        instance.my_method(42)
+        assert true
+      end
+
+      it "will raise if value is not kind of module" do
+        Sig.define klass, [Array], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method(42)
+        end
+      end
+    end
+
+    describe "String" do
+      it "will cast the string to constant and validate" do
+        module A
+          class B
+            module C
+              class D
+              end
+            end
+          end
+        end
+
+        Sig.define klass, ['A::B::C::D'], :my_method
+        instance.my_method(A::B::C::D.new)
+        assert true
+      end
+
+      it "will validate the class" do
+        Sig.define klass, ['String'], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method(:symbol)
+        end
+      end
+
+      it "fails on cast when non existant class is present during runtime" do
+        module A
+          class B
+
+          end
+        end
+
+        Sig.define klass, [['A::B', 'A::C']], :my_method
+
+        assert_raises NameError do
+          instance.my_method(A::B.new)
+        end
+      end
+    end
+
+    describe "Symbol" do
+      it "will do nothing if value is kind of module" do
+        Sig.define klass, [:to_i], :my_method
+        instance.my_method("string")
+        assert true
+      end
+
+      it "will raise if value does not respond to method named by the symbol" do
+        Sig.define klass, [:to_i], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method(true)
+        end
+      end
+    end
+
+    describe "Proc" do
+      it "will do nothing if value does return a falsy result after being processed by the proc" do
+        Sig.define klass, [->(e){ e.odd? }], :my_method
+        instance.my_method(43)
+        assert true
+      end
+
+      it "will raise if value does return a truthy result after being processed by the proc" do
+        Sig.define klass, [->(e){ e.odd? }], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method(42)
+        end
+      end
+    end
+
+    describe "Regexpg" do
+      it "will do nothing if stringified value does match" do
+        Sig.define klass, [/bla/], :my_method
+        instance.my_method("bla")
+        assert true
+      end
+
+      it "will raise if stringified value does not match" do
+        Sig.define klass, [/bla/], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method("blubb")
+        end
+      end
+    end
+
+    describe "Range" do
+      it "will do nothing if included in range" do
+        Sig.define klass, [1...100], :my_method
+        instance.my_method(42)
+        assert true
+      end
+
+      it "will raise if not included in range" do
+        Sig.define klass, [1...100], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method("blubb")
+        end
+      end
+    end
+
+    describe "true" do
+      it "will do nothing if value is truthy" do
+        Sig.define klass, [true], :my_method
+        instance.my_method(42)
+        assert true
+      end
+
+      it "will raise if value is not truthy" do
+        Sig.define klass, [true], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method(nil)
+        end
+      end
+    end
+
+    describe "false" do
+      it "will do nothing if value is falsy" do
+        Sig.define klass, [false], :my_method
+        instance.my_method(nil)
+        assert true
+      end
+
+      it "will raise if value is not falsy" do
+        Sig.define klass, [false], :my_method
+        assert_raises Sig::ArgumentTypeError do
+          instance.my_method(42)
+        end
+      end
+    end
+
+    describe "nil" do
+      it "will never raise" do
+        Sig.define klass, [nil], :my_method
+        instance.my_method(42)
+        assert true
+      end
+    end
+  end
+
+  describe "Formats" do
+    it "checks both parameters" do
+      Sig.define klass, [Integer, Float], :sum
+      assert_raises Sig::ArgumentTypeError do
+        instance.sum(42, 42)
+      end
+    end
+
+    it "will check the result if another parameter is given to sig" do
+      Sig.define klass, [Integer, Integer], Float, :sum
+      assert_raises Sig::ResultTypeError do
+        instance.sum(42, 42)
+      end
+    end
+
+    it "is possible to only check for result type" do
+      Sig.define klass, nil, Float, :sum
+      assert_raises Sig::ResultTypeError do
+        instance.sum(42, 42)
+      end
+    end
+
+    it "is possible to check for one of multiple given types" do
+      Sig.define klass, [[Numeric, String]], :my_method
+      instance.my_method(42)
+      assert true
+    end
+
+    describe "Keyword Arguments" do
+      it "works" do
+        Sig.define klass, {word: String}, :key
+        assert_raises Sig::ArgumentTypeError do
+          instance.key(nil, word: 42)
+        end
+      end
+
+      it "works with mixed positionial and keyword parameters" do
+        Sig.define klass, [Numeric, {word: String}], :key
+        assert_raises Sig::ArgumentTypeError do
+          instance.key(42, word: 43)
+        end
+      end
+
+      it "works with mixed positionial and keyword parameters 2" do
+        Sig.define klass, [Numeric, {word: String}], :key
+        assert_raises Sig::ArgumentTypeError do
+          instance.key("42", word: "43")
+        end
+      end
+    end
+  end
+
+  describe "Implementation Details" do
+    it "can be used on instance level" do
+      Sig.define klass, [Numeric], :sum
+      assert_raises Sig::ArgumentTypeError do
+        instance.sum("str", "ing")
+      end
+    end
+
+    it "can be used on class level" do
+      Sig.define klass.singleton_class, [Numeric], :mul
+      assert_raises Sig::ArgumentTypeError do
+        klass.mul("str", "ing")
+      end
+    end
+
+    it "defines an anomynous signature checker module" do
+      Sig.define klass, [Numeric], :sum
+      assert_equal Module, klass.instance_variable_get(:@_sig).class
+    end
+
+    it "uses the same signature module for multiple signatures" do
+      Sig.define klass, [Numeric], :sum
+      Sig.define klass, [Numeric], :my_method
+      assert_equal 2, klass.instance_variable_get(:@_sig).instance_methods.size
+    end
+
+    it "does not define signature modules if no signature is used in the class" do
+      assert_equal nil, klass.instance_variable_get(:@_sig)
+    end
+
+    it "respects restricted visibility of private methods" do
+      Sig.define klass, [String], :priv
+      assert_raises NoMethodError do
+        instance.priv
+      end
+    end
+
+    it "respects restricted visibility of protected methods" do
+      Sig.define klass, [String], :prot
+      assert_raises NoMethodError do
+        instance.prot
+      end
+    end
+  end
+
+  describe "Wrong Usage" do
+    it "will raise an ArgumentError if trying to define a signature for an unknown method" do
+      assert_raises ArgumentError do
+        Sig.define klass, [String], :unknown
+      end
+    end
+    it "will raise an ArgumentError if unknown signature types are used" do
+      assert_raises ArgumentError do
+        Sig.define klass, [Object.new], :my_method
+        klass.new.my_method(42)
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: charyf_sig
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Richard Ludvigh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-18 00:00:00.000000000 Z
+dependencies: []
+description: Optional Type Assertions for Ruby methods.
+email: richard@ludvigh.sk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/compare.rb
+- lib/charyf_sig.rb
+- lib/sig/kernel.rb
+- lib/sig/none.rb
+- lib/sig/version.rb
+- sig.gemspec
+- spec/sig_spec.rb
+homepage: https://github.com/Charyf/sig/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Optional Type Assertions for Ruby.
+test_files:
+- spec/sig_spec.rb